clawbot
19f282c8b3
check / check (push) Successful in 6s
The timeout tests called newHTTPServer directly, so a Run that built its http.Server inline would drop every timeout with the suite still green. TestRunWiresSocketTimeouts wires a Server as cmd/dnswatcher does, minus the watcher and resolver so no live DNS is touched, drives Run with an unbindable port so it stores its http.Server and returns without listening, and checks that server carries all four timeouts and both required relationships. The addr/handler test, which could not fail, is dropped. The ReadTimeout note now says what net/http does: a request whose headers arrive after ReadTimeout but within ReadHeaderTimeout gets a read deadline that has already passed, so reading its body fails at once. Model: opus-4-8 (implementation); opus-5-5 (rework)
131 lines
3.5 KiB
Go
131 lines
3.5 KiB
Go
package server_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/spf13/viper"
|
|
"go.uber.org/fx"
|
|
|
|
"sneak.berlin/go/dnswatcher/internal/config"
|
|
"sneak.berlin/go/dnswatcher/internal/globals"
|
|
"sneak.berlin/go/dnswatcher/internal/handlers"
|
|
"sneak.berlin/go/dnswatcher/internal/healthcheck"
|
|
"sneak.berlin/go/dnswatcher/internal/logger"
|
|
"sneak.berlin/go/dnswatcher/internal/middleware"
|
|
"sneak.berlin/go/dnswatcher/internal/notify"
|
|
"sneak.berlin/go/dnswatcher/internal/server"
|
|
"sneak.berlin/go/dnswatcher/internal/state"
|
|
)
|
|
|
|
// buildServer wires a *server.Server exactly as cmd/dnswatcher does,
|
|
// minus the watcher/resolver subtree that would touch live DNS. fx
|
|
// builds the object graph but the lifecycle is never started, so no
|
|
// OnStart hook runs and nothing listens or resolves. The caller must
|
|
// first configure viper (config.New reads it), which is also why the
|
|
// caller cannot run in parallel.
|
|
func buildServer(t *testing.T) *server.Server {
|
|
t.Helper()
|
|
|
|
var srv *server.Server
|
|
|
|
app := fx.New(
|
|
fx.NopLogger,
|
|
fx.Provide(
|
|
globals.New,
|
|
logger.New,
|
|
config.New,
|
|
state.New,
|
|
healthcheck.New,
|
|
notify.New,
|
|
middleware.New,
|
|
handlers.New,
|
|
server.New,
|
|
),
|
|
fx.Populate(&srv),
|
|
)
|
|
|
|
err := app.Err()
|
|
if err != nil {
|
|
t.Fatalf("building server graph: %v", err)
|
|
}
|
|
|
|
return srv
|
|
}
|
|
|
|
// TestRunWiresSocketTimeouts pins that the http.Server the running
|
|
// server actually serves — the one Run builds and hands to
|
|
// ListenAndServe — carries every socket-level timeout, plus the two
|
|
// relationships the values must satisfy.
|
|
//
|
|
// Run is driven to completion with an unbindable port: it builds and
|
|
// stores s.httpServer, then ListenAndServe fails at once and Run
|
|
// returns without ever listening. The assertions run in the same
|
|
// goroutine after Run returns, so reading s.httpServer is free of any
|
|
// data race. Nothing here measures elapsed time.
|
|
//
|
|
// ReadTimeout must be at least ReadHeaderTimeout. net/http reads the
|
|
// headers under ReadHeaderTimeout, then sets the read deadline for the
|
|
// rest of the request to ReadTimeout, counted from when it started
|
|
// reading the request. If ReadTimeout were smaller, a request whose
|
|
// headers arrived after ReadTimeout but within ReadHeaderTimeout would
|
|
// get a read deadline that had already passed, so reading its body
|
|
// would fail at once.
|
|
func TestRunWiresSocketTimeouts(t *testing.T) {
|
|
// Sets an env var and touches viper global state, so like the
|
|
// config tests it cannot use t.Parallel.
|
|
viper.Reset()
|
|
t.Setenv("DNSWATCHER_TARGETS", "example.com")
|
|
|
|
srv := buildServer(t)
|
|
server.SetListenPort(srv, -1)
|
|
|
|
srv.Run()
|
|
|
|
hs := server.HTTPServerOf(srv)
|
|
if hs == nil {
|
|
t.Fatal("Run did not build an http.Server")
|
|
}
|
|
|
|
if hs.ReadTimeout <= 0 {
|
|
t.Errorf("ReadTimeout must be non-zero, got %v", hs.ReadTimeout)
|
|
}
|
|
|
|
if hs.ReadHeaderTimeout <= 0 {
|
|
t.Errorf(
|
|
"ReadHeaderTimeout must be non-zero, got %v",
|
|
hs.ReadHeaderTimeout,
|
|
)
|
|
}
|
|
|
|
if hs.WriteTimeout <= 0 {
|
|
t.Errorf("WriteTimeout must be non-zero, got %v", hs.WriteTimeout)
|
|
}
|
|
|
|
if hs.IdleTimeout <= 0 {
|
|
t.Errorf("IdleTimeout must be non-zero, got %v", hs.IdleTimeout)
|
|
}
|
|
|
|
if hs.WriteTimeout <= server.RequestTimeout {
|
|
t.Errorf(
|
|
"WriteTimeout (%v) must exceed handler budget (%v)",
|
|
hs.WriteTimeout,
|
|
server.RequestTimeout,
|
|
)
|
|
}
|
|
|
|
if hs.ReadTimeout < hs.ReadHeaderTimeout {
|
|
t.Errorf(
|
|
"ReadTimeout (%v) must be >= ReadHeaderTimeout (%v)",
|
|
hs.ReadTimeout,
|
|
hs.ReadHeaderTimeout,
|
|
)
|
|
}
|
|
|
|
if hs.Handler != srv {
|
|
t.Errorf(
|
|
"Run wired handler %T, want the *server.Server",
|
|
hs.Handler,
|
|
)
|
|
}
|
|
}
|