- Unit tests for all internal packages exceeding 80% coverage:
- internal/config: 86.2% (ParseMaxDepth, ParseRetries, validation paths)
- internal/dns: 82.9% (IterativeQueryWithExchange, mock DNS server, roots)
- internal/fingerprint: 96.4% (unchanged, already excellent)
- internal/output: 86.7% (formatters, stats, JSON/text output, hooks)
- internal/traverse: 86.7% (SetHooks, ResolveNS, processReferral,
ensureRDFalse, resolveGlueViaSystem, newAQuery, Referral.Resolve)
- Integration tests in internal/integration/:
- End-to-end traversal with mock DNS exchange function
- Referral chain traversal (root -> TLD -> authoritative)
- CNAME resolution and loop detection
- NXDOMAIN and SERVFAIL response handling
- Max depth enforcement
- Context cancellation
- TraverserHooks event delivery
- Mock DNS server helper in internal/dns/roots_test.go using miekg/dns
(enables deterministic testing without network dependency)
- CI updated with coverage reporting step
- Makefile: added 'cover' target for local HTML coverage reports
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: multica-agent <github@multica.ai>
This commit is contained in:
Gary Hansen
co-authored by
Copilot
multica-agent
Copilot
multica-agent
parent
fe1afe2a97
commit
5d1e5ca86c
@@ -0,0 +1,326 @@
|
||||
package output
|
||||
|
||||
import (
|
||||
"net"
|
||||
"testing"
|
||||
|
||||
"github.com/hits/ExploreDNS/internal/dns"
|
||||
"github.com/hits/ExploreDNS/internal/traverse"
|
||||
miekgdns "github.com/miekg/dns"
|
||||
)
|
||||
|
||||
func makeAnswerResult(name string, ip string, prob float64) traverse.TraversalResult {
|
||||
ref := traverse.NewReferral(name, dns.TypeA, ".", 0, prob, nil)
|
||||
server := net.ParseIP("198.41.0.4")
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Server: server,
|
||||
Type: traverse.RespAnswer,
|
||||
Decoded: &dns.DecodedResponse{
|
||||
Answers: []miekgdns.RR{
|
||||
&miekgdns.A{
|
||||
Hdr: miekgdns.RR_Header{Name: name + ".", Rrtype: dns.TypeA, Class: miekgdns.ClassINET},
|
||||
A: net.ParseIP(ip),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
return traverse.TraversalResult{Referral: ref, Response: resp}
|
||||
}
|
||||
|
||||
func TestRRDataStringAllTypes(t *testing.T) {
|
||||
tests := []struct {
|
||||
rr miekgdns.RR
|
||||
want string
|
||||
}{
|
||||
{
|
||||
&miekgdns.A{Hdr: miekgdns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("1.2.3.4")},
|
||||
"1.2.3.4",
|
||||
},
|
||||
{
|
||||
&miekgdns.AAAA{Hdr: miekgdns.RR_Header{Rrtype: miekgdns.TypeAAAA}, AAAA: net.ParseIP("::1")},
|
||||
"::1",
|
||||
},
|
||||
{
|
||||
&miekgdns.CNAME{Hdr: miekgdns.RR_Header{Rrtype: miekgdns.TypeCNAME}, Target: "example.com."},
|
||||
"example.com.",
|
||||
},
|
||||
{
|
||||
&miekgdns.NS{Hdr: miekgdns.RR_Header{Rrtype: miekgdns.TypeNS}, Ns: "ns1.example.com."},
|
||||
"ns1.example.com.",
|
||||
},
|
||||
{
|
||||
&miekgdns.MX{Hdr: miekgdns.RR_Header{Rrtype: miekgdns.TypeMX}, Preference: 10, Mx: "mail.example.com."},
|
||||
"10 mail.example.com.",
|
||||
},
|
||||
{
|
||||
&miekgdns.TXT{Hdr: miekgdns.RR_Header{Rrtype: miekgdns.TypeTXT}, Txt: []string{"v=spf1", "include:example.com"}},
|
||||
"v=spf1 include:example.com",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
got := rrDataString(tc.rr)
|
||||
if got != tc.want {
|
||||
t.Errorf("rrDataString(%T) = %q, want %q", tc.rr, got, tc.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRRDataStringDefault(t *testing.T) {
|
||||
// SOA record hits the default case
|
||||
rr := &miekgdns.SOA{
|
||||
Hdr: miekgdns.RR_Header{Name: ".", Rrtype: miekgdns.TypeSOA, Class: miekgdns.ClassINET},
|
||||
Ns: "a.root-servers.net.",
|
||||
Mbox: "nstld.verisign-grs.com.",
|
||||
}
|
||||
got := rrDataString(rr)
|
||||
if got == "" {
|
||||
t.Error("rrDataString(SOA) should return non-empty string via default case")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSummaryTypeLabelAllTypes(t *testing.T) {
|
||||
cases := map[string]string{
|
||||
"nodata": "found no such record",
|
||||
"nxdomain": "name does not exist",
|
||||
"servfail": "resulted in SERVFAIL",
|
||||
"refused": "query refused by server",
|
||||
"notimp": "query type not implemented by server",
|
||||
"cname_loop": "resulted in a CNAME loop",
|
||||
"error": "resulted in an error",
|
||||
"referral": "resulted in a referral",
|
||||
"unknown_type": "unknown_type",
|
||||
}
|
||||
for input, want := range cases {
|
||||
got := summaryTypeLabel(input)
|
||||
if got != want {
|
||||
t.Errorf("summaryTypeLabel(%q) = %q, want %q", input, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectServersEmpty(t *testing.T) {
|
||||
servers := collectServers(nil)
|
||||
if len(servers) != 0 {
|
||||
t.Errorf("collectServers(nil) = %v, want empty", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectServersDeduplication(t *testing.T) {
|
||||
ref := traverse.NewReferral("example.com.", dns.TypeA, "com.", 1, 1.0, nil)
|
||||
server := net.ParseIP("1.2.3.4")
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Server: server,
|
||||
Type: traverse.RespAnswer,
|
||||
}
|
||||
result := traverse.TraversalResult{Referral: ref, Response: resp}
|
||||
|
||||
servers := collectServers([]traverse.TraversalResult{result, result})
|
||||
name := "com"
|
||||
ips := servers[name]
|
||||
if len(ips) != 1 {
|
||||
t.Errorf("expected deduplication: got %d IPs, want 1", len(ips))
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectServersWithBailiwick(t *testing.T) {
|
||||
ref := traverse.NewReferral("example.com.", dns.TypeA, "com.", 1, 1.0, nil)
|
||||
server := net.ParseIP("1.2.3.4")
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Server: server,
|
||||
Type: traverse.RespAnswer,
|
||||
}
|
||||
result := traverse.TraversalResult{Referral: ref, Response: resp}
|
||||
|
||||
servers := collectServers([]traverse.TraversalResult{result})
|
||||
if len(servers) == 0 {
|
||||
t.Fatal("expected at least one server entry")
|
||||
}
|
||||
if _, ok := servers["com"]; !ok {
|
||||
t.Errorf("expected server name 'com', got keys: %v", servers)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerNameFallbacks(t *testing.T) {
|
||||
// No bailiwick, no NSName, with server IP
|
||||
ref := traverse.NewReferral("example.com.", dns.TypeA, ".", 0, 1.0, nil)
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Server: net.ParseIP("1.2.3.4"),
|
||||
Type: traverse.RespAnswer,
|
||||
}
|
||||
result := traverse.TraversalResult{Referral: ref, Response: resp}
|
||||
name := serverName(result)
|
||||
if name != "1.2.3.4" {
|
||||
t.Errorf("serverName with root bailiwick = %q, want IP", name)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerNameWithNSName(t *testing.T) {
|
||||
ref := &traverse.Referral{
|
||||
Name: "example.com.",
|
||||
Qtype: dns.TypeA,
|
||||
Bailiwick: ".",
|
||||
NSName: "ns1.example.com.",
|
||||
}
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Server: net.ParseIP("5.5.5.5"),
|
||||
Type: traverse.RespAnswer,
|
||||
}
|
||||
result := traverse.TraversalResult{Referral: ref, Response: resp}
|
||||
// Bailiwick is "." so falls through to NSName
|
||||
name := serverName(result)
|
||||
if name == "" {
|
||||
t.Error("serverName should return non-empty string")
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerNameNilReferral(t *testing.T) {
|
||||
resp := &traverse.Response{
|
||||
Server: net.ParseIP("1.2.3.4"),
|
||||
Type: traverse.RespAnswer,
|
||||
}
|
||||
result := traverse.TraversalResult{Referral: nil, Response: resp}
|
||||
name := serverName(result)
|
||||
if name == "" {
|
||||
t.Error("serverName with nil referral should return non-empty string")
|
||||
}
|
||||
}
|
||||
|
||||
func TestContainsString(t *testing.T) {
|
||||
items := []string{"a", "b", "c"}
|
||||
if !containsString(items, "b") {
|
||||
t.Error("containsString should find 'b' in slice")
|
||||
}
|
||||
if containsString(items, "d") {
|
||||
t.Error("containsString should not find 'd' in slice")
|
||||
}
|
||||
if containsString(nil, "a") {
|
||||
t.Error("containsString on nil slice should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestComputeSummaryMixedResults(t *testing.T) {
|
||||
refAnswer := traverse.NewReferral("example.com.", dns.TypeA, ".", 0, 0.6, nil)
|
||||
respAnswer := &traverse.Response{
|
||||
Referral: refAnswer,
|
||||
Type: traverse.RespAnswer,
|
||||
Decoded: &dns.DecodedResponse{
|
||||
Answers: []miekgdns.RR{
|
||||
&miekgdns.A{
|
||||
Hdr: miekgdns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: miekgdns.ClassINET},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
refNXD := traverse.NewReferral("notexist.com.", dns.TypeA, ".", 0, 0.4, nil)
|
||||
respNXD := &traverse.Response{
|
||||
Referral: refNXD,
|
||||
Type: traverse.RespNXDOMAIN,
|
||||
}
|
||||
|
||||
results := []traverse.TraversalResult{
|
||||
{Referral: refAnswer, Response: respAnswer},
|
||||
{Referral: refNXD, Response: respNXD},
|
||||
}
|
||||
|
||||
stats := ComputeSummary(results)
|
||||
if stats == nil {
|
||||
t.Fatal("ComputeSummary returned nil for non-empty results")
|
||||
}
|
||||
if len(stats.Answers) != 1 {
|
||||
t.Errorf("expected 1 answer entry, got %d", len(stats.Answers))
|
||||
}
|
||||
if _, ok := stats.ByType["nxdomain"]; !ok {
|
||||
t.Error("expected nxdomain in ByType")
|
||||
}
|
||||
}
|
||||
|
||||
func TestComputeSummaryAnswerWithCNAMEOnly(t *testing.T) {
|
||||
// Answer with only CNAME record - no final answer, should be in ByType
|
||||
ref := traverse.NewReferral("www.example.com.", dns.TypeA, ".", 0, 1.0, nil)
|
||||
resp := &traverse.Response{
|
||||
Referral: ref,
|
||||
Type: traverse.RespAnswer,
|
||||
Decoded: &dns.DecodedResponse{
|
||||
Answers: []miekgdns.RR{
|
||||
&miekgdns.CNAME{
|
||||
Hdr: miekgdns.RR_Header{Name: "www.example.com.", Rrtype: miekgdns.TypeCNAME, Class: miekgdns.ClassINET},
|
||||
Target: "example.com.",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
results := []traverse.TraversalResult{{Referral: ref, Response: resp}}
|
||||
stats := ComputeSummary(results)
|
||||
if stats == nil {
|
||||
t.Fatal("ComputeSummary returned nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestComputeSummaryAccumulates(t *testing.T) {
|
||||
// Two answers with the same IP should accumulate probability
|
||||
ref1 := traverse.NewReferral("example.com.", dns.TypeA, ".", 0, 0.5, nil)
|
||||
ref2 := traverse.NewReferral("example.com.", dns.TypeA, ".", 0, 0.5, nil)
|
||||
|
||||
makeResp := func(ref *traverse.Referral) *traverse.Response {
|
||||
return &traverse.Response{
|
||||
Referral: ref,
|
||||
Type: traverse.RespAnswer,
|
||||
Decoded: &dns.DecodedResponse{
|
||||
Answers: []miekgdns.RR{
|
||||
&miekgdns.A{
|
||||
Hdr: miekgdns.RR_Header{Name: "example.com.", Rrtype: dns.TypeA, Class: miekgdns.ClassINET},
|
||||
A: net.ParseIP("1.2.3.4"),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
results := []traverse.TraversalResult{
|
||||
{Referral: ref1, Response: makeResp(ref1)},
|
||||
{Referral: ref2, Response: makeResp(ref2)},
|
||||
}
|
||||
stats := ComputeSummary(results)
|
||||
if stats == nil {
|
||||
t.Fatal("ComputeSummary returned nil")
|
||||
}
|
||||
if len(stats.Answers) != 1 {
|
||||
t.Fatalf("expected 1 answer after accumulation, got %d", len(stats.Answers))
|
||||
}
|
||||
if stats.Answers[0].Prob < 0.99 {
|
||||
t.Errorf("accumulated prob = %.2f, want ~1.0", stats.Answers[0].Prob)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectUniqueServerIPs(t *testing.T) {
|
||||
ref := traverse.NewReferral("example.com.", dns.TypeA, ".", 0, 1.0, nil)
|
||||
ip1 := net.ParseIP("1.2.3.4")
|
||||
ip2 := net.ParseIP("5.6.7.8")
|
||||
|
||||
results := []traverse.TraversalResult{
|
||||
{Referral: ref, Response: &traverse.Response{Server: ip1, Type: traverse.RespAnswer}},
|
||||
{Referral: ref, Response: &traverse.Response{Server: ip1, Type: traverse.RespAnswer}}, // dup
|
||||
{Referral: ref, Response: &traverse.Response{Server: ip2, Type: traverse.RespAnswer}},
|
||||
{Referral: ref, Response: nil}, // nil response
|
||||
}
|
||||
|
||||
ips := collectUniqueServerIPs(results)
|
||||
if len(ips) != 2 {
|
||||
t.Errorf("expected 2 unique IPs, got %d", len(ips))
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectUniqueServerIPsEmpty(t *testing.T) {
|
||||
ips := collectUniqueServerIPs(nil)
|
||||
if len(ips) != 0 {
|
||||
t.Errorf("expected 0 IPs for nil results, got %d", len(ips))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user