test(json): cover pooled-buffer Deserialize behaviors

Add correctness coverage for the new pooled-buffer JSON deserializer,
addressing gaps surfaced in review:

- RejectsTrailingData: documents that json.Unmarshal rejects content after
  the first top-level value (a behavior change from streaming json.Decoder).
- PooledBufferReuse: long body followed by a short one must not leak stale
  bytes through the reused buffer.
- PooledBufferConcurrent: many goroutines decoding distinct bodies; under
  -race this catches any aliasing/missing-reset regression (data bleed).
- LargeBodyThenNormal: exercises the >64 KiB buffer-cap path and that the
  oversized buffer does not corrupt the next request.
- BodyReadError: a failing body read surfaces as 400, matching prior behavior.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: vishr

json_test.go

@@ -4,13 +4,26 @@
 package echo
 
 import (
-	"github.com/stretchr/testify/assert"
+	"errors"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
+	"sync"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
+// deserializeJSON decodes body into target via the default serializer using a
+// fresh context. It does not touch *testing.T so it is safe to call from
+// goroutines (used by the concurrency test).
+func deserializeJSON(e *Echo, body string, target any) error {
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+	c := e.NewContext(req, httptest.NewRecorder())
+	return DefaultJSONSerializer{}.Deserialize(c, target)
+}
+
 // Note this test is deliberately simple as there's not a lot to test.
 // Just need to ensure it writes JSONs. The heavy work is done by the context methods.
 func TestDefaultJSONCodec_Encode(t *testing.T) {
@@ -98,3 +111,106 @@ func TestDefaultJSONCodec_Decode(t *testing.T) {
 	assert.EqualError(t, err, "code=400, message=Bad Request, err=json: cannot unmarshal number into Go struct field .id of type string")
 
 }
+
+// TestDefaultJSONCodec_Decode_RejectsTrailingData documents an intentional
+// behavior change: Deserialize uses json.Unmarshal, which (unlike a streaming
+// json.Decoder) rejects any content after the first top-level JSON value.
+func TestDefaultJSONCodec_Decode_RejectsTrailingData(t *testing.T) {
+	e := New()
+	for _, body := range []string{
+		userJSON + `{"id":2,"name":"second"}`, // a second JSON object
+		userJSON + ` trailing garbage`,        // trailing non-JSON
+		userJSON + `,`,                        // trailing token
+	} {
+		var u user
+		err := deserializeJSON(e, body, &u)
+		if assert.Error(t, err, "body %q should be rejected", body) {
+			assert.IsType(t, &HTTPError{}, err)
+			assert.Equal(t, http.StatusBadRequest, err.(*HTTPError).Code)
+		}
+	}
+}
+
+// TestDefaultJSONCodec_Decode_PooledBufferReuse guards against stale bytes
+// bleeding between requests through the reused pooled buffer: a long body
+// followed by a short one must each decode to exactly their own input.
+func TestDefaultJSONCodec_Decode_PooledBufferReuse(t *testing.T) {
+	e := New()
+	for i := 0; i < 50; i++ {
+		longName := strings.Repeat("x", 1000+i)
+		var long user
+		err := deserializeJSON(e, fmt.Sprintf(`{"id":%d,"name":%q}`, i, longName), &long)
+		assert.NoError(t, err)
+		assert.Equal(t, user{ID: i, Name: longName}, long)
+
+		var short user
+		err = deserializeJSON(e, `{"id":7,"name":"a"}`, &short)
+		assert.NoError(t, err)
+		assert.Equal(t, user{ID: 7, Name: "a"}, short)
+	}
+}
+
+// TestDefaultJSONCodec_Decode_PooledBufferConcurrent exercises the pooled
+// buffer from many goroutines at once; run under -race it catches any aliasing
+// or missing-reset regression that would let one request's body corrupt another.
+func TestDefaultJSONCodec_Decode_PooledBufferConcurrent(t *testing.T) {
+	e := New()
+	const n = 64
+	var wg sync.WaitGroup
+	errs := make([]error, n)
+	got := make([]user, n)
+	for i := 0; i < n; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			body := fmt.Sprintf(`{"id":%d,"name":%q}`, i, strings.Repeat("n", i+1))
+			errs[i] = deserializeJSON(e, body, &got[i])
+		}(i)
+	}
+	wg.Wait()
+	for i := 0; i < n; i++ {
+		assert.NoError(t, errs[i])
+		assert.Equal(t, user{ID: i, Name: strings.Repeat("n", i+1)}, got[i])
+	}
+}
+
+// TestDefaultJSONCodec_Decode_LargeBodyThenNormal covers the buffer-cap path: a
+// body larger than maxPooledJSONBuf must decode correctly, and its oversized
+// buffer (dropped from the pool rather than retained) must not affect the next
+// normal-sized request.
+func TestDefaultJSONCodec_Decode_LargeBodyThenNormal(t *testing.T) {
+	e := New()
+	bigName := strings.Repeat("z", 100*1024) // 100 KiB > 64 KiB cap
+	var big user
+	err := deserializeJSON(e, fmt.Sprintf(`{"id":1,"name":%q}`, bigName), &big)
+	assert.NoError(t, err)
+	assert.Equal(t, user{ID: 1, Name: bigName}, big)
+
+	var small user
+	err = deserializeJSON(e, userJSON, &small)
+	assert.NoError(t, err)
+	assert.Equal(t, user{ID: 1, Name: "Jon Snow"}, small)
+}
+
+// errReader is an io.ReadCloser whose Read always fails, used to exercise the
+// body-read error branch of Deserialize.
+type errReader struct{}
+
+func (errReader) Read([]byte) (int, error) { return 0, errors.New("read failed") }
+func (errReader) Close() error             { return nil }
+
+// TestDefaultJSONCodec_Decode_BodyReadError verifies a failing request body read
+// surfaces as a 400, matching the pre-existing decoder behavior.
+func TestDefaultJSONCodec_Decode_BodyReadError(t *testing.T) {
+	e := New()
+	req := httptest.NewRequest(http.MethodPost, "/", http.NoBody)
+	req.Body = errReader{}
+	c := e.NewContext(req, httptest.NewRecorder())
+
+	var u user
+	err := DefaultJSONSerializer{}.Deserialize(c, &u)
+	if assert.Error(t, err) {
+		assert.IsType(t, &HTTPError{}, err)
+		assert.Equal(t, http.StatusBadRequest, err.(*HTTPError).Code)
+	}
+}