Mirrors/coredns
1
0
Fork 0
mirror of https://github.com/coredns/coredns.git synced 2025-11-23 04:12:17 -05:00
Code Issues Packages Projects Releases Wiki Activity

refactor: use reflect.TypeFor (#7696)

Browse Source
This commit is contained in:
zhetaicheleba
2025-11-20 02:40:18 +09:00
committed by GitHub
parent 614a364458
commit 9989ac5060
6 changed files with 112 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
plugin/azure/azure_test.go
View File

@@ -169,7 +169,7 @@ func TestAzure(t *testing.T) {
for i, ns := range rec.Msg.Ns { for i, ns := range rec.Msg.Ns {
got, ok := ns.(*dns.SOA) got, ok := ns.(*dns.SOA)
if !ok { if !ok {
t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeOf(got)) t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeFor[*dns.SOA]())
} }
if got.String() != tc.wantNS[i] { if got.String() != tc.wantNS[i] {
t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got) t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got)

2
plugin/clouddns/clouddns_test.go
View File

@@ -318,7 +318,7 @@ func TestCloudDNS(t *testing.T) {
for i, ns := range rec.Msg.Ns { for i, ns := range rec.Msg.Ns {
got, ok := ns.(*dns.SOA) got, ok := ns.(*dns.SOA)
if !ok { if !ok {
t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeOf(got)) t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeFor[*dns.SOA]())
} }
if got.String() != tc.wantNS[i] { if got.String() != tc.wantNS[i] {
t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got) t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got)

12
plugin/rewrite/cname_target_test.go
View File

@@ -70,12 +70,12 @@ func TestCNameTargetRewrite(t *testing.T) {
args []string args []string
expectedType reflect.Type expectedType reflect.Type
}{ }{
{[]string{"continue", "cname", "exact", "def.example.com.", "xyz.example.com."}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "exact", "def.example.com.", "xyz.example.com."}, reflect.TypeFor[*cnameTargetRule]()},
{[]string{"continue", "cname", "prefix", "chat.openai.com", "bard.google.com"}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "prefix", "chat.openai.com", "bard.google.com"}, reflect.TypeFor[*cnameTargetRule]()},
{[]string{"continue", "cname", "suffix", "uvw.", "xyz."}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "suffix", "uvw.", "xyz."}, reflect.TypeFor[*cnameTargetRule]()},
{[]string{"continue", "cname", "substring", "efgh", "zzzz.www"}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "substring", "efgh", "zzzz.www"}, reflect.TypeFor[*cnameTargetRule]()},
{[]string{"continue", "cname", "regex", `(.*)\.web\.(.*)\.site\.`, `{1}.webapp.{2}.org.`}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "regex", `(.*)\.web\.(.*)\.site\.`, `{1}.webapp.{2}.org.`}, reflect.TypeFor[*cnameTargetRule]()},
{[]string{"continue", "cname", "exact", "music.truncated.spotify.com.", "music.truncated.spotify.com."}, reflect.TypeOf(&cnameTargetRule{})}, {[]string{"continue", "cname", "exact", "music.truncated.spotify.com.", "music.truncated.spotify.com."}, reflect.TypeFor[*cnameTargetRule]()},
} }
for i, r := range ruleset { for i, r := range ruleset {
rule, err := newRule(r.args...) rule, err := newRule(r.args...)

186
plugin/rewrite/rewrite_test.go
View File

@@ -37,31 +37,31 @@ func TestNewRule(t *testing.T) {
{[]string{"name"}, true, nil}, {[]string{"name"}, true, nil},
{[]string{"name", "a.com"}, true, nil}, {[]string{"name", "a.com"}, true, nil},
{[]string{"name", "a.com", "b.com", "c.com"}, true, nil}, {[]string{"name", "a.com", "b.com", "c.com"}, true, nil},
{[]string{"name", "a.com", "b.com"}, false, reflect.TypeOf(&exactNameRule{})}, {[]string{"name", "a.com", "b.com"}, false, reflect.TypeFor[*exactNameRule]()},
{[]string{"name", "exact", "a.com", "b.com"}, false, reflect.TypeOf(&exactNameRule{})}, {[]string{"name", "exact", "a.com", "b.com"}, false, reflect.TypeFor[*exactNameRule]()},
{[]string{"name", "prefix", "a.com", "b.com"}, false, reflect.TypeOf(&prefixNameRule{})}, {[]string{"name", "prefix", "a.com", "b.com"}, false, reflect.TypeFor[*prefixNameRule]()},
{[]string{"name", "suffix", "a.com", "b.com"}, false, reflect.TypeOf(&suffixNameRule{})}, {[]string{"name", "suffix", "a.com", "b.com"}, false, reflect.TypeFor[*suffixNameRule]()},
{[]string{"name", "substring", "a.com", "b.com"}, false, reflect.TypeOf(&substringNameRule{})}, {[]string{"name", "substring", "a.com", "b.com"}, false, reflect.TypeFor[*substringNameRule]()},
{[]string{"name", "regex", "([a])\\.com", "new-{1}.com"}, false, reflect.TypeOf(&regexNameRule{})}, {[]string{"name", "regex", "([a])\\.com", "new-{1}.com"}, false, reflect.TypeFor[*regexNameRule]()},
{[]string{"name", "regex", "([a]\\.com", "new-{1}.com"}, true, nil}, {[]string{"name", "regex", "([a]\\.com", "new-{1}.com"}, true, nil},
{[]string{"name", "regex", "(dns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(dns)\\.(rocks)", "{2}.{1}.{3}"}, false, reflect.TypeOf(&regexNameRule{})}, {[]string{"name", "regex", "(dns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(dns)\\.(rocks)", "{2}.{1}.{3}"}, false, reflect.TypeFor[*regexNameRule]()},
{[]string{"name", "regex", "(adns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(adns)\\.(rocks)", "{2}.{1}.{3}", "too.long", "way.too.long"}, true, nil}, {[]string{"name", "regex", "(adns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(adns)\\.(rocks)", "{2}.{1}.{3}", "too.long", "way.too.long"}, true, nil},
{[]string{"name", "regex", "(bdns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "NoAnswer", "name", "(core)\\.(bdns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil}, {[]string{"name", "regex", "(bdns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "NoAnswer", "name", "(core)\\.(bdns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil},
{[]string{"name", "regex", "(cdns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "ttl", "(core)\\.(cdns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil}, {[]string{"name", "regex", "(cdns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "ttl", "(core)\\.(cdns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil},
{[]string{"name", "regex", "(ddns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "\xecore\\.(ddns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil}, {[]string{"name", "regex", "(ddns)\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "\xecore\\.(ddns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil},
{[]string{"name", "regex", "\xedns\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(edns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil}, {[]string{"name", "regex", "\xedns\\.(core)\\.(rocks)", "{2}.{1}.{3}", "answer", "name", "(core)\\.(edns)\\.(rocks)", "{2}.{1}.{3}"}, true, nil},
{[]string{"name", "substring", "fcore.dns.rocks", "dns.fcore.rocks", "answer", "name", "(fcore)\\.(dns)\\.(rocks)", "{2}.{1}.{3}"}, false, reflect.TypeOf(&substringNameRule{})}, {[]string{"name", "substring", "fcore.dns.rocks", "dns.fcore.rocks", "answer", "name", "(fcore)\\.(dns)\\.(rocks)", "{2}.{1}.{3}"}, false, reflect.TypeFor[*substringNameRule]()},
{[]string{"name", "substring", "a.com", "b.com", "c.com"}, true, nil}, {[]string{"name", "substring", "a.com", "b.com", "c.com"}, true, nil},
{[]string{"type"}, true, nil}, {[]string{"type"}, true, nil},
{[]string{"type", "a"}, true, nil}, {[]string{"type", "a"}, true, nil},
{[]string{"type", "any", "a", "a"}, true, nil}, {[]string{"type", "any", "a", "a"}, true, nil},
{[]string{"type", "any", "a"}, false, reflect.TypeOf(&typeRule{})}, {[]string{"type", "any", "a"}, false, reflect.TypeFor[*typeRule]()},
{[]string{"type", "XY", "WV"}, true, nil}, {[]string{"type", "XY", "WV"}, true, nil},
{[]string{"type", "ANY", "WV"}, true, nil}, {[]string{"type", "ANY", "WV"}, true, nil},
{[]string{"class"}, true, nil}, {[]string{"class"}, true, nil},
{[]string{"class", "IN"}, true, nil}, {[]string{"class", "IN"}, true, nil},
{[]string{"class", "ch", "in", "in"}, true, nil}, {[]string{"class", "ch", "in", "in"}, true, nil},
{[]string{"class", "ch", "in"}, false, reflect.TypeOf(&classRule{})}, {[]string{"class", "ch", "in"}, false, reflect.TypeFor[*classRule]()},
{[]string{"class", "XY", "WV"}, true, nil}, {[]string{"class", "XY", "WV"}, true, nil},
{[]string{"class", "IN", "WV"}, true, nil}, {[]string{"class", "IN", "WV"}, true, nil},
{[]string{"edns0"}, true, nil}, {[]string{"edns0"}, true, nil},
@@ -71,109 +71,109 @@ func TestNewRule(t *testing.T) {
{[]string{"edns0", "local", "set"}, true, nil}, {[]string{"edns0", "local", "set"}, true, nil},
{[]string{"edns0", "local", "set", "0xffee"}, true, nil}, {[]string{"edns0", "local", "set", "0xffee"}, true, nil},
{[]string{"edns0", "local", "set", "invalid-uint", "abcdefg"}, true, nil}, {[]string{"edns0", "local", "set", "invalid-uint", "abcdefg"}, true, nil},
{[]string{"edns0", "local", "set", "65518", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "set", "65518", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "set", "0xffee", "abcdefg", "revert"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "set", "0xffee", "abcdefg", "revert"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "append", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "append", "0xffee", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "append", "0xffee", "abcdefg", "revert"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "append", "0xffee", "abcdefg", "revert"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "abcdefg", "revert"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "abcdefg", "revert"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "unset", "0xffee"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "unset", "0xffee"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "unset", "0xffee", "abcdefg"}, true, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "unset", "0xffee", "abcdefg"}, true, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "unset", "0xffee", "revert"}, true, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"edns0", "local", "unset", "0xffee", "revert"}, true, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"edns0", "local", "foo", "0xffee", "abcdefg"}, true, nil}, {[]string{"edns0", "local", "foo", "0xffee", "abcdefg"}, true, nil},
{[]string{"edns0", "local", "set", "0xffee", "0xabcdefg"}, true, nil}, {[]string{"edns0", "local", "set", "0xffee", "0xabcdefg"}, true, nil},
{[]string{"edns0", "nsid", "set", "junk"}, true, nil}, {[]string{"edns0", "nsid", "set", "junk"}, true, nil},
{[]string{"edns0", "nsid", "set"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "set"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "set", "revert"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "set", "revert"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "append"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "append"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "append", "revert"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "append", "revert"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "replace"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "replace"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "replace", "revert"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "replace", "revert"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "unset"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "unset"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "unset", "revert"}, true, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"edns0", "nsid", "unset", "revert"}, true, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"edns0", "nsid", "foo"}, true, nil}, {[]string{"edns0", "nsid", "foo"}, true, nil},
{[]string{"edns0", "local", "set", "invalid-uint", "{qname}"}, true, nil}, {[]string{"edns0", "local", "set", "invalid-uint", "{qname}"}, true, nil},
{[]string{"edns0", "local", "set", "0xffee", "{dummy}"}, true, nil}, {[]string{"edns0", "local", "set", "0xffee", "{dummy}"}, true, nil},
{[]string{"edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "set", "0xffee", "{server_port}", "revert"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "set", "0xffee", "{server_port}", "revert"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{dummy}"}, true, nil}, {[]string{"edns0", "local", "append", "0xffee", "{dummy}"}, true, nil},
{[]string{"edns0", "local", "append", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{qname}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{qtype}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{client_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{client_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{protocol}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{server_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{server_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "append", "0xffee", "{server_port}", "revert"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "append", "0xffee", "{server_port}", "revert"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{dummy}"}, true, nil}, {[]string{"edns0", "local", "replace", "0xffee", "{dummy}"}, true, nil},
{[]string{"edns0", "local", "replace", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{qname}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{qtype}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{client_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{client_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{protocol}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{server_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{server_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "local", "replace", "0xffee", "{server_port}", "revert"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"edns0", "local", "replace", "0xffee", "{server_port}", "revert"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"edns0", "subnet", "set", "-1", "56"}, true, nil}, {[]string{"edns0", "subnet", "set", "-1", "56"}, true, nil},
{[]string{"edns0", "subnet", "set", "24", "-56"}, true, nil}, {[]string{"edns0", "subnet", "set", "24", "-56"}, true, nil},
{[]string{"edns0", "subnet", "set", "33", "56"}, true, nil}, {[]string{"edns0", "subnet", "set", "33", "56"}, true, nil},
{[]string{"edns0", "subnet", "set", "24", "129"}, true, nil}, {[]string{"edns0", "subnet", "set", "24", "129"}, true, nil},
{[]string{"edns0", "subnet", "set", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "set", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "set", "24", "56", "revert"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "set", "24", "56", "revert"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "append", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "append", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "append", "24", "56", "72"}, true, nil}, {[]string{"edns0", "subnet", "append", "24", "56", "72"}, true, nil},
{[]string{"edns0", "subnet", "append", "24", "56", "revert"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "append", "24", "56", "revert"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "replace", "24", "56", "revert"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "replace", "24", "56", "revert"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "unset"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "unset"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "unset", "24", "56"}, true, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "unset", "24", "56"}, true, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"edns0", "subnet", "unset", "revert"}, true, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"edns0", "subnet", "unset", "revert"}, true, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"unknown-action", "name", "a.com", "b.com"}, true, nil}, {[]string{"unknown-action", "name", "a.com", "b.com"}, true, nil},
{[]string{"stop", "name", "a.com", "b.com"}, false, reflect.TypeOf(&exactNameRule{})}, {[]string{"stop", "name", "a.com", "b.com"}, false, reflect.TypeFor[*exactNameRule]()},
{[]string{"continue", "name", "a.com", "b.com"}, false, reflect.TypeOf(&exactNameRule{})}, {[]string{"continue", "name", "a.com", "b.com"}, false, reflect.TypeFor[*exactNameRule]()},
{[]string{"unknown-action", "type", "any", "a"}, true, nil}, {[]string{"unknown-action", "type", "any", "a"}, true, nil},
{[]string{"stop", "type", "any", "a"}, false, reflect.TypeOf(&typeRule{})}, {[]string{"stop", "type", "any", "a"}, false, reflect.TypeFor[*typeRule]()},
{[]string{"continue", "type", "any", "a"}, false, reflect.TypeOf(&typeRule{})}, {[]string{"continue", "type", "any", "a"}, false, reflect.TypeFor[*typeRule]()},
{[]string{"unknown-action", "class", "ch", "in"}, true, nil}, {[]string{"unknown-action", "class", "ch", "in"}, true, nil},
{[]string{"stop", "class", "ch", "in"}, false, reflect.TypeOf(&classRule{})}, {[]string{"stop", "class", "ch", "in"}, false, reflect.TypeFor[*classRule]()},
{[]string{"continue", "class", "ch", "in"}, false, reflect.TypeOf(&classRule{})}, {[]string{"continue", "class", "ch", "in"}, false, reflect.TypeFor[*classRule]()},
{[]string{"unknown-action", "edns0", "local", "set", "0xffee", "abcedef"}, true, nil}, {[]string{"unknown-action", "edns0", "local", "set", "0xffee", "abcedef"}, true, nil},
{[]string{"stop", "edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeFor[*edns0LocalRule]()},
{[]string{"unknown-action", "edns0", "nsid", "set"}, true, nil}, {[]string{"unknown-action", "edns0", "nsid", "set"}, true, nil},
{[]string{"stop", "edns0", "nsid", "set"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"stop", "edns0", "nsid", "set"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"continue", "edns0", "nsid", "set"}, false, reflect.TypeOf(&edns0NsidRule{})}, {[]string{"continue", "edns0", "nsid", "set"}, false, reflect.TypeFor[*edns0NsidRule]()},
{[]string{"unknown-action", "edns0", "local", "set", "0xffee", "{qname}"}, true, nil}, {[]string{"unknown-action", "edns0", "local", "set", "0xffee", "{qname}"}, true, nil},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"stop", "edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"stop", "edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"continue", "edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})}, {[]string{"continue", "edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeFor[*edns0VariableRule]()},
{[]string{"unknown-action", "edns0", "subnet", "set", "24", "64"}, true, nil}, {[]string{"unknown-action", "edns0", "subnet", "set", "24", "64"}, true, nil},
{[]string{"stop", "edns0", "subnet", "set", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"stop", "edns0", "subnet", "set", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"stop", "edns0", "subnet", "append", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"stop", "edns0", "subnet", "append", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"stop", "edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"stop", "edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"stop", "edns0", "subnet", "unset"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"stop", "edns0", "subnet", "unset"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"continue", "edns0", "subnet", "set", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"continue", "edns0", "subnet", "set", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"continue", "edns0", "subnet", "append", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"continue", "edns0", "subnet", "append", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"continue", "edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"continue", "edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeFor[*edns0SubnetRule]()},
{[]string{"continue", "edns0", "subnet", "unset"}, false, reflect.TypeOf(&edns0SubnetRule{})}, {[]string{"continue", "edns0", "subnet", "unset"}, false, reflect.TypeFor[*edns0SubnetRule]()},
} }
for i, tc := range tests { for i, tc := range tests {

20
plugin/rewrite/ttl_test.go
View File

@@ -78,16 +78,16 @@ func TestTtlRewrite(t *testing.T) {
args []string args []string
expectedType reflect.Type expectedType reflect.Type
}{ }{
{[]string{"stop", "ttl", "srv1.coredns.rocks", "1"}, reflect.TypeOf(&exactTTLRule{})}, {[]string{"stop", "ttl", "srv1.coredns.rocks", "1"}, reflect.TypeFor[*exactTTLRule]()},
{[]string{"stop", "ttl", "exact", "srv15.coredns.rocks", "15"}, reflect.TypeOf(&exactTTLRule{})}, {[]string{"stop", "ttl", "exact", "srv15.coredns.rocks", "15"}, reflect.TypeFor[*exactTTLRule]()},
{[]string{"stop", "ttl", "prefix", "srv30", "30"}, reflect.TypeOf(&prefixTTLRule{})}, {[]string{"stop", "ttl", "prefix", "srv30", "30"}, reflect.TypeFor[*prefixTTLRule]()},
{[]string{"stop", "ttl", "suffix", "45.coredns.rocks", "45"}, reflect.TypeOf(&suffixTTLRule{})}, {[]string{"stop", "ttl", "suffix", "45.coredns.rocks", "45"}, reflect.TypeFor[*suffixTTLRule]()},
{[]string{"stop", "ttl", "substring", "rv50", "50"}, reflect.TypeOf(&substringTTLRule{})}, {[]string{"stop", "ttl", "substring", "rv50", "50"}, reflect.TypeFor[*substringTTLRule]()},
{[]string{"stop", "ttl", "regex", `(srv10)\.(coredns)\.(rocks)`, "10"}, reflect.TypeOf(&regexTTLRule{})}, {[]string{"stop", "ttl", "regex", `(srv10)\.(coredns)\.(rocks)`, "10"}, reflect.TypeFor[*regexTTLRule]()},
{[]string{"stop", "ttl", "regex", `(srv20)\.(coredns)\.(rocks)`, "20"}, reflect.TypeOf(&regexTTLRule{})}, {[]string{"stop", "ttl", "regex", `(srv20)\.(coredns)\.(rocks)`, "20"}, reflect.TypeFor[*regexTTLRule]()},
{[]string{"stop", "ttl", "range.example.com.", "30-300"}, reflect.TypeOf(&exactTTLRule{})}, {[]string{"stop", "ttl", "range.example.com.", "30-300"}, reflect.TypeFor[*exactTTLRule]()},
{[]string{"stop", "ttl", "ceil.example.com.", "-11"}, reflect.TypeOf(&exactTTLRule{})}, {[]string{"stop", "ttl", "ceil.example.com.", "-11"}, reflect.TypeFor[*exactTTLRule]()},
{[]string{"stop", "ttl", "floor.example.com.", "5-"}, reflect.TypeOf(&exactTTLRule{})}, {[]string{"stop", "ttl", "floor.example.com.", "5-"}, reflect.TypeFor[*exactTTLRule]()},
} }
for i, r := range ruleset { for i, r := range ruleset {
rule, err := newRule(r.args...) rule, err := newRule(r.args...)

2
plugin/route53/route53_test.go
View File

@@ -252,7 +252,7 @@ func TestRoute53(t *testing.T) {
for i, ns := range rec.Msg.Ns { for i, ns := range rec.Msg.Ns {
got, ok := ns.(*dns.SOA) got, ok := ns.(*dns.SOA)
if !ok { if !ok {
t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeOf(got)) t.Errorf("Test %d: Unexpected NS type. Want: SOA, got: %v", ti, reflect.TypeFor[*dns.SOA]())
} }
if got.String() != tc.wantNS[i] { if got.String() != tc.wantNS[i] {
t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got) t.Errorf("Test %d: Unexpected NS.\nWant: %v\nGot: %v", ti, tc.wantNS[i], got)