fix(httpx): parse JSON bodies with unknown content length

rest/httpx/requests.go

@@ -1,6 +1,7 @@
 package httpx
 
 import (
+	"bytes"
 	"io"
 	"net/http"
 	"reflect"
@@ -115,6 +116,18 @@ func ParseHeader(headerValue string) map[string]string {
 func ParseJsonBody(r *http.Request, v any) error {
 	if withJsonBody(r) {
 		reader := io.LimitReader(r.Body, maxBodyLen)
+		if r.ContentLength < 0 {
+			var first [1]byte
+			if _, err := io.ReadFull(reader, first[:]); err != nil {
+				if err == io.EOF {
+					return mapping.UnmarshalJsonMap(nil, v)
+				}
+				return err
+			}
+
+			reader = io.MultiReader(bytes.NewReader(first[:]), reader)
+		}
+
 		return mapping.UnmarshalJsonReader(reader, v)
 	}
 
@@ -149,5 +162,5 @@ func getValidator() Validator {
 }
 
 func withJsonBody(r *http.Request) bool {
-	return r.ContentLength > 0 && strings.Contains(r.Header.Get(header.ContentType), header.ApplicationJson)
+	return r.ContentLength != 0 && strings.Contains(r.Header.Get(header.ContentType), header.ApplicationJson)
 }

rest/httpx/requests_test.go

@@ -4,12 +4,14 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
 	"strconv"
 	"strings"
 	"testing"
+	"testing/iotest"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/rest/internal/header"
@@ -484,6 +486,31 @@ func TestParseJsonBody(t *testing.T) {
 		}
 	})
 
+	t.Run("unknown length body", func(t *testing.T) {
+		var v struct {
+			Name string `json:"name"`
+			Age  int    `json:"age"`
+		}
+
+		body := `{"name":"kevin", "age": 18}`
+
+		// wrap the reader so httptest cannot infer the body length,
+		// which produces a request with ContentLength == -1.
+		r := httptest.NewRequest(
+			http.MethodPost,
+			"/",
+			io.NopCloser(strings.NewReader(body)),
+		)
+		r.Header.Set(ContentType, header.ContentTypeJson)
+
+		assert.Equal(t, int64(-1), r.ContentLength)
+
+		if assert.NoError(t, Parse(r, &v)) {
+			assert.Equal(t, "kevin", v.Name)
+			assert.Equal(t, 18, v.Age)
+		}
+	})
+
 	t.Run("bad body", func(t *testing.T) {
 		var v struct {
 			Name string `json:"name"`
@@ -566,6 +593,69 @@ func TestParseJsonBody(t *testing.T) {
 	})
 }
 
+func TestParseJsonBody_EmptyUnknownLength(t *testing.T) {
+	t.Run("optional fields", func(t *testing.T) {
+		var v struct {
+			Name string `json:"name,optional"`
+		}
+		r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader("")))
+		r.Header.Set(ContentType, header.ContentTypeJson)
+
+		assert.Equal(t, int64(-1), r.ContentLength)
+		assert.NoError(t, Parse(r, &v))
+		assert.Empty(t, v.Name)
+	})
+
+	t.Run("default values", func(t *testing.T) {
+		var v struct {
+			Name string `json:"name,default=kevin"`
+			Age  int    `json:"age,default=18"`
+		}
+		r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader("")))
+		r.Header.Set(ContentType, header.ContentTypeJson)
+
+		assert.NoError(t, Parse(r, &v))
+		assert.Equal(t, "kevin", v.Name)
+		assert.Equal(t, 18, v.Age)
+	})
+
+	t.Run("required fields", func(t *testing.T) {
+		var v struct {
+			Name string `json:"name"`
+		}
+		r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader("")))
+		r.Header.Set(ContentType, header.ContentTypeJson)
+
+		err := Parse(r, &v)
+		assert.ErrorContains(t, err, "name")
+		assert.NotErrorIs(t, err, io.EOF)
+	})
+
+	t.Run("whitespace body", func(t *testing.T) {
+		var v struct {
+			Name string `json:"name,optional"`
+		}
+		r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader(" ")))
+		r.Header.Set(ContentType, header.ContentTypeJson)
+
+		assert.ErrorIs(t, Parse(r, &v), io.EOF)
+	})
+}
+
+func TestParseJsonBody_ReadError(t *testing.T) {
+	for _, err := range []error{errors.New("read failed"), io.ErrUnexpectedEOF} {
+		t.Run(err.Error(), func(t *testing.T) {
+			var v struct {
+				Name string `json:"name,optional"`
+			}
+			r := httptest.NewRequest(http.MethodPost, "/", iotest.ErrReader(err))
+			r.Header.Set(ContentType, header.ContentTypeJson)
+
+			assert.ErrorIs(t, Parse(r, &v), err)
+		})
+	}
+}
+
 func TestParseRequired(t *testing.T) {
 	v := struct {
 		Name    string  `form:"name"`