http2: speed up TestTransportFlowControl

Rewrite the slowest test in the http2 package.

This test was added in CL 23812 to verify that a Transport does not
provide flow control window updates until the user consumes data
from a stream.

Rewrite the test to use the more modern testClientConn, which permits
precise examination of when the transport sends WINDOW_UPDATE frames.

Change-Id: Ibcde492549cad6363ce0e1a5ba169da7a4427d85
Reviewed-on: https://go-review.googlesource.com/c/net/+/700923
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Nicholas Husin <nsh@golang.org>
Reviewed-by: Nicholas Husin <husin@google.com>
Auto-Submit: Damien Neil <dneil@google.com>

Author: neild

http2/transport_test.go

@@ -2374,59 +2374,68 @@ func testTransportStreamEndsWhileBodyIsBeingWritten(t testing.TB) {
 	rt.wantStatus(413)
 }
 
-// https://golang.org/issue/15930
-func TestTransportFlowControl(t *testing.T) {
-	const bufLen = 64 << 10
-	var total int64 = 100 << 20 // 100MB
-	if testing.Short() {
-		total = 10 << 20
-	}
-
-	var wrote int64 // updated atomically
-	ts := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
-		b := make([]byte, bufLen)
-		for wrote < total {
-			n, err := w.Write(b)
-			atomic.AddInt64(&wrote, int64(n))
-			if err != nil {
-				t.Errorf("ResponseWriter.Write error: %v", err)
-				break
-			}
-			w.(http.Flusher).Flush()
+func TestTransportFlowControl(t *testing.T) { synctestTest(t, testTransportFlowControl) }
+func testTransportFlowControl(t testing.TB) {
+	const maxBuffer = 64 << 10 // 64KiB
+	tc := newTestClientConn(t, func(tr *http.Transport) {
+		tr.HTTP2 = &http.HTTP2Config{
+			MaxReceiveBufferPerConnection: maxBuffer,
+			MaxReceiveBufferPerStream:     maxBuffer,
+			MaxReadFrameSize:              16 << 20, // 16MiB
 		}
 	})
+	tc.greet()
 
-	tr := &Transport{TLSClientConfig: tlsConfigInsecure}
-	defer tr.CloseIdleConnections()
-	req, err := http.NewRequest("GET", ts.URL, nil)
-	if err != nil {
-		t.Fatal("NewRequest error:", err)
-	}
-	resp, err := tr.RoundTrip(req)
-	if err != nil {
-		t.Fatal("RoundTrip error:", err)
-	}
-	defer resp.Body.Close()
+	req, _ := http.NewRequest("GET", "https://dummy.tld/", nil)
+	rt := tc.roundTrip(req)
+	tc.wantFrameType(FrameHeaders)
+
+	tc.writeHeaders(HeadersFrameParam{
+		StreamID:   rt.streamID(),
+		EndHeaders: true,
+		EndStream:  false,
+		BlockFragment: tc.makeHeaderBlockFragment(
+			":status", "200",
+		),
+	})
+	rt.wantStatus(200)
 
-	var read int64
-	b := make([]byte, bufLen)
+	// Server fills up its transmit buffer.
+	// The client does not provide more flow control tokens,
+	// since the data hasn't been consumed by the user.
+	tc.writeData(rt.streamID(), false, make([]byte, maxBuffer))
+	tc.wantIdle()
+
+	// User reads data from the response body.
+	// The client sends more flow control tokens.
+	resp := rt.response()
+	if _, err := io.ReadFull(resp.Body, make([]byte, maxBuffer)); err != nil {
+		t.Fatalf("io.Body.Read: %v", err)
+	}
+	var connTokens, streamTokens uint32
 	for {
-		n, err := resp.Body.Read(b)
-		if err == io.EOF {
+		f := tc.readFrame()
+		if f == nil {
 			break
 		}
-		if err != nil {
-			t.Fatal("Read error:", err)
+		wu, ok := f.(*WindowUpdateFrame)
+		if !ok {
+			t.Fatalf("received unexpected frame %T (want WINDOW_UPDATE)", f)
 		}
-		read += int64(n)
-
-		const max = transportDefaultStreamFlow
-		if w := atomic.LoadInt64(&wrote); -max > read-w || read-w > max {
-			t.Fatalf("Too much data inflight: server wrote %v bytes but client only received %v", w, read)
+		switch wu.StreamID {
+		case 0:
+			connTokens += wu.Increment
+		case wu.StreamID:
+			streamTokens += wu.Increment
+		default:
+			t.Fatalf("received unexpected WINDOW_UPDATE for stream %v", wu.StreamID)
 		}
-
-		// Let the server get ahead of the client.
-		time.Sleep(1 * time.Millisecond)
+	}
+	if got, want := connTokens, uint32(maxBuffer); got != want {
+		t.Errorf("transport provided %v bytes of connection WINDOW_UPDATE, want %v", got, want)
+	}
+	if got, want := streamTokens, uint32(maxBuffer); got != want {
+		t.Errorf("transport provided %v bytes of stream WINDOW_UPDATE, want %v", got, want)
 	}
 }