From 889855306f4372a27d958ce6be6db9d947316c12 Mon Sep 17 00:00:00 2001 From: clawbot Date: Sun, 22 Feb 2026 04:25:33 -0800 Subject: [PATCH] fix: mock DNS in resolver tests for deterministic fast suite MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace all real DNS queries in resolver_test.go with a mock DNSClient that simulates the full iterative resolution hierarchy (root → TLD → auth NS). - Uses NewFromLoggerWithClient with mock DNSClient - All 28 test behaviors preserved (NS lookup, A/AAAA/MX/TXT, NXDOMAIN, sorting, dedup, context cancellation, trailing dots) - Tests pass with -race flag, no data races - Total resolver test time: ~1.5s (was >30s) - Zero linter issues Closes #32 --- internal/resolver/resolver_test.go | 591 ++++++++++++++++++++++++++--- 1 file changed, 543 insertions(+), 48 deletions(-) diff --git a/internal/resolver/resolver_test.go b/internal/resolver/resolver_test.go index 3b9d936..8c00350 100644 --- a/internal/resolver/resolver_test.go +++ b/internal/resolver/resolver_test.go @@ -2,6 +2,7 @@ package resolver_test import ( "context" + "fmt" "log/slog" "net" "os" @@ -10,12 +11,504 @@ import ( "testing" "time" + "github.com/miekg/dns" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "sneak.berlin/go/dnswatcher/internal/resolver" ) +// ---------------------------------------------------------------- +// Mock DNS client +// ---------------------------------------------------------------- + +// mockDNSClient implements resolver.DNSClient with canned responses. +type mockDNSClient struct { + handlers map[string]func(msg *dns.Msg) *dns.Msg +} + +func newMockClient() *mockDNSClient { + return &mockDNSClient{ + handlers: make(map[string]func(msg *dns.Msg) *dns.Msg), + } +} + +func (m *mockDNSClient) ExchangeContext( + ctx context.Context, + msg *dns.Msg, + addr string, +) (*dns.Msg, time.Duration, error) { + err := ctx.Err() + if err != nil { + return nil, 0, err + } + + host, _, _ := net.SplitHostPort(addr) + if host == "" { + host = addr + } + + qname := msg.Question[0].Name + qtype := dns.TypeToString[msg.Question[0].Qtype] + + resp := m.findHandler(host, qname, qtype, msg) + + return resp, time.Millisecond, nil +} + +func (m *mockDNSClient) findHandler( + host, qname, qtype string, + msg *dns.Msg, +) *dns.Msg { + key := fmt.Sprintf( + "%s|%s|%s", host, strings.ToLower(qname), qtype, + ) + + if h, ok := m.handlers[key]; ok { + return h(msg) + } + + wildKey := fmt.Sprintf( + "*|%s|%s", strings.ToLower(qname), qtype, + ) + + if h, ok := m.handlers[wildKey]; ok { + return h(msg) + } + + resp := new(dns.Msg) + resp.SetReply(msg) + + return resp +} + +func (m *mockDNSClient) on( + server, qname, qtype string, + handler func(msg *dns.Msg) *dns.Msg, +) { + key := fmt.Sprintf( + "%s|%s|%s", + server, dns.Fqdn(strings.ToLower(qname)), qtype, + ) + m.handlers[key] = handler +} + +// ---------------------------------------------------------------- +// Response builders +// ---------------------------------------------------------------- + +func referralResponse( + msg *dns.Msg, + nsNames []string, + glue map[string]string, +) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + + for _, ns := range nsNames { + resp.Ns = append(resp.Ns, &dns.NS{ + Hdr: dns.RR_Header{ + Name: msg.Question[0].Name, + Rrtype: dns.TypeNS, + Class: dns.ClassINET, + Ttl: 3600, + }, + Ns: dns.Fqdn(ns), + }) + } + + for name, ip := range glue { + resp.Extra = append(resp.Extra, &dns.A{ + Hdr: dns.RR_Header{ + Name: dns.Fqdn(name), + Rrtype: dns.TypeA, + Class: dns.ClassINET, + Ttl: 3600, + }, + A: net.ParseIP(ip), + }) + } + + return resp +} + +func nsAnswerResponse( + msg *dns.Msg, nsNames []string, +) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + + for _, ns := range nsNames { + resp.Answer = append(resp.Answer, &dns.NS{ + Hdr: dns.RR_Header{ + Name: msg.Question[0].Name, + Rrtype: dns.TypeNS, + Class: dns.ClassINET, + Ttl: 3600, + }, + Ns: dns.Fqdn(ns), + }) + } + + return resp +} + +func nxdomainResponse(msg *dns.Msg) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + resp.Rcode = dns.RcodeNameError + + return resp +} + +func aResponse( + msg *dns.Msg, name string, ip string, +) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + resp.Answer = append(resp.Answer, &dns.A{ + Hdr: dns.RR_Header{ + Name: dns.Fqdn(name), Rrtype: dns.TypeA, + Class: dns.ClassINET, Ttl: 300, + }, + A: net.ParseIP(ip), + }) + + return resp +} + +func aaaaResponse( + msg *dns.Msg, name string, ip string, +) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + resp.Answer = append(resp.Answer, &dns.AAAA{ + Hdr: dns.RR_Header{ + Name: dns.Fqdn(name), Rrtype: dns.TypeAAAA, + Class: dns.ClassINET, Ttl: 300, + }, + AAAA: net.ParseIP(ip), + }) + + return resp +} + +func emptyResponse(msg *dns.Msg) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + + return resp +} + +// ---------------------------------------------------------------- +// Mock DNS hierarchy setup +// ---------------------------------------------------------------- + +// mockData holds all test DNS hierarchy configuration. +type mockData struct { + tldNS []string + tldGlue map[string]string + exNS []string + exGlue map[string]string + cfNS []string + cfGlue map[string]string +} + +func newMockData() mockData { + return mockData{ + tldNS: []string{"ns1.tld.com", "ns2.tld.com"}, + tldGlue: map[string]string{ + "ns1.tld.com": "10.0.0.1", + "ns2.tld.com": "10.0.0.2", + }, + exNS: []string{ + "ns1.example.com", "ns2.example.com", + "ns3.example.com", + }, + exGlue: map[string]string{ + "ns1.example.com": "10.1.0.1", + "ns2.example.com": "10.1.0.2", + "ns3.example.com": "10.1.0.3", + }, + cfNS: []string{ + "ns1.cloudflare.com", "ns2.cloudflare.com", + }, + cfGlue: map[string]string{ + "ns1.cloudflare.com": "10.2.0.1", + "ns2.cloudflare.com": "10.2.0.2", + }, + } +} + +func rootIPList() []string { + return []string{ + "198.41.0.4", "170.247.170.2", "192.33.4.12", + "199.7.91.13", "192.203.230.10", "192.5.5.241", + "192.112.36.4", "198.97.190.53", "192.36.148.17", + "192.58.128.30", "193.0.14.129", "199.7.83.42", + "202.12.27.33", + } +} + +func allQueryTypes() []string { + return []string{ + "NS", "A", "AAAA", "CNAME", "MX", "TXT", "SRV", "CAA", + } +} + +func setupRootDelegations( + m *mockDNSClient, + tNS []string, + tGlue map[string]string, +) { + domains := []string{ + "example.com.", "www.example.com.", + "this-surely-does-not-exist-xyz.example.com.", + "cloudflare.com.", + } + + for _, rootIP := range rootIPList() { + for _, domain := range domains { + for _, qtype := range allQueryTypes() { + m.on(rootIP, domain, qtype, + func(msg *dns.Msg) *dns.Msg { + return referralResponse( + msg, tNS, tGlue, + ) + }, + ) + } + } + } +} + +func setupRootARecords(m *mockDNSClient) { + nsIPs := map[string]string{ + "ns1.example.com.": "10.1.0.1", + "ns2.example.com.": "10.1.0.2", + "ns3.example.com.": "10.1.0.3", + "ns1.cloudflare.com.": "10.2.0.1", + "ns2.cloudflare.com.": "10.2.0.2", + } + + for _, rootIP := range rootIPList() { + for nsName, nsIP := range nsIPs { + ip := nsIP + name := nsName + + m.on(rootIP, name, "A", + func(msg *dns.Msg) *dns.Msg { + return aResponse(msg, name, ip) + }, + ) + } + } +} + +func setupTLDDelegations( + m *mockDNSClient, + exNS []string, + exGlue map[string]string, + cfNS []string, + cfGlue map[string]string, +) { + tldIPs := []string{"10.0.0.1", "10.0.0.2"} + + exDomains := []string{ + "example.com.", "www.example.com.", + "this-surely-does-not-exist-xyz.example.com.", + } + + for _, tldIP := range tldIPs { + for _, domain := range exDomains { + for _, qtype := range allQueryTypes() { + m.on(tldIP, domain, qtype, + func(msg *dns.Msg) *dns.Msg { + return referralResponse( + msg, exNS, exGlue, + ) + }, + ) + } + } + + for _, qtype := range allQueryTypes() { + m.on(tldIP, "cloudflare.com.", qtype, + func(msg *dns.Msg) *dns.Msg { + return referralResponse( + msg, cfNS, cfGlue, + ) + }, + ) + } + } +} + +func setupExampleNSAndA( + m *mockDNSClient, exNS []string, +) { + exIPs := []string{"10.1.0.1", "10.1.0.2", "10.1.0.3"} + + for _, authIP := range exIPs { + m.on(authIP, "example.com.", "NS", + func(msg *dns.Msg) *dns.Msg { + return nsAnswerResponse(msg, exNS) + }, + ) + + m.on(authIP, "example.com.", "A", + func(msg *dns.Msg) *dns.Msg { + return aResponse( + msg, "example.com.", "93.184.216.34", + ) + }, + ) + + m.on(authIP, "example.com.", "AAAA", + func(msg *dns.Msg) *dns.Msg { + return aaaaResponse( + msg, "example.com.", + "2606:2800:220:1:248:1893:25c8:1946", + ) + }, + ) + } +} + +func setupExampleMXAndTXT(m *mockDNSClient) { + exIPs := []string{"10.1.0.1", "10.1.0.2", "10.1.0.3"} + + for _, authIP := range exIPs { + m.on(authIP, "example.com.", "MX", + func(msg *dns.Msg) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + resp.Answer = append(resp.Answer, + &dns.MX{ + Hdr: dns.RR_Header{ + Name: "example.com.", + Rrtype: dns.TypeMX, + Class: dns.ClassINET, + Ttl: 300, + }, + Preference: 10, + Mx: "mail.example.com.", + }, + &dns.MX{ + Hdr: dns.RR_Header{ + Name: "example.com.", + Rrtype: dns.TypeMX, + Class: dns.ClassINET, + Ttl: 300, + }, + Preference: 20, + Mx: "mail2.example.com.", + }, + ) + + return resp + }, + ) + + m.on(authIP, "example.com.", "TXT", + func(msg *dns.Msg) *dns.Msg { + resp := new(dns.Msg) + resp.SetReply(msg) + resp.Answer = append(resp.Answer, &dns.TXT{ + Hdr: dns.RR_Header{ + Name: "example.com.", + Rrtype: dns.TypeTXT, + Class: dns.ClassINET, + Ttl: 300, + }, + Txt: []string{ + "v=spf1 include:_spf.example.com ~all", + }, + }) + + return resp + }, + ) + } +} + +func setupExampleSubdomains( + m *mockDNSClient, exNS []string, +) { + exIPs := []string{"10.1.0.1", "10.1.0.2", "10.1.0.3"} + + for _, authIP := range exIPs { + m.on(authIP, "www.example.com.", "NS", + func(msg *dns.Msg) *dns.Msg { + return nsAnswerResponse(msg, exNS) + }, + ) + + m.on(authIP, "www.example.com.", "A", + func(msg *dns.Msg) *dns.Msg { + return aResponse( + msg, "www.example.com.", "93.184.216.34", + ) + }, + ) + + nxName := "this-surely-does-not-exist-xyz.example.com." + for _, qtype := range allQueryTypes() { + m.on(authIP, nxName, qtype, nxdomainResponse) + } + } +} + +func setupCloudflareAuthRecords( + m *mockDNSClient, cfNS []string, +) { + cfIPs := []string{"10.2.0.1", "10.2.0.2"} + + for _, authIP := range cfIPs { + m.on(authIP, "cloudflare.com.", "NS", + func(msg *dns.Msg) *dns.Msg { + return nsAnswerResponse(msg, cfNS) + }, + ) + + m.on(authIP, "cloudflare.com.", "A", + func(msg *dns.Msg) *dns.Msg { + return aResponse( + msg, "cloudflare.com.", "104.16.132.229", + ) + }, + ) + + m.on(authIP, "cloudflare.com.", "AAAA", + func(msg *dns.Msg) *dns.Msg { + return aaaaResponse( + msg, "cloudflare.com.", + "2606:4700::6810:84e5", + ) + }, + ) + + m.on(authIP, "cloudflare.com.", "MX", emptyResponse) + m.on(authIP, "cloudflare.com.", "TXT", emptyResponse) + } +} + +func setupMockDNS() *mockDNSClient { + m := newMockClient() + + d := newMockData() + + setupRootDelegations(m, d.tldNS, d.tldGlue) + setupRootARecords(m) + setupTLDDelegations(m, d.exNS, d.exGlue, d.cfNS, d.cfGlue) + setupExampleNSAndA(m, d.exNS) + setupExampleMXAndTXT(m) + setupExampleSubdomains(m, d.exNS) + setupCloudflareAuthRecords(m, d.cfNS) + + return m +} + // ---------------------------------------------------------------- // Test helpers // ---------------------------------------------------------------- @@ -28,14 +521,14 @@ func newTestResolver(t *testing.T) *resolver.Resolver { &slog.HandlerOptions{Level: slog.LevelDebug}, )) - return resolver.NewFromLogger(log) + return resolver.NewFromLoggerWithClient(log, setupMockDNS()) } func testContext(t *testing.T) context.Context { t.Helper() ctx, cancel := context.WithTimeout( - context.Background(), 60*time.Second, + context.Background(), 10*time.Second, ) t.Cleanup(cancel) @@ -72,23 +565,23 @@ func TestFindAuthoritativeNameservers_ValidDomain( ctx := testContext(t) nameservers, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) require.NotEmpty(t, nameservers) - hasGoogleNS := false + hasExampleNS := false for _, ns := range nameservers { - if strings.Contains(ns, "google") { - hasGoogleNS = true + if strings.Contains(ns, "example") { + hasExampleNS = true break } } - assert.True(t, hasGoogleNS, - "expected google nameservers, got: %v", nameservers, + assert.True(t, hasExampleNS, + "expected example nameservers, got: %v", nameservers, ) } @@ -101,7 +594,7 @@ func TestFindAuthoritativeNameservers_Subdomain( ctx := testContext(t) nameservers, err := r.FindAuthoritativeNameservers( - ctx, "www.google.com", + ctx, "www.example.com", ) require.NoError(t, err) require.NotEmpty(t, nameservers) @@ -116,7 +609,7 @@ func TestFindAuthoritativeNameservers_ReturnsSorted( ctx := testContext(t) nameservers, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) @@ -136,12 +629,12 @@ func TestFindAuthoritativeNameservers_Deterministic( ctx := testContext(t) first, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) second, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) @@ -157,12 +650,12 @@ func TestFindAuthoritativeNameservers_TrailingDot( ctx := testContext(t) ns1, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) ns2, err := r.FindAuthoritativeNameservers( - ctx, "google.com.", + ctx, "example.com.", ) require.NoError(t, err) @@ -199,10 +692,10 @@ func TestQueryNameserver_BasicA(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( - ctx, ns, "www.google.com", + ctx, ns, "www.example.com", ) require.NoError(t, err) require.NotNil(t, resp) @@ -213,7 +706,7 @@ func TestQueryNameserver_BasicA(t *testing.T) { hasRecords := len(resp.Records["A"]) > 0 || len(resp.Records["CNAME"]) > 0 assert.True(t, hasRecords, - "expected A or CNAME records for www.google.com", + "expected A or CNAME records for www.example.com", ) } @@ -247,16 +740,16 @@ func TestQueryNameserver_MX(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( - ctx, ns, "google.com", + ctx, ns, "example.com", ) require.NoError(t, err) mxRecords := resp.Records["MX"] require.NotEmpty(t, mxRecords, - "google.com should have MX records", + "example.com should have MX records", ) } @@ -265,16 +758,16 @@ func TestQueryNameserver_TXT(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( - ctx, ns, "google.com", + ctx, ns, "example.com", ) require.NoError(t, err) txtRecords := resp.Records["TXT"] require.NotEmpty(t, txtRecords, - "google.com should have TXT records", + "example.com should have TXT records", ) hasSPF := false @@ -288,7 +781,7 @@ func TestQueryNameserver_TXT(t *testing.T) { } assert.True(t, hasSPF, - "google.com should have SPF TXT record", + "example.com should have SPF TXT record", ) } @@ -297,11 +790,11 @@ func TestQueryNameserver_NXDomain(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( ctx, ns, - "this-surely-does-not-exist-xyz.google.com", + "this-surely-does-not-exist-xyz.example.com", ) require.NoError(t, err) @@ -313,10 +806,10 @@ func TestQueryNameserver_RecordsSorted(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( - ctx, ns, "google.com", + ctx, ns, "example.com", ) require.NoError(t, err) @@ -353,11 +846,11 @@ func TestQueryNameserver_EmptyRecordsOnNXDomain( r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp, err := r.QueryNameserver( ctx, ns, - "this-surely-does-not-exist-xyz.google.com", + "this-surely-does-not-exist-xyz.example.com", ) require.NoError(t, err) @@ -374,15 +867,15 @@ func TestQueryNameserver_TrailingDotHandling(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ns := findOneNSForDomain(t, r, ctx, "google.com") + ns := findOneNSForDomain(t, r, ctx, "example.com") resp1, err := r.QueryNameserver( - ctx, ns, "google.com", + ctx, ns, "example.com", ) require.NoError(t, err) resp2, err := r.QueryNameserver( - ctx, ns, "google.com.", + ctx, ns, "example.com.", ) require.NoError(t, err) @@ -400,7 +893,7 @@ func TestQueryAllNameservers_ReturnsAllNS(t *testing.T) { ctx := testContext(t) results, err := r.QueryAllNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) require.NotEmpty(t, results) @@ -419,7 +912,7 @@ func TestQueryAllNameservers_AllReturnOK(t *testing.T) { ctx := testContext(t) results, err := r.QueryAllNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) @@ -441,7 +934,7 @@ func TestQueryAllNameservers_NXDomainFromAllNS( results, err := r.QueryAllNameservers( ctx, - "this-surely-does-not-exist-xyz.google.com", + "this-surely-does-not-exist-xyz.example.com", ) require.NoError(t, err) @@ -463,7 +956,7 @@ func TestLookupNS_ValidDomain(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - nameservers, err := r.LookupNS(ctx, "google.com") + nameservers, err := r.LookupNS(ctx, "example.com") require.NoError(t, err) require.NotEmpty(t, nameservers) @@ -480,7 +973,7 @@ func TestLookupNS_Sorted(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - nameservers, err := r.LookupNS(ctx, "google.com") + nameservers, err := r.LookupNS(ctx, "example.com") require.NoError(t, err) assert.True(t, sort.StringsAreSorted(nameservers)) @@ -492,11 +985,11 @@ func TestLookupNS_MatchesFindAuthoritative(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - fromLookup, err := r.LookupNS(ctx, "google.com") + fromLookup, err := r.LookupNS(ctx, "example.com") require.NoError(t, err) fromFind, err := r.FindAuthoritativeNameservers( - ctx, "google.com", + ctx, "example.com", ) require.NoError(t, err) @@ -513,7 +1006,7 @@ func TestResolveIPAddresses_ReturnsIPs(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ips, err := r.ResolveIPAddresses(ctx, "google.com") + ips, err := r.ResolveIPAddresses(ctx, "example.com") require.NoError(t, err) require.NotEmpty(t, ips) @@ -531,7 +1024,7 @@ func TestResolveIPAddresses_Deduplicated(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ips, err := r.ResolveIPAddresses(ctx, "google.com") + ips, err := r.ResolveIPAddresses(ctx, "example.com") require.NoError(t, err) seen := make(map[string]bool) @@ -548,7 +1041,7 @@ func TestResolveIPAddresses_Sorted(t *testing.T) { r := newTestResolver(t) ctx := testContext(t) - ips, err := r.ResolveIPAddresses(ctx, "google.com") + ips, err := r.ResolveIPAddresses(ctx, "example.com") require.NoError(t, err) assert.True(t, sort.StringsAreSorted(ips)) @@ -564,7 +1057,7 @@ func TestResolveIPAddresses_NXDomainReturnsEmpty( ips, err := r.ResolveIPAddresses( ctx, - "this-surely-does-not-exist-xyz.google.com", + "this-surely-does-not-exist-xyz.example.com", ) require.NoError(t, err) assert.Empty(t, ips) @@ -594,7 +1087,9 @@ func TestFindAuthoritativeNameservers_ContextCanceled( ctx, cancel := context.WithCancel(context.Background()) cancel() - _, err := r.FindAuthoritativeNameservers(ctx, "google.com") + _, err := r.FindAuthoritativeNameservers( + ctx, "example.com", + ) assert.Error(t, err) } @@ -606,7 +1101,7 @@ func TestQueryNameserver_ContextCanceled(t *testing.T) { cancel() _, err := r.QueryNameserver( - ctx, "ns1.google.com.", "google.com", + ctx, "ns1.example.com.", "example.com", ) assert.Error(t, err) } @@ -618,7 +1113,7 @@ func TestQueryAllNameservers_ContextCanceled(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() - _, err := r.QueryAllNameservers(ctx, "google.com") + _, err := r.QueryAllNameservers(ctx, "example.com") assert.Error(t, err) } @@ -629,6 +1124,6 @@ func TestResolveIPAddresses_ContextCanceled(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() - _, err := r.ResolveIPAddresses(ctx, "google.com") + _, err := r.ResolveIPAddresses(ctx, "example.com") assert.Error(t, err) }