github.com/pmoroney/dnscontrol@v0.2.4-0.20171024134423-fad98f73f44a/pkg/normalize/validate_test.go (about) 1 package normalize 2 3 import ( 4 "testing" 5 6 "fmt" 7 8 "github.com/StackExchange/dnscontrol/models" 9 ) 10 11 func TestCheckLabel(t *testing.T) { 12 var tests = []struct { 13 label string 14 rType string 15 target string 16 isError bool 17 }{ 18 {"@", "A", "0.0.0.0", false}, 19 {"@", "A", "foo.tld", true}, 20 {"foo.bar", "A", "0.0.0.0", false}, 21 {"_foo", "SRV", "foo.tld", false}, 22 {"_foo", "TLSA", "foo.tld", false}, 23 {"_foo", "TXT", "foo.tld", false}, 24 } 25 26 for _, test := range tests { 27 err := checkLabel(test.label, test.rType, test.target) 28 if err != nil && test.isError { 29 t.Errorf("%v: Expected error but got none \n", "TestCheckLabel") 30 } 31 } 32 } 33 34 func checkError(t *testing.T, err error, shouldError bool, experiment string) { 35 if err != nil && !shouldError { 36 t.Errorf("%v: Error (%v)\n", experiment, err) 37 } 38 if err == nil && shouldError { 39 t.Errorf("%v: Expected error but got none \n", experiment) 40 } 41 } 42 43 func Test_assert_valid_ipv4(t *testing.T) { 44 var tests = []struct { 45 experiment string 46 isError bool 47 }{ 48 {"1.2.3.4", false}, 49 {"1.2.3.4/10", true}, 50 {"1.2.3", true}, 51 {"foo", true}, 52 } 53 54 for _, test := range tests { 55 err := checkIPv4(test.experiment) 56 checkError(t, err, test.isError, test.experiment) 57 } 58 } 59 60 func Test_assert_valid_target(t *testing.T) { 61 var tests = []struct { 62 experiment string 63 isError bool 64 }{ 65 {"@", false}, 66 {"foo", false}, 67 {"foo.bar.", false}, 68 {"foo.", false}, 69 {"foo.bar", true}, 70 {"foo&bar", true}, 71 {"foo bar", true}, 72 {"elb21.freshdesk.com/", true}, 73 {"elb21.freshdesk.com/.", true}, 74 } 75 76 for _, test := range tests { 77 err := checkTarget(test.experiment) 78 checkError(t, err, test.isError, test.experiment) 79 } 80 } 81 82 func Test_transform_cname(t *testing.T) { 83 var tests = []struct { 84 experiment string 85 expected string 86 }{ 87 {"@", "old.com.new.com."}, 88 {"foo", "foo.old.com.new.com."}, 89 {"foo.bar", "foo.bar.old.com.new.com."}, 90 {"foo.bar.", "foo.bar.new.com."}, 91 {"chat.stackexchange.com.", "chat.stackexchange.com.new.com."}, 92 } 93 94 for _, test := range tests { 95 actual := transformCNAME(test.experiment, "old.com", "new.com") 96 if test.expected != actual { 97 t.Errorf("%v: expected (%v) got (%v)\n", test.experiment, test.expected, actual) 98 } 99 } 100 } 101 102 func TestNSAtRoot(t *testing.T) { 103 //do not allow ns records for @ 104 rec := &models.RecordConfig{Name: "test", Type: "NS", Target: "ns1.name.com."} 105 errs := checkTargets(rec, "foo.com") 106 if len(errs) > 0 { 107 t.Error("Expect no error with ns record on subdomain") 108 } 109 rec.Name = "@" 110 errs = checkTargets(rec, "foo.com") 111 if len(errs) != 1 { 112 t.Error("Expect error with ns record on @") 113 } 114 } 115 116 func TestTransforms(t *testing.T) { 117 var tests = []struct { 118 givenIP string 119 expectedRecords []string 120 }{ 121 {"0.0.5.5", []string{"2.0.5.5"}}, 122 {"3.0.5.5", []string{"5.5.5.5"}}, 123 {"7.0.5.5", []string{"9.9.9.9", "10.10.10.10"}}, 124 } 125 const transform = "0.0.0.0~1.0.0.0~2.0.0.0~; 3.0.0.0~4.0.0.0~~5.5.5.5; 7.0.0.0~8.0.0.0~~9.9.9.9,10.10.10.10" 126 for i, test := range tests { 127 dc := &models.DomainConfig{ 128 Records: []*models.RecordConfig{ 129 {Type: "A", Target: test.givenIP, Metadata: map[string]string{"transform": transform}}, 130 }, 131 } 132 err := applyRecordTransforms(dc) 133 if err != nil { 134 t.Errorf("error on test %d: %s", i, err) 135 continue 136 } 137 if len(dc.Records) != len(test.expectedRecords) { 138 t.Errorf("test %d: expect %d records but found %d", i, len(test.expectedRecords), len(dc.Records)) 139 continue 140 } 141 for r, rec := range dc.Records { 142 if rec.Target != test.expectedRecords[r] { 143 t.Errorf("test %d at index %d: records don't match. Expect %s but found %s.", i, r, test.expectedRecords[r], rec.Target) 144 continue 145 } 146 } 147 } 148 } 149 150 func TestCNAMEMutex(t *testing.T) { 151 var recA = &models.RecordConfig{Type: "CNAME", Name: "foo", NameFQDN: "foo.example.com", Target: "example.com."} 152 tests := []struct { 153 rType string 154 name string 155 fail bool 156 }{ 157 {"A", "foo", true}, 158 {"A", "foo2", false}, 159 {"CNAME", "foo", true}, 160 {"CNAME", "foo2", false}, 161 } 162 for _, tst := range tests { 163 t.Run(fmt.Sprintf("%s %s", tst.rType, tst.name), func(t *testing.T) { 164 var recB = &models.RecordConfig{Type: tst.rType, Name: tst.name, NameFQDN: tst.name + ".example.com", Target: "example2.com."} 165 dc := &models.DomainConfig{ 166 Name: "example.com", 167 Records: []*models.RecordConfig{recA, recB}, 168 } 169 errs := checkCNAMEs(dc) 170 if errs != nil && !tst.fail { 171 t.Error("Got error but expected none") 172 } 173 if errs == nil && tst.fail { 174 t.Error("Expected error but got none") 175 } 176 }) 177 } 178 } 179 180 func TestCAAValidation(t *testing.T) { 181 config := &models.DNSConfig{ 182 Domains: []*models.DomainConfig{ 183 { 184 Name: "example.com", 185 Registrar: "BIND", 186 Records: []*models.RecordConfig{ 187 {Name: "@", Type: "CAA", CaaTag: "invalid", Target: "example.com"}, 188 }, 189 }, 190 }, 191 } 192 errs := NormalizeAndValidateConfig(config) 193 if len(errs) != 1 { 194 t.Error("Expect error on invalid CAA but got none") 195 } 196 } 197 198 func TestTLSAValidation(t *testing.T) { 199 config := &models.DNSConfig{ 200 Domains: []*models.DomainConfig{ 201 { 202 Name: "_443._tcp.example.com", 203 Registrar: "BIND", 204 Records: []*models.RecordConfig{ 205 {Name: "_443._tcp", Type: "TLSA", TlsaUsage: 4, TlsaSelector: 1, TlsaMatchingType: 1, Target: "abcdef0"}, 206 }, 207 }, 208 }, 209 } 210 errs := NormalizeAndValidateConfig(config) 211 if len(errs) != 1 { 212 t.Error("Expect error on invalid TLSA but got none") 213 } 214 }