aboutsummaryrefslogtreecommitdiff
path: root/middleware/rewrite/rewrite_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'middleware/rewrite/rewrite_test.go')
-rw-r--r--middleware/rewrite/rewrite_test.go532
1 files changed, 0 insertions, 532 deletions
diff --git a/middleware/rewrite/rewrite_test.go b/middleware/rewrite/rewrite_test.go
deleted file mode 100644
index 39648711e..000000000
--- a/middleware/rewrite/rewrite_test.go
+++ /dev/null
@@ -1,532 +0,0 @@
-package rewrite
-
-import (
- "bytes"
- "reflect"
- "testing"
-
- "github.com/coredns/coredns/middleware"
- "github.com/coredns/coredns/middleware/pkg/dnsrecorder"
- "github.com/coredns/coredns/middleware/test"
-
- "github.com/miekg/dns"
- "golang.org/x/net/context"
-)
-
-func msgPrinter(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
- w.WriteMsg(r)
- return 0, nil
-}
-
-func TestNewRule(t *testing.T) {
- tests := []struct {
- args []string
- shouldError bool
- expType reflect.Type
- }{
- {[]string{}, true, nil},
- {[]string{"foo"}, true, nil},
- {[]string{"name"}, true, nil},
- {[]string{"name", "a.com"}, true, nil},
- {[]string{"name", "a.com", "b.com", "c.com"}, true, nil},
- {[]string{"name", "a.com", "b.com"}, false, reflect.TypeOf(&nameRule{})},
- {[]string{"type"}, true, nil},
- {[]string{"type", "a"}, true, nil},
- {[]string{"type", "any", "a", "a"}, true, nil},
- {[]string{"type", "any", "a"}, false, reflect.TypeOf(&typeRule{})},
- {[]string{"type", "XY", "WV"}, true, nil},
- {[]string{"type", "ANY", "WV"}, true, nil},
- {[]string{"class"}, true, nil},
- {[]string{"class", "IN"}, true, nil},
- {[]string{"class", "ch", "in", "in"}, true, nil},
- {[]string{"class", "ch", "in"}, false, reflect.TypeOf(&classRule{})},
- {[]string{"class", "XY", "WV"}, true, nil},
- {[]string{"class", "IN", "WV"}, true, nil},
- {[]string{"edns0"}, true, nil},
- {[]string{"edns0", "local"}, true, nil},
- {[]string{"edns0", "local", "set"}, true, nil},
- {[]string{"edns0", "local", "set", "0xffee"}, true, nil},
- {[]string{"edns0", "local", "set", "65518", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "abcdefg"}, false, reflect.TypeOf(&edns0LocalRule{})},
- {[]string{"edns0", "local", "foo", "0xffee", "abcdefg"}, true, nil},
- {[]string{"edns0", "local", "set", "0xffee", "0xabcdefg"}, true, nil},
- {[]string{"edns0", "nsid", "set", "junk"}, true, nil},
- {[]string{"edns0", "nsid", "set"}, false, reflect.TypeOf(&edns0NsidRule{})},
- {[]string{"edns0", "nsid", "append"}, false, reflect.TypeOf(&edns0NsidRule{})},
- {[]string{"edns0", "nsid", "replace"}, false, reflect.TypeOf(&edns0NsidRule{})},
- {[]string{"edns0", "nsid", "foo"}, 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", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{dummy}"}, true, nil},
- {[]string{"edns0", "local", "append", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "append", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{dummy}"}, true, nil},
- {[]string{"edns0", "local", "replace", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{client_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "local", "replace", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
- {[]string{"edns0", "subnet", "set", "-1", "56"}, true, nil},
- {[]string{"edns0", "subnet", "set", "24", "-56"}, true, nil},
- {[]string{"edns0", "subnet", "set", "33", "56"}, true, nil},
- {[]string{"edns0", "subnet", "set", "24", "129"}, true, nil},
- {[]string{"edns0", "subnet", "set", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})},
- {[]string{"edns0", "subnet", "append", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})},
- {[]string{"edns0", "subnet", "replace", "24", "56"}, false, reflect.TypeOf(&edns0SubnetRule{})},
- }
-
- for i, tc := range tests {
- r, err := newRule(tc.args...)
- if err == nil && tc.shouldError {
- t.Errorf("Test %d: expected error but got success", i)
- } else if err != nil && !tc.shouldError {
- t.Errorf("Test %d: expected success but got error: %s", i, err)
- }
-
- if !tc.shouldError && reflect.TypeOf(r) != tc.expType {
- t.Errorf("Test %d: expected %q but got %q", i, tc.expType, r)
- }
- }
-}
-
-func TestRewrite(t *testing.T) {
- rules := []Rule{}
- r, _ := newNameRule("from.nl.", "to.nl.")
- rules = append(rules, r)
- r, _ = newClassRule("CH", "IN")
- rules = append(rules, r)
- r, _ = newTypeRule("ANY", "HINFO")
- rules = append(rules, r)
-
- rw := Rewrite{
- Next: middleware.HandlerFunc(msgPrinter),
- Rules: rules,
- noRevert: true,
- }
-
- tests := []struct {
- from string
- fromT uint16
- fromC uint16
- to string
- toT uint16
- toC uint16
- }{
- {"from.nl.", dns.TypeA, dns.ClassINET, "to.nl.", dns.TypeA, dns.ClassINET},
- {"a.nl.", dns.TypeA, dns.ClassINET, "a.nl.", dns.TypeA, dns.ClassINET},
- {"a.nl.", dns.TypeA, dns.ClassCHAOS, "a.nl.", dns.TypeA, dns.ClassINET},
- {"a.nl.", dns.TypeANY, dns.ClassINET, "a.nl.", dns.TypeHINFO, dns.ClassINET},
- // name is rewritten, type is not.
- {"from.nl.", dns.TypeANY, dns.ClassINET, "to.nl.", dns.TypeANY, dns.ClassINET},
- // name is not, type is, but class is, because class is the 2nd rule.
- {"a.nl.", dns.TypeANY, dns.ClassCHAOS, "a.nl.", dns.TypeANY, dns.ClassINET},
- }
-
- ctx := context.TODO()
- for i, tc := range tests {
- m := new(dns.Msg)
- m.SetQuestion(tc.from, tc.fromT)
- m.Question[0].Qclass = tc.fromC
-
- rec := dnsrecorder.New(&test.ResponseWriter{})
- rw.ServeDNS(ctx, rec, m)
-
- resp := rec.Msg
- if resp.Question[0].Name != tc.to {
- t.Errorf("Test %d: Expected Name to be %q but was %q", i, tc.to, resp.Question[0].Name)
- }
- if resp.Question[0].Qtype != tc.toT {
- t.Errorf("Test %d: Expected Type to be '%d' but was '%d'", i, tc.toT, resp.Question[0].Qtype)
- }
- if resp.Question[0].Qclass != tc.toC {
- t.Errorf("Test %d: Expected Class to be '%d' but was '%d'", i, tc.toC, resp.Question[0].Qclass)
- }
- }
-}
-
-func TestRewriteEDNS0Local(t *testing.T) {
- rw := Rewrite{
- Next: middleware.HandlerFunc(msgPrinter),
- noRevert: true,
- }
-
- tests := []struct {
- fromOpts []dns.EDNS0
- args []string
- toOpts []dns.EDNS0
- }{
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "0xabcdef"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0xab, 0xcd, 0xef}}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "append", "0xffee", "abcdefghijklmnop"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("abcdefghijklmnop")}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "replace", "0xffee", "abcdefghijklmnop"},
- []dns.EDNS0{},
- },
- {
- []dns.EDNS0{},
- []string{"nsid", "set"},
- []dns.EDNS0{&dns.EDNS0_NSID{Code: dns.EDNS0NSID, Nsid: ""}},
- },
- {
- []dns.EDNS0{},
- []string{"nsid", "append"},
- []dns.EDNS0{&dns.EDNS0_NSID{Code: dns.EDNS0NSID, Nsid: ""}},
- },
- {
- []dns.EDNS0{},
- []string{"nsid", "replace"},
- []dns.EDNS0{},
- },
- }
-
- ctx := context.TODO()
- for i, tc := range tests {
- m := new(dns.Msg)
- m.SetQuestion("example.com.", dns.TypeA)
- m.Question[0].Qclass = dns.ClassINET
-
- r, err := newEdns0Rule(tc.args...)
- if err != nil {
- t.Errorf("Error creating test rule: %s", err)
- continue
- }
- rw.Rules = []Rule{r}
-
- rec := dnsrecorder.New(&test.ResponseWriter{})
- rw.ServeDNS(ctx, rec, m)
-
- resp := rec.Msg
- o := resp.IsEdns0()
- if o == nil {
- t.Errorf("Test %d: EDNS0 options not set", i)
- continue
- }
- if !optsEqual(o.Option, tc.toOpts) {
- t.Errorf("Test %d: Expected %v but got %v", i, tc.toOpts, o)
- }
- }
-}
-
-func TestEdns0LocalMultiRule(t *testing.T) {
- rules := []Rule{}
- r, _ := newEdns0Rule("local", "replace", "0xffee", "abcdef")
- rules = append(rules, r)
- r, _ = newEdns0Rule("local", "set", "0xffee", "fedcba")
- rules = append(rules, r)
-
- rw := Rewrite{
- Next: middleware.HandlerFunc(msgPrinter),
- Rules: rules,
- noRevert: true,
- }
-
- tests := []struct {
- fromOpts []dns.EDNS0
- toOpts []dns.EDNS0
- }{
- {
- nil,
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("fedcba")}},
- },
- {
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("foobar")}},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("abcdef")}},
- },
- }
-
- ctx := context.TODO()
- for i, tc := range tests {
- m := new(dns.Msg)
- m.SetQuestion("example.com.", dns.TypeA)
- m.Question[0].Qclass = dns.ClassINET
- if tc.fromOpts != nil {
- o := m.IsEdns0()
- if o == nil {
- m.SetEdns0(4096, true)
- o = m.IsEdns0()
- }
- o.Option = append(o.Option, tc.fromOpts...)
- }
- rec := dnsrecorder.New(&test.ResponseWriter{})
- rw.ServeDNS(ctx, rec, m)
-
- resp := rec.Msg
- o := resp.IsEdns0()
- if o == nil {
- t.Errorf("Test %d: EDNS0 options not set", i)
- continue
- }
- if !optsEqual(o.Option, tc.toOpts) {
- t.Errorf("Test %d: Expected %v but got %v", i, tc.toOpts, o)
- }
- }
-}
-
-func optsEqual(a, b []dns.EDNS0) bool {
- if len(a) != len(b) {
- return false
- }
- for i := range a {
- switch aa := a[i].(type) {
- case *dns.EDNS0_LOCAL:
- if bb, ok := b[i].(*dns.EDNS0_LOCAL); ok {
- if aa.Code != bb.Code {
- return false
- }
- if !bytes.Equal(aa.Data, bb.Data) {
- return false
- }
- } else {
- return false
- }
- case *dns.EDNS0_NSID:
- if bb, ok := b[i].(*dns.EDNS0_NSID); ok {
- if aa.Nsid != bb.Nsid {
- return false
- }
- } else {
- return false
- }
- case *dns.EDNS0_SUBNET:
- if bb, ok := b[i].(*dns.EDNS0_SUBNET); ok {
- if aa.Code != bb.Code {
- return false
- }
- if aa.Family != bb.Family {
- return false
- }
- if aa.SourceNetmask != bb.SourceNetmask {
- return false
- }
- if aa.SourceScope != bb.SourceScope {
- return false
- }
- if !bytes.Equal(aa.Address, bb.Address) {
- return false
- }
- if aa.DraftOption != bb.DraftOption {
- return false
- }
- } else {
- return false
- }
-
- default:
- return false
- }
- }
- return true
-}
-
-func TestRewriteEDNS0LocalVariable(t *testing.T) {
- rw := Rewrite{
- Next: middleware.HandlerFunc(msgPrinter),
- noRevert: true,
- }
-
- // test.ResponseWriter has the following values:
- // The remote will always be 10.240.0.1 and port 40212.
- // The local address is always 127.0.0.1 and port 53.
-
- tests := []struct {
- fromOpts []dns.EDNS0
- args []string
- toOpts []dns.EDNS0
- }{
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{qname}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("example.com.")}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{qtype}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0x00, 0x01}}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{client_ip}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0x0A, 0xF0, 0x00, 0x01}}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{client_port}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0x9D, 0x14}}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{protocol}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte("udp")}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{server_ip}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0x7F, 0x00, 0x00, 0x01}}},
- },
- {
- []dns.EDNS0{},
- []string{"local", "set", "0xffee", "{server_port}"},
- []dns.EDNS0{&dns.EDNS0_LOCAL{Code: 0xffee, Data: []byte{0x00, 0x35}}},
- },
- }
-
- ctx := context.TODO()
- for i, tc := range tests {
- m := new(dns.Msg)
- m.SetQuestion("example.com.", dns.TypeA)
- m.Question[0].Qclass = dns.ClassINET
-
- r, err := newEdns0Rule(tc.args...)
- if err != nil {
- t.Errorf("Error creating test rule: %s", err)
- continue
- }
- rw.Rules = []Rule{r}
-
- rec := dnsrecorder.New(&test.ResponseWriter{})
- rw.ServeDNS(ctx, rec, m)
-
- resp := rec.Msg
- o := resp.IsEdns0()
- if o == nil {
- t.Errorf("Test %d: EDNS0 options not set", i)
- continue
- }
- if !optsEqual(o.Option, tc.toOpts) {
- t.Errorf("Test %d: Expected %v but got %v", i, tc.toOpts, o)
- }
- }
-}
-
-func TestRewriteEDNS0Subnet(t *testing.T) {
- rw := Rewrite{
- Next: middleware.HandlerFunc(msgPrinter),
- noRevert: true,
- }
-
- tests := []struct {
- writer dns.ResponseWriter
- fromOpts []dns.EDNS0
- args []string
- toOpts []dns.EDNS0
- }{
- {
- &test.ResponseWriter{},
- []dns.EDNS0{},
- []string{"subnet", "set", "24", "56"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x1,
- SourceNetmask: 0x18,
- SourceScope: 0x0,
- Address: []byte{0x0A, 0xF0, 0x00, 0x00},
- DraftOption: false}},
- },
- {
- &test.ResponseWriter{},
- []dns.EDNS0{},
- []string{"subnet", "set", "32", "56"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x1,
- SourceNetmask: 0x20,
- SourceScope: 0x0,
- Address: []byte{0x0A, 0xF0, 0x00, 0x01},
- DraftOption: false}},
- },
- {
- &test.ResponseWriter{},
- []dns.EDNS0{},
- []string{"subnet", "set", "0", "56"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x1,
- SourceNetmask: 0x0,
- SourceScope: 0x0,
- Address: []byte{0x00, 0x00, 0x00, 0x00},
- DraftOption: false}},
- },
- {
- &test.ResponseWriter6{},
- []dns.EDNS0{},
- []string{"subnet", "set", "24", "56"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x2,
- SourceNetmask: 0x38,
- SourceScope: 0x0,
- Address: []byte{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- DraftOption: false}},
- },
- {
- &test.ResponseWriter6{},
- []dns.EDNS0{},
- []string{"subnet", "set", "24", "128"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x2,
- SourceNetmask: 0x80,
- SourceScope: 0x0,
- Address: []byte{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x42, 0x00, 0xff, 0xfe, 0xca, 0x4c, 0x65},
- DraftOption: false}},
- },
- {
- &test.ResponseWriter6{},
- []dns.EDNS0{},
- []string{"subnet", "set", "24", "0"},
- []dns.EDNS0{&dns.EDNS0_SUBNET{Code: 0x8,
- Family: 0x2,
- SourceNetmask: 0x0,
- SourceScope: 0x0,
- Address: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- DraftOption: false}},
- },
- }
-
- ctx := context.TODO()
- for i, tc := range tests {
- m := new(dns.Msg)
- m.SetQuestion("example.com.", dns.TypeA)
- m.Question[0].Qclass = dns.ClassINET
-
- r, err := newEdns0Rule(tc.args...)
- if err != nil {
- t.Errorf("Error creating test rule: %s", err)
- continue
- }
- rw.Rules = []Rule{r}
- rec := dnsrecorder.New(tc.writer)
- rw.ServeDNS(ctx, rec, m)
-
- resp := rec.Msg
- o := resp.IsEdns0()
- if o == nil {
- t.Errorf("Test %d: EDNS0 options not set", i)
- continue
- }
- if !optsEqual(o.Option, tc.toOpts) {
- t.Errorf("Test %d: Expected %v but got %v", i, tc.toOpts, o)
- }
- }
-}