docs: TESTING.md constraints match the resolver and the test-time policy (closes #289)

The Constraints list named a query timeout calibrated to round-trip time and a
limited root-server fan-out; the resolver has neither. It now gives the
2-second timeout and the second try over UDP, says a zone's servers are asked
one at a time in a random order, and gives the 60-second cap and 20-second
target for make test from REPO_POLICIES.md.

Model: opus-5-5

README.md

@@ -133,19 +133,18 @@ notification endpoint set, changes show only on the dashboard; see
 - Queries **each** authoritative nameserver independently for **all** record
   types: A, AAAA, CNAME, MX, TXT, SRV, CAA, NS.
 - Each record type is a query of its own. When a nameserver answers some types
-  but the query for another gets no usable reply at any of its addresses (no
+  but the query for another gets no usable reply (no reply after two tries, an
-  reply after two tries, an error reply such as SERVFAIL, a referral, or a reply
+  error reply such as SERVFAIL, a referral, or a reply too large for UDP whose
-  too large for UDP whose retry over TCP fails), the failure is logged with the
+  retry over TCP fails), the failure is logged with the reason, and the type is
-  reason, and the type is listed in the nameserver's `failedTypes` and keeps the
+  listed in the nameserver's `failedTypes` and keeps the records saved for the
-  records saved for the nameserver by the previous check. On that check those
+  nameserver by the previous check. On that check those records are not compared
-  records are not compared with the other nameservers', so no record change or
+  with the other nameservers', so no record change or inconsistency is reported
-  inconsistency is reported for the type; on the next check they are compared
+  for the type; on the next check they are compared with the nameserver's answer
-  with the nameserver's answer as usual. When the previous check did not know
+  as usual. When the previous check did not know the type's records either,
-  the type's records either, because the nameserver was new or failing then or
+  because the nameserver was new or failing then or the type was already listed
-  the type was already listed in `unknownTypes`, the type is also listed in
+  in `unknownTypes`, the type is also listed in `unknownTypes` and left out of
-  `unknownTypes` and left out of every comparison until it answers. A nameserver
+  every comparison until it answers. A nameserver none of whose queries got a
-  none of whose queries got a usable reply has failed (see NS query failure
+  usable reply has failed (see NS query failure below).
-  below).
 - Stores results **per nameserver**. The state for a hostname is not a merged
   view — it is a map from nameserver to record set.
 - DNS names inside record values (CNAME, MX, SRV and NS targets) are stored in
@@ -286,7 +285,7 @@ includes:
 
 Each endpoint is sent each notification on its own, in the background. A
 delivery that fails (a network error, no reply within 10 seconds, or an HTTP
-status other than 2xx) is retried up to 5 times: the first retry after about 1
+status of 400 or more) is retried up to 5 times: the first retry after about 1
 second, each wait after that twice as long up to 60 seconds, every wait varied
 at random by up to 25%. A delivery still failing after that is logged and
 dropped.
@@ -550,29 +549,12 @@ name's nameservers and in the lookup of a nameserver's own address. Such a
 lookup can need others in turn; lookups go at most three deep, one inside
 another, so delegations that point at each other still end.
 
-In step 4 each record type is asked at the IPv4 addresses the nameserver's name
-resolves to, one at a time, until one gives a usable reply; the next type is
-asked first at that address. A type's query fails only when none of them gives
-one, and the nameserver has failed only when that is so for every type.
-
 This approach ensures:
 
 - Independence from any upstream resolver's cache or filtering.
 - Ability to detect split-horizon or inconsistent responses across authoritative
   servers.
 
-A root server never offers recursion, so a reply marked "recursion available"
-from a root server's address came from a recursive resolver on the network
-answering in its place, as on a network where a router rule, a VPN or a DNS
-filter sends all DNS to one resolver. The first such reply from a root server's
-address, a refusal included, stops the lookup at once with the error "this
-network intercepts DNS queries", naming that address, and no other root server
-is asked. A lookup that every root server refuses without that mark fails with
-the same error. Every lookup starts at the root servers, so on such a network
-every lookup fails with that error, whether or not that resolver has the name
-cached, and dnswatcher's tests fail there too. That is by design: nothing asks
-again another way or otherwise works around the interception.
-
 A watched name's records are stored as its nameservers return them, CNAME
 included. When they return a CNAME and no address, the chain of every CNAME
 target they gave is followed (with a depth limit to prevent loops) to the A and
@@ -922,7 +904,6 @@ internal/
     templates/dashboard.html   Dashboard template (embedded)
     status.go                  /api/v1/status
     healthcheck.go             Health check handler
-    static.go                  Static assets under /s/
   server/
     server.go                  HTTP server lifecycle
     routes.go                  Route definitions

TESTING.md

@@ -29,8 +29,8 @@ works correctly in production.
 - Live lookups that expect an answer go through `internal/livednstest`, which
   limits how many run at once in a test binary and retries a lookup that got
   none
-- A flaky live test is a robustness problem, fixed with retries with backoff,
+- Flaky failures from transient network issues are acceptable and should be
-  several independent nameservers or longer timeouts, never with mocks or skip
+  investigated as potential resolver bugs, not papered over with mocks or skip
   flags
 
 ### What NOT to do

TODO.md

@@ -19,29 +19,10 @@ milestone: https://git.eeqj.de/sneak/dnswatcher/milestone/7
 
 # Completed Steps
 
