roundtrip: unit-test h2Body close-error propagation

Make h2Body.cc an io.Closer (a *http2.ClientConn in practice) so the
teardown precedence is unit-testable, and add TestH2Body_Close covering:
the cc error surfaces when body close succeeds, a body-close error takes
precedence, and the connection is closed exactly once.

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

Author: myleshorton

h2_test.go

@@ -3,6 +3,7 @@ package domainfront
 import (
 	stdtls "crypto/tls"
 	"crypto/x509"
+	"errors"
 	"io"
 	"log/slog"
 	"net"
@@ -103,6 +104,47 @@ func TestVerifyWithPost_HTTP2(t *testing.T) {
 	assert.Equal(t, http.MethodPost, <-gotMethod)
 }
 
+// errCloser is a test io.Closer that records call count and returns a fixed err.
+type errCloser struct {
+	err   error
+	calls int
+}
+
+func (c *errCloser) Close() error { c.calls++; return c.err }
+
+// TestH2Body_Close covers the connection-teardown semantics: the underlying h2
+// connection is closed exactly once, its error surfaces when the body close
+// itself succeeds, and a body-close error takes precedence.
+func TestH2Body_Close(t *testing.T) {
+	t.Run("propagates cc error when body close ok", func(t *testing.T) {
+		cc := &errCloser{err: assert.AnError}
+		b := &h2Body{ReadCloser: io.NopCloser(nil), cc: cc}
+		assert.Equal(t, assert.AnError, b.Close())
+		assert.Equal(t, 1, cc.calls)
+	})
+
+	t.Run("body error takes precedence over cc error", func(t *testing.T) {
+		bodyErr := errors.New("body boom")
+		cc := &errCloser{err: assert.AnError}
+		b := &h2Body{ReadCloser: errReadCloser{bodyErr}, cc: cc}
+		assert.Equal(t, bodyErr, b.Close())
+		assert.Equal(t, 1, cc.calls, "cc still closed even when body close fails")
+	})
+
+	t.Run("closes the connection only once", func(t *testing.T) {
+		cc := &errCloser{}
+		b := &h2Body{ReadCloser: io.NopCloser(nil), cc: cc}
+		assert.NoError(t, b.Close())
+		assert.NoError(t, b.Close())
+		assert.Equal(t, 1, cc.calls)
+	})
+}
+
+type errReadCloser struct{ err error }
+
+func (e errReadCloser) Read([]byte) (int, error) { return 0, e.err }
+func (e errReadCloser) Close() error             { return e.err }
+
 func TestHasConnectionUpgrade(t *testing.T) {
 	mk := func(vals ...string) *http.Request {
 		r, _ := http.NewRequest(http.MethodGet, "https://x/", nil)

roundtrip.go

@@ -167,10 +167,11 @@ func roundTripH2(conn net.Conn, req *http.Request) (*http.Response, error) {
 }
 
 // h2Body closes the underlying HTTP/2 connection when the response body is
-// closed, since each connection serves exactly one request.
+// closed, since each connection serves exactly one request. cc is an io.Closer
+// (a *http2.ClientConn in practice) so the teardown logic stays unit-testable.
 type h2Body struct {
 	io.ReadCloser
-	cc   *http2.ClientConn
+	cc   io.Closer
 	once sync.Once
 }