This commit was merged in pull request #12.
This commit is contained in:
@@ -0,0 +1,727 @@
|
||||
package traverse
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
dnsinternal "github.com/hits/ExploreDNS/internal/dns"
|
||||
"github.com/miekg/dns"
|
||||
)
|
||||
|
||||
func TestSetHooks(t *testing.T) {
|
||||
tr := NewTraverser(nil)
|
||||
hooks := &TraverserHooks{
|
||||
OnEvent: func(event TraversalEvent) {},
|
||||
}
|
||||
tr.SetHooks(hooks)
|
||||
if tr.config.Hooks != hooks {
|
||||
t.Error("SetHooks should set config.Hooks")
|
||||
}
|
||||
|
||||
// SetHooks on nil config traverser (initializes config)
|
||||
tr2 := &Traverser{}
|
||||
tr2.SetHooks(hooks)
|
||||
if tr2.config == nil || tr2.config.Hooks != hooks {
|
||||
t.Error("SetHooks should initialize config when nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewAQuery(t *testing.T) {
|
||||
msg := newAQuery("example.com.")
|
||||
if msg == nil {
|
||||
t.Fatal("newAQuery returned nil")
|
||||
}
|
||||
if !msg.RecursionDesired {
|
||||
t.Error("expected RD=true in newAQuery")
|
||||
}
|
||||
if len(msg.Question) == 0 {
|
||||
t.Fatal("expected question in newAQuery")
|
||||
}
|
||||
if msg.Question[0].Qtype != dns.TypeA {
|
||||
t.Errorf("expected TypeA, got %d", msg.Question[0].Qtype)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveGlueViaSystemCacheHit(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
cache := NewInfoCache(nil)
|
||||
expected := []net.IP{net.ParseIP("1.2.3.4")}
|
||||
cache.StoreGlue("ns1.example.com.", expected)
|
||||
|
||||
ctx := context.Background()
|
||||
addrs := tr.resolveGlueViaSystem(ctx, "ns1.example.com.", cache)
|
||||
if len(addrs) == 0 {
|
||||
t.Error("expected addresses from cache hit")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveGlueViaSystemExpiredContext(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
|
||||
// Expired context → remaining <= 0 → returns nil immediately
|
||||
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
|
||||
defer cancel()
|
||||
|
||||
addrs := tr.resolveGlueViaSystem(ctx, "ns1.example.com.", nil)
|
||||
if len(addrs) != 0 {
|
||||
t.Errorf("expected nil from expired context, got %v", addrs)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveGlueViaSystemTimeout(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
|
||||
// Very short timeout will fail the DNS query to 127.0.0.1:53
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
|
||||
defer cancel()
|
||||
time.Sleep(15 * time.Millisecond) // ensure it's expired
|
||||
|
||||
addrs := tr.resolveGlueViaSystem(ctx, "ns1.example.com.", nil)
|
||||
// May return nil (timeout) or addresses (if local resolver responds instantly)
|
||||
t.Logf("resolveGlueViaSystem returned %d addresses", len(addrs))
|
||||
}
|
||||
|
||||
func TestEnsureRDFalseWithExchange(t *testing.T) {
|
||||
rdFalseMsg := new(dns.Msg)
|
||||
rdFalseMsg.SetReply(new(dns.Msg))
|
||||
rdFalseMsg.RecursionDesired = false
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return rdFalseMsg.Copy(), nil
|
||||
})
|
||||
|
||||
rdTrueMsg := new(dns.Msg)
|
||||
rdTrueMsg.SetReply(new(dns.Msg))
|
||||
rdTrueMsg.RecursionDesired = true
|
||||
|
||||
result := tr.ensureRDFalse(rdTrueMsg, net.ParseIP("198.41.0.4"), "example.com.", dnsinternal.TypeA, nil)
|
||||
if result == nil {
|
||||
t.Fatal("ensureRDFalse with exchange should return non-nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnsureRDFalseNilMsg(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
result := tr.ensureRDFalse(nil, net.ParseIP("1.2.3.4"), "example.com.", dnsinternal.TypeA, nil)
|
||||
if result != nil {
|
||||
t.Error("ensureRDFalse(nil) should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnsureRDFalseRDAlreadyFalse(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
|
||||
msg := new(dns.Msg)
|
||||
msg.RecursionDesired = false
|
||||
result := tr.ensureRDFalse(msg, net.ParseIP("1.2.3.4"), "example.com.", dnsinternal.TypeA, nil)
|
||||
if result != msg {
|
||||
t.Error("ensureRDFalse should return same msg when RD=false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnsureRDFalseNoExchange(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
// No exchange set
|
||||
|
||||
msg := new(dns.Msg)
|
||||
msg.RecursionDesired = true
|
||||
result := tr.ensureRDFalse(msg, net.ParseIP("1.2.3.4"), "example.com.", dnsinternal.TypeA, nil)
|
||||
if result == nil {
|
||||
t.Fatal("ensureRDFalse without exchange should return msg with RD cleared")
|
||||
}
|
||||
if result.RecursionDesired {
|
||||
t.Error("expected RD=false after ensureRDFalse without exchange")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveNSFromCache(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
cache := NewInfoCache(nil)
|
||||
expected := []net.IP{net.ParseIP("1.2.3.4")}
|
||||
cache.StoreGlue("ns1.example.com.", expected)
|
||||
|
||||
ctx := context.Background()
|
||||
addrs, err := tr.ResolveNS(ctx, "ns1.example.com.", cache, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("ResolveNS cache hit: %v", err)
|
||||
}
|
||||
if len(addrs) == 0 {
|
||||
t.Error("expected addresses from cache")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveNSCircularReferral(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
visited := map[string]bool{"ns1.example.com.": true}
|
||||
ctx := context.Background()
|
||||
_, err := tr.ResolveNS(ctx, "ns1.example.com.", nil, visited, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected circular referral error")
|
||||
}
|
||||
var circErr *CircularReferralError
|
||||
if _, ok := err.(*CircularReferralError); !ok {
|
||||
t.Errorf("expected CircularReferralError, got %T: %v", err, err)
|
||||
}
|
||||
_ = circErr
|
||||
}
|
||||
|
||||
func TestResolveNSMaxDepth(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
_, err := tr.ResolveNS(ctx, "ns1.example.com.", nil, nil, DefaultMaxDepth+1)
|
||||
if err == nil {
|
||||
t.Fatal("expected max depth error")
|
||||
}
|
||||
if _, ok := err.(*UnresolvableNameserverError); !ok {
|
||||
t.Errorf("expected UnresolvableNameserverError, got %T: %v", err, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveNSWithAnswer(t *testing.T) {
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns1.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
addrs, err := tr.ResolveNS(ctx, "ns1.example.com.", nil, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("ResolveNS with answer: %v", err)
|
||||
}
|
||||
if len(addrs) == 0 {
|
||||
t.Fatal("expected addresses from NS resolution")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveNSNXDOMAIN(t *testing.T) {
|
||||
nxMsg := new(dns.Msg)
|
||||
nxMsg.Rcode = dns.RcodeNameError
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nxMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
_, err := tr.ResolveNS(ctx, "nonexistent.invalid.", nil, nil, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for NXDOMAIN NS resolution")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveNSContextCancellation(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
// Keep returning referrals to keep the loop going
|
||||
refMsg := new(dns.Msg)
|
||||
refMsg.Rcode = dns.RcodeSuccess
|
||||
refMsg.Ns = append(refMsg.Ns, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS, Class: dns.ClassINET},
|
||||
Ns: "ns.example.com.",
|
||||
})
|
||||
refMsg.Extra = append(refMsg.Extra, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
return refMsg, nil
|
||||
})
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel() // Cancel immediately
|
||||
|
||||
_, err := tr.ResolveNS(ctx, "ns1.example.com.", nil, nil, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected error on cancelled context")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsWithRootAddrs(t *testing.T) {
|
||||
expected := []net.IP{net.ParseIP("198.41.0.4"), net.ParseIP("199.9.14.201")}
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: expected,
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
addrs, err := tr.discoverRoots(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("discoverRoots with RootAddrs: %v", err)
|
||||
}
|
||||
if len(addrs) != len(expected) {
|
||||
t.Errorf("expected %d addresses, got %d", len(expected), len(addrs))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscoverRootsFromSystem(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
// No RootAddrs - will call dns.DiscoverRoots
|
||||
})
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
addrs, err := tr.discoverRoots(ctx)
|
||||
if err != nil {
|
||||
t.Logf("discoverRoots without RootAddrs error (may skip): %v", err)
|
||||
t.Skip()
|
||||
}
|
||||
if len(addrs) == 0 {
|
||||
t.Error("expected at least one root address")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTraverserSetHooksAndTraverse(t *testing.T) {
|
||||
answerResp := new(dns.Msg)
|
||||
answerResp.SetReply(new(dns.Msg))
|
||||
answerResp.Answer = append(answerResp.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
QueryType: dnsinternal.TypeA,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerResp.Copy(), nil
|
||||
})
|
||||
|
||||
var events []TraversalEvent
|
||||
tr.SetHooks(&TraverserHooks{
|
||||
OnEvent: func(e TraversalEvent) {
|
||||
events = append(events, e)
|
||||
},
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
_, err := tr.Traverse(ctx, "example.com")
|
||||
if err != nil {
|
||||
t.Fatalf("Traverse: %v", err)
|
||||
}
|
||||
if len(events) == 0 {
|
||||
t.Error("expected events from hooks")
|
||||
}
|
||||
}
|
||||
|
||||
func TestProcessReferralNoAddresses(t *testing.T) {
|
||||
// Scenario: a referral without addresses. resolveGlueViaSystem fails (expired ctx),
|
||||
// then ResolveNS is tried via the mock exchange.
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns1.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
finalAnswerMsg := new(dns.Msg)
|
||||
finalAnswerMsg.SetReply(new(dns.Msg))
|
||||
finalAnswerMsg.Answer = append(finalAnswerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("5.6.7.8"),
|
||||
})
|
||||
|
||||
callCount := 0
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
QueryType: dnsinternal.TypeA,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
callCount++
|
||||
q := msg.Question[0]
|
||||
if q.Qtype == dns.TypeA && q.Name == "ns1.example.com." {
|
||||
return answerMsg.Copy(), nil
|
||||
}
|
||||
return finalAnswerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
// Create a referral with no addresses (the NS name needs to be resolved)
|
||||
ref := NewReferral("example.com.", dnsinternal.TypeA, "ns1.example.com.", 1, 1.0, nil)
|
||||
// Do NOT set addresses - this exercises processReferral's no-address path
|
||||
|
||||
cache := NewInfoCache(nil)
|
||||
// Use expired context for resolveGlueViaSystem so it returns nil fast
|
||||
bgCtx := context.Background()
|
||||
resp := tr.processReferral(bgCtx, ref, cache)
|
||||
// Result may vary depending on whether 127.0.0.1:53 is available,
|
||||
// but the function should not panic.
|
||||
t.Logf("processReferral result type: %v", resp.Type)
|
||||
}
|
||||
|
||||
func TestReferralResolveAlreadyHasAddresses(t *testing.T) {
|
||||
ref := NewReferral("example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
ref.Addresses = []net.IP{net.ParseIP("1.2.3.4")}
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("Resolve with existing addresses: %v", err)
|
||||
}
|
||||
if ref.State != StateResolved {
|
||||
t.Errorf("expected StateResolved, got %v", ref.State)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveCacheHit(t *testing.T) {
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
cache := NewInfoCache(nil)
|
||||
cache.StoreGlue("ns1.example.com.", []net.IP{net.ParseIP("1.2.3.4")})
|
||||
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, cache, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("Resolve cache hit: %v", err)
|
||||
}
|
||||
if ref.State != StateResolved {
|
||||
t.Errorf("expected StateResolved, got %v", ref.State)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveCircular(t *testing.T) {
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
visited := map[string]bool{"ns1.example.com.": true}
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, visited, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected circular referral error")
|
||||
}
|
||||
if _, ok := err.(*CircularReferralError); !ok {
|
||||
t.Errorf("expected CircularReferralError, got %T: %v", err, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveMaxDepth(t *testing.T) {
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, nil, DefaultMaxDepth+1)
|
||||
if err == nil {
|
||||
t.Fatal("expected max depth error")
|
||||
}
|
||||
if _, ok := err.(*UnresolvableNameserverError); !ok {
|
||||
t.Errorf("expected UnresolvableNameserverError, got %T: %v", err, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveWithAnswer(t *testing.T) {
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns1.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("Resolve: %v", err)
|
||||
}
|
||||
if ref.State != StateResolved {
|
||||
t.Errorf("expected StateResolved, got %v", ref.State)
|
||||
}
|
||||
if len(ref.Addresses) == 0 {
|
||||
t.Error("expected addresses after resolution")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveNXDOMAIN(t *testing.T) {
|
||||
nxMsg := new(dns.Msg)
|
||||
nxMsg.Rcode = dns.RcodeNameError
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return nxMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ref := NewReferral("nonexistent.invalid.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, nil, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for NXDOMAIN")
|
||||
}
|
||||
if _, ok := err.(*UnresolvableNameserverError); !ok {
|
||||
t.Errorf("expected UnresolvableNameserverError, got %T: %v", err, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveContextCancellation(t *testing.T) {
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
refMsg := new(dns.Msg)
|
||||
refMsg.Rcode = dns.RcodeSuccess
|
||||
refMsg.Ns = append(refMsg.Ns, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeNS},
|
||||
Ns: "ns.example.com.",
|
||||
})
|
||||
refMsg.Extra = append(refMsg.Extra, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns.example.com.", Rrtype: dns.TypeA},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
return refMsg, nil
|
||||
})
|
||||
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel() // Cancel immediately
|
||||
|
||||
err := ref.Resolve(ctx, tr, nil, nil, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected error on cancelled context")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReferralResolveReferralPath(t *testing.T) {
|
||||
// Test Resolve when it gets a referral response that pushes to stack
|
||||
referralMsg := new(dns.Msg)
|
||||
referralMsg.Rcode = dns.RcodeSuccess
|
||||
referralMsg.Ns = append(referralMsg.Ns, &dns.NS{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeNS, Class: dns.ClassINET},
|
||||
Ns: "ns1.example.com.",
|
||||
})
|
||||
referralMsg.Extra = append(referralMsg.Extra, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns1.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "ns1.example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("5.6.7.8"),
|
||||
})
|
||||
|
||||
callCount := 0
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
callCount++
|
||||
if callCount <= 1 {
|
||||
return referralMsg.Copy(), nil
|
||||
}
|
||||
return answerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ref := NewReferral("ns1.example.com.", dnsinternal.TypeA, ".", 0, 1.0, nil)
|
||||
ctx := context.Background()
|
||||
err := ref.Resolve(ctx, tr, nil, nil, 0)
|
||||
// May succeed or exhaust depending on referral loop
|
||||
t.Logf("Resolve referral path: err=%v, state=%v", err, ref.State)
|
||||
}
|
||||
|
||||
func TestResolutionStateStringUnknown(t *testing.T) {
|
||||
// Cover the default case of ResolutionState.String()
|
||||
unknown := ResolutionState(99)
|
||||
s := unknown.String()
|
||||
if s != "unknown" {
|
||||
t.Errorf("expected 'unknown' for invalid ResolutionState, got %q", s)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTraverserNonFastMode(t *testing.T) {
|
||||
answerResp := new(dns.Msg)
|
||||
answerResp.SetReply(new(dns.Msg))
|
||||
answerResp.Answer = append(answerResp.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
QueryType: dnsinternal.TypeA,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
Fast: false, // Non-fast mode
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerResp.Copy(), nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
results, err := tr.Traverse(ctx, "example.com")
|
||||
if err != nil {
|
||||
t.Fatalf("Traverse non-fast: %v", err)
|
||||
}
|
||||
if len(results) == 0 {
|
||||
t.Fatal("expected results")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIterativeQueryWithExchangeUsesConfig(t *testing.T) {
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
QueryType: dnsinternal.TypeA,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
QueryConfig: dnsinternal.DefaultQueryConfig(),
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
ctx := context.Background()
|
||||
msg, err := tr.iterativeQueryWithExchange(ctx, net.ParseIP("198.41.0.4"), "example.com.", dnsinternal.TypeA)
|
||||
if err != nil {
|
||||
t.Fatalf("iterativeQueryWithExchange with config: %v", err)
|
||||
}
|
||||
if msg == nil {
|
||||
t.Fatal("expected non-nil response")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTraverserReferralWithHooks(t *testing.T) {
|
||||
// Tests that hooks are called with IsResolve=true during ResolveNS sub-traversal
|
||||
answerMsg := new(dns.Msg)
|
||||
answerMsg.SetReply(new(dns.Msg))
|
||||
answerMsg.Answer = append(answerMsg.Answer, &dns.A{
|
||||
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 300},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
})
|
||||
|
||||
tr := NewTraverser(&TraverserConfig{
|
||||
MaxDepth: 5,
|
||||
QueryType: dnsinternal.TypeA,
|
||||
RootAddrs: []net.IP{net.ParseIP("198.41.0.4")},
|
||||
})
|
||||
tr.SetExchange(func(ctx context.Context, server string, msg *dns.Msg, useTCP bool) (*dns.Msg, error) {
|
||||
return answerMsg.Copy(), nil
|
||||
})
|
||||
|
||||
var resolveEvents, progressEvents int
|
||||
tr.SetHooks(&TraverserHooks{
|
||||
OnEvent: func(e TraversalEvent) {
|
||||
if e.IsResolve {
|
||||
resolveEvents++
|
||||
} else {
|
||||
progressEvents++
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
// Test directly via ResolveNS with hooks
|
||||
ctx := context.Background()
|
||||
addrs, err := tr.ResolveNS(ctx, "ns1.example.com.", nil, nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("ResolveNS: %v", err)
|
||||
}
|
||||
_ = addrs
|
||||
t.Logf("resolveEvents=%d progressEvents=%d", resolveEvents, progressEvents)
|
||||
}
|
||||
Reference in New Issue
Block a user