internal/http3: make read-data tests usable for server handlers

A reading a transport response body behaves much the same as a server handler reading a request body. Move the transport test into body_test.go and rearrange it a bit so we can reuse it as a server test. For golang/go#70914 Change-Id: I24e10dd078ffab867c9b678e1d0b99172763b069 Reviewed-on: https://go-review.googlesource.com/c/net/+/652457 Auto-Submit: Damien Neil <dneil@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Jonathan Amsterdam <jba@google.com>

Author: neild

internal/http3/body_test.go

@@ -0,0 +1,276 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.24 && goexperiment.synctest
+
+package http3
+
+import (
+"bytes"
+"fmt"
+"io"
+"net/http"
+"testing"
+)
+
+// TestReadData tests servers reading request bodies, and clients reading response bodies.
+func TestReadData(t *testing.T) {
+// These tests consist of a series of steps,
+// where each step is either something arriving on the stream
+// or the client/server reading from the body.
+type (
+// HEADERS frame arrives (headers).
+receiveHeaders struct {
+contentLength int64 // -1 for no content-length
+}
+// DATA frame header arrives.
+receiveDataHeader struct {
+size int64
+}
+// DATA frame content arrives.
+receiveData struct {
+size int64
+}
+// HEADERS frame arrives (trailers).
+receiveTrailers struct{}
+// Some other frame arrives.
+receiveFrame struct {
+ftype frameType
+data []byte
+}
+// Stream closed, ending the body.
+receiveEOF struct{}
+// Server reads from Request.Body, or client reads from Response.Body.
+wantBody struct {
+size int64
+eof bool
+}
+wantError struct{}
+)
+for _, test := range []struct {
+name string
+respHeader http.Header
+steps []any
+wantError bool
+}{{
+name: "no content length",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveDataHeader{size: 10},
+receiveData{size: 10},
+receiveEOF{},
+wantBody{size: 10, eof: true},
+},
+}, {
+name: "valid content length",
+steps: []any{
+receiveHeaders{contentLength: 10},
+receiveDataHeader{size: 10},
+receiveData{size: 10},
+receiveEOF{},
+wantBody{size: 10, eof: true},
+},
+}, {
+name: "data frame exceeds content length",
+steps: []any{
+receiveHeaders{contentLength: 5},
+receiveDataHeader{size: 10},
+receiveData{size: 10},
+wantError{},
+},
+}, {
+name: "data frame after all content read",
+steps: []any{
+receiveHeaders{contentLength: 5},
+receiveDataHeader{size: 5},
+receiveData{size: 5},
+wantBody{size: 5},
+receiveDataHeader{size: 1},
+receiveData{size: 1},
+wantError{},
+},
+}, {
+name: "content length too long",
+steps: []any{
+receiveHeaders{contentLength: 10},
+receiveDataHeader{size: 5},
+receiveData{size: 5},
+receiveEOF{},
+wantBody{size: 5},
+wantError{},
+},
+}, {
+name: "stream ended by trailers",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveDataHeader{size: 5},
+receiveData{size: 5},
+receiveTrailers{},
+wantBody{size: 5, eof: true},
+},
+}, {
+name: "trailers and content length too long",
+steps: []any{
+receiveHeaders{contentLength: 10},
+receiveDataHeader{size: 5},
+receiveData{size: 5},
+wantBody{size: 5},
+receiveTrailers{},
+wantError{},
+},
+}, {
+name: "unknown frame before headers",
+steps: []any{
+receiveFrame{
+ftype: 0x1f + 0x21, // reserved frame type
+data: []byte{1, 2, 3, 4},
+},
+receiveHeaders{contentLength: -1},
+receiveDataHeader{size: 10},
+receiveData{size: 10},
+wantBody{size: 10},
+},
+}, {
+name: "unknown frame after headers",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveFrame{
+ftype: 0x1f + 0x21, // reserved frame type
+data: []byte{1, 2, 3, 4},
+},
+receiveDataHeader{size: 10},
+receiveData{size: 10},
+wantBody{size: 10},
+},
+}, {
+name: "invalid frame",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveFrame{
+ftype: frameTypeSettings, // not a valid frame on this stream
+data: []byte{1, 2, 3, 4},
+},
+wantError{},
+},
+}, {
+name: "data frame consumed by several reads",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveDataHeader{size: 16},
+receiveData{size: 16},
+wantBody{size: 2},
+wantBody{size: 4},
+wantBody{size: 8},
+wantBody{size: 2},
+},
+}, {
+name: "read multiple frames",
+steps: []any{
+receiveHeaders{contentLength: -1},
+receiveDataHeader{size: 2},
+receiveData{size: 2},
+receiveDataHeader{size: 4},
+receiveData{size: 4},
+receiveDataHeader{size: 8},
+receiveData{size: 8},
+wantBody{size: 2},
+wantBody{size: 4},
+wantBody{size: 8},
+},
+}} {
+
+runTest := func(t testing.TB, h http.Header, st *testQUICStream, body func() io.ReadCloser) {
+var (
+bytesSent int
+bytesReceived int
+)
+for _, step := range test.steps {
+switch step := step.(type) {
+case receiveHeaders:
+header := h.Clone()
+if step.contentLength != -1 {
+header["content-length"] = []string{
+fmt.Sprint(step.contentLength),
+}
+}
+st.writeHeaders(header)
+case receiveDataHeader:
+t.Logf("receive DATA frame header: size=%v", step.size)
+st.writeVarint(int64(frameTypeData))
+st.writeVarint(step.size)
+st.Flush()
+case receiveData:
+t.Logf("receive DATA frame content: size=%v", step.size)
+for range step.size {
+st.stream.stream.WriteByte(byte(bytesSent))
+bytesSent++
+}
+st.Flush()
+case receiveTrailers:
+st.writeHeaders(http.Header{
+"x-trailer": []string{"trailer"},
+})
+case receiveFrame:
+st.writeVarint(int64(step.ftype))
+st.writeVarint(int64(len(step.data)))
+st.Write(step.data)
+st.Flush()
+case receiveEOF:
+t.Logf("receive EOF on request stream")
+st.stream.stream.CloseWrite()
+case wantBody:
+t.Logf("read %v bytes from response body", step.size)
+want := make([]byte, step.size)
+for i := range want {
+want[i] = byte(bytesReceived)
+bytesReceived++
+}
+got := make([]byte, step.size)
+n, err := body().Read(got)
+got = got[:n]
+if !bytes.Equal(got, want) {
+t.Errorf("resp.Body.Read:")
+t.Errorf(" got: {%x}", got)
+t.Fatalf(" want: {%x}", want)
+}
+if err != nil {
+if step.eof && err == io.EOF {
+continue
+}
+t.Fatalf("resp.Body.Read: unexpected error %v", err)
+}
+if step.eof {
+if n, err := body().Read([]byte{0}); n != 0 || err != io.EOF {
+t.Fatalf("resp.Body.Read() = %v, %v; want io.EOF", n, err)
+}
+}
+case wantError:
+if n, err := body().Read([]byte{0}); n != 0 || err == nil || err == io.EOF {
+t.Fatalf("resp.Body.Read() = %v, %v; want error", n, err)
+}
+default:
+t.Fatalf("unknown test step %T", step)
+}
+}
+
+}
+
+runSynctestSubtest(t, test.name+"/client", func(t testing.TB) {
+tc := newTestClientConn(t)
+tc.greet()
+
+req, _ := http.NewRequest("GET", "https://example.tld/", nil)
+rt := tc.roundTrip(req)
+st := tc.wantStream(streamTypeRequest)
+st.wantHeaders(nil)
+
+header := http.Header{
+":status": []string{"200"},
+}
+runTest(t, header, st, func() io.ReadCloser {
+return rt.response().Body
+})
+})
+}
+}