def test_integration5_ip(self): root_domain = create_fake_zone("wee5.wee.mozilla.com", "") create_fake_zone("10.in-addr.arpa", "") res, error = self.search("10.in-addr.arpa OR " "wee5.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 2) self.assertEqual(len(res['NS']), 2) self.assertEqual(len(res['DOMAIN']), 2) ptr = PTR(name="host1.wee2.wee.mozilla.com", ip_str="10.0.0.1", ip_type="4") ptr.save() addr = AddressRecord(label="host1", domain=root_domain, ip_str="10.0.0.1", ip_type="4") addr.save() res, error = self.search(ptr.ip_str) self.assertFalse(error) self.assertEqual(len(res['PTR']), 1) self.assertEqual(len(res['A']), 1) res, error = self.search("10.0.0.2") self.assertFalse(error) self.assertEqual(len(res['PTR']), 0) self.assertEqual(len(res['A']), 0)
def test_integration1(self): create_fake_zone("wee.wee.mozilla.com", "") res, error = self.search("wee.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) create_fake_zone("wee1.wee.mozilla.com", "") res, error = self.search("wee1.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) res, error = self.search("wee1.wee.mozilla.com OR " "wee.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 2) self.assertEqual(len(res['NS']), 2) self.assertEqual(len(res['DOMAIN']), 2) res, error = self.search("wee1.wee.mozilla.com type=:SOA") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 0) self.assertEqual(len(res['DOMAIN']), 0) res, error = self.search("wee1.wee.mozilla.com type=:NS OR " "wee.wee.mozilla.com type=:DOMAIN") self.assertFalse(error) self.assertEqual(len(res['SOA']), 0) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1)
def test_integration1(self): create_fake_zone("wee.wee.mozilla.com", "") res, error = self.search("wee.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) create_fake_zone("wee1.wee.mozilla.com", "") res, error = self.search("wee1.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) res, error = self.search("wee1.wee.mozilla.com OR " "wee.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 2) self.assertEqual(len(res['NS']), 2) self.assertEqual(len(res['DOMAIN']), 2) res, error = self.search("wee1.wee.mozilla.com type=:SOA") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 0) self.assertEqual(len(res['DOMAIN']), 0) res, error = self.search( "wee1.wee.mozilla.com type=:NS OR " "wee.wee.mozilla.com type=:DOMAIN") self.assertFalse(error) self.assertEqual(len(res['SOA']), 0) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1)
def setUp(self): self.g = create_fake_zone("gz", suffix="") self.c_g = create_fake_zone("coo.gz", suffix="") self.d = create_fake_zone("dz", suffix="") self.r1 = create_fake_zone("10.in-addr.arpa", suffix="") self.r1.save() self.s = System() self.s.save()
def test_basic_add_remove9(self): # Make sure all record types block f_c = create_fake_zone("foo.foo22", suffix="") self.assertFalse(f_c.purgeable) fqdn = "y.z.foo.foo22" label, the_domain = ensure_label_domain(fqdn) addr = AddressRecord(label=label, domain=the_domain, ip_type='4', ip_str="10.2.3.4") addr.save() self.assertFalse(prune_tree(the_domain)) f_c = create_fake_zone("y.z.foo.foo22", suffix="") self.assertFalse(f_c.purgeable)
def test_build_zone(self): create_fake_zone('asdf1') b = DNSBuilder(STAGE_DIR=self.stage_dir, PROD_DIR=self.prod_dir, LOCK_FILE=self.lock_file, LOG_SYSLOG=False, FIRST_RUN=True, PUSH_TO_PROD=False, STOP_UPDATE_FILE=self.stop_update_file) b.build_dns() create_fake_zone('asdf2') b.build_dns() create_fake_zone('asdf3') create_fake_zone('asdf4') b.build_dns() create_fake_zone('asdf5') b.build_dns()
def generic_check(self, obj, do_label=True, label_prefix=""): # Make sure all record types block f_c = create_fake_zone("foo.foo22", suffix="") self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.foo22" label, the_domain = ensure_label_domain(fqdn) if do_label: # NS records don't like labels label = label_prefix + label obj.label = label obj.domain = the_domain obj.save() fqdn = "bar.x.y.xx.foo.foo22" label, new_domain = ensure_label_domain(fqdn) obj.domain = new_domain obj.save() # The original domain should have been deleted. self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22")) # Make sure no objects were harmed. self.assertTrue(obj.__class__.objects.get(pk=obj.pk)) obj.delete() # The new domain should now have been deleted. self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
def test_bad_nameserver_soa_state_case_3_2(self): # This is Case 3 ... with ptrs root_domain = create_fake_zone("32.in-addr.arpa", suffix="") for ns in root_domain.nameserver_set.all(): ns.delete() soa = ns.domain.soa ns.domain.soa = None root_domain.soa = None # Shit's getting cached ns.domain.save() soa.delete() # At his point we should have a domain pointed at no SOA record with no # records attached to it. It also has no child domains. # Add a record to the domain. ptr = PTR(name="asdf", ip_str="32.1.1.1", ip_type="4") ptr.save() s = SOA(primary="asdf.asdf", contact="asdf.asdf", description="asdf") s.save() root_domain.soa = s self.assertRaises(ValidationError, root_domain.save)
def test_bad_nameserver_soa_state_case_3_0(self): # This is Case 3 root_domain = create_fake_zone("asdf30") for ns in root_domain.nameserver_set.all(): ns.delete() soa = ns.domain.soa ns.domain.soa = None root_domain.soa = None # Shit's getting cached ns.domain.save() soa.delete() # At his point we should have a domain pointed at no SOA record with no # records attached to it. It also has no child domains. # Add a record to the domain. a = AddressRecord(label='', domain=root_domain, ip_type="6", ip_str="1::") a.save() s = SOA(primary="asdf.asdf", contact="asdf.asdf", description="asdf") s.save() root_domain.soa = s self.assertRaises(ValidationError, root_domain.save)
def setUp(self): self.system = System() self.system.save() d1 = create_fake_zone("oregonstate.com", suffix="") soa = d1.soa self.soa = soa v, _ = Vlan.objects.get_or_create(name="private", number=3) s, _ = Site.objects.get_or_create(name="phx1") s1, _ = Site.objects.get_or_create(name="corp", parent=s) d, _ = Domain.objects.get_or_create(name="phx1.oregonstate.com") d.soa = soa d.save() d1, _ = Domain.objects.get_or_create(name="corp.phx1.oregonstate.com") d1.soa = soa d1.save() d2, _ = Domain.objects.get_or_create( name="private.corp.phx1.oregonstate.com") d2.soa = soa d2.save() d, _ = Domain.objects.get_or_create(name="arpa") d, _ = Domain.objects.get_or_create(name="in-addr.arpa") d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa") n = Network(network_str="15.0.0.0/8", ip_type="4") n.clean() n.site = s1 n.vlan = v n.save() r = Range(start_str="15.0.0.0", end_str="15.0.0.10", network=n, ip_type='4') r.clean() r.save()
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"))
def test_bad_nameserver_soa_state_case_3_0(self): # This is Case 3 root_domain = create_fake_zone("asdf30") for ns in root_domain.nameserver_set.all(): ns.delete() soa = ns.domain.soa ns.domain.soa = None root_domain.soa = None # Shit's getting cached ns.domain.save() soa.delete() # At his point we should have a domain pointed at no SOA record with no # records attached to it. It also has no child domains. # Add a record to the domain. a = AddressRecord( label='', domain=root_domain, ip_type="6", ip_str="1::") a.save() s = SOA(primary="asdf.asdf", contact="asdf.asdf", description="asdf") s.save() root_domain.soa = s self.assertRaises(ValidationError, root_domain.save)
def setUp(self): self.r1 = create_fake_zone("10.in-addr.arpa", suffix="") self.sr = self.r1.soa self.sr.dirty = False self.sr.save() self.dom = create_fake_zone("bgaz", suffix="") self.soa = self.dom.soa self.soa.dirty = False self.soa.save() self.rdom = create_fake_zone("123.in-addr.arpa", suffix="") self.rsoa = self.r1.soa self.rsoa.dirty = False self.rsoa.save() self.s = System() self.s.save()
def test_integration2(self): root_domain = create_fake_zone("wee2.wee.mozilla.com", "") res, error = self.search("wee2.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) create_fake_zone("1.1.ip6.arpa", "") res, error = self.search("1.1.ip6.arpa") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) ptr = PTR(name="host1.wee2.wee.mozilla.com", ip_str="1111::", ip_type="6") ptr.save() addr = AddressRecord(label="host1", domain=root_domain, ip_str="11::", ip_type="6") addr.save() res, error = self.search("host1.wee2.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['A']), 1) self.assertEqual(len(res['PTR']), 1) res, error = self.search("host1.wee2.wee.mozilla.com type=:A") self.assertFalse(error) self.assertEqual(len(res['A']), 1) self.assertEqual(len(res['PTR']), 0) res, error = self.search("host1.wee2.wee.mozilla.com type=:PTR") self.assertFalse(error) self.assertEqual(len(res['A']), 0) self.assertEqual(len(res['PTR']), 1) res, error = self.search("host1.wee2.wee.mozilla.com type=:A " "type=:PTR") self.assertFalse(error) self.assertEqual(len(res['A']), 0) self.assertEqual(len(res['PTR']), 0)
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.i6_arpa = self.create_domain(name='ip6.arpa') self.i6_arpa.save() self.domain = create_fake_zone('foo.mozilla.com', suffix='') self.s = System.objects.create(name='mozilla.com')
def test_basic_add_remove6(self): # Make sure CNAME record block f_c = create_fake_zone("foo.foo1", suffix="") f_c.save() 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()
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_too_many_config_lines_changed(self): create_fake_zone('asdf86') root_domain1 = create_fake_zone('asdf87') root_domain2 = create_fake_zone('asdf88') root_domain3 = create_fake_zone('asdf89') b = DNSBuilder(STAGE_DIR=self.stage_dir, PROD_DIR=self.prod_dir, LOCK_FILE=self.lock_file, LOG_SYSLOG=False, FIRST_RUN=True, PUSH_TO_PROD=True, STOP_UPDATE_FILE=self.stop_update_file) b.build_dns() for ns in root_domain1.nameserver_set.all(): ns.delete() b.build_dns() # One zone removed should be okay for ns in root_domain2.nameserver_set.all(): ns.delete() for ns in root_domain3.nameserver_set.all(): ns.delete() self.assertRaises(BuildError, b.build_dns)
def test_basic_add_remove7(self): # try a star record f_c = create_fake_zone("foo.foo2", suffix="") f_c.save() self.assertFalse(f_c.purgeable) fqdn = "*.x.y.z.foo.foo2" label, the_domain = ensure_label_domain(fqdn) self.assertEqual('*', label) cname = CNAME(label=label, domain=the_domain, target="foo") cname.save() self.assertFalse(prune_tree(the_domain)) cname.delete()
def test_bad_nameserver_soa_state_case_1_2(self): # This is Case 1 ... with ptr's root_domain = create_fake_zone("12.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. # 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="12.10.1.1", ip_type="4") self.assertRaises(ValidationError, ptr.save)
def test_integration4_ip_range(self): create_fake_zone("wee3.wee.mozilla.com", "") create_fake_zone("1.2.ip6.arpa", "") res, error = self.search("1.2.ip6.arpa") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) self.assertEqual(len(res['DOMAIN']), 1) ptr = PTR(name="host1.wee2.wee.mozilla.com", ip_str="2111:0::", ip_type="6") ptr.save() res, error = self.search(ptr.ip_str) self.assertFalse(error) self.assertEqual(len(res['PTR']), 1) self.assertEqual(len(res['A']), 0) res, error = self.search("2111:0:0::") self.assertFalse(error) self.assertEqual(len(res['PTR']), 0) self.assertEqual(len(res['A']), 0)
def test_bad_nameserver_soa_state_case_2_2(self): # This is Case 2 ... with ptrs root_domain = create_fake_zone("22.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. ptr = PTR(name="asdf", ip_str="22.1.1.1", ip_type="4") ptr.save() self.assertRaises(ValidationError, ns.delete)
def test_bad_nameserver_soa_state_case_2_0(self): # This is Case 2 root_domain = create_fake_zone("asdf20") 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. a = AddressRecord( label='', domain=root_domain, ip_type="6", ip_str="1::") a.save() self.assertRaises(ValidationError, ns.delete)
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_1_0(self): # This is Case 1 root_domain = create_fake_zone("asdf10") 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. # Adding a record shouldn't be allowed because there is no NS record on # the zone's root domain. a = AddressRecord( label='', domain=root_domain, ip_type="6", ip_str="1::") self.assertRaises(ValidationError, a.save) cn = CNAME(label='', domain=root_domain, target="asdf") self.assertRaises(ValidationError, cn.save)
def test_bad_nameserver_soa_state_case_2_0(self): # This is Case 2 root_domain = create_fake_zone("asdf20") 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. a = AddressRecord(label='', domain=root_domain, ip_type="6", ip_str="1::") a.save() self.assertRaises(ValidationError, ns.delete)
def test_bad_nameserver_soa_state_case_1_0(self): # This is Case 1 root_domain = create_fake_zone("asdf10") 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. # Adding a record shouldn't be allowed because there is no NS record on # the zone's root domain. a = AddressRecord(label='', domain=root_domain, ip_type="6", ip_str="1::") self.assertRaises(ValidationError, a.save) cn = CNAME(label='', domain=root_domain, target="asdf") self.assertRaises(ValidationError, cn.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() a = AddressRecord(label='', domain=cdomain, ip_type="6", ip_str="1::") a.save() 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 test_integration3_zone(self): root_domain = create_fake_zone("wee3.wee.mozilla.com", "") res, error = self.search("zone=:wee3.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['SOA']), 1) self.assertEqual(len(res['NS']), 1) cn = CNAME(label="host1", domain=root_domain, target="whop.whop") cn.save() res, error = self.search("zone=:wee3.wee.mozilla.com host1") self.assertFalse(error) self.assertEqual(len(res['SOA']), 0) self.assertEqual(len(res['NS']), 0) self.assertEqual(len(res['CNAME']), 1) res, error = self.search("zone=:wee3.wee.mozilla.com " "type=:CNAME") self.assertFalse(error) self.assertEqual(len(res['SOA']), 0) self.assertEqual(len(res['NS']), 0) self.assertEqual(len(res['CNAME']), 1)
def test_basic_add_remove4(self): # Move a record down the tree testing prune's ability to not delete # stuff. f_c = create_fake_zone("foo.goo", suffix="") self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.goo" label, the_domain = ensure_label_domain(fqdn) txt = TXT(label=label, domain=the_domain, txt_data="Nthing") txt.save() self.assertTrue(the_domain.purgeable) # txt makes the domain un-purgeable. self.assertFalse(prune_tree(the_domain)) txt.domain = the_domain.master_domain the_next_domain = the_domain.master_domain txt.save() self.assertFalse(Domain.objects.filter(pk=the_domain.pk)) # We should be able to delete now. self.assertTrue(prune_tree(the_domain)) the_domain = the_next_domain # txt makes the domain un-purgeable. y.z.foo.com self.assertFalse(prune_tree(the_domain)) txt.domain = the_domain.master_domain the_next_domain = the_domain.master_domain txt.save() self.assertFalse(Domain.objects.filter(pk=the_domain.pk)) # We should be able to delete now. the_domain = the_next_domain # txt makes the domain un-purgeable. z.foo.com self.assertFalse(prune_tree(the_domain)) txt.domain = the_domain.master_domain the_next_domain = the_domain.master_domain txt.save() self.assertFalse(Domain.objects.filter(pk=the_domain.pk)) # We should be able to delete now. the_domain = the_next_domain # txt makes the domain un-purgeable. foo.com self.assertFalse(prune_tree(the_domain))
def test_basic_add_remove8(self): # Make sure a record's label is changed to '' when a domain with the # same name as it's fqdn is created. f_c = create_fake_zone("foo.foo3", suffix="") f_c.save() self.assertFalse(f_c.purgeable) fqdn = "www.x.y.z.foo.foo3" label, the_domain = ensure_label_domain(fqdn) self.assertEqual('www', label) self.assertEqual('x.y.z.foo.foo3', the_domain.name) self.assertTrue(the_domain.pk) cname = CNAME(label=label, domain=the_domain, target="foo") cname.save() fqdn = "*.www.x.y.z.foo.foo3" label2, the_domain2 = ensure_label_domain(fqdn) cname = CNAME.objects.get(fqdn=cname.fqdn) self.assertEqual('', cname.label) self.assertEqual('www.x.y.z.foo.foo3', cname.domain.name) self.assertEqual('*', label2) self.assertEqual('www.x.y.z.foo.foo3', the_domain2.name)
def test_basic_add_remove3(self): # MAke sure that if a domain is set to not purgeable the prune stops at # that domain when a record exists in a domain f_c = create_fake_zone("foo.foo", suffix="") self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.foo" label, the_domain = ensure_label_domain(fqdn) txt = TXT(label=label, domain=the_domain, txt_data="Nthing") txt.save() self.assertTrue(the_domain.purgeable) # txt makes the domain un-purgeable. self.assertFalse(prune_tree(the_domain)) txt.delete() # The tree should have pruned itself # Make sure stuff was deleted. self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo")) self.assertFalse(Domain.objects.filter(name="y.z.foo.foo")) self.assertFalse(Domain.objects.filter(name="z.foo.foo")) self.assertTrue(Domain.objects.filter(name="foo.foo"))
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 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_basic_add_remove5(self): # Make sure all record types block f_c = create_fake_zone("foo.foo22", suffix="") self.assertFalse(f_c.purgeable) fqdn = "bar.x.y.z.foo.foo22" label, the_domain = ensure_label_domain(fqdn) txt = TXT(label=label, domain=the_domain, txt_data="Nthing") txt.save() self.assertFalse(prune_tree(the_domain)) txt.delete() label, the_domain = ensure_label_domain(fqdn) addr = AddressRecord(label=label, domain=the_domain, ip_type='4', ip_str="10.2.3.4") addr.save() self.assertFalse(prune_tree(the_domain)) addr.delete() label, the_domain = ensure_label_domain(fqdn) mx = MX(label=label, domain=the_domain, server="foo", priority=4) mx.save() self.assertFalse(prune_tree(the_domain)) mx.delete() label, the_domain = ensure_label_domain(fqdn) ns = Nameserver(domain=the_domain, server="asdfasffoo") ns.save() self.assertFalse(prune_tree(the_domain)) ns.delete() label, the_domain = ensure_label_domain(fqdn) srv = SRV( label='_' + label, domain=the_domain, target="foo", priority=4, weight=4, port=34) srv.save() self.assertFalse(prune_tree(the_domain)) srv.delete()