routedns/blocklistdb-domain_test.go at master · folbricht/routedns · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package rdns

import (
	"testing"

	"github.com/miekg/dns"
	"github.com/stretchr/testify/require"
)

func TestDomainDB(t *testing.T) {
	loader := NewStaticLoader([]string{
		"domain1.com.",    // exact match
		".domain2.com.",   // exact match and subdomains
		"x.domain2.com",   // above rule should take precedence
		"*.domain3.com",   // subdomains only
		"x.x.domain3.com", // more general wildcard above should take precedence
		"domain4.com",     // the more general rule below wins
		".domain4.com",
		".DOMAIN5.com",
	})

	m, err := NewDomainDB("testlist", loader)
	require.NoError(t, err)

	tests := []struct {
		q     string
		match bool
	}{
		// exact
		{"domain1.com.", true},
		{"x.domain1.com.", false},

		// exact and subdomains
		{"domain2.com.", true},
		{"sub.domain2.com.", true},

		// wildcard (match only on subdomains)
		{"domain3.com.", false},
		{"sub.domain3.com.", true},

		// two rules for this, the generic one wins
		{"domain4.com.", true},
		{"sub.domain4.com.", true},

		// not matching
		{"unblocked.test.", false},
		{"com.", false},

		// capitalized query
		{"Domain1.com.", true},

		// match capital blocklist item
		{"domain5.com.", true},
	}
	for _, test := range tests {
		msg := new(dns.Msg)
		msg.SetQuestion(test.q, dns.TypeA)

		_, _, _, ok := m.Match(msg)
		require.Equal(t, test.match, ok, "query: %s", test.q)
	}
}

func TestDomainSubdomainDB(t *testing.T) {
	loader := NewStaticLoader([]string{
		"domain1.com",     // bare entry: apex + subdomains
		".domain2.com",    // explicit dot: apex + subdomains (unchanged)
		"*.domain3.com",   // explicit wildcard: subdomains-only opt-out
		"DOMAIN4.com",     // capitalized bare entry
		"trailing.dot.com.",
	})

	m, err := NewDomainSubdomainDB("testlist", loader)
	require.NoError(t, err)

	tests := []struct {
		q     string
		match bool
	}{
		// bare entry matches apex and subdomains
		{"domain1.com.", true},
		{"sub.domain1.com.", true},
		{"deep.sub.domain1.com.", true},

		// leading-dot entry behaves identically
		{"domain2.com.", true},
		{"sub.domain2.com.", true},

		// wildcard entry remains subdomains-only (opt-out)
		{"domain3.com.", false},
		{"sub.domain3.com.", true},

		// capitalized blocklist entry, lowercase query
		{"domain4.com.", true},
		{"sub.domain4.com.", true},

		// trailing-dot entry handled
		{"trailing.dot.com.", true},
		{"sub.trailing.dot.com.", true},

		// non-matching
		{"unblocked.test.", false},
		{"com.", false},

		// capitalized query
		{"Domain1.com.", true},
	}
	for _, test := range tests {
		msg := new(dns.Msg)
		msg.SetQuestion(test.q, dns.TypeA)

		_, _, _, ok := m.Match(msg)
		require.Equal(t, test.match, ok, "query: %s", test.q)
	}
}

func TestDomainSubdomainDBError(t *testing.T) {
	tests := []struct {
		name string
	}{
		{"sub.*.com"},
		{"*domain.com"},
	}
	for _, test := range tests {
		loader := NewStaticLoader([]string{test.name})
		_, err := NewDomainSubdomainDB("testlist", loader)
		require.Error(t, err)
	}
}

func TestDomainDBError(t *testing.T) {
	tests := []struct {
		name string
	}{
		{"sub.*.com"},
		{"*domain.com"},
	}
	for _, test := range tests {
		loader := NewStaticLoader([]string{test.name})
		_, err := NewDomainDB("testlist", loader)
		require.Error(t, err)
	}
}