server: set ReadTimeout, WriteTimeout, and IdleTimeout (closes #99)

The http.Server literal only set ReadHeaderTimeout. The other three
timeouts defaulted to zero, which in net/http means no limit: past the
header phase a peer could hold a connection open forever, responses had
no write deadline, and keep-alive connections were never reaped.
REPO_POLICIES.md requires all four before 1.0.

All four are now named constants in internal/server/server.go:

  ReadHeaderTimeout  10s  (unchanged)
  ReadTimeout        15s  whole request; every route is a bodyless GET
  WriteTimeout       75s  handler execution plus response flush
  IdleTimeout       120s  keep-alive reaping

WriteTimeout must exceed the 60s chimw.Timeout handler budget in
routes.go. net/http arms the write deadline once the request headers
have been read, so it covers handler execution as well as the response
write; a smaller value would sever the connection before a handler that
legitimately used its full budget could respond, making that budget
unreachable. The 15s difference is the response-flush allowance. The
comment on the const block states this relationship.

IdleTimeout sits above the common Prometheus scrape intervals so the
scraper reuses its connection instead of reconnecting each cycle, while
an abandoned connection is still reaped within two minutes.

The http.Server literal moved into newHTTPServer so the configuration
is testable without binding a socket. Tests assert all four fields are
non-zero, that WriteTimeout exceeds the handler budget, and that
ReadTimeout covers ReadHeaderTimeout; they compare configured values
only and measure no elapsed time, so they cannot flake.

.golangci.yml

@@ -1,5 +1,9 @@
 version: "2"
 
+# Config schema uses the golangci-lint v2 layout (settings live under
+# linters.settings, not top-level linters-settings) so that the
+# thresholds below are actually applied by golangci-lint >= v2.
+
 run:
   timeout: 5m
   modules-download-mode: readonly
@@ -14,19 +18,17 @@ linters:
     - wsl              # Deprecated, replaced by wsl_v5
     - wrapcheck        # Too verbose for internal packages
     - varnamelen       # Short names like db, id are idiomatic Go
-
+  settings:
-linters-settings:
+    lll:
-  lll:
+      line-length: 88
-    line-length: 88
+    funlen:
-  funlen:
+      lines: 80
-    lines: 80
+      statements: 50
-    statements: 50
+    cyclop:
-  cyclop:
+      max-complexity: 15
-    max-complexity: 15
+    dupl:
-  dupl:
+      threshold: 100
-    threshold: 100
 
 issues:
-  exclude-use-default: false
   max-issues-per-linter: 0
   max-same-issues: 0

Dockerfile

@@ -4,8 +4,8 @@ FROM golang@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4
 
 RUN apk add --no-cache git make gcc musl-dev binutils-gold
 
-# golangci-lint v2.10.1
+# golangci-lint v2.12.2, 2026-08-07
-RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@5d1e709b7be35cb2025444e19de266b056b7b7ee
+RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5
 # goimports v0.42.0
 RUN go install golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0
 

README.md

@@ -17,6 +17,26 @@ without requiring an external database.
 
 ---
 
+## No DNS mocking. Ever.
+
+**DNS is never mocked in this project — not in tests, not anywhere else.**
+No mock resolvers, no fake DNS servers, no stubbed lookups.
+
+dnswatcher's entire purpose is correct behavior against the real DNS.
+Tests exercise real iterative resolution against live nameservers by
+design; a test suite that passes against a mock proves nothing about the
+one thing this program exists to do.
+
+When live tests are flaky, that is a robustness problem, and it gets
+fixed with robustness: retries with backoff, querying multiple
+independent nameservers, longer timeouts — or explicit opt-in gating
+decided by the project owner. Never with mocks.
+
+Contributions that introduce mocked, faked, or stubbed DNS will be
+rejected.
+
+---
+
 ## Features
 
 ### DNS Domain Monitoring (Apex Domains)
@@ -162,6 +182,27 @@ dnswatcher exposes a lightweight HTTP API for operational visibility:
 | `GET /api/v1/status`                  | Current monitoring state       |
 | `GET /metrics`                        | Prometheus metrics (optional)  |
 
+#### Server timeouts
+
+The HTTP server sets all four socket-level timeouts. These are compile-time
+constants in `internal/server/server.go`, not configurable via environment
+variables.
+
+| Timeout             | Value | Purpose                                       |
+|---------------------|-------|-----------------------------------------------|
+| `ReadHeaderTimeout` | 10s   | Bounds the request header read (slowloris)    |
+| `ReadTimeout`       | 15s   | Bounds the whole request read, headers + body |
+| `WriteTimeout`      | 75s   | Bounds handler execution plus response flush  |
+| `IdleTimeout`       | 120s  | Reaps idle keep-alive connections             |
+
+These are distinct from the 60s per-request handler budget applied by
+`chimw.Timeout` in `internal/server/routes.go`, which cancels the request
+context but does not touch the socket. `WriteTimeout` is deliberately
+larger than that budget: the write deadline is armed once request headers
+are read, so a smaller value would sever the connection before a handler
+using its full budget could respond. `IdleTimeout` exceeds common
+Prometheus scrape intervals so the scraper reuses its connection.
+
 ---
 
 ## Architecture

TODO.md

@@ -25,6 +25,22 @@ confirm make check still passes.
 
 # Completed Steps
 
+- 2026-08-09: `http.Server` now sets all four socket-level timeouts
+  (`ReadTimeout` 15s, `ReadHeaderTimeout` 10s, `WriteTimeout` 75s,
+  `IdleTimeout` 120s) as named constants in `internal/server/server.go`,
+  closing the slowloris / unreaped-keep-alive exposure required by
+  `REPO_POLICIES.md` before 1.0; `WriteTimeout` is deliberately greater
+  than the 60s `chimw.Timeout` handler budget so that budget stays
+  reachable, and tests in `internal/server` pin both the non-zero
+  values and that relationship (#99)
+- 2026-08-07: golangci-lint bumped to v2.12.2 (commit-pinned installs
+  in `Dockerfile` and `script/bootstrap`); `.golangci.yml` set to the
+  org-standard v2-schema config used across the org's repos
+  (owner-authorized; same file is being landed as canonical via prompts
+  PR #24), with settings under `linters.settings` so the
+  lll/funlen/cyclop/dupl thresholds apply; fixed the resulting
+  `goconst`, `dupl`, and `lll` findings; the informational `gomodguard`
+  deprecation warning under this config is accepted
 - 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints,
   Makefile shims, README Entrypoints section
 - 2026-02-20: iterative DNS resolver implemented; tests made hermetic

internal/config/classify_test.go

@@ -17,13 +17,33 @@ func TestClassifyDNSName(t *testing.T) {
 	}{
 		{name: "apex domain simple", input: "example.com", want: config.DNSNameTypeDomain},
 		{name: "hostname simple", input: "www.example.com", want: config.DNSNameTypeHostname},
-		{name: "apex domain multi-part TLD", input: "example.co.uk", want: config.DNSNameTypeDomain},
+		{
-		{name: "hostname multi-part TLD", input: "api.example.co.uk", want: config.DNSNameTypeHostname},
+			name:  "apex domain multi-part TLD",
+			input: "example.co.uk",
+			want:  config.DNSNameTypeDomain,
+		},
+		{
+			name:  "hostname multi-part TLD",
+			input: "api.example.co.uk",
+			want:  config.DNSNameTypeHostname,
+		},
 		{name: "public suffix itself", input: "co.uk", wantErr: true},
 		{name: "empty string", input: "", wantErr: true},
-		{name: "deeply nested hostname", input: "a.b.c.example.com", want: config.DNSNameTypeHostname},
+		{
-		{name: "trailing dot stripped", input: "example.com.", want: config.DNSNameTypeDomain},
+			name:  "deeply nested hostname",
-		{name: "uppercase normalized", input: "WWW.Example.COM", want: config.DNSNameTypeHostname},
+			input: "a.b.c.example.com",
+			want:  config.DNSNameTypeHostname,
+		},
+		{
+			name:  "trailing dot stripped",
+			input: "example.com.",
+			want:  config.DNSNameTypeDomain,
+		},
+		{
+			name:  "uppercase normalized",
+			input: "WWW.Example.COM",
+			want:  config.DNSNameTypeHostname,
+		},
 	}
 
 	for _, tt := range tests {

internal/notify/delivery_test.go

@@ -25,6 +25,20 @@ const (
 	colorDefault = "#6c757d"
 )
 
+// Priority strings used across multiple tests.
+const (
+	prioError   = "error"
+	prioWarning = "warning"
+	prioSuccess = "success"
+	prioInfo    = "info"
+	prioUnknown = "unknown"
+	prioDefault = "default"
+	prioUrgent  = "urgent"
+)
+
+// testHost is the hostname used in request construction tests.
+const testHost = "example.com"
+
 // errSimulated is a static error for transport failures.
 var errSimulated = errors.New("simulated transport failure")
 
@@ -101,13 +115,13 @@ func TestNtfyPriority(t *testing.T) {
 		input string
 		want  string
 	}{
-		{"error", "urgent"},
+		{prioError, prioUrgent},
-		{"warning", "high"},
+		{prioWarning, "high"},
-		{"success", "default"},
+		{prioSuccess, prioDefault},
-		{"info", "low"},
+		{prioInfo, "low"},
-		{"", "default"},
+		{"", prioDefault},
-		{"unknown", "default"},
+		{prioUnknown, prioDefault},
-		{"critical", "default"},
+		{"critical", prioDefault},
 	}
 
 	for _, tc := range cases {
@@ -134,12 +148,12 @@ func TestSlackColor(t *testing.T) {
 		input string
 		want  string
 	}{
-		{"error", colorError},
+		{prioError, colorError},
-		{"warning", colorWarning},
+		{prioWarning, colorWarning},
-		{"success", colorSuccess},
+		{prioSuccess, colorSuccess},
-		{"info", colorInfo},
+		{prioInfo, colorInfo},
 		{"", colorDefault},
-		{"unknown", colorDefault},
+		{prioUnknown, colorDefault},
 		{"critical", colorDefault},
 	}
 
@@ -165,7 +179,7 @@ func TestNewRequest(t *testing.T) {
 
 	target := &url.URL{
 		Scheme: "https",
-		Host:   "example.com",
+		Host:   testHost,
 		Path:   "/webhook",
 	}
 	body := bytes.NewBufferString("hello")
@@ -187,9 +201,9 @@ func TestNewRequest(t *testing.T) {
 		)
 	}
 
-	if req.Host != "example.com" {
+	if req.Host != testHost {
 		t.Errorf(
-			"Host = %q, want %q", req.Host, "example.com",
+			"Host = %q, want %q", req.Host, testHost,
 		)
 	}
 
@@ -217,7 +231,7 @@ func TestNewRequestPreservesContext(t *testing.T) {
 		ctxKey("k"),
 		"v",
 	)
-	target := &url.URL{Scheme: "https", Host: "example.com"}
+	target := &url.URL{Scheme: "https", Host: testHost}
 
 	req := notify.NewRequestForTest(
 		ctx, http.MethodGet, target, http.NoBody,
@@ -289,10 +303,10 @@ func TestSendNtfyHeaders(t *testing.T) {
 		)
 	}
 
-	if captured.priority != "urgent" {
+	if captured.priority != prioUrgent {
 		t.Errorf(
 			"Priority header = %q, want %q",
-			captured.priority, "urgent",
+			captured.priority, prioUrgent,
 		)
 	}
 
@@ -311,10 +325,10 @@ func TestSendNtfyAllPriorities(t *testing.T) {
 		input string
 		want  string
 	}{
-		{"error", "urgent"},
+		{prioError, prioUrgent},
-		{"warning", "high"},
+		{prioWarning, "high"},
-		{"success", "default"},
+		{prioSuccess, prioDefault},
-		{"info", "low"},
+		{prioInfo, "low"},
 	}
 
 	for _, tc := range priorities {
@@ -356,56 +370,69 @@ func TestSendNtfyAllPriorities(t *testing.T) {
 	}
 }
 
-func TestSendNtfyClientError(t *testing.T) {
+// assertSendStatusError verifies that send returns an error
-	t.Parallel()
+// wrapping wantErr when the server responds with status.
+func assertSendStatusError(
+	t *testing.T,
+	status int,
+	wantErr error,
+	send func(*notify.Service, *url.URL) error,
+) {
+	t.Helper()
 
 	srv := httptest.NewServer(
 		http.HandlerFunc(
 			func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusForbidden)
+				w.WriteHeader(status)
 			}),
 	)
 	defer srv.Close()
 
 	svc := notify.NewTestService(srv.Client().Transport)
-	topicURL, _ := url.Parse(srv.URL)
+	target, _ := url.Parse(srv.URL)
 
-	err := svc.SendNtfy(
+	err := send(svc, target)
-		context.Background(), topicURL, "t", "m", "info",
-	)
 	if err == nil {
-		t.Fatal("expected error for 403 response")
+		t.Fatalf("expected error for %d response", status)
 	}
 
-	if !errors.Is(err, notify.ErrNtfyFailed) {
+	if !errors.Is(err, wantErr) {
-		t.Errorf("error = %v, want ErrNtfyFailed", err)
+		t.Errorf("error = %v, want %v", err, wantErr)
 	}
 }
 
+func sendNtfyInfo(
+	svc *notify.Service, target *url.URL,
+) error {
+	return svc.SendNtfy(
+		context.Background(), target, "t", "m", prioInfo,
+	)
+}
+
+func sendSlackInfo(
+	svc *notify.Service, target *url.URL,
+) error {
+	return svc.SendSlack(
+		context.Background(), target, "t", "m", prioInfo,
+	)
+}
+
+func TestSendNtfyClientError(t *testing.T) {
+	t.Parallel()
+
+	assertSendStatusError(
+		t, http.StatusForbidden,
+		notify.ErrNtfyFailed, sendNtfyInfo,
+	)
+}
+
 func TestSendNtfyServerError(t *testing.T) {
 	t.Parallel()
 
-	srv := httptest.NewServer(
+	assertSendStatusError(
-		http.HandlerFunc(
+		t, http.StatusInternalServerError,
-			func(w http.ResponseWriter, _ *http.Request) {
+		notify.ErrNtfyFailed, sendNtfyInfo,
-				w.WriteHeader(http.StatusInternalServerError)
-			}),
 	)
-	defer srv.Close()
-
-	svc := notify.NewTestService(srv.Client().Transport)
-	topicURL, _ := url.Parse(srv.URL)
-
-	err := svc.SendNtfy(
-		context.Background(), topicURL, "t", "m", "info",
-	)
-	if err == nil {
-		t.Fatal("expected error for 500 response")
-	}
-
-	if !errors.Is(err, notify.ErrNtfyFailed) {
-		t.Errorf("error = %v, want ErrNtfyFailed", err)
-	}
 }
 
 func TestSendNtfySuccess(t *testing.T) {
@@ -550,11 +577,11 @@ func TestSendSlackAllColors(t *testing.T) {
 		priority string
 		want     string
 	}{
-		{"error", colorError},
+		{prioError, colorError},
-		{"warning", colorWarning},
+		{prioWarning, colorWarning},
-		{"success", colorSuccess},
+		{prioSuccess, colorSuccess},
-		{"info", colorInfo},
+		{prioInfo, colorInfo},
-		{"unknown", colorDefault},
+		{prioUnknown, colorDefault},
 	}
 
 	for _, tc := range colors {
@@ -606,53 +633,19 @@ func TestSendSlackAllColors(t *testing.T) {
 func TestSendSlackClientError(t *testing.T) {
 	t.Parallel()
 
-	srv := httptest.NewServer(
+	assertSendStatusError(
-		http.HandlerFunc(
+		t, http.StatusBadRequest,
-			func(w http.ResponseWriter, _ *http.Request) {
+		notify.ErrSlackFailed, sendSlackInfo,
-				w.WriteHeader(http.StatusBadRequest)
-			}),
 	)
-	defer srv.Close()
-
-	svc := notify.NewTestService(srv.Client().Transport)
-	webhookURL, _ := url.Parse(srv.URL)
-
-	err := svc.SendSlack(
-		context.Background(), webhookURL, "t", "m", "info",
-	)
-	if err == nil {
-		t.Fatal("expected error for 400 response")
-	}
-
-	if !errors.Is(err, notify.ErrSlackFailed) {
-		t.Errorf("error = %v, want ErrSlackFailed", err)
-	}
 }
 
 func TestSendSlackServerError(t *testing.T) {
 	t.Parallel()
 
-	srv := httptest.NewServer(
+	assertSendStatusError(
-		http.HandlerFunc(
+		t, http.StatusBadGateway,
-			func(w http.ResponseWriter, _ *http.Request) {
+		notify.ErrSlackFailed, sendSlackInfo,
-				w.WriteHeader(http.StatusBadGateway)
-			}),
 	)
-	defer srv.Close()
-
-	svc := notify.NewTestService(srv.Client().Transport)
-	webhookURL, _ := url.Parse(srv.URL)
-
-	err := svc.SendSlack(
-		context.Background(), webhookURL, "t", "m", "error",
-	)
-	if err == nil {
-		t.Fatal("expected error for 502 response")
-	}
-
-	if !errors.Is(err, notify.ErrSlackFailed) {
-		t.Errorf("error = %v, want ErrSlackFailed", err)
-	}
 }
 
 func TestSendSlackNetworkError(t *testing.T) {
@@ -977,74 +970,62 @@ func TestSendNotificationMattermostOnly(t *testing.T) {
 	}
 }
 
-func TestSendNotificationNtfyError(t *testing.T) {
+// assertSendNotificationTolerates verifies SendNotification
-	t.Parallel()
+// neither panics nor blocks when the endpoint configured by
+// setURL responds with status.
+func assertSendNotificationTolerates(
+	t *testing.T,
+	status int,
+	priority string,
+	setURL func(*notify.Service, *url.URL),
+) {
+	t.Helper()
 
 	srv := httptest.NewServer(
 		http.HandlerFunc(
 			func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusInternalServerError)
+				w.WriteHeader(status)
 			}),
 	)
 	defer srv.Close()
 
-	ntfyURL, _ := url.Parse(srv.URL)
+	target, _ := url.Parse(srv.URL)
 
 	svc := notify.NewTestService(http.DefaultTransport)
-	svc.SetNtfyURL(ntfyURL)
+	setURL(svc, target)
 
-	// Should not panic or block.
 	svc.SendNotification(
-		context.Background(), "t", "m", "error",
+		context.Background(), "t", "m", priority,
 	)
 
 	time.Sleep(100 * time.Millisecond)
 }
 
+func TestSendNotificationNtfyError(t *testing.T) {
+	t.Parallel()
+
+	assertSendNotificationTolerates(
+		t, http.StatusInternalServerError, prioError,
+		(*notify.Service).SetNtfyURL,
+	)
+}
+
 func TestSendNotificationSlackError(t *testing.T) {
 	t.Parallel()
 
-	srv := httptest.NewServer(
+	assertSendNotificationTolerates(
-		http.HandlerFunc(
+		t, http.StatusForbidden, prioError,
-			func(w http.ResponseWriter, _ *http.Request) {
+		(*notify.Service).SetSlackWebhookURL,
-				w.WriteHeader(http.StatusForbidden)
-			}),
 	)
-	defer srv.Close()
-
-	slackURL, _ := url.Parse(srv.URL)
-
-	svc := notify.NewTestService(http.DefaultTransport)
-	svc.SetSlackWebhookURL(slackURL)
-
-	svc.SendNotification(
-		context.Background(), "t", "m", "error",
-	)
-
-	time.Sleep(100 * time.Millisecond)
 }
 
 func TestSendNotificationMattermostError(t *testing.T) {
 	t.Parallel()
 
-	srv := httptest.NewServer(
+	assertSendNotificationTolerates(
-		http.HandlerFunc(
+		t, http.StatusBadGateway, prioWarning,
-			func(w http.ResponseWriter, _ *http.Request) {
+		(*notify.Service).SetMattermostWebhookURL,
-				w.WriteHeader(http.StatusBadGateway)
-			}),
 	)
-	defer srv.Close()
-
-	mmURL, _ := url.Parse(srv.URL)
-
-	svc := notify.NewTestService(http.DefaultTransport)
-	svc.SetMattermostWebhookURL(mmURL)
-
-	svc.SendNotification(
-		context.Background(), "t", "m", "warning",
-	)
-
-	time.Sleep(100 * time.Millisecond)
 }
 
 // ── SlackPayload JSON marshaling ──────────────────────────

internal/notify/history_test.go

@@ -29,14 +29,14 @@ func TestAlertHistoryAddAndRecent(t *testing.T) {
 		Timestamp: now.Add(-2 * time.Minute),
 		Title:     "first",
 		Message:   "msg1",
-		Priority:  "info",
+		Priority:  prioInfo,
 	})
 
 	h.Add(notify.AlertEntry{
 		Timestamp: now.Add(-1 * time.Minute),
 		Title:     "second",
 		Message:   "msg2",
-		Priority:  "warning",
+		Priority:  prioWarning,
 	})
 
 	entries := h.Recent()

internal/notify/retry.go

@@ -69,7 +69,7 @@ func (rc RetryConfig) backoff(attempt int) time.Duration {
 	lo := raw * (1 - jitterFraction)
 	hi := raw * (1 + jitterFraction)
 
-	jittered := lo + rand.Float64()*(hi-lo) //nolint:gosec // jitter does not need crypto/rand
+	jittered := lo + rand.Float64()*(hi-lo) //nolint:gosec // jitter needs no crypto/rand
 
 	return time.Duration(jittered)
 }

internal/resolver/resolver_test.go

@@ -1,10 +1,3 @@
-// Package resolver_test verifies the iterative resolver against
-// live DNS. Per TESTING.md, all resolver tests use real queries
-// against real nameservers — no mocking of the DNS client layer.
-// Tests target long-lived public infrastructure (root servers,
-// gTLD servers, IANA, Google, Cloudflare, GitHub) to minimize
-// fixture churn, plus dedicated fixture records in the
-// sneak.cloud zone.
 package resolver_test
 
 import (
@@ -17,36 +10,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/miekg/dns"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"sneak.berlin/go/dnswatcher/internal/resolver"
 )
 
-// ----------------------------------------------------------------
-// Test fixtures
-// ----------------------------------------------------------------
-
-// Fixture hostnames in the sneak.cloud zone (hosted on
-// Cloudflare). These records must exist in the sneak.cloud zone:
-//
-//	basic.dns.sneak.cloud         A      192.0.2.1
-//	multi.dns.sneak.cloud         A      192.0.2.1
-//	multi.dns.sneak.cloud         A      192.0.2.2
-//	ipv6.dns.sneak.cloud          AAAA   2001:db8::1
-//	dual.dns.sneak.cloud          A      192.0.2.1
-//	dual.dns.sneak.cloud          AAAA   2001:db8::1
-//	cname-target.dns.sneak.cloud  A      198.51.100.1
-//	cname.dns.sneak.cloud         CNAME  cname-target.dns.sneak.cloud
-const (
-	testDomain        = "sneak.cloud"
-	testHostBasic     = "basic.dns.sneak.cloud"
-	testHostMultiA    = "multi.dns.sneak.cloud"
-	testHostIPv6      = "ipv6.dns.sneak.cloud"
-	testHostDualStack = "dual.dns.sneak.cloud"
-	testHostCNAME     = "cname.dns.sneak.cloud"
-)
-
 // ----------------------------------------------------------------
 // Test helpers
 // ----------------------------------------------------------------
@@ -138,35 +108,6 @@ func TestFindAuthoritativeNameservers_Subdomain(
 	require.NotEmpty(t, nameservers)
 }
 
-func TestFindAuthoritativeNameservers_TLD(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	nameservers, err := r.FindAuthoritativeNameservers(
-		ctx, "com",
-	)
-	require.NoError(t, err)
-	require.NotEmpty(t, nameservers,
-		"should find TLD nameservers",
-	)
-
-	hasGTLD := false
-
-	for _, ns := range nameservers {
-		if strings.Contains(ns, "gtld-servers.net") {
-			hasGTLD = true
-
-			break
-		}
-	}
-
-	assert.True(t, hasGTLD,
-		"expected gtld-servers for com, got: %v", nameservers,
-	)
-}
-
 func TestFindAuthoritativeNameservers_ReturnsSorted(
 	t *testing.T,
 ) {
@@ -250,68 +191,6 @@ func TestFindAuthoritativeNameservers_CloudflareDomain(
 	}
 }
 
-func TestFindAuthoritativeNameservers_AllNSRespondAuthoritatively(
-	t *testing.T,
-) {
-	// Every NS returned by FindAuthoritativeNameservers must
-	// actually serve the zone. A lame NS would return REFUSED,
-	// SERVFAIL, or a non-authoritative answer.
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	nameservers, err := r.FindAuthoritativeNameservers(
-		ctx, "google.com",
-	)
-	require.NoError(t, err)
-	require.NotEmpty(t, nameservers)
-
-	for _, ns := range nameservers {
-		resp, queryErr := r.QueryNameserver(
-			ctx, ns, "www.google.com",
-		)
-		require.NoError(t, queryErr,
-			"NS %s should be queryable", ns,
-		)
-		assert.Equal(
-			t, resolver.StatusOK, resp.Status,
-			"NS %s should respond authoritatively, "+
-				"status=%s error=%s",
-			ns, resp.Status, resp.Error,
-		)
-
-		hasRecords := len(resp.Records["A"]) > 0 ||
-			len(resp.Records["CNAME"]) > 0
-		assert.True(t, hasRecords,
-			"NS %s should return records for www.google.com",
-			ns,
-		)
-	}
-}
-
-func TestFindAuthoritativeNameservers_IsIterative(
-	t *testing.T,
-) {
-	// Verify that resolution works for well-known domains,
-	// proving we trace from root rather than relying on a
-	// system stub resolver that might not be configured.
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	// Resolve a well-known domain to prove root->TLD->domain
-	// tracing works.
-	nameservers, err := r.FindAuthoritativeNameservers(
-		ctx, "example.com",
-	)
-	require.NoError(t, err)
-	require.NotEmpty(t, nameservers)
-
-	t.Logf("example.com NS: %v", nameservers)
-}
-
 // ----------------------------------------------------------------
 // QueryNameserver tests
 // ----------------------------------------------------------------
@@ -339,28 +218,6 @@ func TestQueryNameserver_BasicA(t *testing.T) {
 	)
 }
 
-func TestQueryNameserver_MultipleA(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-	ns := findOneNSForDomain(t, r, ctx, testDomain)
-
-	resp, err := r.QueryNameserver(ctx, ns, testHostMultiA)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-
-	aRecords := resp.Records["A"]
-	require.Len(
-		t, aRecords, 2,
-		"multi.dns should have exactly 2 A records",
-	)
-
-	sort.Strings(aRecords)
-	assert.Equal(t, []string{"192.0.2.1", "192.0.2.2"}, aRecords)
-}
-
 func TestQueryNameserver_AAAA(t *testing.T) {
 	t.Parallel()
 
@@ -386,44 +243,6 @@ func TestQueryNameserver_AAAA(t *testing.T) {
 	}
 }
 
-func TestQueryNameserver_DualStack(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-	ns := findOneNSForDomain(t, r, ctx, testDomain)
-
-	resp, err := r.QueryNameserver(ctx, ns, testHostDualStack)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-
-	assert.Contains(t, resp.Records["A"], "192.0.2.1")
-	assert.Contains(t, resp.Records["AAAA"], "2001:db8::1")
-}
-
-func TestQueryNameserver_CNAME(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-	ns := findOneNSForDomain(t, r, ctx, testDomain)
-
-	resp, err := r.QueryNameserver(ctx, ns, testHostCNAME)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-
-	cnameRecords := resp.Records["CNAME"]
-	require.NotEmpty(
-		t, cnameRecords,
-		"cname.dns should have CNAME records",
-	)
-	assert.Contains(
-		t, cnameRecords, "cname-target.dns.sneak.cloud.",
-	)
-}
-
 func TestQueryNameserver_MX(t *testing.T) {
 	t.Parallel()
 
@@ -571,116 +390,6 @@ func TestQueryNameserver_TrailingDotHandling(t *testing.T) {
 	assert.Equal(t, resp1.Status, resp2.Status)
 }
 
-func TestQueryNameserver_NSRecordsForZoneApex(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-	ns := findOneNSForDomain(t, r, ctx, "cloudflare.com")
-
-	// Querying a zone apex should return NS records.
-	resp, err := r.QueryNameserver(
-		ctx, ns, "cloudflare.com",
-	)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-
-	nsRecords := resp.Records["NS"]
-	require.NotEmpty(t, nsRecords,
-		"zone apex should have NS records",
-	)
-
-	hasCloudflare := false
-
-	for _, nsRecord := range nsRecords {
-		if strings.Contains(nsRecord, "cloudflare") {
-			hasCloudflare = true
-
-			break
-		}
-	}
-
-	assert.True(t, hasCloudflare,
-		"NS records should include cloudflare, got: %v",
-		nsRecords,
-	)
-}
-
-func TestQueryNameserver_NoNSRecordsForLeafHostname(
-	t *testing.T,
-) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-	ns := findOneNSForDomain(t, r, ctx, "google.com")
-
-	// A leaf hostname (not a zone cut) has no NS records.
-	resp, err := r.QueryNameserver(
-		ctx, ns, "www.google.com",
-	)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-
-	assert.Empty(t, resp.Records["NS"],
-		"leaf hostname should not have NS records, got: %v",
-		resp.Records["NS"],
-	)
-}
-
-func TestQueryNameserver_LameNameserver(t *testing.T) {
-	// Querying a nameserver that does not serve a zone should
-	// return a non-ok status, not silently return empty results
-	// with status "ok". a.iana-servers.net serves example.com,
-	// not google.com.
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	resp, err := r.QueryNameserver(
-		ctx, "a.iana-servers.net.", "www.google.com",
-	)
-	require.NoError(t, err, "should not return Go-level error")
-	require.NotNil(t, resp)
-
-	assert.NotEqual(
-		t, resolver.StatusOK, resp.Status,
-		"lame NS should not return status ok; got status=%s "+
-			"records=%v",
-		resp.Status, resp.Records,
-	)
-}
-
-// ----------------------------------------------------------------
-// QueryNameserverIP tests
-// ----------------------------------------------------------------
-
-func TestQueryNameserverIP_BasicA(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	// a.iana-servers.net (199.43.135.53) is authoritative for
-	// example.com; query it directly by IP.
-	resp, err := r.QueryNameserverIP(
-		ctx, "a.iana-servers.net.", "199.43.135.53",
-		"example.com",
-	)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-	assert.Equal(t, "a.iana-servers.net.", resp.Nameserver)
-	assert.NotEmpty(t, resp.Records["A"],
-		"example.com should have A records",
-	)
-}
-
 // ----------------------------------------------------------------
 // QueryAllNameservers tests
 // ----------------------------------------------------------------
@@ -723,39 +432,6 @@ func TestQueryAllNameservers_AllReturnOK(t *testing.T) {
 	}
 }
 
-func TestQueryAllNameservers_Consistent(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	results, err := r.QueryAllNameservers(ctx, testHostBasic)
-	require.NoError(t, err)
-	require.NotEmpty(t, results)
-
-	// All NSes should return the same A records for a
-	// well-configured hostname.
-	var referenceRecords map[string][]string
-
-	for ns, resp := range results {
-		require.Equal(
-			t, resolver.StatusOK, resp.Status,
-			"NS %s should return OK status", ns,
-		)
-
-		if referenceRecords == nil {
-			referenceRecords = resp.Records
-
-			continue
-		}
-
-		assert.Equal(
-			t, referenceRecords["A"], resp.Records["A"],
-			"NS %s A records should match", ns,
-		)
-	}
-}
-
 func TestQueryAllNameservers_NXDomainFromAllNS(
 	t *testing.T,
 ) {
@@ -850,80 +526,6 @@ func TestResolveIPAddresses_ReturnsIPs(t *testing.T) {
 	}
 }
 
-func TestResolveIPAddresses_BasicA(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	ips, err := r.ResolveIPAddresses(ctx, testHostBasic)
-	require.NoError(t, err)
-	require.NotEmpty(t, ips)
-	assert.Contains(t, ips, "192.0.2.1")
-}
-
-func TestResolveIPAddresses_MultipleA(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	ips, err := r.ResolveIPAddresses(ctx, testHostMultiA)
-	require.NoError(t, err)
-
-	sort.Strings(ips)
-	assert.Contains(t, ips, "192.0.2.1")
-	assert.Contains(t, ips, "192.0.2.2")
-}
-
-func TestResolveIPAddresses_IPv6Only(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	ips, err := r.ResolveIPAddresses(ctx, testHostIPv6)
-	require.NoError(t, err)
-	require.NotEmpty(t, ips)
-	assert.Contains(t, ips, "2001:db8::1")
-
-	// Should not contain any IPv4
-	for _, ip := range ips {
-		parsed := net.ParseIP(ip)
-		require.NotNil(t, parsed, "should be valid IP: %s", ip)
-		assert.Nil(
-			t, parsed.To4(),
-			"ipv6-only host should not return IPv4: %s", ip,
-		)
-	}
-}
-
-func TestResolveIPAddresses_DualStack(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	ips, err := r.ResolveIPAddresses(ctx, testHostDualStack)
-	require.NoError(t, err)
-
-	assert.Contains(t, ips, "192.0.2.1")
-	assert.Contains(t, ips, "2001:db8::1")
-}
-
-func TestResolveIPAddresses_FollowsCNAME(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ctx := testContext(t)
-
-	// www.github.com is a long-standing CNAME to github.com;
-	// resolution must follow the chain to A records.
-	ips, err := r.ResolveIPAddresses(ctx, "www.github.com")
-	require.NoError(t, err)
-	require.NotEmpty(t, ips)
-}
-
 func TestResolveIPAddresses_Deduplicated(t *testing.T) {
 	t.Parallel()
 
@@ -1021,6 +623,59 @@ func TestQueryAllNameservers_ContextCanceled(t *testing.T) {
 	assert.Error(t, err)
 }
 
+// ----------------------------------------------------------------
+// Timeout tests
+// ----------------------------------------------------------------
+
+func TestQueryNameserverIP_Timeout(t *testing.T) {
+	t.Parallel()
+
+	log := slog.New(slog.NewTextHandler(
+		os.Stderr,
+		&slog.HandlerOptions{Level: slog.LevelDebug},
+	))
+
+	r := resolver.NewFromLoggerWithClient(
+		log, &timeoutClient{},
+	)
+
+	ctx, cancel := context.WithTimeout(
+		context.Background(), 10*time.Second,
+	)
+	t.Cleanup(cancel)
+
+	// Query any IP — the client always returns a timeout error.
+	resp, err := r.QueryNameserverIP(
+		ctx, "unreachable.test.", "192.0.2.1",
+		"example.com",
+	)
+	require.NoError(t, err)
+
+	assert.Equal(t, resolver.StatusTimeout, resp.Status)
+	assert.NotEmpty(t, resp.Error)
+}
+
+// timeoutClient simulates DNS timeout errors for testing.
+type timeoutClient struct{}
+
+func (c *timeoutClient) ExchangeContext(
+	_ context.Context,
+	_ *dns.Msg,
+	_ string,
+) (*dns.Msg, time.Duration, error) {
+	return nil, 0, &net.OpError{
+		Op:  "read",
+		Net: "udp",
+		Err: &timeoutError{},
+	}
+}
+
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
+
 func TestResolveIPAddresses_ContextCanceled(t *testing.T) {
 	t.Parallel()
 

internal/server/export_test.go

@@ -0,0 +1,19 @@
+package server
+
+import (
+	"net/http"
+	"time"
+)
+
+// NewHTTPServer exports newHTTPServer for testing.
+func NewHTTPServer(
+	listenAddr string,
+	handler http.Handler,
+) *http.Server {
+	return newHTTPServer(listenAddr, handler)
+}
+
+// RequestTimeout exports the handler execution budget applied by
+// chimw.Timeout in SetupRoutes, so tests can assert the relationship
+// between it and the server's WriteTimeout.
+const RequestTimeout time.Duration = requestTimeout

internal/server/server.go

@@ -33,8 +33,52 @@ type Params struct {
 // shutdownTimeout is how long to wait for graceful shutdown.
 const shutdownTimeout = 30 * time.Second
 
-// readHeaderTimeout is the max duration for reading request headers.
+// Socket-level timeouts for the HTTP server.
-const readHeaderTimeout = 10 * time.Second
+//
+// These bound time spent on the connection itself and are a distinct
+// control from the per-request handler budget enforced by
+// chimw.Timeout(requestTimeout) in routes.go: that one cancels the
+// request context after requestTimeout but never touches the socket,
+// so without the values below a peer can hold a connection open
+// forever (slowloris, unreaped keep-alives).
+//
+// The one hard constraint between the two controls is
+// writeTimeout > requestTimeout. net/http arms the write deadline
+// once the request headers have been read, so on a plaintext
+// connection it covers handler execution AND the response flush. If
+// writeTimeout were <= requestTimeout the server would sever the
+// connection before a handler that legitimately consumed its full
+// budget could emit anything, making the 60s budget unreachable in
+// practice. The margin between them is the response-flush allowance.
+//
+// The only clients of this service are browsers loading the dashboard
+// and a Prometheus scraper; the values are sized for those.
+const (
+	// readHeaderTimeout is the max duration for reading request
+	// headers.
+	readHeaderTimeout = 10 * time.Second
+
+	// readTimeout bounds reading the entire request, headers plus
+	// body. Every route here is a GET with no body, so this only
+	// ever needs to cover headers; the extra 5s over
+	// readHeaderTimeout is slack, not a real allowance, and keeps a
+	// body dribbled one byte at a time from holding the read side
+	// open indefinitely.
+	readTimeout = 15 * time.Second
+
+	// writeTimeout must exceed the requestTimeout handler budget
+	// (60s) per the note above. The 15s difference is the allowance
+	// for flushing a completed response to a slow client.
+	writeTimeout = 75 * time.Second
+
+	// idleTimeout reaps keep-alive connections between requests. It
+	// is deliberately longer than the common Prometheus scrape
+	// intervals (15s/30s/60s) so the scraper reuses its connection
+	// rather than reconnecting every cycle, while a browser tab
+	// left open on the dashboard stops occupying a connection
+	// within two minutes of going quiet.
+	idleTimeout = 120 * time.Second
+)
 
 // Server is the HTTP server.
 type Server struct {
@@ -76,16 +120,29 @@ func New(
 	return srv, nil
 }
 
+// newHTTPServer builds the listening http.Server with every
+// socket-level timeout set. All four are set deliberately: a zero
+// value in net/http means "no limit", not "some default".
+func newHTTPServer(
+	listenAddr string,
+	handler http.Handler,
+) *http.Server {
+	return &http.Server{
+		Addr:              listenAddr,
+		Handler:           handler,
+		ReadTimeout:       readTimeout,
+		ReadHeaderTimeout: readHeaderTimeout,
+		WriteTimeout:      writeTimeout,
+		IdleTimeout:       idleTimeout,
+	}
+}
+
 // Run starts the HTTP server.
 func (s *Server) Run() {
 	s.SetupRoutes()
 
 	listenAddr := fmt.Sprintf(":%d", s.port)
-	s.httpServer = &http.Server{
+	s.httpServer = newHTTPServer(listenAddr, s)
-		Addr:              listenAddr,
-		Handler:           s,
-		ReadHeaderTimeout: readHeaderTimeout,
-	}
 
 	s.log.Info("http server starting", "addr", listenAddr)
 

internal/server/server_test.go

@@ -0,0 +1,112 @@
+package server_test
+
+import (
+	"net/http"
+	"testing"
+
+	"sneak.berlin/go/dnswatcher/internal/server"
+)
+
+// noopHandler stands in for the router; newHTTPServer only stores it.
+func noopHandler() http.Handler {
+	return http.HandlerFunc(
+		func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		},
+	)
+}
+
+// TestHTTPServerTimeoutsAreSet asserts that every socket-level
+// timeout is configured. A zero value in net/http means "no limit",
+// so a refactor that silently drops one of these reintroduces the
+// slowloris / unreaped-keep-alive exposure this guards against.
+//
+// The assertions are on the configured field values only; nothing
+// here measures elapsed time, so the test cannot flake on timing.
+func TestHTTPServerTimeoutsAreSet(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.ReadTimeout <= 0 {
+		t.Errorf(
+			"ReadTimeout must be non-zero, got %v",
+			srv.ReadTimeout,
+		)
+	}
+
+	if srv.ReadHeaderTimeout <= 0 {
+		t.Errorf(
+			"ReadHeaderTimeout must be non-zero, got %v",
+			srv.ReadHeaderTimeout,
+		)
+	}
+
+	if srv.WriteTimeout <= 0 {
+		t.Errorf(
+			"WriteTimeout must be non-zero, got %v",
+			srv.WriteTimeout,
+		)
+	}
+
+	if srv.IdleTimeout <= 0 {
+		t.Errorf(
+			"IdleTimeout must be non-zero, got %v",
+			srv.IdleTimeout,
+		)
+	}
+}
+
+// TestWriteTimeoutExceedsHandlerBudget pins the one relationship the
+// values must satisfy. net/http arms the write deadline once request
+// headers are read, so it covers handler execution plus the response
+// flush. If WriteTimeout were not greater than the chimw.Timeout
+// handler budget, the connection would be severed before a handler
+// that used its full budget could respond, making that budget
+// unreachable.
+func TestWriteTimeoutExceedsHandlerBudget(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.WriteTimeout <= server.RequestTimeout {
+		t.Errorf(
+			"WriteTimeout (%v) must exceed handler budget (%v)",
+			srv.WriteTimeout,
+			server.RequestTimeout,
+		)
+	}
+}
+
+// TestReadTimeoutCoversHeaderTimeout asserts the read deadline for
+// the whole request is at least as long as the header-only deadline;
+// a smaller ReadTimeout would make ReadHeaderTimeout unreachable.
+func TestReadTimeoutCoversHeaderTimeout(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.ReadTimeout < srv.ReadHeaderTimeout {
+		t.Errorf(
+			"ReadTimeout (%v) must be >= ReadHeaderTimeout (%v)",
+			srv.ReadTimeout,
+			srv.ReadHeaderTimeout,
+		)
+	}
+}
+
+// TestHTTPServerAddrAndHandler covers the rest of the constructor so
+// a future edit cannot drop the listen address or the handler.
+func TestHTTPServerAddrAndHandler(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":9999", noopHandler())
+
+	if srv.Addr != ":9999" {
+		t.Errorf("Addr = %q, want %q", srv.Addr, ":9999")
+	}
+
+	if srv.Handler == nil {
+		t.Error("Handler must not be nil")
+	}
+}

internal/state/state_test.go

@@ -13,6 +13,16 @@ import (
 
 const testHostname = "www.example.com"
 
+// Shared fixture values used across tests.
+const (
+	testNS1     = "ns1.example.com."
+	testNS2     = "ns2.example.com."
+	testAltNS1  = "ns1.test.com."
+	testIPv4    = "93.184.216.34"
+	testIP      = "1.2.3.4"
+	statusError = "error"
+)
+
 // populateState fills a State with representative test data across all categories.
 func populateState(t *testing.T, s *state.State) {
 	t.Helper()
@@ -20,7 +30,7 @@ func populateState(t *testing.T, s *state.State) {
 	now := time.Now().UTC().Truncate(time.Second)
 
 	s.SetDomainState("example.com", &state.DomainState{
-		Nameservers: []string{"ns1.example.com.", "ns2.example.com."},
+		Nameservers: []string{testNS1, testNS2},
 		LastChecked: now,
 	})
 
@@ -31,17 +41,17 @@ func populateState(t *testing.T, s *state.State) {
 
 	s.SetHostnameState(testHostname, &state.HostnameState{
 		RecordsByNameserver: map[string]*state.NameserverRecordState{
-			"ns1.example.com.": {
+			testNS1: {
 				Records: map[string][]string{
-					"A":    {"93.184.216.34"},
+					"A":    {testIPv4},
 					"AAAA": {"2606:2800:220:1:248:1893:25c8:1946"},
 				},
 				Status:      "ok",
 				LastChecked: now,
 			},
-			"ns2.example.com.": {
+			testNS2: {
 				Records: map[string][]string{
-					"A": {"93.184.216.34"},
+					"A": {testIPv4},
 				},
 				Status:      "ok",
 				LastChecked: now,
@@ -152,13 +162,13 @@ func TestSaveLoadRoundTrip_Hostnames(t *testing.T) {
 func verifyNS1Records(t *testing.T, hn *state.HostnameState) {
 	t.Helper()
 
-	ns1, ok := hn.RecordsByNameserver["ns1.example.com."]
+	ns1, ok := hn.RecordsByNameserver[testNS1]
 	if !ok {
 		t.Fatal("missing nameserver ns1.example.com.")
 	}
 
 	aRecords := ns1.Records["A"]
-	if len(aRecords) != 1 || aRecords[0] != "93.184.216.34" {
+	if len(aRecords) != 1 || aRecords[0] != testIPv4 {
 		t.Errorf("ns1 A records: got %v", aRecords)
 	}
 
@@ -213,7 +223,8 @@ func TestSaveLoadRoundTrip_Ports(t *testing.T) {
 	}
 }
 
-// TestSaveLoadRoundTrip_Certificates verifies certificate data survives a save/load cycle.
+// TestSaveLoadRoundTrip_Certificates verifies certificate data
+// survives a save/load cycle.
 func TestSaveLoadRoundTrip_Certificates(t *testing.T) {
 	t.Parallel()
 
@@ -653,7 +664,7 @@ func TestDomainState_GetSet(t *testing.T) {
 
 	now := time.Now().UTC().Truncate(time.Second)
 	ds := &state.DomainState{
-		Nameservers: []string{"ns1.test.com."},
+		Nameservers: []string{testAltNS1},
 		LastChecked: now,
 	}
 
@@ -664,7 +675,7 @@ func TestDomainState_GetSet(t *testing.T) {
 		t.Fatal("expected true for existing domain")
 	}
 
-	if len(got.Nameservers) != 1 || got.Nameservers[0] != "ns1.test.com." {
+	if len(got.Nameservers) != 1 || got.Nameservers[0] != testAltNS1 {
 		t.Errorf("nameservers: got %v", got.Nameservers)
 	}
 
@@ -674,7 +685,7 @@ func TestDomainState_GetSet(t *testing.T) {
 
 	// Overwrite.
 	ds2 := &state.DomainState{
-		Nameservers: []string{"ns1.test.com.", "ns2.test.com."},
+		Nameservers: []string{testAltNS1, "ns2.test.com."},
 		LastChecked: now.Add(time.Hour),
 	}
 
@@ -704,8 +715,8 @@ func TestHostnameState_GetSet(t *testing.T) {
 	now := time.Now().UTC().Truncate(time.Second)
 	hs := &state.HostnameState{
 		RecordsByNameserver: map[string]*state.NameserverRecordState{
-			"ns1.example.com.": {
+			testNS1: {
-				Records:     map[string][]string{"A": {"1.2.3.4"}},
+				Records:     map[string][]string{"A": {testIP}},
 				Status:      "ok",
 				LastChecked: now,
 			},
@@ -720,7 +731,7 @@ func TestHostnameState_GetSet(t *testing.T) {
 		t.Fatal("expected true for existing hostname")
 	}
 
-	nsState, ok := got.RecordsByNameserver["ns1.example.com."]
+	nsState, ok := got.RecordsByNameserver[testNS1]
 	if !ok {
 		t.Fatal("missing nameserver entry")
 	}
@@ -730,7 +741,7 @@ func TestHostnameState_GetSet(t *testing.T) {
 	}
 
 	aRecords := nsState.Records["A"]
-	if len(aRecords) != 1 || aRecords[0] != "1.2.3.4" {
+	if len(aRecords) != 1 || aRecords[0] != testIP {
 		t.Errorf("A records: got %v", aRecords)
 	}
 }
@@ -869,7 +880,7 @@ func TestCertificateState_ErrorField(t *testing.T) {
 
 	now := time.Now().UTC().Truncate(time.Second)
 	cs := &state.CertificateState{
-		Status:      "error",
+		Status:      statusError,
 		Error:       "connection refused",
 		LastChecked: now,
 	}
@@ -893,8 +904,8 @@ func TestCertificateState_ErrorField(t *testing.T) {
 		t.Fatal("missing certificate after load")
 	}
 
-	if got.Status != "error" {
+	if got.Status != statusError {
-		t.Errorf("status: got %q, want %q", got.Status, "error")
+		t.Errorf("status: got %q, want %q", got.Status, statusError)
 	}
 
 	if got.Error != "connection refused" {
@@ -912,9 +923,9 @@ func TestHostnameState_ErrorField(t *testing.T) {
 	now := time.Now().UTC().Truncate(time.Second)
 	hs := &state.HostnameState{
 		RecordsByNameserver: map[string]*state.NameserverRecordState{
-			"ns1.example.com.": {
+			testNS1: {
 				Records:     nil,
-				Status:      "error",
+				Status:      statusError,
 				Error:       "SERVFAIL",
 				LastChecked: now,
 			},
@@ -941,9 +952,9 @@ func TestHostnameState_ErrorField(t *testing.T) {
 		t.Fatal("missing hostname after load")
 	}
 
-	nsState := got.RecordsByNameserver["ns1.example.com."]
+	nsState := got.RecordsByNameserver[testNS1]
-	if nsState.Status != "error" {
+	if nsState.Status != statusError {
-		t.Errorf("status: got %q, want %q", nsState.Status, "error")
+		t.Errorf("status: got %q, want %q", nsState.Status, statusError)
 	}
 
 	if nsState.Error != "SERVFAIL" {
@@ -1062,7 +1073,8 @@ func TestConcurrentGetSet(t *testing.T) {
 	wg.Wait()
 }
 
-// runConcurrentOps performs a series of get/set/delete operations for concurrency testing.
+// runConcurrentOps performs a series of get/set/delete
+// operations for concurrency testing.
 func runConcurrentOps(s *state.State, key string, now time.Time) {
 	const iterations = 50
 
@@ -1085,7 +1097,7 @@ func runConcurrentOps(s *state.State, key string, now time.Time) {
 		s.SetHostnameState(key+".example.com", &state.HostnameState{
 			RecordsByNameserver: map[string]*state.NameserverRecordState{
 				"ns1.test.": {
-					Records:     map[string][]string{"A": {"1.2.3.4"}},
+					Records:     map[string][]string{"A": {testIP}},
 					Status:      "ok",
 					LastChecked: now,
 				},

internal/watcher/watcher.go

@@ -26,6 +26,12 @@ const tlsPort = 443
 // hoursPerDay converts days to hours for duration calculations.
 const hoursPerDay = 24
 
+// Status values recorded for nameserver and certificate checks.
+const (
+	statusOK    = "ok"
+	statusError = "error"
+)
+
 // Params contains dependencies for Watcher.
 type Params struct {
 	fx.In
@@ -344,7 +350,7 @@ func buildHostnameState(
 	for ns, recs := range records {
 		hs.RecordsByNameserver[ns] = &state.NameserverRecordState{
 			Records:     recs,
-			Status:      "ok",
+			Status:      statusOK,
 			LastChecked: now,
 		}
 	}
@@ -402,7 +408,7 @@ func (w *Watcher) detectNSDisappearances(
 	current map[string]map[string][]string,
 ) {
 	for ns, prevNS := range prev.RecordsByNameserver {
-		if _, ok := current[ns]; ok || prevNS.Status != "ok" {
+		if _, ok := current[ns]; ok || prevNS.Status != statusOK {
 			continue
 		}
 
@@ -421,7 +427,7 @@ func (w *Watcher) detectNSDisappearances(
 
 	for ns := range current {
 		prevNS, ok := prev.RecordsByNameserver[ns]
-		if !ok || prevNS.Status != "error" {
+		if !ok || prevNS.Status != statusError {
 			continue
 		}
 
@@ -705,7 +711,7 @@ func (w *Watcher) handleTLSError(
 	now time.Time,
 	err error,
 ) {
-	if hasPrev && !w.firstRun && prev.Status == "ok" {
+	if hasPrev && !w.firstRun && prev.Status == statusOK {
 		msg := fmt.Sprintf(
 			"Host: %s\nIP: %s\nError: %s",
 			hostname, ip, err,
@@ -721,7 +727,7 @@ func (w *Watcher) handleTLSError(
 
 	w.state.SetCertificateState(
 		certKey, &state.CertificateState{
-			Status:      "error",
+			Status:      statusError,
 			Error:       err.Error(),
 			LastChecked: now,
 		},
@@ -748,7 +754,7 @@ func (w *Watcher) handleTLSSuccess(
 			Issuer:                  cert.Issuer,
 			NotAfter:                cert.NotAfter,
 			SubjectAlternativeNames: cert.SubjectAlternativeNames,
-			Status:                  "ok",
+			Status:                  statusOK,
 			LastChecked:             now,
 		},
 	)
@@ -760,7 +766,7 @@ func (w *Watcher) detectTLSChanges(
 	prev *state.CertificateState,
 	cert *tlscheck.CertificateInfo,
 ) {
-	if prev.Status == "error" {
+	if prev.Status == statusError {
 		msg := fmt.Sprintf(
 			"Host: %s\nIP: %s\nTLS recovered",
 			hostname, ip,

internal/watcher/watcher_test.go

@@ -18,6 +18,17 @@ import (
 // errNotFound is returned when mock data is missing.
 var errNotFound = errors.New("not found")
 
+// Fixture values shared across tests.
+const (
+	testDomain = "example.com"
+	testHost   = "www.example.com"
+	testNS1    = "ns1.example.com."
+	testNS2    = "ns2.example.com."
+	testIPv4   = "93.184.216.34"
+	testIP     = "1.2.3.4"
+	testIssuer = "DigiCert"
+)
+
 // --- Mock implementations ---
 
 type mockResolver struct {
@@ -256,8 +267,8 @@ func TestFirstRunBaseline(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 	setupBaselineMocks(deps)
@@ -269,37 +280,37 @@ func TestFirstRunBaseline(t *testing.T) {
 }
 
 func setupBaselineMocks(deps *testDeps) {
-	deps.resolver.nsRecords["example.com"] = []string{
+	deps.resolver.nsRecords[testDomain] = []string{
-		"ns1.example.com.",
+		testNS1,
-		"ns2.example.com.",
+		testNS2,
 	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testDomain] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
+		testNS1: {"A": {testIPv4}},
-		"ns2.example.com.": {"A": {"93.184.216.34"}},
+		testNS2: {"A": {testIPv4}},
 	}
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
+		testNS1: {"A": {testIPv4}},
-		"ns2.example.com.": {"A": {"93.184.216.34"}},
+		testNS2: {"A": {testIPv4}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"93.184.216.34",
+		testIPv4,
 	}
 	deps.portChecker.results["93.184.216.34:80"] = true
 	deps.portChecker.results["93.184.216.34:443"] = true
 	deps.tlsChecker.certs["93.184.216.34:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
+		CommonName: testHost,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"www.example.com",
+			testHost,
 		},
 	}
 	deps.tlsChecker.certs["93.184.216.34:example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "example.com",
+		CommonName: testDomain,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"example.com",
+			testDomain,
 		},
 	}
 }
@@ -348,24 +359,24 @@ func TestDomainPortAndTLSChecks(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.nsRecords["example.com"] = []string{
+	deps.resolver.nsRecords[testDomain] = []string{
-		"ns1.example.com.",
+		testNS1,
 	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testDomain] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
+		testNS1: {"A": {testIPv4}},
 	}
 	deps.portChecker.results["93.184.216.34:80"] = true
 	deps.portChecker.results["93.184.216.34:443"] = true
 	deps.tlsChecker.certs["93.184.216.34:example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "example.com",
+		CommonName: testDomain,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"example.com",
+			testDomain,
 		},
 	}
 
@@ -406,17 +417,17 @@ func TestNSChangeDetection(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.nsRecords["example.com"] = []string{
+	deps.resolver.nsRecords[testDomain] = []string{
-		"ns1.example.com.",
+		testNS1,
-		"ns2.example.com.",
+		testNS2,
 	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testDomain] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
-		"ns2.example.com.": {"A": {"1.2.3.4"}},
+		testNS2: {"A": {testIP}},
 	}
 	deps.portChecker.results["1.2.3.4:80"] = false
 	deps.portChecker.results["1.2.3.4:443"] = false
@@ -425,13 +436,13 @@ func TestNSChangeDetection(t *testing.T) {
 	w.RunOnce(ctx)
 
 	deps.resolver.mu.Lock()
-	deps.resolver.nsRecords["example.com"] = []string{
+	deps.resolver.nsRecords[testDomain] = []string{
-		"ns1.example.com.",
+		testNS1,
 		"ns3.example.com.",
 	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testDomain] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1:            {"A": {testIP}},
-		"ns3.example.com.": {"A": {"1.2.3.4"}},
+		"ns3.example.com.": {"A": {testIP}},
 	}
 	deps.resolver.mu.Unlock()
 
@@ -459,15 +470,15 @@ func TestRecordChangeDetection(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.34"}},
+		testNS1: {"A": {testIPv4}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"93.184.216.34",
+		testIPv4,
 	}
 	deps.portChecker.results["93.184.216.34:80"] = false
 	deps.portChecker.results["93.184.216.34:443"] = false
@@ -476,10 +487,10 @@ func TestRecordChangeDetection(t *testing.T) {
 	w.RunOnce(ctx)
 
 	deps.resolver.mu.Lock()
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"93.184.216.35"}},
+		testNS1: {"A": {"93.184.216.35"}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
 		"93.184.216.35",
 	}
 	deps.resolver.mu.Unlock()
@@ -501,24 +512,24 @@ func TestPortStateChange(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"1.2.3.4",
+		testIP,
 	}
 	deps.portChecker.results["1.2.3.4:80"] = true
 	deps.portChecker.results["1.2.3.4:443"] = true
 	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
+		CommonName: testHost,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"www.example.com",
+			testHost,
 		},
 	}
 
@@ -541,24 +552,24 @@ func TestTLSExpiryWarning(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"1.2.3.4",
+		testIP,
 	}
 	deps.portChecker.results["1.2.3.4:80"] = true
 	deps.portChecker.results["1.2.3.4:443"] = true
 	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
+		CommonName: testHost,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(3 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"www.example.com",
+			testHost,
 		},
 	}
 
@@ -592,25 +603,25 @@ func TestTLSExpiryWarningDedup(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 	cfg.TLSInterval = 24 * time.Hour
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"1.2.3.4",
+		testIP,
 	}
 	deps.portChecker.results["1.2.3.4:80"] = true
 	deps.portChecker.results["1.2.3.4:443"] = true
 	deps.tlsChecker.certs["1.2.3.4:www.example.com"] = &tlscheck.CertificateInfo{
-		CommonName: "www.example.com",
+		CommonName: testHost,
-		Issuer:     "DigiCert",
+		Issuer:     testIssuer,
 		NotAfter:   time.Now().Add(3 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{
-			"www.example.com",
+			testHost,
 		},
 	}
 
@@ -647,17 +658,17 @@ func TestGracefulShutdown(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
 	cfg.DNSInterval = 100 * time.Millisecond
 	cfg.TLSInterval = 100 * time.Millisecond
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.nsRecords["example.com"] = []string{
+	deps.resolver.nsRecords[testDomain] = []string{
-		"ns1.example.com.",
+		testNS1,
 	}
-	deps.resolver.allRecords["example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testDomain] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
 	}
 	deps.portChecker.results["1.2.3.4:80"] = false
 	deps.portChecker.results["1.2.3.4:443"] = false
@@ -687,13 +698,13 @@ func setupHostnameIP(
 	hostname, ip string,
 ) {
 	deps.resolver.allRecords[hostname] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {ip}},
+		testNS1: {"A": {ip}},
 	}
 	deps.portChecker.results[ip+":80"] = true
 	deps.portChecker.results[ip+":443"] = true
 	deps.tlsChecker.certs[ip+":"+hostname] = &tlscheck.CertificateInfo{
 		CommonName:              hostname,
-		Issuer:                  "DigiCert",
+		Issuer:                  testIssuer,
 		NotAfter:                time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{hostname},
 	}
@@ -702,7 +713,7 @@ func setupHostnameIP(
 func updateHostnameIP(deps *testDeps, hostname, ip string) {
 	deps.resolver.mu.Lock()
 	deps.resolver.allRecords[hostname] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {ip}},
+		testNS1: {"A": {ip}},
 	}
 	deps.resolver.mu.Unlock()
 
@@ -714,7 +725,7 @@ func updateHostnameIP(deps *testDeps, hostname, ip string) {
 	deps.tlsChecker.mu.Lock()
 	deps.tlsChecker.certs[ip+":"+hostname] = &tlscheck.CertificateInfo{
 		CommonName:              hostname,
-		Issuer:                  "DigiCert",
+		Issuer:                  testIssuer,
 		NotAfter:                time.Now().Add(90 * 24 * time.Hour),
 		SubjectAlternativeNames: []string{hostname},
 	}
@@ -725,11 +736,11 @@ func TestDNSRunsBeforePortAndTLSChecks(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	setupHostnameIP(deps, "www.example.com", "10.0.0.1")
+	setupHostnameIP(deps, testHost, "10.0.0.1")
 
 	ctx := t.Context()
 	w.RunOnce(ctx)
@@ -740,7 +751,7 @@ func TestDNSRunsBeforePortAndTLSChecks(t *testing.T) {
 	}
 
 	// DNS changes to a new IP; port and TLS must pick it up.
-	updateHostnameIP(deps, "www.example.com", "10.0.0.2")
+	updateHostnameIP(deps, testHost, "10.0.0.2")
 
 	w.RunOnce(ctx)
 
@@ -760,8 +771,8 @@ func TestSendTestNotification_Enabled(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 	cfg.SendTestNotification = true
 
 	w, deps := newTestWatcher(t, cfg)
@@ -786,8 +797,8 @@ func TestSendTestNotification_ViaRun(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 	cfg.SendTestNotification = true
 	cfg.DNSInterval = 24 * time.Hour
 	cfg.TLSInterval = 24 * time.Hour
@@ -833,8 +844,8 @@ func TestSendTestNotification_Disabled(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Domains = []string{"example.com"}
+	cfg.Domains = []string{testDomain}
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 	cfg.SendTestNotification = false
 	cfg.DNSInterval = 24 * time.Hour
 	cfg.TLSInterval = 24 * time.Hour
@@ -871,16 +882,16 @@ func TestNSFailureAndRecovery(t *testing.T) {
 	t.Parallel()
 
 	cfg := defaultTestConfig(t)
-	cfg.Hostnames = []string{"www.example.com"}
+	cfg.Hostnames = []string{testHost}
 
 	w, deps := newTestWatcher(t, cfg)
 
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
-		"ns2.example.com.": {"A": {"1.2.3.4"}},
+		testNS2: {"A": {testIP}},
 	}
-	deps.resolver.ipAddresses["www.example.com"] = []string{
+	deps.resolver.ipAddresses[testHost] = []string{
-		"1.2.3.4",
+		testIP,
 	}
 	deps.portChecker.results["1.2.3.4:80"] = false
 	deps.portChecker.results["1.2.3.4:443"] = false
@@ -890,8 +901,8 @@ func TestNSFailureAndRecovery(t *testing.T) {
 	w.RunOnce(ctx)
 
 	deps.resolver.mu.Lock()
-	deps.resolver.allRecords["www.example.com"] = map[string]map[string][]string{
+	deps.resolver.allRecords[testHost] = map[string]map[string][]string{
-		"ns1.example.com.": {"A": {"1.2.3.4"}},
+		testNS1: {"A": {testIP}},
 	}
 	deps.resolver.mu.Unlock()
 

script/bootstrap

@@ -9,9 +9,9 @@ set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
-# Pinned versions, 2026-07-07 (same pins as the Dockerfile)
+# Pinned versions, 2026-08-07 (same pins as the Dockerfile)
-# golangci-lint v2.10.1
+# golangci-lint v2.12.2
-GOLANGCI_LINT_REF="github.com/golangci/golangci-lint/v2/cmd/golangci-lint@5d1e709b7be35cb2025444e19de266b056b7b7ee"
+GOLANGCI_LINT_REF="github.com/golangci/golangci-lint/v2/cmd/golangci-lint@c0d3ddc9cf3faa61a4e378e879ece580256d76e5"
 # goimports v0.42.0
 GOIMPORTS_REF="golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0"