def test_update_has_child_domain(self): Domain(name='com99').save() f_c = Domain(name='foo.com99') f_c.save() Domain(name='boo.foo.com99').save() f_c.name = 'foobar.com99' self.assertRaises(ValidationError, f_c.save)
def test_bad_delete(self): network = "129.0.0.0" prefixlen = "24" kwargs = {'network': network, 'prefixlen': prefixlen, 'ip_type': '4'} s = self.do_basic_add(**kwargs) s_pk = s.pk self.assertTrue(s) d = Domain(name="asdf") d.save() start_str = "129.0.0.1" end_str = "129.0.0.255" network = s r = Range(start_str=start_str, end_str=end_str, network=network) r.clean() r.save() self.assertEqual(r.network, s) self.assertTrue(len(s.range_set.all()) == 1) self.assertRaises(ValidationError, s.delete) self.assertTrue(Network.objects.get(pk=s_pk)) r.delete() s.delete() self.assertEqual(len(Network.objects.filter(pk=s_pk)), 0)
class CNAMEStaticRegTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d def setUp(self): self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = System() self.n.clean() self.n.save() def do_add_intr(self, mac, label, domain, ip_str, ip_type='4'): r = StaticInterface(mac=mac, label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=self.n) r.clean() r.save() repr(r) return r def test1_delete_cname(self): mac = "11:22:33:44:55:66" label = "foo4" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'mac': mac, 'label': label, 'domain': domain, 'ip_str': ip_str} i = self.do_add_intr(**kwargs) cn, _ = CNAME.objects.get_or_create(label='foo', domain=domain, target=label + "." + domain.name) self.assertRaises(ValidationError, i.delete) def test1_delete_override(self): mac = "12:22:33:44:55:66" label = "foo6" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'mac': mac, 'label': label, 'domain': domain, 'ip_str': ip_str} i = self.do_add_intr(**kwargs) cn, _ = CNAME.objects.get_or_create(label='food', domain=domain, target=label + "." + domain.name) i.delete(check_cname=False)
def test_cleanup_cname(self): # Make sure CNAME record block c = Domain(name='foo1') c.save() self.assertFalse(c.purgeable) f_c = create_fake_zone('foo.foo1', suffix="") self.assertEqual(f_c.name, 'foo.foo1') self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1")) self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1")) self.assertFalse(Domain.objects.filter(name="z.foo.foo1")) self.assertTrue(Domain.objects.filter(name="foo.foo1")) self.assertFalse(f_c.purgeable) fqdn = "cname.x.y.z.foo.foo1" label, the_domain = ensure_label_domain(fqdn) cname = CNAME(label=label, domain=the_domain, target="foo") cname.save() self.assertFalse(prune_tree(the_domain)) cname.delete() self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1")) self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1")) self.assertFalse(Domain.objects.filter(name="z.foo.foo1")) fqdn = "bar.x.y.z.foo.poo" self.assertTrue(Domain.objects.filter(name="foo.foo1"))
class DeleteStaticStaticRegTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d def setUp(self): self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save() View.objects.get_or_create(name="private") def do_add(self, label, domain, ip_str, system, ip_type='4'): r = StaticReg( label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=system ) r.clean() r.save() return r def do_delete(self, r): ip_str = r.ip_str fqdn = r.fqdn r.delete() self.assertFalse( AddressRecord.objects.filter(ip_str=ip_str, fqdn=fqdn)) def test1_delete_basic(self): # Does deleting a system delete it's interfaces? label = "foo" domain = self.f_c ip_str = "10.0.0.2" system = create_fake_host(hostname="foo") system.save() kwargs = { 'label': label, 'domain': domain, 'ip_str': ip_str, 'system': system} self.do_add(**kwargs) self.assertTrue(StaticReg.objects.filter(**kwargs)) system.delete() self.assertFalse(StaticReg.objects.filter(**kwargs))
def test_delegation_add_domain(self): name = "boom1" dom = Domain(name=name, delegated=True) dom.save() name = "boom.boom1" dom = Domain(name=name, delegated=False) self.assertRaises(ValidationError, dom.save)
def test_basic_add_remove2(self): # MAke sure that if a domain is set to not purgeable the prune stops at # that domain. c = Domain(name='edu') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.edu') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", description="foo.edu") f_c.soa = s f_c.save() self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.edu" label, the_domain = ensure_label_domain(fqdn) self.assertEqual(label, "bar") self.assertEqual(the_domain.name, "x.y.z.foo.edu") self.assertTrue(the_domain.purgeable) self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu") self.assertTrue(the_domain.master_domain.purgeable) self.assertEqual(the_domain.master_domain.master_domain.name, "z.foo.edu") self.assertTrue(the_domain.master_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.master_domain.name, "foo.edu") self.assertFalse( the_domain.master_domain.master_domain.master_domain.purgeable) # See if purgeable stops prune the_domain.purgeable = False the_domain.save() self.assertFalse(prune_tree(the_domain)) the_domain.purgeable = True the_domain.save() # Ok, reset y_z = Domain.objects.get(name="y.z.foo.edu") y_z.purgeable = False y_z.save() # Refresh the domain the_domain = Domain.objects.get(pk=the_domain.pk) # This should delete up to and stop at the domain "y.z.foo.edu" self.assertTrue(prune_tree(the_domain)) self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu")) self.assertTrue(Domain.objects.filter(name="y.z.foo.edu")) self.assertTrue(Domain.objects.filter(name="z.foo.edu")) self.assertTrue(Domain.objects.filter(name="foo.edu")) # If we delete y.z.foo.com and then call prune on z.foo.com is should # delete z.foo.com Domain.objects.get(name="y.z.foo.edu").delete() self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu"))) self.assertFalse(Domain.objects.filter(name="z.foo.edu")) self.assertTrue(Domain.objects.filter(name="foo.edu"))
def test_remove_domain(self): c = Domain(name='com') c.save() f_c = Domain(name='foo.com') f_c.save() f_c.delete() foo = Domain(name='foo.com') str(foo) foo.__repr__()
class SSHFPTests(TestCase): def setUp(self): self.o = Domain(name="org") self.o.save() self.o_e = Domain(name="mozilla.org") self.o_e.save() def do_generic_add(self, data): sshfp = SSHFP(**data) sshfp.__repr__() sshfp.save() self.assertTrue(sshfp.details()) self.assertTrue(sshfp.get_absolute_url()) self.assertTrue(sshfp.get_edit_url()) self.assertTrue(sshfp.get_delete_url()) rsshfp = SSHFP.objects.filter(**data) self.assertEqual(len(rsshfp), 1) return sshfp def do_remove(self, data): sshfp = self.do_generic_add(data) sshfp.delete() rmx = SSHFP.objects.filter(**data) self.assertTrue(len(rmx) == 0) def test_add_remove_sshfp(self): label = "asdf" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = {'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} self.do_generic_add(data) label = "asdk" key = "eee85bca3608ac860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = {'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} self.do_generic_add(data) label = "df" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = {'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} self.do_generic_add(data) label = "12314" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = {'label': label, 'key': key, 'domain': self.o, 'algorithm_number': a_type, 'fingerprint_type': s_type} self.do_generic_add(data)
def test_basic_add_remove2(self): # MAke sure that if a domain is set to not purgeable the prune stops at # that domain. c = Domain(name='edu') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.edu') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", description="foo.edu") f_c.soa = s f_c.save() self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.edu" label, the_domain = ensure_label_domain(fqdn) self.assertEqual(label, "bar") self.assertEqual(the_domain.name, "x.y.z.foo.edu") self.assertTrue(the_domain.purgeable) self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu") self.assertTrue(the_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.name, "z.foo.edu") self.assertTrue(the_domain.master_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.master_domain.name, "foo.edu") self.assertFalse( the_domain.master_domain.master_domain.master_domain.purgeable) # See if purgeable stops prune the_domain.purgeable = False the_domain.save() self.assertFalse(prune_tree(the_domain)) the_domain.purgeable = True the_domain.save() # Ok, reset y_z = Domain.objects.get(name="y.z.foo.edu") y_z.purgeable = False y_z.save() # Refresh the domain the_domain = Domain.objects.get(pk=the_domain.pk) # This should delete up to and stop at the domain "y.z.foo.edu" self.assertTrue(prune_tree(the_domain)) self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu")) self.assertTrue(Domain.objects.filter(name="y.z.foo.edu")) self.assertTrue(Domain.objects.filter(name="z.foo.edu")) self.assertTrue(Domain.objects.filter(name="foo.edu")) # If we delete y.z.foo.com and then call prune on z.foo.com is should # delete z.foo.com Domain.objects.get(name="y.z.foo.edu").delete() self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu"))) self.assertFalse(Domain.objects.filter(name="z.foo.edu")) self.assertTrue(Domain.objects.filter(name="foo.edu"))
class DomainViewTests(TestCase): def setUp(self): self.url_slug = 'domain' soa = SOA(primary=random_label(), contact=random_label(), description=random_label()) self.test_obj = Domain(name=random_label()) self.test_obj.save() self.test_obj.soa = soa self.test_obj.save() def test_base_mozdns_app_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/" % (self.url_slug), follow=True) self.assertEqual(resp.status_code, 200) def test_get_create_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/create/" % (self.url_slug), follow=True) self.assertEqual(resp.status_code, 200) def test_post_create_domain(self): resp = self.client.post(MOZDNS_BASE_URL + "/%s/create/" % (self.url_slug), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_update_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/update/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def test_post_object_update_domain(self): resp = self.client.post(MOZDNS_BASE_URL + "/%s/%s/update/" % (self.url_slug, self.test_obj.pk), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_details_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def test_get_object_delete_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/delete/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def post_data(self): return {'name': random_label()}
def test_remove_has_child_records(self): Domain(name='com').save() f_c = Domain(name='foo.com') f_c.save() cn = CNAME(domain=f_c, label="no", target="asdf") cn.full_clean() cn.save() self.assertRaises(ValidationError, f_c.delete)
def test_delete_with_domains(self): data = {'primary': "ns1asfdadsf.foo.com", 'contact': "email.foo.com"} soa = SOA(**data) soa.save() d0 = Domain(name='com') d0.save() d1 = Domain(name='foo.com', soa=soa) d1.soa = soa d1.save() self.assertRaises(ValidationError, soa.delete)
def test_add_address_underscore_in_name_domain(self): d = Domain(name="_mssucks.edu") d.save() data = {'label': '*', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data) data = {'label': 'foo', 'domain': d, 'ip': "128.193.0.10"} a = self.do_add_record(data) a.save() data = {'label': 'noop', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data)
def build_sample_domain(): domain_name = '' for i in range(2): domain_name = random_label() domain = Domain(name=domain_name) soa = SOA( primary=random_label(), contact="asf", description=random_label()) soa.save() domain.soa = soa domain.save() return domain
def test_no_soa_block(self): fqdn = "baz.bar.foo.eu" self.assertRaises(ValidationError, ensure_label_domain, fqdn) c = Domain(name='eu') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.eu') f_c.save() self.assertFalse(f_c.purgeable) # Even with domains there, they aren't part of a zone and should so # creation should fail. self.assertRaises(ValidationError, ensure_label_domain, fqdn)
class TXTTests(TestCase): def setUp(self): self.o = Domain(name="org") self.o.save() self.o_e = Domain(name="oregonstate.org") self.o_e.save() def do_generic_add(self, data): txt = TXT(**data) txt.__repr__() txt.save() self.assertTrue(txt.details()) self.assertTrue(txt.get_absolute_url()) self.assertTrue(txt.get_edit_url()) self.assertTrue(txt.get_delete_url()) rtxt = TXT.objects.filter(**data) self.assertTrue(len(rtxt) == 1) return txt def do_remove(self, data): txt = self.do_generic_add(data) txt.delete() rmx = TXT.objects.filter(**data) self.assertTrue(len(rmx) == 0) def test_add_remove_txt(self): label = "asdf" data = "asdf" data = {'label': label, 'txt_data': data, 'domain': self.o_e} self.do_generic_add(data) label = "asdf" data = "asdfasfd" data = {'label': label, 'txt_data': data, 'domain': self.o_e} self.do_generic_add(data) label = "df" data = "aasdf" data = {'label': label, 'txt_data': data, 'domain': self.o_e} self.do_generic_add(data) label = "12314" data = "dd" data = {'label': label, 'txt_data': data, 'domain': self.o} self.do_generic_add(data) def test_bad_data(self): label = "asdf" data = '"dfa f' data = {'label': label, 'txt_data': data, 'domain': self.o_e} self.assertRaises(ValidationError, self.do_generic_add, data)
def test_delegation_block(self): s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", description="foo") c = Domain(name='com') c.soa = s c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.com') f_c.delegated = True f_c.save() self.assertFalse(f_c.purgeable) self.assertTrue(f_c.delegated) fqdn = "z.baz.foo.com" self.assertRaises(ValidationError, ensure_label_domain, fqdn)
def test_bad_nameserver_soa_state_case_1_3(self): # This is Case 1 ... with ptr's root_domain = create_fake_zone("13.in-addr.arpa", suffix="") for ns in root_domain.nameserver_set.all(): ns.delete() # At his point we should have a domain at the root of a zone with no # other records in it. # Let's create a child domain and try to add a record there. cdomain = Domain(name="10.13.in-addr.arpa") cdomain.soa = root_domain.soa cdomain.save() # Adding a record shouldn't be allowed because there is no NS record on # the zone's root domain. ptr = PTR(name="asdf", ip_str="13.10.1.1", ip_type="4") self.assertRaises(ValidationError, ptr.save)
def test_bad_nameserver_soa_state_case_2_1(self): # This is Case 2 root_domain = create_fake_zone("asdf21") self.assertEqual(root_domain.nameserver_set.count(), 1) ns = root_domain.nameserver_set.all()[0] # At his point we should have a domain at the root of a zone with one # ns record associated to the domain. # Let's create a child domain and add a record there, then try to # delete the NS record cdomain = Domain(name="test." + root_domain.name) cdomain.soa = root_domain.soa cdomain.save() AddressRecord.objects.create( label='', domain=cdomain, ip_type="6", ip_str="1::") self.assertRaises(ValidationError, ns.delete)
def test_bad_nameserver_soa_state_case_2_3(self): # This is Case 2 ... with ptrs root_domain = create_fake_zone("10.23.in-addr.arpa", suffix="") self.assertEqual(root_domain.nameserver_set.count(), 1) ns = root_domain.nameserver_set.all()[0] # At his point we should have a domain at the root of a zone with one # ns record associated to the domain. # Let's create a child domain and add a record there, then try to # delete the NS record cdomain = Domain(name="test." + root_domain.name) cdomain.soa = root_domain.soa cdomain.save() ptr = PTR(name="asdf", ip_str="23.10.1.1", ip_type="4") ptr.save() self.assertRaises(ValidationError, ns.delete)
def create_domains(self): private = View(name="private") private.save() public = View(name="public") public.save() d0 = create_fake_zone("dc.mozilla.com", suffix="") s = d0.soa d = Domain(name='vlan.dc.mozilla.com') d.save() d.soa = s d.save() Domain(name='arpa').save() Domain(name='in-addr.arpa').save() # Create Reverse Domains d = create_fake_zone("10.in-addr.arpa", suffix="") d = create_fake_zone("66.in-addr.arpa", suffix="") vlan = Vlan(name='vlan', number=99) vlan.save() site = Site(name='dc') site.save() network = Network(network_str="10.0.0.0/8", ip_type='4') network2 = Network(network_str="66.66.66.0/24", ip_type='4') network2.update_network() network2.save() network.vlan = vlan network.site = site network.update_network() network.save() r = Range( start_str='10.99.99.1', end_str='10.99.99.254', network=network,) r.clean() r.save() r = Range( start_str='66.66.66.1', end_str='66.66.66.254', network=network2,) r.clean() r.save()
def test_bad_nameserver_soa_state_case_1_1(self): # This is Case 1 root_domain = create_fake_zone("asdf111") for ns in root_domain.nameserver_set.all(): ns.delete() # At his point we should have a domain at the root of a zone with no # other records in it. # Let's create a child domain and try to add a record there. cdomain = Domain(name="test." + root_domain.name) cdomain.soa = root_domain.soa cdomain.save() # Adding a record shouldn't be allowed because there is no NS record on # the zone's root domain. a = AddressRecord(label='', domain=cdomain, ip_type="6", ip_str="1::") self.assertRaises(ValidationError, a.save) cn = CNAME(label='', domain=cdomain, target="asdf") self.assertRaises(ValidationError, cn.save)
class DomainViewTests(TestCase): def setUp(self): self.url_slug = "domain" soa = SOA(primary=random_label(), contact=random_label(), description=random_label()) self.test_obj = Domain(name=random_label()) self.test_obj.save() self.test_obj.soa = soa self.test_obj.save() def test_base_mozdns_app_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/" % (self.url_slug), follow=True) self.assertEqual(resp.status_code, 200) def test_get_create_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/create/" % (self.url_slug), follow=True) self.assertEqual(resp.status_code, 200) def test_post_create_domain(self): resp = self.client.post(MOZDNS_BASE_URL + "/%s/create/" % (self.url_slug), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_update_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/update/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def test_post_object_update_domain(self): resp = self.client.post( MOZDNS_BASE_URL + "/%s/%s/update/" % (self.url_slug, self.test_obj.pk), self.post_data(), follow=True ) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_details_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def test_get_object_delete_domain(self): resp = self.client.get(MOZDNS_BASE_URL + "/%s/%s/delete/" % (self.url_slug, self.test_obj.pk), follow=True) self.assertEqual(resp.status_code, 200) def post_data(self): return {"name": random_label()}
def test_bad_nameserver_soa_state_case_1_4(self): # This is Case 1 ... with StaticInterfaces's reverse_root_domain = create_fake_zone("14.in-addr.arpa", suffix="") root_domain = create_fake_zone("asdf14") for ns in root_domain.nameserver_set.all(): ns.delete() # At his point we should have a domain at the root of a zone with no # other records in it. # Let's create a child domain and try to add a record there. cdomain = Domain(name="10.14.in-addr.arpa") cdomain.soa = reverse_root_domain.soa cdomain.save() # Adding a record shouldn't be allowed because there is no NS record on # the zone's root domain. intr = StaticInterface( label="asdf", domain=root_domain, ip_str="14.10.1.1", ip_type="4", mac="11:22:33:44:55:66", system=self.s) self.assertRaises(ValidationError, intr.save)
def test_bad_nameserver_soa_state_case_2_1(self): # This is Case 2 root_domain = create_fake_zone("asdf21") self.assertEqual(root_domain.nameserver_set.count(), 1) ns = root_domain.nameserver_set.all()[0] # At his point we should have a domain at the root of a zone with one # ns record associated to the domain. # Let's create a child domain and add a record there, then try to # delete the NS record cdomain = Domain(name="test." + root_domain.name) cdomain.soa = root_domain.soa cdomain.save() AddressRecord.objects.create(label='', domain=cdomain, ip_type="6", ip_str="1::") self.assertRaises(ValidationError, ns.delete)
def test_basic_add_remove1(self): c = Domain(name='com') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.com') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", description="foo.zfoo.comom") f_c.soa = s f_c.save() self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.com" label, the_domain = ensure_label_domain(fqdn) self.assertEqual(label, "bar") self.assertEqual(the_domain.name, "x.y.z.foo.com") self.assertTrue(the_domain.purgeable) self.assertEqual(the_domain.master_domain.name, "y.z.foo.com") self.assertTrue(the_domain.master_domain.purgeable) self.assertEqual(the_domain.master_domain.master_domain.name, "z.foo.com") self.assertTrue(the_domain.master_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.master_domain.name, "foo.com") self.assertFalse( the_domain.master_domain.master_domain.master_domain.purgeable) # Now call prune tree one the_domain self.assertTrue(prune_tree(the_domain)) self.assertFalse(Domain.objects.filter(name="x.y.z.foo.com")) self.assertFalse(Domain.objects.filter(name="y.z.foo.com")) self.assertFalse(Domain.objects.filter(name="z.foo.com")) self.assertTrue(Domain.objects.filter(name="foo.com")) # Make sure other domain's can't be pruned self.assertFalse(prune_tree(f_c)) self.assertTrue(Domain.objects.filter(name="foo.com")) self.assertFalse(prune_tree(c)) self.assertTrue(Domain.objects.filter(name="com"))
def test_basic_add_remove1(self): c = Domain(name='com') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.com') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", description="foo.zfoo.comom") f_c.soa = s f_c.save() self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.com" label, the_domain = ensure_label_domain(fqdn) self.assertEqual(label, "bar") self.assertEqual(the_domain.name, "x.y.z.foo.com") self.assertTrue(the_domain.purgeable) self.assertEqual(the_domain.master_domain.name, "y.z.foo.com") self.assertTrue(the_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.name, "z.foo.com") self.assertTrue(the_domain.master_domain.master_domain.purgeable) self.assertEqual( the_domain.master_domain.master_domain.master_domain.name, "foo.com") self.assertFalse( the_domain.master_domain.master_domain.master_domain.purgeable) # Now call prune tree one the_domain self.assertTrue(prune_tree(the_domain)) self.assertFalse(Domain.objects.filter(name="x.y.z.foo.com")) self.assertFalse(Domain.objects.filter(name="y.z.foo.com")) self.assertFalse(Domain.objects.filter(name="z.foo.com")) self.assertTrue(Domain.objects.filter(name="foo.com")) # Make sure other domain's can't be pruned self.assertFalse(prune_tree(f_c)) self.assertTrue(Domain.objects.filter(name="foo.com")) self.assertFalse(prune_tree(c)) self.assertTrue(Domain.objects.filter(name="com"))
def test_bad_resize(self): network = "129.0.0.0" prefixlen = "24" kwargs = {'network': network, 'prefixlen': prefixlen, 'ip_type': '4'} s = self.do_basic_add(**kwargs) self.assertTrue(s) d = Domain(name="asdf") d.save() start_str = "129.0.0.1" end_str = "129.0.0.255" network = s r = Range(start_str=start_str, end_str=end_str, network=network) r.save() self.assertEqual(r.network, s) self.assertTrue(len(s.range_set.all()) == 1) s.network_str = "129.0.0.0/25" self.assertRaises(ValidationError, s.clean)
def test_bad_nameserver_soa_state_case_3_1(self): # This is Case 3 root_domain = create_fake_zone("asdf31") for ns in root_domain.nameserver_set.all(): ns.delete() # At his point we should have a domain pointed at an SOA record with no # records attached to it (esspecially no ns recods). It also has no # child domains. # Try case 3 but add a record to a child domain of root_domain cdomain = Domain(name="test." + root_domain.name) cdomain.save() # Add a record to the domain. a = AddressRecord(label='', domain=cdomain, ip_type="6", ip_str="1::") a.save() # Now try to add the domain to the zone that has no NS records at it's # root cdomain.soa = root_domain.soa self.assertRaises(ValidationError, cdomain.save)
def test_bad_nameserver_soa_state_case_3_3(self): # This is Case 3 ... with ptrs root_domain = create_fake_zone("33.in-addr.arpa", suffix="") for ns in root_domain.nameserver_set.all(): ns.delete() # At his point we should have a domain pointed at an SOA record with no # records attached to it (esspecially no ns recods). It also has no # child domains. # Try case 3 but add a record to a child domain of root_domain cdomain = Domain(name="10.33.in-addr.arpa") cdomain.save() # Add a record to the domain. ptr = PTR(name="asdf", ip_str="33.10.1.1", ip_type="4") ptr.save() # Now try to add the domain to the zone that has no NS records at it's # root cdomain.soa = root_domain.soa self.assertRaises(ValidationError, cdomain.save)
def test2_add_domain(self): # Some domains have '_' in their name. Make sure validation allows # this. c = Domain(name='cz') c.save() c1 = Domain(name='_foo.cz') c1.save() c2 = Domain(name='moo_foo._foo.cz') c2.save()
def test_no_soa_block2(self): c = Domain(name='moo') c.save() f_c = Domain(name='foo.moo') f_c.save() s, _ = SOA.objects.get_or_create(primary="bar23", contact="Foo", description="bar") f_c.soa = s f_c.save() self.assertRaises(ValidationError, ensure_label_domain, "baz.moo")
def test_delegation(self): name = "boom" dom = Domain(name=name, delegated=True) dom.save() # Creating objects in the domain should be locked. arec = AddressRecord(label="ns1", domain=dom, ip_str="128.193.99.9", ip_type='4') self.assertRaises(ValidationError, arec.save) ns = Nameserver(domain=dom, server="ns1." + dom.name) self.assertRaises(ValidationError, ns.save) cn = CNAME(label="999asdf", domain=dom, target="asdf.asdf") self.assertRaises(ValidationError, cn.full_clean) # Undelegate (unlock) the domain. dom.delegated = False dom.save() # Add glue and ns record. arec.save() ns.save() # Re delegate the domain. dom.delegated = True dom.save() # Creation should still be locked arec1 = AddressRecord(label="ns2", domain=dom, ip_str="128.193.99.9", ip_type='4') self.assertRaises(ValidationError, arec1.save) cn1 = CNAME(label="1000asdf", domain=dom, target="asdf.asdf") self.assertRaises(ValidationError, cn1.full_clean) # Editing should be allowed. arec = AddressRecord.objects.get(pk=arec.pk) arec.ip_str = "129.193.88.2" arec.save() # Adding new A records that have the same name as an NS should # be allowed. arec1 = AddressRecord(label="ns1", domain=dom, ip_str="128.193.100.10", ip_type='4') arec1.save()
def test1_add_domain(self): c = Domain(name='com') c.save() f_c = Domain(name='foo.com') f_c.save() f_c.save() f_c.details() self.assertTrue(f_c.get_absolute_url()) self.assertTrue(f_c.get_edit_url()) self.assertTrue(f_c.get_delete_url()) self.assertTrue(f_c.master_domain == c) b_c = Domain(name='bar.com') b_c.save() self.assertTrue(b_c.master_domain == c) b_b_c = Domain(name='baz.bar.com') b_b_c.save() self.assertTrue(b_b_c.master_domain == b_c)
class SRVTests(TestCase): def setUp(self): self.o = Domain(name="org") self.o.save() self.o_e = Domain(name="oregonstate.org") self.o_e.save() self.b_o_e = Domain(name="bar.oregonstate.org") self.b_o_e.save() def do_generic_add(self, data): srv = SRV(**data) srv.__repr__() srv.save() self.assertTrue(srv.details()) self.assertTrue(srv.get_absolute_url()) self.assertTrue(srv.get_edit_url()) self.assertTrue(srv.get_delete_url()) rsrv = SRV.objects.filter(**data) self.assertTrue(len(rsrv) == 1) return srv def do_remove(self, data): srv = self.do_generic_add(data) srv.delete() rsrv = SRV.objects.filter(**data) self.assertTrue(len(rsrv) == 0) def test_add_remove_srv(self): data = {'label': '*', 'domain': self.o_e, 'target': 'relay.oregonstate.edu', 'priority': 2, 'weight': 2222, 'port': 222} self.do_remove(data) data = {'label': '_df', 'domain': self.o_e, 'target': 'relay.oregonstate.edu', 'priority': 2, 'weight': 2222, 'port': 222} self.do_remove(data) data = {'label': '_df', 'domain': self.o, 'target': 'foo.com.nar', 'priority': 1234, 'weight': 23414, 'port': 222} self.do_remove(data) data = {'label': '_sasfd', 'domain': self.b_o_e, 'target': 'foo.safasdlcom.nar', 'priority': 12234, 'weight': 23414, 'port': 222} self.do_remove(data) data = {'label': '_faf', 'domain': self.o, 'target': 'foo.com.nar', 'priority': 1234, 'weight': 23414, 'port': 222} self.do_remove(data) data = {'label': '_bar', 'domain': self.o_e, 'target': 'relay.oregonstate.edu', 'priority': 2, 'weight': 2222, 'port': 222} self.do_remove(data) data = {'label': '_bar', 'domain': self.o_e, 'target': '', 'priority': 2, 'weight': 2222, 'port': 222} self.do_remove(data) def test_invalid_add_update(self): data = {'label': '_df', 'domain': self.o_e, 'target': 'relay.oregonstate.edu', 'priority': 2, 'weight': 2222, 'port': 222} srv0 = self.do_generic_add(data) self.assertRaises(ValidationError, self.do_generic_add, data) data = { 'label': '_df', 'domain': self.o_e, 'target': 'foo.oregonstate.edu', 'priority': 2, 'weight': 2222, 'port': 222} self.do_generic_add(data) self.assertRaises(ValidationError, self.do_generic_add, data) srv0.target = "foo.oregonstate.edu" self.assertRaises(ValidationError, srv0.save) srv0.port = 65536 self.assertRaises(ValidationError, srv0.save) srv0.port = 1 srv0.priority = 65536 self.assertRaises(ValidationError, srv0.save) srv0.priority = 1 srv0.weight = 65536 self.assertRaises(ValidationError, srv0.save) srv0.target = "asdfas" srv0.label = "no_first" self.assertRaises(ValidationError, srv0.save) srv0.target = "_df" self.assertRaises(ValidationError, srv0.save)
class PTRStaticRegTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d def setUp(self): Domain.objects.all().delete() self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save() def do_add_sreg(self, label, domain, ip_str, ip_type='4'): r = StaticReg( label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=self.n ) r.full_clean() r.save() repr(r) return r def do_add_ptr(self, label, domain, ip_str, ip_type='4'): ptr = PTR.objects.create( name=label + '.' + domain.name, ip_str=ip_str, ip_type=ip_type ) return ptr def test1_conflict_add_sreg_first(self): # PTRdd an sreg and make sure PTR can't exist. label = "foo4" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.do_add_sreg(**kwargs) kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.assertRaises(ValidationError, self.do_add_ptr, **kwargs) def test1_conflict_add_PTR_first(self): # Add an PTR and make sure an sreg can't exist. label = "foo5" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.do_add_ptr(**kwargs) kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.assertRaises(ValidationError, self.do_add_sreg, **kwargs) def test2_conflict_add_sreg_first(self): # Add an sreg and update an existing PTR to conflict. Test for # exception. label = "fo99" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.do_add_sreg(**kwargs) ip_str = "10.0.0.3" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} ptr = self.do_add_ptr(**kwargs) ptr.ip_str = "10.0.0.2" self.assertRaises(ValidationError, ptr.clean) def test2_conflict_add_A_first(self): # Add an PTR and update and existing sreg to conflict. Test for # exception. label = "foo98" domain = self.f_c ip_str = "10.0.0.2" # Add PTR kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} self.do_add_ptr(**kwargs) # Add StaticReg with diff IP ip_str = "10.0.0.3" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} sreg = self.do_add_sreg(**kwargs) # Conflict the IP on the sreg sreg.ip_str = "10.0.0.2" self.assertRaises(ValidationError, sreg.save)
def test_remove_has_child_domain(self): Domain(name='com').save() f_c = Domain(name='foo.com') f_c.save() Domain(name='boo.foo.com').save() self.assertRaises(ValidationError, f_c.delete)
class AddressRecordTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d, _ = Domain.objects.get_or_create(name=name, delegated=delegated) self.assertTrue(d.is_reverse) return d def setUp(self): self.arpa = self.create_domain(name='arpa') self.i_arpa = self.create_domain(name='in-addr.arpa') self.i6_arpa = self.create_domain(name='ip6.arpa') self.osu_block = "633:105:F000:" boot_strap_ipv6_reverse_domain("0.6.3") try: self.e = Domain(name='edu') self.e.save() except IntegrityError: pass try: self.o_e = Domain(name='oregonstate.edu') self.o_e.save() except IntegrityError: self.o_e = Domain.objects.filter(name='oregonstate.edu')[0] pass try: self.f_o_e = Domain(name='foo.oregonstate.edu') self.f_o_e.save() except IntegrityError: self.f_o_e = Domain.objects.filter(name='foo.oregonstate.edu')[0] pass try: self.m_o_e = Domain(name='max.oregonstate.edu') self.m_o_e.save() except IntegrityError: self.m_o_e = Domain.objects.filter(name='max.oregonstate.edu')[0] pass try: self.z_o_e = Domain(name='zax.oregonstate.edu') self.z_o_e.save() except IntegrityError: self.z_o_e = Domain.objects.filter(name='zax.oregonstate.edu')[0] pass try: self.g_o_e = Domain(name='george.oregonstate.edu') self.g_o_e.save() except IntegrityError: self.g_o_e = Domain.objects.filter( name='george.oregonstate.edu')[0] pass try: self._128 = self.create_domain(name='128') self._128.save() except IntegrityError: raise Exception self._128 = self.create_domain.objects.filter(name='128')[0] pass try: self._128_193 = self.create_domain(name='128.193') self._128_193.save() except IntegrityError: raise Exception self._128_193 = Domain.objects.filter(name='128.193')[0] pass ###################### ### Updating Tests ### ###################### def test_invalid_update_to_existing(self): rec1 = AddressRecord(label='bar', domain=self.z_o_e, ip_str="128.193.40.1", ip_type='4') rec2 = AddressRecord(label='bar', domain=self.z_o_e, ip_str="128.193.40.2", ip_type='4') rec3 = AddressRecord(label='foo', domain=self.z_o_e, ip_str="128.193.40.1", ip_type='4') rec3.save() rec2.save() rec1.save() rec1.label = "foo" self.assertRaises(ValidationError, rec1.save) rec3.label = "bar" self.assertRaises(ValidationError, rec3.save) osu_block = "633:105:F000:" rec1 = AddressRecord(label='bar', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') rec2 = AddressRecord(label='bar', domain=self.z_o_e, ip_str=osu_block + ":2", ip_type='6') rec3 = AddressRecord(label='foo', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') rec1.save() rec2.save() rec3.save() rec2.ip_str = osu_block + ":1" self.assertRaises(ValidationError, rec2.save) rec3.label = 'bar' self.assertRaises(ValidationError, rec3.save) """ Things that could go wrong. 1) Update to an invalid ip. 2) Update to an invalid name. """ def _do_generic_update_test(self, record, new_name, new_ip, ip_type): if new_ip: if ip_type == '4': ip_upper, ip_lower = 0, ipaddr.IPv4Address(new_ip).__int__() else: ip_upper, ip_lower = ipv6_to_longs(new_ip) else: ip_upper, ip_lower = record.ip_upper, record.ip_lower if new_name is not None and new_ip is not None: aret = AddressRecord.objects.filter(label=new_name, ip_upper=ip_upper, ip_lower=ip_lower, ip_type=ip_type)[0] elif new_name is not None: # Just new_name aret = AddressRecord.objects.filter(label=new_name, ip_upper=ip_upper, ip_lower=ip_lower, ip_type=ip_type)[0] else: # Just new_ip aret = AddressRecord.objects.filter(label=new_name, ip_upper=ip_upper, ip_lower=ip_lower, ip_type=ip_type)[0] if new_name: self.assertEqual(aret.label, new_name) if new_ip: if ip_type == '4': self.assertEqual(aret.ip_str, ipaddr.IPv4Address(new_ip).__str__()) else: self.assertEqual(aret.ip_str, ipaddr.IPv6Address(new_ip).__str__()) def do_update_A_record(self, record, new_name, new_ip): if new_name is not None: record.label = new_name if new_ip is not None: record.ip_str = new_ip record.save() self._do_generic_update_test(record, new_name, new_ip, '4') def do_update_AAAA_record(self, record, new_name, new_ip): if new_name is not None: record.label = new_name if new_ip is not None: record.ip_str = new_ip record.save() self._do_generic_update_test(record, new_name, new_ip, '6') def test_update_A_record(self): rec0 = AddressRecord(label='', domain=self.m_o_e, ip_str="128.193.0.1", ip_type='4') rec0.save() rec1 = AddressRecord(label='foo', domain=self.m_o_e, ip_str="128.193.0.1", ip_type='4') rec1.save() rec2 = AddressRecord(label='bar', domain=self.m_o_e, ip_str="128.193.0.1", ip_type='4') rec2.save() rec3 = AddressRecord(label='0123456780123456780123456780123456780' '123456789999901234567891', domain=self.m_o_e, ip_str="128.193.0.1", ip_type='4') rec3.save() self.do_update_A_record(rec0, "whooooop1", "128.193.23.1") self.do_update_A_record(rec1, "whoooasfdasdflasdfjoop3", "128.193.23.2") self.do_update_A_record(rec2, "whsdflhjsafdohaosdfhsadooooop1", "128.193.23.4") self.do_update_A_record(rec3, "wasdflsadhfaoshfuoiwehfjsdkfavbhooooop1", "128.193.23.3") self.do_update_A_record(rec0, "liaslfdjsa8df09823hsdljf-whooooop1", "128.193.25.17") self.do_update_A_record(rec1, "w", "128.193.29.83") self.do_update_A_record(rec0, '', "128.193.23.1") self.do_update_A_record(rec1, "whoooasfdasdflasdfjoop3", None) def test_update_AAAA_record(self): boot_strap_ipv6_reverse_domain("8.6.2.0") osu_block = "8620:105:F000:" rec0 = AddressRecord(label='', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') rec1 = AddressRecord(label='foo', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') rec2 = AddressRecord(label='bar', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') self.do_update_AAAA_record(rec0, "whoooooasfjsp1", osu_block + "0:0:123:321::") self.do_update_AAAA_record(rec1, "wasfasfsafdhooooop1", osu_block + "0:0:123:321::") self.do_update_AAAA_record(rec2, "whoooooasfdisafsap1", osu_block + "0:24:123:322:1") self.do_update_AAAA_record(rec0, "whooooop1", osu_block + "0:aaa::1") self.do_update_AAAA_record(rec0, "wasflasksdfhooooop1", osu_block + "0:dead::") self.do_update_AAAA_record(rec1, "whooooosf13fp1", osu_block + "0:0::") self.do_update_AAAA_record(rec1, "whooooodfijasf1", osu_block + "0:1:23::") self.do_update_AAAA_record(rec2, "lliasdflsafwhooooop1", osu_block + ":") self.do_update_AAAA_record(rec1, "whooooopsjafasf1", osu_block + "0::") self.do_update_AAAA_record(rec1, "", osu_block + "0:0:123:321::") def test_update_invalid_ip_A_record(self): rec0 = AddressRecord(label='', domain=self.m_o_e, ip_str="128.193.23.1", ip_type='4') rec1 = AddressRecord(label='foo', domain=self.m_o_e, ip_str="128.193.26.7", ip_type='4') # BAD Names self.assertRaises(ValidationError, self.do_update_A_record, **{ 'record': rec1, 'new_name': ".", "new_ip": None }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': " sdfsa ", "new_ip": None }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': "asdf.", "new_ip": None }) # BAD IPs self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': None, "new_ip": 71134 }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': None, "new_ip": "19.193.23.1.2" }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': None, "new_ip": 12314123 }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': "narf", "new_ip": 1214123 }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': "%asdfsaf", "new_ip": "1928.193.23.1" }) self.assertRaises( ValidationError, self.do_update_A_record, **{ 'record': rec0, 'new_name': None, "new_ip": "1928.193.23.1" }) def test_update_invalid_ip_AAAA_record(self): osu_block = "7620:105:F000:" boot_strap_ipv6_reverse_domain("7.6.2.0") rec0 = AddressRecord(label='foo', domain=self.z_o_e, ip_str=osu_block + ":1", ip_type='6') self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': None, 'new_ip': 71134 }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': None, 'new_ip': osu_block + ":::" }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': "%asdfsaf", 'new_ip': osu_block }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': "sdfsa", 'new_ip': 1239812472934623847 }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': None, 'new_ip': "128.193.1.1" }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': "%asdfsaf", 'new_ip': osu_block + ":1" }) self.assertRaises( ValidationError, self.do_update_AAAA_record, **{ 'record': rec0, 'new_name': " sdfsa ", 'new_ip': None }) ###################### ### Removing Tests ### ###################### def do_remove_A_record(self, aname, domain, ip): aret = AddressRecord(label=aname, domain=domain, ip_str=ip, ip_type='4') aret.save() self.assertTrue(aret) aret.delete() aret = AddressRecord.objects.filter(label=aname, domain=domain, ip_str=ip) self.assertFalse(aret) def do_remove_AAAA_record(self, aname, domain, ip): aret = AddressRecord(label=aname, domain=domain, ip_str=ip, ip_type='6') aret.save() self.assertTrue(aret) aret.delete() nret = AddressRecord.objects.filter(label=aname, domain=domain, ip_str=ip) self.assertFalse(nret) def test_remove_A_address_records(self): self.do_remove_A_record("", self.o_e, "128.193.10.1") self.do_remove_A_record("far", self.o_e, "128.193.0.2") self.do_remove_A_record("fetched", self.o_e, "128.193.1.1") self.do_remove_A_record("drum", self.o_e, "128.193.2.1") self.do_remove_A_record("and", self.o_e, "128.193.0.3") self.do_remove_A_record("bass", self.o_e, "128.193.2.2") self.do_remove_A_record("dude", self.o_e, "128.193.5.1") self.do_remove_A_record("man", self.o_e, "128.193.1.4") self.do_remove_A_record("right", self.o_e, "128.193.2.6") self.do_remove_A_record("", self.f_o_e, "128.193.0.1") self.do_remove_A_record("far", self.f_o_e, "128.193.0.2") self.do_remove_A_record("fetched", self.f_o_e, "128.193.1.1") self.do_remove_A_record("drum", self.f_o_e, "128.193.2.1") self.do_remove_A_record("and", self.f_o_e, "128.193.0.3") self.do_remove_A_record("bass", self.f_o_e, "128.193.2.2") self.do_remove_A_record("dude", self.f_o_e, "128.193.5.1") self.do_remove_A_record("man", self.f_o_e, "128.193.1.4") self.do_remove_A_record("right", self.f_o_e, "128.193.2.6") def test_remove_AAAA_address_records(self): osu_block = "4620:105:F000:" boot_strap_ipv6_reverse_domain("4.6.2.0") self.do_remove_AAAA_record("", self.o_e, osu_block + ":1") self.do_remove_AAAA_record("please", self.o_e, osu_block + ":2") self.do_remove_AAAA_record("visit", self.o_e, osu_block + ":4") self.do_remove_AAAA_record("from", self.o_e, osu_block + ":2") self.do_remove_AAAA_record("either", self.o_e, osu_block + ":1") self.do_remove_AAAA_record("webpages", self.o_e, osu_block + ":1") self.do_remove_AAAA_record("read", self.o_e, osu_block + ":1") self.do_remove_AAAA_record("", self.f_o_e, osu_block + ":1") self.do_remove_AAAA_record("please", self.f_o_e, osu_block + ":2") self.do_remove_AAAA_record("visit", self.f_o_e, osu_block + ":4") self.do_remove_AAAA_record("from", self.f_o_e, osu_block + ":2") self.do_remove_AAAA_record("either", self.f_o_e, osu_block + ":1") self.do_remove_AAAA_record("webpages", self.f_o_e, osu_block + ":1") self.do_remove_AAAA_record("read", self.f_o_e, osu_block + ":1") #################### ### Adding Tests ### #################### def do_add_record(self, data): rec = AddressRecord(label=data['label'], domain=data['domain'], ip_str=data['ip'], ip_type='4') rec.save() self.assertTrue(rec.__repr__()) self.assertTrue(rec.get_absolute_url()) self.assertTrue(rec.get_edit_url()) self.assertTrue(rec.get_delete_url()) self.assertTrue(rec.details()) search = AddressRecord.objects.filter(label=data['label'], domain=data['domain'], ip_type='4', ip_str=data['ip']) found = False for record in search: if record.ip_str == data['ip']: found = True self.assertTrue(found) return rec def do_add_record6(self, data): rec = AddressRecord(label=data['label'], domain=data['domain'], ip_str=data['ip'], ip_type='6') rec.save() self.assertTrue(rec.__repr__()) self.assertTrue(rec.get_absolute_url()) self.assertTrue(rec.get_edit_url()) self.assertTrue(rec.get_delete_url()) self.assertTrue(rec.details()) ### GLOB * ### Records def test_add_A_address_glob_records(self): # Test the glob form: *.foo.com A 10.0.0.1 rec = AddressRecord(label='', domain=self.o_e, ip_str="128.193.0.1", ip_type='4') rec.clean() rec.save() self.assertEqual(rec.__str__(), "oregonstate.edu A 128.193.0.1") data = {'label': '*', 'domain': self.f_o_e, 'ip': "128.193.0.10"} self.do_add_record(data) data = { 'label': '*foob1ar', 'domain': self.f_o_e, 'ip': "128.193.0.10" } self.do_add_record(data) data = {'label': '*foob1ar', 'domain': self.o_e, 'ip': "128.193.0.5"} self.do_add_record(data) data = {'label': '*foo2', 'domain': self.f_o_e, 'ip': "128.193.0.7"} self.do_add_record(data) data = {'label': '*foo2', 'domain': self.o_e, 'ip': "128.193.0.2"} self.do_add_record(data) data = {'label': '*ba-r', 'domain': self.f_o_e, 'ip': "128.193.0.9"} self.do_add_record(data) data = {'label': '*ba-r', 'domain': self.o_e, 'ip': "128.193.0.4"} self.do_add_record(data) # Understore '_' tests def test_add_address_underscore_in_name_domain(self): d = Domain(name="_mssucks.edu") d.save() data = {'label': '*', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data) data = {'label': 'foo', 'domain': d, 'ip': "128.193.0.10"} a = self.do_add_record(data) a.save() data = {'label': 'noop', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data) def test_add_A_address_records(self): rec = AddressRecord(label='', domain=self.o_e, ip_str="128.193.0.1", ip_type='4') rec.clean() rec.save() self.assertEqual(rec.__str__(), "oregonstate.edu A 128.193.0.1") data = {'label': 'foob1ar', 'domain': self.f_o_e, 'ip': "128.193.0.10"} self.do_add_record(data) data = {'label': 'foob1ar', 'domain': self.o_e, 'ip': "128.193.0.5"} self.do_add_record(data) data = {'label': 'foo2', 'domain': self.f_o_e, 'ip': "128.193.0.7"} self.do_add_record(data) data = {'label': 'foo2', 'domain': self.o_e, 'ip': "128.193.0.2"} self.do_add_record(data) data = {'label': 'ba-r', 'domain': self.f_o_e, 'ip': "128.193.0.9"} self.do_add_record(data) data = {'label': 'ba-r', 'domain': self.o_e, 'ip': "128.193.0.4"} self.do_add_record(data) def test_add_AAAA_address_records(self): osu_block = "2620:105:F000:" boot_strap_ipv6_reverse_domain("2.6.2.0") data = {'label': '', 'domain': self.f_o_e, 'ip': osu_block + ":4"} self.do_add_record6(data) data = {'label': '', 'domain': self.o_e, 'ip': osu_block + ":1"} self.do_add_record6(data) data = {'label': '6ba-r', 'domain': self.o_e, 'ip': osu_block + ":6"} self.do_add_record6(data) data = {'label': '6ba-r', 'domain': self.f_o_e, 'ip': osu_block + ":7"} self.do_add_record6(data) data = {'label': '6foo', 'domain': self.f_o_e, 'ip': osu_block + ":5"} self.do_add_record6(data) data = {'label': '6foo', 'domain': self.o_e, 'ip': osu_block + ":3"} self.do_add_record6(data) data = {'label': '6ba3z', 'domain': self.o_e, 'ip': osu_block + ":4"} self.do_add_record6(data) data = {'label': '6ba3z', 'domain': self.f_o_e, 'ip': osu_block + ":6"} self.do_add_record6(data) data = { 'label': '6foob1ar', 'domain': self.o_e, 'ip': osu_block + ":5" } self.do_add_record6(data) data = { 'label': '6foob1ar', 'domain': self.f_o_e, 'ip': osu_block + ":8" } self.do_add_record6(data) data = { 'label': '23412341253254243', 'domain': self.f_o_e, 'ip': osu_block + ":8" } self.do_add_record6(data) def test_no_type(self): data = {'label': 'uuu', 'domain': self.f_o_e, 'ip': '128.193.4.1'} rec = AddressRecord(label=data['label'], domain=data['domain'], ip_str=data['ip'], ip_type='x') self.assertRaises(ValidationError, rec.save) data = {'label': 'uuu', 'domain': self.f_o_e, 'ip': '128.193.4.1'} rec = AddressRecord(label=data['label'], domain=data['domain'], ip_str=data['ip']) self.assertRaises(ValidationError, rec.save) def test_bad_A_ip(self): # IPv4 Tests osu_block = "2620:105:F000:" data = {'label': 'asdf0', 'domain': self.o_e, 'ip': osu_block + ":1"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'asdf1', 'domain': self.o_e, 'ip': 123142314} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'asdf1', 'domain': self.o_e, 'ip': "128.193.0.1.22"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'asdf2', 'domain': self.o_e, 'ip': "128.193.8"} self.assertRaises(ValidationError, self.do_add_record, data) def test_bad_AAAA_ip(self): # IPv6 Tests osu_block = "2620:105:F000:" data = {'label': 'asdf5', 'domain': self.o_e, 'ip': "128.193.8.1"} self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'asdf4', 'domain': self.o_e, 'ip': osu_block + ":::"} self.assertRaises(ValidationError, self.do_add_record6, data) data = { 'label': 'asdf4', 'domain': self.o_e, 'ip': 123213487823762347612346 } self.assertRaises(ValidationError, self.do_add_record6, data) def test_add_A_records_exist(self): data = {'label': '', 'domain': self.f_o_e, 'ip': "128.193.0.2"} self.do_add_record(data) self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'new', 'domain': self.f_o_e, 'ip': "128.193.0.2"} self.do_add_record(data) self.assertRaises(ValidationError, self.do_add_record, data) def test_add_AAAA_records_exist(self): osu_block = "9620:105:F000:" boot_strap_ipv6_reverse_domain("9.6.2.0") data = {'label': 'new', 'domain': self.f_o_e, 'ip': osu_block + ":2"} self.do_add_record6(data) self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'new', 'domain': self.f_o_e, 'ip': osu_block + ":0:9"} self.do_add_record6(data) self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'nope', 'domain': self.o_e, 'ip': osu_block + ":4"} self.do_add_record6(data) self.assertRaises(ValidationError, self.do_add_record6, data) def test_add_A_invalid_address_records(self): data = {'label': "oregonstate", 'domain': self.e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': "foo", 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'foo.nas', 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = { 'label': 'foo.bar.nas', 'domain': self.o_e, 'ip': "128.193.0.2" } self.assertRaises(ValidationError, self.do_add_record, data) data = { 'label': 'foo.baz.bar.nas', 'domain': self.o_e, 'ip': "128.193.0.2" } self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'n as', 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'n as', 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'n%as', 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) data = {'label': 'n+as', 'domain': self.o_e, 'ip': "128.193.0.2"} self.assertRaises(ValidationError, self.do_add_record, data) def test_add_AAAA_invalid_address_records(self): osu_block = "3620:105:F000:" boot_strap_ipv6_reverse_domain("3.6.2.0") data = {'label': 'foo.nas', 'domain': self.o_e, 'ip': osu_block + ":1"} self.assertRaises(ValidationError, self.do_add_record6, data) data = { 'label': 'foo.bar.nas', 'domain': self.o_e, 'ip': osu_block + ":2" } self.assertRaises(ValidationError, self.do_add_record6, data) data = { 'label': 'foo.baz.bar.nas', 'domain': self.o_e, 'ip': osu_block + ":3" } self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'n as', 'domain': self.o_e, 'ip': osu_block + ":4"} self.assertRaises(ValidationError, self.do_add_record6, data) data = { 'label': 'n!+/*&%$#@as', 'domain': self.o_e, 'ip': osu_block + ":5" } self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'n%as', 'domain': self.o_e, 'ip': osu_block + ":6"} self.assertRaises(ValidationError, self.do_add_record6, data) data = {'label': 'n+as', 'domain': self.o_e, 'ip': osu_block + ":7"} self.assertRaises(ValidationError, self.do_add_record6, data) def test_no_update_when_glue(self): """A record shouldn't update it's label or domain when it is a glue record""" label = 'ns99' glue = AddressRecord(label=label, domain=self.o_e, ip_str='128.193.1.10', ip_type='4') glue.save() server = "%s.%s" % (label, self.o_e) ns = Nameserver(domain=self.o_e, server=server) ns.save() self.assertTrue(ns.glue == glue) # Shouldn't be able to edit label or domain. glue.label = "ns100" self.assertRaises(ValidationError, glue.save) glue.domain = self.m_o_e self.assertRaises(ValidationError, glue.save) glue = AddressRecord.objects.get(pk=glue.pk) glue.label = "ns101" glue.domain = self.e self.assertRaises(ValidationError, glue.save) # Ip can change. glue = AddressRecord.objects.get(pk=glue.pk) glue.ip_str = "192.192.12.12" glue.save() def test_delete_with_cname_pointing_to_a(self): label = 'foo100' a = AddressRecord(label=label, domain=self.o_e, ip_str='128.193.1.10', ip_type='4') a.clean() a.save() cn = CNAME(label="foomom", domain=self.o_e, target=label + "." + self.o_e.name) cn.clean() cn.save() self.assertRaises(ValidationError, a.delete) a.delete(check_cname=False) def test_delete_with_cname_pointing_to_a_with_rr(self): # You should be allowed to delete an A record if there is another A # record that the cname could point to. label = 'foo100' a = AddressRecord.objects.create(label=label, domain=self.o_e, ip_str='128.193.1.10', ip_type='4') a2 = AddressRecord.objects.create(label=label, domain=self.o_e, ip_str='128.193.1.11', ip_type='4') CNAME.objects.create(label="foomom", domain=self.o_e, target=label + "." + self.o_e.name) a_pk = a.pk a.delete() self.assertFalse(AddressRecord.objects.filter(pk=a_pk)) self.assertRaises(ValidationError, a2.delete) a2.delete(check_cname=False)
class SystemIntegrationTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d def setUp(self): self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save() def do_add(self, label, domain, ip_str, ip_type='4'): r = StaticReg(label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=self.n) r.clean() r.save() repr(r) return r def do_delete(self, r): ip_str = r.ip_str fqdn = r.fqdn r.delete() self.assertFalse(AddressRecord.objects.filter(ip_str=ip_str, fqdn=fqdn)) def test1_create(self): label = "foo" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} sreg = self.do_add(**kwargs) sreg.update_attrs() def bad_get(): sreg.attrs.primary self.assertRaises(AttributeError, bad_get) x = StaticRegKeyValue.objects.filter(key='primary', obj=sreg) self.assertFalse(x) sreg.attrs.primary = '1' self.assertEqual(sreg.attrs.primary, '1') x = StaticRegKeyValue.objects.filter(key='primary', obj=sreg) self.assertEqual(x[0].value, '1') def test6_create(self): label = "foo" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} sreg = self.do_add(**kwargs) sreg.update_attrs() sreg.update_attrs() sreg.update_attrs() def bad_get(): sreg.attrs.primary self.assertRaises(AttributeError, bad_get) sreg.attrs.primary = '1' self.assertEqual(sreg.attrs.primary, '1') def test2_create(self): label = "foo" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} sreg = self.do_add(**kwargs) sreg.update_attrs() sreg.attrs.primary = '2' self.assertEqual(sreg.attrs.primary, '2') del sreg.attrs.primary def bad_get(): sreg.attrs.primary self.assertRaises(AttributeError, bad_get) sreg.attrs.primary = '3' self.assertEqual(sreg.attrs.primary, '3') def test1_del(self): label = "foo" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} sreg = self.do_add(**kwargs) sreg.update_attrs() sreg.attrs.primary = '88' self.assertEqual(sreg.attrs.primary, '88') del sreg.attrs.primary def bad_get(): sreg.attrs.primary self.assertRaises(AttributeError, bad_get)
def test_soa_validators(self): m = Domain(name='moo') m.save() f_m = Domain(name='foo.moo') f_m.save() n_f_m = Domain(name='noo.foo.moo') n_f_m.save() b_m = Domain(name='baz.moo') b_m.save() s = SOA(primary="ns1.foo.com", contact="asdf", description="test") s.save() f_m.soa = s f_m.save() b_m.soa = s self.assertRaises(ValidationError, b_m.save) n_f_m = Domain.objects.get(pk=n_f_m.pk) # Refresh object n_f_m.soa = s n_f_m.save() m.soa = s m.save() b_m.soa = s b_m.save() m.soa = None self.assertRaises(ValidationError, m.save) s2 = SOA(primary="ns1.foo.com", contact="asdf", description="test2") s2.save() m.soa = s2 self.assertRaises(ValidationError, m.save)
class SSHFPTests(TestCase): def setUp(self): self.o = Domain(name="org") self.o.save() self.o_e = Domain(name="mozilla.org") self.o_e.save() def do_generic_add(self, data): sshfp = SSHFP(**data) sshfp.__repr__() sshfp.save() self.assertTrue(sshfp.details()) self.assertTrue(sshfp.get_absolute_url()) self.assertTrue(sshfp.get_edit_url()) self.assertTrue(sshfp.get_delete_url()) rsshfp = SSHFP.objects.filter(**data) self.assertEqual(len(rsshfp), 1) return sshfp def do_remove(self, data): sshfp = self.do_generic_add(data) sshfp.delete() rmx = SSHFP.objects.filter(**data) self.assertTrue(len(rmx) == 0) def test_add_remove_sshfp(self): label = "asdf" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = { 'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type } self.do_generic_add(data) label = "asdk" key = "eee85bca3608ac860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = { 'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type } self.do_generic_add(data) label = "df" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = { 'label': label, 'key': key, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type } self.do_generic_add(data) label = "12314" key = "eee85bca3608ec860fc290bea491ce35d1f0a094" s_type = 1 a_type = 1 data = { 'label': label, 'key': key, 'domain': self.o, 'algorithm_number': a_type, 'fingerprint_type': s_type } self.do_generic_add(data)
class CNAMEStaticRegTests(TestCase): def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d def setUp(self): Domain.objects.all().delete() self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save() def do_add_sreg(self, label, domain, ip_str, ip_type='4'): r = StaticReg( label=label, domain=domain, ip_str=ip_str, ip_type=ip_type, system=self.n ) r.clean() r.save() repr(r) return r def test1_delete_cname(self): label = "foo4" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} i = self.do_add_sreg(**kwargs) cn, _ = CNAME.objects.get_or_create(label='foo', domain=domain, target=label + "." + domain.name) self.assertRaises(ValidationError, i.delete) def test1_delete_override(self): label = "foo6" domain = self.f_c ip_str = "10.0.0.2" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} i = self.do_add_sreg(**kwargs) cn, _ = CNAME.objects.get_or_create(label='food', domain=domain, target=label + "." + domain.name) i.delete(check_cname=False)