package watcher_test

import (
	"log/slog"
	"testing"

	"sneak.berlin/go/dnswatcher/internal/resolver"
	"sneak.berlin/go/dnswatcher/internal/watcher"
)

// TestDNSUnreachableWhenNoRootServerGivesUsableReply runs one round of
// checks of a domain and a hostname with every walk starting at real
// servers that are not root servers. At 192.0.2.1, a documentation
// address, nothing answers, as when no root server answers. Public
// recursive resolvers of four operators mark their replies recursion
// available, as on a network that intercepts DNS queries; one that gives
// no reply is passed over for the next, and if none replies, no root
// server answered. Either way every lookup failed because no root server
// gave a usable reply, so the round could not reach the DNS.
// TestFirstRunBaseline and TestDomainThatDoesNotExist check rounds in
// which the root servers gave a usable reply.
func TestDNSUnreachableWhenNoRootServerGivesUsableReply(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		servers []string
	}{
		{"no root server answers", []string{"192.0.2.1"}},
		{
			"the network intercepts DNS queries",
			[]string{"1.1.1.1", "8.8.8.8", "9.9.9.9", "208.67.222.222"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			cfg := defaultTestConfig(t)
			cfg.Domains = []string{testSmallDomain}
			cfg.Hostnames = []string{testHost}

			deps := newTestDeps(t, cfg)
			w := watcher.NewForTest(
				cfg,
				deps.state,
				resolver.NewWithRootServers(slog.Default(), tt.servers),
				deps.portChecker,
				deps.tlsChecker,
				deps.notifier,
			)

			if w.DNSUnreachable() {
				t.Error("DNSUnreachable is true before the first round")
			}

			w.RunOnce(t.Context())

			if !w.DNSUnreachable() {
				t.Error("DNSUnreachable is false after a round in " +
					"which no root server gave a usable reply")
			}
		})
	}
}