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
|
package rewrite
import (
"context"
"strings"
"testing"
"github.com/coredns/coredns/plugin"
"github.com/coredns/coredns/plugin/pkg/dnstest"
"github.com/coredns/coredns/plugin/test"
"github.com/miekg/dns"
)
func TestRewriteIllegalName(t *testing.T) {
r, _ := newNameRule("stop", "example.org.", "example..org.")
rw := Rewrite{
Next: plugin.HandlerFunc(msgPrinter),
Rules: []Rule{r},
noRevert: true,
}
ctx := context.TODO()
m := new(dns.Msg)
m.SetQuestion("example.org.", dns.TypeA)
rec := dnstest.NewRecorder(&test.ResponseWriter{})
_, err := rw.ServeDNS(ctx, rec, m)
if !strings.Contains(err.Error(), "invalid name") {
t.Errorf("Expected invalid name, got %s", err.Error())
}
}
func TestRewriteNamePrefixSuffix(t *testing.T) {
ctx, close := context.WithCancel(context.TODO())
defer close()
tests := []struct {
next string
args []string
question string
expected string
}{
{"stop", []string{"prefix", "foo", "bar"}, "foo.example.com.", "bar.example.com."},
{"stop", []string{"prefix", "foo.", "bar."}, "foo.example.com.", "bar.example.com."},
{"stop", []string{"suffix", "com", "org"}, "foo.example.com.", "foo.example.org."},
{"stop", []string{"suffix", ".com", ".org"}, "foo.example.com.", "foo.example.org."},
}
for _, tc := range tests {
r, err := newNameRule(tc.next, tc.args...)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
rw := Rewrite{
Next: plugin.HandlerFunc(msgPrinter),
Rules: []Rule{r},
noRevert: true,
}
m := new(dns.Msg)
m.SetQuestion(tc.question, dns.TypeA)
rec := dnstest.NewRecorder(&test.ResponseWriter{})
_, err = rw.ServeDNS(ctx, rec, m)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
actual := rec.Msg.Question[0].Name
if actual != tc.expected {
t.Fatalf("Expected rewrite to %v, got %v", tc.expected, actual)
}
}
}
func TestNewNameRule(t *testing.T) {
tests := []struct {
next string
args []string
expectedFail bool
}{
{"stop", []string{"exact", "srv3.coredns.rocks", "srv4.coredns.rocks"}, false},
{"stop", []string{"srv1.coredns.rocks", "srv2.coredns.rocks"}, false},
{"stop", []string{"suffix", "coredns.rocks", "coredns.rocks."}, false},
{"stop", []string{"suffix", "coredns.rocks.", "coredns.rocks"}, false},
{"stop", []string{"suffix", "coredns.rocks.", "coredns.rocks."}, false},
{"stop", []string{"regex", "srv1.coredns.rocks", "10"}, false},
{"stop", []string{"regex", "(.*).coredns.rocks", "10"}, false},
{"stop", []string{"regex", "(.*).coredns.rocks", "{1}.coredns.rocks"}, false},
{"stop", []string{"regex", "(.*).coredns.rocks", "{1}.{2}.coredns.rocks"}, true},
{"stop", []string{"regex", "staging.mydomain.com", "aws-loadbalancer-id.us-east-1.elb.amazonaws.com"}, false},
}
for i, tc := range tests {
failed := false
rule, err := newNameRule(tc.next, tc.args...)
if err != nil {
failed = true
}
if !failed && !tc.expectedFail {
t.Logf("Test %d: PASS, passed as expected: (%s) %s", i, tc.next, tc.args)
continue
}
if failed && tc.expectedFail {
t.Logf("Test %d: PASS, failed as expected: (%s) %s: %s", i, tc.next, tc.args, err)
continue
}
if failed && !tc.expectedFail {
t.Fatalf("Test %d: FAIL, expected fail=%t, but received fail=%t: (%s) %s, rule=%v, error=%s", i, tc.expectedFail, failed, tc.next, tc.args, rule, err)
}
t.Fatalf("Test %d: FAIL, expected fail=%t, but received fail=%t: (%s) %s, rule=%v", i, tc.expectedFail, failed, tc.next, tc.args, rule)
}
for i, tc := range tests {
failed := false
tc.args = append([]string{tc.next, "name"}, tc.args...)
rule, err := newRule(tc.args...)
if err != nil {
failed = true
}
if !failed && !tc.expectedFail {
t.Logf("Test %d: PASS, passed as expected: (%s) %s", i, tc.next, tc.args)
continue
}
if failed && tc.expectedFail {
t.Logf("Test %d: PASS, failed as expected: (%s) %s: %s", i, tc.next, tc.args, err)
continue
}
t.Fatalf("Test %d: FAIL, expected fail=%t, but received fail=%t: (%s) %s, rule=%v", i, tc.expectedFail, failed, tc.next, tc.args, rule)
}
}
|
