Let a handler flush or set a write deadline through the access log and metrics (closes #191)

The access log's response writer had no Unwrap method, so
http.ResponseController stopped at it and a handler's Flush or
SetWriteDeadline returned http.ErrNotSupported. It now has one.

With metrics on, the metrics library's std.Handler put a writer of its
own in the chain with the same gap. The Metrics middleware now calls
the library's Measure with a writer of ours that has Unwrap, and keeps
its place in the chain.

A new test sets a write deadline and flushes through the production
router over a real connection, with metrics off and on, on a global
route and in an admin page route group.

Model: opus-5-5

internal/server/response_controller_test.go

@@ -0,0 +1,109 @@
+package server_test
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/server"
+)
+
+// TestResponseControllerThroughProductionRouter sets a write deadline
+// and flushes through http.ResponseController, behind the shipped
+// router and over a real connection, and checks that both reach
+// net/http's own writer.
+//
+// Every middleware that wraps the writer has to let them through with
+// an Unwrap method. One that does not makes the call return
+// http.ErrNotSupported, or, if it has a Flush of its own that cannot
+// reach further in, makes the flush silently do nothing; either way
+// the handler that trips over it is far from the cause.
+//
+// It runs once with the defaults and once with metrics and Sentry on,
+// because those two add middleware to the chain, and through both the
+// global middleware and an admin page route group, which adds its own.
+func TestResponseControllerThroughProductionRouter(t *testing.T) {
+	t.Parallel()
+
+	// Without /metrics credentials, metricsConfig is the default
+	// Config.
+	cases := []struct {
+		name               string
+		username, password string
+		sentryEnabled      bool
+	}{
+		{name: "defaults"},
+		{
+			name:     "metrics and Sentry on",
+			username: metricsUser, password: metricsAuthValue,
+			sentryEnabled: true,
+		},
+	}
+
+	// The probe answers with what each call returned.
+	probe := func(w http.ResponseWriter, _ *http.Request) {
+		rc := http.NewResponseController(w)
+
+		deadlineErr := rc.SetWriteDeadline(time.Now().Add(time.Minute))
+		flushErr := rc.Flush()
+
+		_, _ = fmt.Fprintf(
+			w, "deadline: %v, flush: %v", deadlineErr, flushErr,
+		)
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			env := newTestEnvWithConfig(
+				t, metricsConfig(t, tc.username, tc.password),
+			)
+
+			routers := map[string]http.Handler{
+				server.ProbePattern: server.NewRouterWithProbeForTest(
+					env.log.Get(), env.cfg, env.mw, env.hnd,
+					tc.sentryEnabled, probe,
+				),
+				server.PageProbePattern: server.NewRouterWithPageProbeForTest(
+					env.log.Get(), env.cfg, env.mw, env.hnd,
+					tc.sentryEnabled, probe,
+				),
+			}
+
+			for path, router := range routers {
+				srv := httptest.NewServer(router)
+				t.Cleanup(srv.Close)
+
+				req, err := http.NewRequestWithContext(
+					t.Context(), http.MethodGet, srv.URL+path, nil,
+				)
+				require.NoError(t, err)
+
+				resp, err := srv.Client().Do(req)
+				require.NoError(t, err)
+
+				body, err := io.ReadAll(resp.Body)
+				require.NoError(t, err)
+				require.NoError(t, resp.Body.Close())
+
+				assert.Equal(
+					t, "deadline: <nil>, flush: <nil>", string(body), path,
+				)
+
+				// A response the server holds until the handler returns
+				// goes out with a Content-Length; one flushed while the
+				// handler is still running goes out in chunks.
+				assert.Equal(
+					t, []string{"chunked"}, resp.TransferEncoding,
+					"%s: the flush must reach the client", path,
+				)
+			}
+		})
+	}
+}