-- 2026-10-16: the first reply marked "recursion available" from a root server's
-  address, a refusal included, stops the lookup with "this network intercepts
-  DNS queries", so on a network that sends DNS to a resolver dnswatcher and its
-  tests fail, by design (closes #300).
-- 2026-10-15: a query its caller's context ends before it is sent records no
-  reason about the nameserver, and a try the context's deadline cuts short is a
-  timeout, so a nameserver whose only failures were timeouts is `timeout`, not a
-  network error or `ok` (closes #298).
-- 2026-10-15: the resolver no longer says its query timeout grows on each try;
-  every try waits the same 2 seconds, and the unused `timeoutMultiplier` is gone
-  (closes #296).
 - 2026-10-15: `TESTING.md` Constraints give the resolver's 2-second query
   timeout and second try, say a zone's servers are asked one at a time in a
-  random order, give the 60-second cap and 20-second target for `make test`, and
+  random order, and give the 60-second cap and 20-second target for `make test`
-  say a flaky live test is fixed with robustness, not with mocks (closes #289).
+  (closes #289).
-- 2026-10-15: a request under `/s/` that names a directory, such as `/s/` or
-  `/s/css`, answers 404 instead of a listing of its files (closes #286).
-- 2026-10-15: a notification endpoint that answers with a redirect, or any
-  status other than 2xx, is a failed delivery, retried and logged (closes #287).
-- 2026-10-15: a nameserver is asked at each of its IPv4 addresses in turn, so it
-  has failed only when none of them gives a usable reply (closes #285).
-- 2026-10-15: the log names a notification endpoint (`slack`, `mattermost`,
-  `ntfy`) and never shows its URL's path or query (closes #288).
 - 2026-10-13: a hostname or a domain whose zone's nameservers all stop answering
   gets an NS Failure for each, then an NS Recovery (closes #284).
 - 2026-10-13: an IPv6 address is written in brackets before its port, as in

internal/handlers/static.go

@@ -1,36 +0,0 @@
-package handlers
-
-import (
-	"io/fs"
-	"net/http"
-	"strings"
-
-	"sneak.berlin/go/dnswatcher/static"
-)
-
-// HandleStatic returns the handler for the embedded static assets. It
-// is mounted under /s, with that prefix stripped from the path. A
-// request that names a directory answers 404: http.FileServer would
-// answer it with a listing of the directory, or with a redirect to
-// that listing when the trailing slash is missing.
-func (h *Handlers) HandleStatic() http.HandlerFunc {
-	files := http.FileServer(http.FS(static.Static))
-
-	return func(
-		writer http.ResponseWriter,
-		request *http.Request,
-	) {
-		// fs.Stat refuses a name that is empty or ends in a slash,
-		// so /s/ and /s/css/ answer 404 here along with /s/css.
-		name := strings.TrimPrefix(request.URL.Path, "/")
-
-		info, err := fs.Stat(static.Static, name)
-		if err != nil || info.IsDir() {
-			http.NotFound(writer, request)
-
-			return
-		}
-
-		files.ServeHTTP(writer, request)
-	}
-}

internal/notify/delivery_test.go

@@ -6,12 +6,10 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"log/slog"
 	"maps"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
-	"slices"
 	"strings"
 	"sync"
 	"testing"
@@ -40,13 +38,6 @@ const (
 	prioUrgent  = "urgent"
 )
 
-// Endpoint names, as the log gives them, used across multiple tests.
-const (
-	endpointNtfy       = "ntfy"
-	endpointSlack      = "slack"
-	endpointMattermost = "mattermost"
-)
-
 // testHost is the hostname used in request construction tests.
 const testHost = "example.com"
 
@@ -1103,182 +1094,6 @@ func TestSendNotificationErrorNamesEndpoint(t *testing.T) {
 	}
 }
 
-// ── webhook URLs kept out of the log ──────────────────────
-
-// webhookPathAndQuery follows the server's address in every
-// endpoint's URL in the tests below. A webhook URL's path or query
-// lets anyone post to the channel or topic, so neither word marked
-// secret in it may reach the log.
-const webhookPathAndQuery = "/hooks/secret-in-path?token=secret-in-query"
-
-// assertNoWebhookSecret fails the test if text holds either word
-// marked secret in webhookPathAndQuery.
-func assertNoWebhookSecret(t *testing.T, text string) {
-	t.Helper()
-
-	for _, secret := range []string{"secret-in-path", "secret-in-query"} {
-		if strings.Contains(text, secret) {
-			t.Errorf("%q from the webhook URL is in:\n%s", secret, text)
-		}
-	}
-}
-
-// logRecord is the part of a JSON log line the tests below read.
-type logRecord struct {
-	Level    string `json:"level"`
-	Msg      string `json:"msg"`
-	Endpoint string `json:"endpoint"`
-	Title    string `json:"title"`
-	Error    string `json:"error"`
-}
-
-// parseLog decodes each line of a JSON log.
-func parseLog(t *testing.T, logs string) []logRecord {
-	t.Helper()
-
-	var records []logRecord
-
-	for line := range strings.Lines(logs) {
-		var record logRecord
-
-		err := json.Unmarshal([]byte(line), &record)
-		if err != nil {
-			t.Fatalf("decoding log line %q: %v", line, err)
-		}
-
-		records = append(records, record)
-	}
-
-	return records
-}
-
-// sendToEachEndpoint sends one notification with the given title to
-// ntfy, Slack and Mattermost, each at baseURL followed by
-// webhookPathAndQuery, and retries a failed delivery once. When
-// every delivery has finished it returns the JSON log written,
-// debug lines included.
-func sendToEachEndpoint(t *testing.T, baseURL, title string) string {
-	t.Helper()
-
-	target, err := url.Parse(baseURL + webhookPathAndQuery)
-	if err != nil {
-		t.Fatalf("parsing webhook URL: %v", err)
-	}
-
-	svc, logs := newLoggingService(http.DefaultTransport)
-	svc.SetNtfyURL(target)
-	svc.SetSlackWebhookURL(target)
-	svc.SetMattermostWebhookURL(target)
-	svc.SetSleepFunc(instantSleep)
-	svc.SetRetryConfig(notify.RetryConfig{
-		MaxRetries: 1,
-		BaseDelay:  time.Millisecond,
-		MaxDelay:   time.Millisecond,
-	})
-
-	svc.SendNotification(context.Background(), title, "m", prioInfo)
-
-	waitForCondition(t, func() bool {
-		return svc.OutstandingDeliveries() == 0
-	})
-
-	return logs.String()
-}
-
-// assertEachEndpointRetriedThenFailed fails the test unless, for each
-// of ntfy, Slack and Mattermost, the lines of logs whose error
-// contains reason are the retry line and then the final failure line.
-func assertEachEndpointRetriedThenFailed(
-	t *testing.T, logs, reason string,
-) {
-	t.Helper()
-
-	// For each endpoint, the messages of its lines whose error
-	// contains reason, in the order they were logged.
-	got := map[string][]string{}
-
-	for _, record := range parseLog(t, logs) {
-		if strings.Contains(record.Error, reason) {
-			got[record.Endpoint] = append(
-				got[record.Endpoint], record.Msg,
-			)
-		}
-	}
-
-	lines := []string{
-		"notification delivery failed, retrying",
-		"failed to send notification after retries",
-	}
-	want := map[string][]string{
-		endpointNtfy:       lines,
-		endpointSlack:      lines,
-		endpointMattermost: lines,
-	}
-
-	if !maps.EqualFunc(got, want, slices.Equal) {
-		t.Errorf("lines whose error contains %q = %v, want %v",
-			reason, got, want)
-	}
-}
-
-// TestSendNotificationDebugLogOmitsWebhookURL checks that, with debug
-// logging on, a delivery to each endpoint logs the endpoint's name and
-// the title, and no part of the URL's path or query.
-func TestSendNotificationDebugLogOmitsWebhookURL(t *testing.T) {
-	t.Parallel()
-
-	const title = "Port Change"
-
-	srv := httptest.NewServer(
-		http.HandlerFunc(
-			func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusOK)
-			}),
-	)
-	defer srv.Close()
-
-	logs := sendToEachEndpoint(t, srv.URL, title)
-
-	assertNoWebhookSecret(t, logs)
-
-	got := map[string]string{}
-
-	for _, record := range parseLog(t, logs) {
-		if record.Level == slog.LevelDebug.String() {
-			got[record.Endpoint] = record.Title
-		}
-	}
-
-	want := map[string]string{
-		endpointNtfy:       title,
-		endpointSlack:      title,
-		endpointMattermost: title,
-	}
-
-	if !maps.Equal(got, want) {
-		t.Errorf("debug lines' endpoint and title = %v, want %v", got, want)
-	}
-}
-
-// TestSendNotificationErrorLogOmitsWebhookURL checks that a delivery
-// to each endpoint that cannot connect logs the transport's error,
-// which names the refused connection, on its retry line and on its
-// final failure line, and that no line holds any part of the URL's
-// path or query.
-func TestSendNotificationErrorLogOmitsWebhookURL(t *testing.T) {
-	t.Parallel()
-
-	// Closed before anything is sent, so every attempt fails to
-	// connect.
-	srv := httptest.NewServer(http.NotFoundHandler())
-	srv.Close()
-
-	logs := sendToEachEndpoint(t, srv.URL, "t")
-
-	assertNoWebhookSecret(t, logs)
-	assertEachEndpointRetriedThenFailed(t, logs, "connection refused")
-}
-
 // ── SlackPayload JSON marshaling ──────────────────────────
 
 func TestSlackPayloadJSON(t *testing.T) {

internal/notify/export_test.go

@@ -81,8 +81,7 @@ func (svc *Service) SendNtfy(
 	return svc.sendNtfy(ctx, topicURL, title, message, priority)
 }
 
-// SendSlack exports sendSlack for testing. It sends as the
+// SendSlack exports sendSlack for testing.
-// "slack" endpoint.
 func (svc *Service) SendSlack(
 	ctx context.Context,
 	webhookURL *url.URL,
@@ -90,7 +89,7 @@ func (svc *Service) SendSlack(
 	title, message, priority string,
 ) error {
 	return svc.sendSlack(
-		ctx, webhookURL, "slack", failed, title, message, priority,
+		ctx, webhookURL, failed, title, message, priority,
 	)
 }
 

internal/notify/notify.go

@@ -25,6 +25,9 @@ import (
 // HTTP client timeout.
 const httpClientTimeout = 10 * time.Second
 
+// HTTP status code thresholds.
+const httpStatusClientError = 400
+
 // Sentinel errors for notification failures.
 var (
 	// ErrNtfyFailed indicates the ntfy request failed.
@@ -53,15 +56,6 @@ func IsAllowedScheme(scheme string) bool {
 func ValidateWebhookURL(raw string) (*url.URL, error) {
 	u, err := url.ParseRequestURI(raw)
 	if err != nil {
-		// A *url.Error quotes the whole URL, and this error is
-		// logged at startup. A webhook URL's path or query lets
-		// anyone post to the channel or topic, so keep only the
-		// reason.
-		var urlErr *url.Error
-		if errors.As(err, &urlErr) {
-			err = urlErr.Err
-		}
-
 		return nil, fmt.Errorf("invalid URL: %w", err)
 	}
 
@@ -283,7 +277,7 @@ func (svc *Service) dispatchSlack(
 
 	svc.dispatch(ctx, "slack", func(c context.Context) error {
 		return svc.sendSlack(
-			c, svc.slackWebhookURL, "slack", ErrSlackFailed,
+			c, svc.slackWebhookURL, ErrSlackFailed,
 			title, message, priority,
 		)
 	})
@@ -301,8 +295,8 @@ func (svc *Service) dispatchMattermost(
 		ctx, "mattermost",
 		func(c context.Context) error {
 			return svc.sendSlack(
-				c, svc.mattermostWebhookURL, "mattermost",
+				c, svc.mattermostWebhookURL, ErrMattermostFailed,
-				ErrMattermostFailed, title, message, priority,
+				title, message, priority,
 			)
 		},
 	)
@@ -313,11 +307,9 @@ func (svc *Service) sendNtfy(
 	topicURL *url.URL,
 	title, message, priority string,
 ) error {
-	// The topic URL is left out of the log: it lets anyone who has
-	// it read and post to the topic.
 	svc.log.Debug(
 		"sending ntfy notification",
-		"endpoint", "ntfy",
+		"topic", topicURL.String(),
 		"title", title,
 	)
 
@@ -341,10 +333,7 @@ func (svc *Service) sendNtfy(
 
 	defer func() { _ = resp.Body.Close() }()
 
-	// Only a 2xx reply means ntfy took the notification. A
+	if resp.StatusCode >= httpStatusClientError {
-	// redirect is not followed, so it is a failure too.
-	if resp.StatusCode < http.StatusOK ||
-		resp.StatusCode >= http.StatusMultipleChoices {
 		return fmt.Errorf(
 			"%w: status %d",
 			ErrNtfyFailed, resp.StatusCode,
@@ -383,15 +372,12 @@ type SlackAttachment struct {
 }
 
 // sendSlack posts to a Slack or Mattermost incoming webhook, which
-// take the same payload. endpoint, "slack" or "mattermost", names
+// take the same payload. An HTTP error status is returned wrapped in
-// the webhook in the log in place of its URL, which lets anyone who
+// failed, ErrSlackFailed or ErrMattermostFailed, so the error names
-// has it post to the channel. A reply status other than 2xx is
+// the endpoint.
-// returned wrapped in failed, ErrSlackFailed or ErrMattermostFailed,
-// so the error names the endpoint.
 func (svc *Service) sendSlack(
 	ctx context.Context,
 	webhookURL *url.URL,
-	endpoint string,
 	failed error,
 	title, message, priority string,
 ) error {
@@ -402,7 +388,7 @@ func (svc *Service) sendSlack(
 
 	svc.log.Debug(
 		"sending webhook notification",
-		"endpoint", endpoint,
+		"url", webhookURL.String(),
 		"title", title,
 	)
 
@@ -437,10 +423,7 @@ func (svc *Service) sendSlack(
 
 	defer func() { _ = resp.Body.Close() }()
 
-	// Only a 2xx reply means the webhook took the notification. A
+	if resp.StatusCode >= httpStatusClientError {
-	// redirect is not followed, so it is a failure too.
-	if resp.StatusCode < http.StatusOK ||
-		resp.StatusCode >= http.StatusMultipleChoices {
 		return fmt.Errorf(
 			"%w: status %d",
 			failed, resp.StatusCode,

internal/notify/notify_test.go

@@ -79,23 +79,6 @@ func TestValidateWebhookURLInvalid(t *testing.T) {
 	}
 }
 
-// TestValidateWebhookURLErrorOmitsURL checks that the error for a
-// webhook URL that does not parse, here because a carriage return
-// was left at its end, leaves out the URL's path and query: the
-// error is logged at startup.
-func TestValidateWebhookURLErrorOmitsURL(t *testing.T) {
-	t.Parallel()
-
-	_, err := notify.ValidateWebhookURL(
-		"https://hooks.example.com" + webhookPathAndQuery + "\r",
-	)
-	if err == nil {
-		t.Fatal("expected an error for a URL ending in a carriage return")
-	}
-
-	assertNoWebhookSecret(t, err.Error())
-}
-
 func TestIsAllowedScheme(t *testing.T) {
 	t.Parallel()
 

internal/notify/retry_test.go

@@ -536,33 +536,3 @@ func TestSendNotificationPermanentFailureLogsError(
 		return attempts >= 3
 	})
 }
-
-// TestSendNotificationRedirectFails checks that a 302 reply is a
-// failed delivery at each endpoint: the server is sent the first
-// attempt and the retry, and each endpoint logs a retry line and
-// then the final failure line, both naming the 302.
-func TestSendNotificationRedirectFails(t *testing.T) {
-	t.Parallel()
-
-	var requests atomic.Int64
-
-	srv := httptest.NewServer(
-		http.HandlerFunc(
-			func(w http.ResponseWriter, r *http.Request) {
-				requests.Add(1)
-				http.Redirect(w, r, "/moved", http.StatusFound)
-			}),
-	)
-	defer srv.Close()
-
-	logs := sendToEachEndpoint(t, srv.URL, "t")
-
-	// ntfy, Slack and Mattermost each send once and retry once.
-	const wantRequests = 3 * 2
-
-	if sent := requests.Load(); sent != wantRequests {
-		t.Errorf("server got %d requests, want %d", sent, wantRequests)
-	}
-
-	assertEachEndpointRetriedThenFailed(t, logs, "status 302")
-}

internal/resolver/errors.go

@@ -36,10 +36,6 @@ var (
 	// so whether the name has addresses is unknown.
 	ErrNoNameserverAnswered = errors.New("no nameserver answered")
 
-	// ErrNoNameserverAddress is returned when a nameserver is to be
-	// asked and no address for it was given.
-	ErrNoNameserverAddress = errors.New("nameserver has no address")
-
 	// ErrUnusableReply is returned when a server replied with an
 	// error such as SERVFAIL, or with a referral that leads no
 	// closer to the name asked about.
@@ -53,13 +49,9 @@ var (
 		"reply truncated and its retry over TCP failed",
 	)
 
-	// ErrIntercepted is returned when a root server's address gave a
+	// ErrIntercepted is returned when every root server refused a
-	// reply marked recursion available, a refusal included, which ends
+	// query. Root servers refuse no query, so the refusals came from
-	// the lookup at once, or when every root server refused a query.
+	// something on the network answering in their place.
-	// Root servers do neither, so those replies came from something on
-	// the network answering in their place. On such a network
-	// dnswatcher fails with it, by design: nothing works around the
-	// interception.
 	ErrIntercepted = errors.New("this network intercepts DNS queries")
 
 	// ErrCNAMEDepthExceeded is returned when a CNAME chain

internal/resolver/export_test.go

@@ -96,17 +96,6 @@ func (r *Resolver) QueryServers(
 	return r.queryServers(ctx, servers, zone, name, qtype)
 }
 
-// QueryTypes exports queryTypes for testing.
-func (r *Resolver) QueryTypes(
-	ctx context.Context,
-	nsHostname string,
-	nsIPs []string,
-	hostname string,
-	qtypes []uint16,
-) (*NameserverResponse, error) {
-	return r.queryTypes(ctx, nsHostname, nsIPs, hostname, qtypes)
-}
-
 // QueryEachNS exports queryEachNS for testing.
 func (r *Resolver) QueryEachNS(
 	ctx context.Context,

internal/resolver/iterative.go

@@ -19,6 +19,7 @@ const (
 	queryTimeoutDuration = 2 * time.Second
 	maxRetries           = 2
 	maxDelegation        = 20
+	timeoutMultiplier    = 2
 
 	// maxLookupDepth is how many lookups of nameserver addresses may be
 	// under way one inside another. Looking up a nameserver's address
@@ -61,11 +62,19 @@ func checkCtx(ctx context.Context) error {
 	return nil
 }
 
-// tryExchange sends msg to addr over UDP, up to maxRetries times, until
+func (r *Resolver) exchangeWithTimeout(
-// a reply comes. Every try waits the same queryTimeoutDuration, or less
+	ctx context.Context,
-// when ctx's deadline comes first. When ctx has ended before a further
+	msg *dns.Msg,
-// try, it returns the error of the try already made, such as a timeout,
+	addr string,
-// or ErrContextCanceled when none was made.
+	attempt int,
+) (*dns.Msg, error) {
+	_ = attempt // timeout escalation handled by client config
+
+	resp, _, err := r.client.ExchangeContext(ctx, msg, addr)
+
+	return resp, err
+}
+
 func (r *Resolver) tryExchange(
 	ctx context.Context,
 	msg *dns.Msg,
@@ -75,16 +84,14 @@ func (r *Resolver) tryExchange(
 
 	var err error
 
-	for range maxRetries {
+	for attempt := range maxRetries {
 		if checkCtx(ctx) != nil {
-			if err == nil {
+			return nil, ErrContextCanceled
-				return nil, ErrContextCanceled
-			}
-
-			return nil, err
 		}
 
-		resp, _, err = r.client.ExchangeContext(ctx, msg, addr)
+		resp, err = r.exchangeWithTimeout(
+			ctx, msg, addr, attempt,
+		)
 		if err == nil {
 			break
 		}
@@ -115,8 +122,7 @@ func (r *Resolver) retryTCP(
 }
 
 // queryDNS sends a DNS query to a specific server IP, never asking it
-// for recursion. A reply of REFUSED is returned together with
+// for recursion. A reply of REFUSED is returned as ErrRefused.
-// ErrRefused, so that the caller can still read the reply's flags.
 func (r *Resolver) queryDNS(
 	ctx context.Context,
 	serverIP string,
@@ -140,7 +146,7 @@ func (r *Resolver) queryDNS(
 	}
 
 	if resp.Rcode == dns.RcodeRefused {
-		return resp, fmt.Errorf(
+		return nil, fmt.Errorf(
 			"query %s @%s: %w", name, serverIP, ErrRefused,
 		)
 	}
@@ -285,15 +291,10 @@ func shuffled(
 }
 
 // queryServers asks servers, the servers of zone, about name in a random
-// order until one gives a usable reply. When they are the root servers,
+// order until one gives a usable reply. A server that times out, refuses
-// the first reply marked recursion available, a refusal included, ends
+// or gives a reply that is not usable is passed over for the next. When
-// the lookup with ErrIntercepted, naming the address it came from, and
+// every server refused, the error says so, and when they are the root
-// no other root server is asked: root servers offer no recursion, so
+// servers it is ErrIntercepted.
-// that reply came from something on the network answering in their
-// place. Otherwise a server that times out, refuses or gives a reply
-// that is not usable is passed over for the next. When every server
-// refused, the error says so, and when they are the root servers it is
-// ErrIntercepted.
 func (r *Resolver) queryServers(
 	ctx context.Context,
 	servers []string,
@@ -310,17 +311,7 @@ func (r *Resolver) queryServers(
 			return nil, ErrContextCanceled
 		}
 
-		// queryDNS returns a refusal together with its reply, so a
-		// refusal's mark is checked here too.
 		resp, err := r.queryDNS(ctx, ip, name, qtype)
-		if resp != nil && zone == "." && resp.RecursionAvailable {
-			return nil, fmt.Errorf(
-				"query %s @%s: reply marked recursion available, "+
-					"so not from a root server: %w",
-				name, ip, ErrIntercepted,
-			)
-		}
-
 		if err == nil && !usableReply(resp, zone, name) {
 			err = fmt.Errorf(
 				"query %s @%s: %w", name, ip, ErrUnusableReply,
@@ -717,9 +708,8 @@ func (r *Resolver) QueryNameserver(
 	return r.queryNameserver(ctx, nsHostname, hostname, recordTypes())
 }
 
-// queryNameserver queries a specific nameserver, at the IPv4 addresses
+// queryNameserver queries a specific nameserver for the record types
-// its name resolves to, for the record types in qtypes and builds a
+// in qtypes and builds a NameserverResponse.
-// NameserverResponse.
 func (r *Resolver) queryNameserver(
 	ctx context.Context,
 	nsHostname string,
@@ -737,7 +727,7 @@ func (r *Resolver) queryNameserver(
 
 	hostname = dns.Fqdn(hostname)
 
-	return r.queryTypes(ctx, nsHostname, nsIPs, hostname, qtypes)
+	return r.queryTypes(ctx, nsHostname, nsIPs[0], hostname, qtypes)
 }
 
 // QueryNameserverIP queries a nameserver by its IP address directly,
@@ -754,33 +744,23 @@ func (r *Resolver) QueryNameserverIP(
 
 	hostname = dns.Fqdn(hostname)
 
-	return r.queryTypes(
+	return r.queryTypes(ctx, nsHostname, nsIP, hostname, recordTypes())
-		ctx, nsHostname, []string{nsIP}, hostname, recordTypes(),
-	)
 }
 
-// queryTypes asks the nameserver nsHostname, at its addresses nsIPs,
-// about hostname's records of each type in qtypes and builds a
-// NameserverResponse. With no address there is nothing to ask, and it
-// returns ErrNoNameserverAddress.
 func (r *Resolver) queryTypes(
 	ctx context.Context,
 	nsHostname string,
-	nsIPs []string,
+	nsIP string,
 	hostname string,
 	qtypes []uint16,
 ) (*NameserverResponse, error) {
-	if len(nsIPs) == 0 {
-		return nil, fmt.Errorf("%w: %s", ErrNoNameserverAddress, nsHostname)
-	}
-
 	resp := &NameserverResponse{
 		Nameserver: nsHostname,
 		Records:    make(map[string][]string),
 		Status:     StatusOK,
 	}
 
-	state := r.queryEachType(ctx, nsIPs, hostname, qtypes, resp)
+	state := r.queryEachType(ctx, nsIP, hostname, qtypes, resp)
 	classifyResponse(resp, state)
 
 	return resp, nil
@@ -798,37 +778,28 @@ type queryState struct {
 	answered      bool
 }
 
-// queryEachType asks the nameserver about hostname's records of each type
+// queryEachType asks the nameserver at nsIP about hostname once for each
-// in qtypes, at its addresses nsIPs in turn until one gives a usable
+// record type in qtypes, and lists in resp.FailedTypes the types whose
-// reply, and lists in resp.FailedTypes the types that got none at any of
+// query got no usable reply, logging each with the reason unless ctx was
-// them, logging each with the reasons unless ctx was cancelled: shutdown
+// cancelled: shutdown cancels it, and a query it cut short did not fail.
-// cancels it, and a query it cut short did not fail.
 func (r *Resolver) queryEachType(
 	ctx context.Context,
-	nsIPs []string,
+	nsIP string,
 	hostname string,
 	qtypes []uint16,
 	resp *NameserverResponse,
 ) queryState {
 	var state queryState
 
-	// Reordered below; the caller's list is left as it was.
-	nsIPs = slices.Clone(nsIPs)
-
 	for _, qtype := range qtypes {
 		if checkCtx(ctx) != nil {
 			break
 		}
 
-		answeredAt, err := r.querySingleType(
+		err := r.querySingleType(ctx, nsIP, hostname, qtype, resp, &state)
-			ctx, nsIPs, hostname, qtype, resp, &state,
-		)
 		if err == nil {
 			state.answered = true
 
-			// The next type is asked first at the address that answered.
-			nsIPs[0], nsIPs[answeredAt] = nsIPs[answeredAt], nsIPs[0]
-
 			continue
 		}
 
@@ -862,34 +833,20 @@ func (r *Resolver) queryEachType(
 	return state
 }
 
-// querySingleType asks the nameserver about hostname's records of type
+// querySingleType asks the nameserver at nsIP about hostname's records
-// qtype at its addresses nsIPs, of which there is at least one, one at a
+// of type qtype. It returns nil when the nameserver answered: with
-// time, until one answers: with records, with none, or with NXDOMAIN.
+// records, with none, or with NXDOMAIN; otherwise it returns why not.
-// It returns the index in nsIPs of the address that answered; when none
-// did, it returns why each did not, each reason naming its address.
 func (r *Resolver) querySingleType(
 	ctx context.Context,
-	nsIPs []string,
+	nsIP string,
 	hostname string,
 	qtype uint16,
 	resp *NameserverResponse,
 	state *queryState,
-) (int, error) {
+) error {
-	var errs []error
+	msg, err := r.queryDNS(ctx, nsIP, hostname, qtype)
-
+	if err != nil {
-	for i, nsIP := range nsIPs {
-		msg, err := r.queryDNS(ctx, nsIP, hostname, qtype)
-
 		switch {
-		case err == nil:
-			err = readReply(msg, resp, state)
-			if err != nil {
-				err = fmt.Errorf("query %s @%s: %w", hostname, nsIP, err)
-			}
-		case errors.Is(err, ErrContextCanceled):
-			// The caller's context ended before the query was sent.
-			// That says nothing about the nameserver, so no reason is
-			// recorded.
 		case isTimeout(err):
 			state.gotTimeout = true
 		case errors.Is(err, ErrRefused):
@@ -898,14 +855,10 @@ func (r *Resolver) querySingleType(
 			state.netErr = err
 		}
 
-		if err == nil {
+		return err
-			return i, nil
-		}
-
-		errs = append(errs, err)
 	}
 
-	return 0, errors.Join(errs...)
+	return readReply(msg, resp, state)
 }
 
 // readReply adds to resp the records in msg, a nameserver's reply to a
@@ -999,15 +952,17 @@ func isTimeout(err error) bool {
 }
 
 // classifyResponse sets the nameserver's status. One that answered no
-// record type has failed, and Error says why; it says all queries timed
+// record type has failed, and Error says why; one that answered some has
-// out only when every query, at every address, did. One that answered
+// the status of those answers. It has no data only when every type
-// some has the status of those answers. It has no data only when every type
 // answered with no records: a type in FailedTypes may have records, so a
 // nameserver with one stays ok.
 func classifyResponse(resp *NameserverResponse, state queryState) {
 	switch {
 	case state.gotNXDomain && !state.hasRecords:
 		resp.Status = StatusNXDomain
+	case state.gotTimeout && !state.answered:
+		resp.Status = StatusTimeout
+		resp.Error = "all queries timed out"
 	case state.gotErrorReply && !state.answered:
 		resp.Status = StatusError
 		resp.Error = "server returned " + state.errorReply
@@ -1020,9 +975,6 @@ func classifyResponse(resp *NameserverResponse, state queryState) {
 	case state.gotReferral && !state.answered:
 		resp.Status = StatusError
 		resp.Error = "server returned a referral"
-	case state.gotTimeout && !state.answered:
-		resp.Status = StatusTimeout
-		resp.Error = "all queries timed out"
 	// An NXDOMAIN reply with no records was taken by the first case.
 	case !state.hasRecords && len(resp.FailedTypes) == 0:
 		resp.Status = StatusNoData

internal/resolver/iterative_internal_test.go

@@ -1,8 +1,6 @@
 package resolver
 
 import (
-	"context"
-	"log/slog"
 	"strconv"
 	"syscall"
 	"testing"
@@ -17,10 +15,8 @@ import (
 // that answered some record types, even with no records, has not failed
 // when its query for another type got no usable reply, whatever the
 // reason, and is ok, not nodata: that type may have records. One whose
-// every query got none has failed, and its error says all queries timed
+// every query got none has failed. Only one whose every type answered
-// out only when every one did: a reply such as a refusal, or a network
+// with no records is nodata.
-// error, at one of its addresses is given instead. Only one whose every
-// type answered with no records is nodata.
 func TestClassifyResponse(t *testing.T) {
 	t.Parallel()
 
@@ -31,46 +27,63 @@ func TestClassifyResponse(t *testing.T) {
 		wantStatus  string
 		wantError   string
 	}{
-		{"every type answered with no records",
+		{
+			"every type answered with no records",
 			queryState{answered: true},
-			nil, StatusNoData, ""},
+			nil,
-		{"some types answered with no records, another timed out",
+			StatusNoData, "",
+		},
+		{
+			"some types answered with no records, another timed out",
 			queryState{answered: true, gotTimeout: true},
-			[]string{"A"}, StatusOK, ""},
+			[]string{"A"},
-		{"some types answered with no records, another got SERVFAIL",
+			StatusOK, "",
-			queryState{answered: true, gotErrorReply: true, errorReply: "SERVFAIL"},
+		},
-			[]string{"A"}, StatusOK, ""},
+		{
-		{"some types answered with no records, another was refused",
+			"some types answered with no records, another got SERVFAIL",
+			queryState{
+				answered: true, gotErrorReply: true, errorReply: "SERVFAIL",
+			},
+			[]string{"A"},
+			StatusOK, "",
+		},
+		{
+			"some types answered with no records, another was refused",
 			queryState{answered: true, gotRefused: true},
-			[]string{"A"}, StatusOK, ""},
+			[]string{"A"},
-		{"some types answered with no records, another got a network error",
+			StatusOK, "",
+		},
+		{
+			"some types answered with no records, another got a network error",
 			queryState{answered: true, netErr: syscall.ECONNREFUSED},
-			[]string{"A"}, StatusOK, ""},
+			[]string{"A"},
-		{"some types answered with no records, another's reply was " +
+			StatusOK, "",
-			"truncated and its retry over TCP failed",
+		},
+		{
+			"some types answered with no records, another's reply was " +
+				"truncated and its retry over TCP failed",
 			queryState{answered: true, netErr: ErrTruncated},
-			[]string{"TXT"}, StatusOK, ""},
+			[]string{"TXT"},
-		{"some types answered with no records, another got a referral",
+			StatusOK, "",
+		},
+		{
+			"some types answered with no records, another got a referral",
 			queryState{answered: true, gotReferral: true},
-			[]string{"A"}, StatusOK, ""},
+			[]string{"A"},
-		{"every query timed out",
+			StatusOK, "",
+		},
+		{
+			"every query timed out",
 			queryState{gotTimeout: true},
-			[]string{"A", "AAAA", "CNAME"}, StatusTimeout, "all queries timed out"},
+			[]string{"A", "AAAA", "CNAME"},
-		{"every query got NOTIMP",
+			StatusTimeout, "all queries timed out",
+		},
+		{
+			"every query got NOTIMP",
 			queryState{gotErrorReply: true, errorReply: "NOTIMP"},
-			[]string{"A", "AAAA", "CNAME"}, StatusError, "server returned NOTIMP"},
+			[]string{"A", "AAAA", "CNAME"},
-		{"every query got SERVFAIL at one address, timed out at another",
+			StatusError, "server returned NOTIMP",
-			queryState{gotErrorReply: true, errorReply: "SERVFAIL", gotTimeout: true},
+		},
-			[]string{"A"}, StatusError, "server returned SERVFAIL"},
-		{"every query was refused at one address, timed out at another",
-			queryState{gotRefused: true, gotTimeout: true},
-			[]string{"A"}, StatusError, "server returned REFUSED"},
-		{"every query got a network error at one address, timed out at another",
-			queryState{netErr: syscall.ECONNREFUSED, gotTimeout: true},
-			[]string{"A"}, StatusError, "network error: connection refused"},
-		{"every query got a referral at one address, timed out at another",
-			queryState{gotReferral: true, gotTimeout: true},
-			[]string{"A"}, StatusError, "server returned a referral"},
 	}
 
 	for _, tt := range tests {
@@ -134,33 +147,3 @@ func TestReadReply(t *testing.T) {
 		})
 	}
 }
-
-// TestQuerySingleType_ContextEnded asks a nameserver about one record
-// type with a context that has already ended, so no query is sent. A
-// query the context ended before it was sent says nothing about the
-// nameserver and records no reason: a nameserver whose earlier query
-// timed out is still reported as timed out, not as a network error.
-func TestQuerySingleType_ContextEnded(t *testing.T) {
-	t.Parallel()
-
-	r := NewFromLogger(slog.New(slog.DiscardHandler))
-
-	ctx, cancel := context.WithCancel(t.Context())
-	cancel()
-
-	resp := &NameserverResponse{Records: map[string][]string{}, Status: StatusOK}
-
-	// The query for an earlier record type timed out.
-	state := queryState{gotTimeout: true}
-
-	_, err := r.querySingleType(
-		ctx, []string{"192.0.2.1"}, "example.com.", dns.TypeA, resp, &state,
-	)
-	require.ErrorIs(t, err, ErrContextCanceled)
-	assert.Equal(t, queryState{gotTimeout: true}, state)
-
-	classifyResponse(resp, state)
-
-	assert.Equal(t, StatusTimeout, resp.Status)
-	assert.Equal(t, "all queries timed out", resp.Error)
-}

internal/resolver/resolver_test.go

@@ -360,124 +360,6 @@ func TestQueryNameserver_ZoneDelegatedWithoutAddresses(t *testing.T) {
 	assert.Equal(t, resolver.StatusOK, resp.Status)
 }
 
-// TestQueryTypes_FirstAddressNeverAnswers asks a google.com nameserver
-// about google.com's A and AAAA records at a list of addresses that puts
-// 192.0.2.1, where nothing answers, before the nameserver's own. The
-// nameserver answers at its own address, so it is ok, with its records.
-// Each attempt has time for one round of tries at 192.0.2.1, two tries
-// of two seconds, and not for two, so AAAA must be asked first at the
-// address that answered A.
-func TestQueryTypes_FirstAddressNeverAnswers(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	ns := findOneNSForDomain(t, r, "google.com")
-	nsIPs := append(
-		[]string{noAnswerAddress}, liveResolveNSIPs(t, r, []string{ns}, 1)...,
-	)
-
-	var resp *resolver.NameserverResponse
-
-	livednstest.Retry(
-		t,
-		"QueryTypes("+ns+" at "+strings.Join(nsIPs, ", ")+", google.com)",
-		func(ctx context.Context) error {
-			ctx, cancel := context.WithTimeout(ctx, 6*time.Second)
-			defer cancel()
-
-			var err error
-
-			resp, err = r.QueryTypes(
-				ctx, ns, nsIPs, "google.com.",
-				[]uint16{dns.TypeA, dns.TypeAAAA},
-			)
-			if err != nil {
-				return err
-			}
-
-			if len(resp.FailedTypes) > 0 {
-				return fmt.Errorf(
-					"%w: %s gave no usable reply for %s",
-					livednstest.ErrNoAnswer, ns,
-					strings.Join(resp.FailedTypes, ", "),
-				)
-			}
-
-			return nil
-		},
-	)
-
-	assert.Equal(t, resolver.StatusOK, resp.Status)
-	assert.NotEmpty(t, resp.Records["A"])
-	assert.NotEmpty(t, resp.Records["AAAA"])
-}
-
-// TestQueryTypes_EveryAddressFails asks a google.com nameserver about
-// cloudflare.com, a zone it does not serve, at 192.0.2.1, where nothing
-// answers, and then at its own address, which refuses. The nameserver
-// has failed with the refusal, not a timeout, and the warning about the
-// type gives the reason at each address.
-func TestQueryTypes_EveryAddressFails(t *testing.T) {
-	t.Parallel()
-
-	var logs bytes.Buffer
-
-	r := resolver.NewFromLogger(slog.New(slog.NewTextHandler(&logs, nil)))
-	ns := findOneNSForDomain(t, r, "google.com")
-	nsIPs := append(
-		[]string{noAnswerAddress}, liveResolveNSIPs(t, r, []string{ns}, 1)...,
-	)
-
-	var resp *resolver.NameserverResponse
-
-	livednstest.Retry(
-		t,
-		"QueryTypes("+ns+" at "+strings.Join(nsIPs, ", ")+", cloudflare.com)",
-		func(ctx context.Context) error {
-			logs.Reset()
-
-			var err error
-
-			resp, err = r.QueryTypes(
-				ctx, ns, nsIPs, "cloudflare.com.", []uint16{dns.TypeA},
-			)
-			if err != nil {
-				return err
-			}
-
-			// A timeout or a network error at its own address is no
-			// reply at all.
-			if resp.Status == resolver.StatusTimeout ||
-				strings.HasPrefix(resp.Error, "network error") {
-				return fmt.Errorf(
-					"%w: %s: %s", livednstest.ErrNoAnswer, ns, resp.Error,
-				)
-			}
-
-			return nil
-		},
-	)
-
-	assert.Equal(t, resolver.StatusError, resp.Status)
-	assert.Equal(t, "server returned REFUSED", resp.Error)
-	assert.Contains(t, logs.String(), "@"+noAnswerAddress+": ")
-	assert.Contains(t, logs.String(), "@"+nsIPs[1]+": ")
-}
-
-// TestQueryTypes_NoAddress asks a nameserver given no address. There is
-// nothing to ask it at, so it has failed, with an error that says it has
-// no address; it is not ok.
-func TestQueryTypes_NoAddress(t *testing.T) {
-	t.Parallel()
-
-	resp, err := newTestResolver(t).QueryTypes(
-		t.Context(), "ns1.example.net.", nil, "www.example.net.",
-		[]uint16{dns.TypeA},
-	)
-	require.ErrorIs(t, err, resolver.ErrNoNameserverAddress)
-	assert.Nil(t, resp)
-}
-
 func TestQueryNameserver_AAAA(t *testing.T) {
 	t.Parallel()
 
@@ -542,9 +424,8 @@ func TestQueryNameserver_TXT(t *testing.T) {
 // nameserver about google.com with a resolver whose retries over TCP
 // fail. google.com's TXT records do not fit in a reply over UDP, so TXT
 // is reported as failed, holding none of the records that fit, and
-// logged with the reason, which names the address whose reply was
+// logged with the reason, while the nameserver, which answered the other
-// truncated, while the nameserver, which answered the other types, is
+// types, is ok.
-// ok.
 func TestQueryNameserver_TruncatedReplyWhoseTCPRetryFails(t *testing.T) {
 	t.Parallel()
 
@@ -561,13 +442,6 @@ func TestQueryNameserver_TruncatedReplyWhoseTCPRetryFails(t *testing.T) {
 	assert.Contains(t, logs.String(),
 		"hostname=google.com. nameserver="+ns+" type=TXT error=",
 	)
-
-	nsIPs := liveResolveNSIPs(t, newTestResolver(t), []string{ns}, 1)
-	for _, ip := range nsIPs {
-		assert.Contains(t, logs.String(),
-			"@"+ip+": "+resolver.ErrTruncated.Error(),
-		)
-	}
 }
 
 func TestQueryNameserver_NXDomain(t *testing.T) {
@@ -621,57 +495,6 @@ func TestQueryNameserver_Refused(t *testing.T) {
 	assert.Equal(t, "server returned REFUSED", resp.Error)
 }
 
-// TestQueryNameserver_EveryAddressRefuses asks ada.ns.cloudflare.com,
-// whose name has several IPv4 addresses, about google.com, a zone it
-// does not serve, which it refuses. A record type is asked at each of
-// the nameserver's addresses before it fails, so the warning about it
-// names every one.
-func TestQueryNameserver_EveryAddressRefuses(t *testing.T) {
-	t.Parallel()
-
-	const ns = "ada.ns.cloudflare.com."
-
-	var logs bytes.Buffer
-
-	r := resolver.NewFromLogger(slog.New(slog.NewTextHandler(&logs, nil)))
-	nsIPs := liveResolveNSIPs(t, r, []string{ns}, 2)
-
-	var resp *resolver.NameserverResponse
-
-	livednstest.Retry(
-		t,
-		"QueryNameserver("+ns+", google.com)",
-		func(ctx context.Context) error {
-			logs.Reset()
-
-			var err error
-
-			resp, err = r.QueryNameserver(ctx, ns, "google.com")
-			if err != nil {
-				return err
-			}
-
-			// A timeout or a network error at every address is no
-			// reply at all.
-			if resp.Status == resolver.StatusTimeout ||
-				strings.HasPrefix(resp.Error, "network error") {
-				return fmt.Errorf(
-					"%w: %s: %s", livednstest.ErrNoAnswer, ns, resp.Error,
-				)
-			}
-
-			return nil
-		},
-	)
-
-	assert.Equal(t, resolver.StatusError, resp.Status)
-	assert.Equal(t, "server returned REFUSED", resp.Error)
-
-	for _, ip := range nsIPs {
-		assert.Contains(t, logs.String(), "@"+ip+": ")
-	}
-}
-
 // TestQueryServers_RecursiveResolverRefused passes a public recursive
 // resolver to QueryServers as the server of google.com. These resolvers
 // refuse a query that does not ask for recursion and answer one that
@@ -850,74 +673,6 @@ func TestQueryServers_NotEveryRootServerRefused(t *testing.T) {
 	require.NotContains(t, err.Error(), "refused a query for")
 }
 
-// TestQueryServers_RecursiveResolversAsRootServers passes public
-// recursive resolvers to QueryServers as the servers of the root zone,
-// as a network that sends every DNS query to a resolver would. Their
-// replies are marked recursion available, which no root server's is:
-// SERVFAIL, REFUSED, or an answer from a resolver's cache, as 1.1.1.1
-// gives for com., which would be used if a root server gave it. The
-// first such reply ends the lookup with ErrIntercepted, naming the
-// resolver that gave it. In the first group the replies differ; every
-// resolver in the second refuses a query that does not ask for
-// recursion, as 9.9.9.9 does, so there a refusal ends the lookup
-// instead of being passed over. Each group has resolvers of four
-// operators, and a resolver that gives no reply is passed over for the
-// next, so one of them answering is enough.
-func TestQueryServers_RecursiveResolversAsRootServers(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-	groups := [][]string{
-		{"1.1.1.1", "8.8.8.8", "9.9.9.9", "208.67.222.222"},
-		{"64.6.64.6", "185.222.222.222", "4.2.2.1", "94.140.14.14"},
-	}
-
-	for _, resolvers := range groups {
-		for _, name := range []string{"com.", "desec.io."} {
-			var err error
-
-			livednstest.Retry(
-				t,
-				"QueryServers("+strings.Join(resolvers, ", ")+
-					" as root servers, "+name+")",
-				func(ctx context.Context) error {
-					_, err = r.QueryServers(
-						ctx, resolvers, ".", name, dns.TypeNS,
-					)
-
-					// When no resolver gave a reply marked recursion
-					// available, none may have replied at all, so the
-					// attempt is tried again.
-					if err != nil && !strings.Contains(
-						err.Error(), "marked recursion available",
-					) {
-						return fmt.Errorf(
-							"%w: %w", livednstest.ErrNoAnswer, err,
-						)
-					}
-
-					return nil
-				},
-			)
-
-			require.ErrorIs(t, err, resolver.ErrIntercepted)
-
-			// The error names the resolver whose reply ended the
-			// lookup.
-			messages := make([]string, 0, len(resolvers))
-			for _, ip := range resolvers {
-				messages = append(messages,
-					"query "+name+" @"+ip+": reply marked recursion "+
-						"available, so not from a root server: "+
-						"this network intercepts DNS queries",
-				)
-			}
-
-			require.Contains(t, messages, err.Error())
-		}
-	}
-}
-
 func TestQueryNameserver_RecordsSorted(t *testing.T) {
 	t.Parallel()
 
@@ -1448,10 +1203,10 @@ func TestQueryNameserverIP_Timeout(t *testing.T) {
 	r := newTestResolver(t)
 
 	// Nothing answers at 192.0.2.1, a documentation address. The
-	// resolver tries each query twice, and each try gives up after two
+	// resolver tries each query twice, and the first try gives up
-	// seconds. This deadline ends during the second try of the first
+	// after two seconds. A deadline that ends during the first try
-	// record type; TestQueryNameserverIP_DeadlineDuringFirstTry covers
+	// makes the status vary from run to run between error and
-	// one that ends during the first.
+	// timeout, so the deadline must outlast the first try.
 	ctx, cancel := context.WithTimeout(
 		context.Background(), 3*time.Second,
 	)
@@ -1467,62 +1222,6 @@ func TestQueryNameserverIP_Timeout(t *testing.T) {
 	assert.NotEmpty(t, resp.Error)
 }
 
-// TestQueryNameserverIP_DeadlineDuringFirstTry gives a query to
-// 192.0.2.1, where nothing answers, a deadline that ends during its
-// first try. That try ends at the deadline as a timeout, so the
-// nameserver is reported as timed out, not as answering.
-func TestQueryNameserverIP_DeadlineDuringFirstTry(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-
-	// Well under the two seconds one try waits.
-	ctx, cancel := context.WithTimeout(
-		context.Background(), 500*time.Millisecond,
-	)
-	t.Cleanup(cancel)
-
-	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)
-}
-
-// TestQueryNameserverIP_CancelDuringFirstTry cancels the context while
-// the first try of a query to 192.0.2.1, where nothing answers, waits
-// for a reply. That try's timeout is all that is learned about the
-// nameserver, so it is reported as timed out, not as answering.
-func TestQueryNameserverIP_CancelDuringFirstTry(t *testing.T) {
-	t.Parallel()
-
-	r := newTestResolver(t)
-
-	// The first try starts at once and waits two seconds for a reply;
-	// the cancel comes a second in. The DNS client cuts a try short at
-	// the context's deadline but not at a cancel, so the try still
-	// waits its full two seconds and ends as a timeout a second after
-	// the cancel. By then the context has certainly ended, so no second
-	// try is made. With a deadline instead, the try ends at the moment
-	// the context does, and whether a second try is made depends on
-	// which the resolver sees first.
-	ctx, cancel := context.WithCancel(context.Background())
-	t.Cleanup(cancel)
-	time.AfterFunc(time.Second, cancel)
-
-	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)
-}
-
 // TestQueryNameserverIP_CancelledLogsNothing cancels the context while
 // a query to 192.0.2.1, where nothing answers, is waiting for a reply,
 // as shutdown does. The query was cut short, not failed, so nothing is

internal/server/routes.go

@@ -8,6 +8,8 @@ import (
 	"github.com/go-chi/chi/v5"
 	chimw "github.com/go-chi/chi/v5/middleware"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+
+	"sneak.berlin/go/dnswatcher/static"
 )
 
 // requestTimeout is the maximum duration for handling a request.
@@ -45,7 +47,13 @@ func (s *Server) SetupRoutes() {
 	public.Get("/", s.handlers.HandleDashboard())
 
 	// Static assets (embedded CSS/JS)
-	public.Mount("/s", http.StripPrefix("/s", s.handlers.HandleStatic()))
+	public.Mount(
+		"/s",
+		http.StripPrefix(
+			"/s",
+			http.FileServer(http.FS(static.Static)),
+		),
+	)
 
 	// Health check (standard well-known path)
 	public.Get(

internal/server/routes_test.go

@@ -1,7 +1,6 @@
 package server_test
 
 import (
-	"mime"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -289,42 +288,3 @@ func TestMetricsRateLimitComesBeforeAuth(t *testing.T) {
 		t.Errorf("another address: status = %d, want 200", rec.Code)
 	}
 }
-
-// TestStaticDirectoriesAnswerNotFound checks that a request naming a
-// directory of the static assets, with or without the trailing slash,
-// answers 404 rather than a listing of it or a redirect to one, and
-// that the stylesheet is still served as CSS.
-func TestStaticDirectoriesAnswerNotFound(t *testing.T) {
-	viper.Reset()
-	t.Setenv("DNSWATCHER_TARGETS", "example.com")
-
-	srv := routedServer(t)
-
-	for _, path := range []string{"/s", "/s/", "/s/css", "/s/css/"} {
-		rec := serve(srv, httptest.NewRequestWithContext(
-			t.Context(), http.MethodGet, path, nil,
-		))
-
-		if rec.Code != http.StatusNotFound {
-			t.Errorf("GET %s: status = %d, want 404", path, rec.Code)
-		}
-	}
-
-	rec := serve(srv, httptest.NewRequestWithContext(
-		t.Context(), http.MethodGet, "/s/css/tailwind.min.css", nil,
-	))
-
-	if rec.Code != http.StatusOK {
-		t.Errorf("GET stylesheet: status = %d, want 200", rec.Code)
-	}
-
-	contentType := rec.Header().Get("Content-Type")
-
-	mediaType, _, err := mime.ParseMediaType(contentType)
-	if err != nil || mediaType != "text/css" {
-		t.Errorf(
-			"GET stylesheet: Content-Type = %q, want text/css",
-			contentType,
-		)
-	}
-}