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 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 migrate_AAAA(zone, root_domain, soa, views): for (name, ttl, rdata) in zone.iterate_rdatas('AAAA'): name = name.to_text().strip('.') print str(name) + " AAAA " + str(rdata) exists_domain = Domain.objects.filter(name=name) if exists_domain: label = '' domain = exists_domain[0] else: label = name.split('.')[0] if label.startswith('unused'): continue domain_name = '.'.join(name.split('.')[1:]) domain = ensure_domain(domain_name, force=True) ip_upper, ip_lower = ipv6_to_longs(rdata.to_text()) if AddressRecord.objects.filter(label=label, domain=domain, ip_upper=ip_upper, ip_lower=ip_lower, ip_type='6').exists(): a = AddressRecord.objects.get( label=label, domain=domain, ip_type='6', ip_upper=ip_upper, ip_lower=ip_lower ) else: a = AddressRecord( label=label, domain=domain, ip_str=rdata.to_text(), ip_type='6', description=rdata.comment, ttl=ttl ) a.clean() a.save() for view in views: a.views.add(view) a.save()
def test2(self): ip_start = "10.0.1.0" ip_end = "10.0.1.99" ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type="4") ptr.full_clean() ptr.save() a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.1.3", ip_type="4") a.full_clean() a.save() s = create_fake_host(hostname="foo.mozilla.com") s.save() sreg = StaticReg.objects.create(label="foo", domain=self.domain, ip_str="10.0.1.4", ip_type="4", system=s) istart, iend, ipf_q = start_end_filter(ip_start, ip_end, "4") addrs = list(AddressRecord.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper")) ptrs = list(PTR.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper")) sregs = list(StaticReg.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper")) self.assertEqual(a.pk, addrs[0].pk) self.assertEqual(ptr.pk, ptrs[0].pk) self.assertEqual(sreg.pk, sregs[0].pk) range_details = range_usage(ip_start, ip_end, "4") self.assertEqual(98, range_details["unused"]) self.assertEqual(2, range_details["used"]) self.assertEqual( [(int(istart) + 0, int(istart) + 2), (int(istart) + 5, int(istart) + 99)], range_details["free_ranges"] )
def test1(self): ip_start = "10.0.0.10" ip_end = "10.0.0.19" ptr = PTR(name="foo.mz", ip_str="10.0.0.15", ip_type='4') ptr.full_clean() ptr.save() a = AddressRecord( label="foo", domain=self.domain, ip_str="10.0.0.16", ip_type='4') a.full_clean() a.save() istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4') addrs = list(AddressRecord.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) ptrs = list(PTR.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) intrs = list(StaticInterface.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) self.assertEqual(a.pk, addrs[0].pk) self.assertEqual(ptr.pk, ptrs[0].pk) self.assertFalse(intrs) range_details = range_usage(ip_start, ip_end, '4') self.assertEqual(8, range_details['unused']) self.assertEqual(2, range_details['used']) self.assertEqual([(int(istart), int(istart) + 4), (int(istart) + 7, int(istart) + 9)], range_details['free_ranges'])
def test_integration5_ip(self): root_domain = create_fake_zone("wee5.wee.mozilla.com", "") create_fake_zone("10.in-addr.arpa", "") res, error = compile_to_django("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 = compile_to_django(ptr.ip_str) self.assertFalse(error) self.assertEqual(len(res['PTR']), 1) self.assertEqual(len(res['A']), 1) res, error = compile_to_django("10.0.0.2") self.assertFalse(error) self.assertEqual(len(res['PTR']), 0) self.assertEqual(len(res['A']), 0) res, error = compile_to_django("ip=:10.0.0.1") self.assertFalse(error) self.assertEqual(len(res['PTR']), 1) self.assertEqual(len(res['A']), 1)
def test1(self): ip_start = "10.0.0.10" ip_end = "10.0.0.19" ptr = PTR(name="foo.mz", ip_str="10.0.0.15", ip_type='4') ptr.full_clean() ptr.save() a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.0.16", ip_type='4') a.full_clean() a.save() istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4') addrs = list( AddressRecord.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) ptrs = list( PTR.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) sregs = list( StaticReg.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) self.assertEqual(a.pk, addrs[0].pk) self.assertEqual(ptr.pk, ptrs[0].pk) self.assertFalse(sregs) range_details = range_usage(ip_start, ip_end, '4') self.assertEqual(8, range_details['unused']) self.assertEqual(2, range_details['used']) self.assertEqual([(int(istart), int(istart) + 4), (int(istart) + 7, int(istart) + 9)], range_details['free_ranges'])
def test_manual_assign_of_glue(self): # Test that assigning a different glue record doesn't get overriden by # the auto assinging during the Nameserver's clean function. glue = StaticReg.objects.create( label='ns25', domain=self.f_r, ip_str='128.193.99.10', ip_type='4', system=self.s ) data = {'domain': self.f_r, 'server': 'ns25.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.glue, glue) glue2 = AddressRecord(label='ns25', domain=self.f_r, ip_str= '128.193.1.78', ip_type='4') glue2.clean() glue2.save() ns.clean() # Make sure things didn't get overriden. self.assertEqual(ns.glue, glue) ns.glue = glue2 ns.save() # Refresh the object ns = Nameserver.objects.get(pk=ns.pk) # Again, Make sure things didn't get overriden. self.assertEqual(ns.glue, glue2) # Make sure we still can't delete. self.assertRaises(ValidationError, glue2.delete) self.assertRaises(ValidationError, ns.glue.delete) # We shuold be able to delelte the other one. glue.delete()
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)
def do_add_a(self, label, domain, ip_str, ip_type='4'): a = AddressRecord(label=label, domain=domain, ip_str=ip_str, ip_type=ip_type) a.clean() a.save() return a
def test_private_view_case_1_addr(self): a = AddressRecord(label="asf", domain=self.f_o, ip_str="10.0.0.1", ip_type="4") a.clean() a.save() # Object has to exist before views can be assigned. a.views.add(self.private) a.save()
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())
def test_update_glue_to_no_glue(self): glue = AddressRecord(label='ns3', domain=self.r, ip_str='128.193.1.10', ip_type='4') glue.save() data = {'domain': self.r, 'server': 'ns3.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) ns.server = "ns4.wee" ns.save() self.assertTrue(ns.glue is None)
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 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())
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_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_disallow_name_update_of_glue_A(self): # Glue records should not be allowed to change their name. glue = AddressRecord(label='ns39', domain=self.f_r, ip_str= '128.193.1.77', ip_type='4') glue.clean() glue.save() data = {'domain': self.f_r, 'server': 'ns39.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.glue, glue) glue.label = "ns22" self.assertRaises(ValidationError, glue.clean)
def test_delete_ns(self): glue = AddressRecord(label='ns4', domain=self.f_r, ip_str='128.196.1.10', ip_type='4') glue.save() data = {'domain': self.f_r, 'server': 'ns4.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.server, ns.glue.fqdn) ns.delete() nsret = Nameserver.objects.filter( server='ns2.foo.ru', domain=self.f_r) self.assertFalse(nsret)
def test_existing_record_new_domain(self): name = "bo" b_dom, _ = Domain.objects.get_or_create(name=name, delegated=False) name = "to.bo" t_dom, _ = Domain.objects.get_or_create(name=name, delegated=False) arec1 = AddressRecord(label="no", domain=t_dom, ip_str="128.193.99.9", ip_type='4') arec1.save() name = "no.to.bo" n_dom = Domain(name=name, delegated=False) self.assertRaises(ValidationError, n_dom.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 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_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_invalid_create(self): glue = AddressRecord(label='ns2', domain=self.r, ip_str='128.193.1.10', ip_type='4') glue.save() data = {'domain': self.r, 'server': 'ns2 .ru'} self.assertRaises(ValidationError, self.do_add, **data) data = {'domain': self.r, 'server': 'ns2$.ru'} self.assertRaises(ValidationError, self.do_add, **data) data = {'domain': self.r, 'server': 'ns2..ru'} self.assertRaises(ValidationError, self.do_add, **data) data = {'domain': self.r, 'server': 'ns2.ru '} self.assertRaises(ValidationError, self.do_add, **data) data = {'domain': self.r, 'server': ''} self.assertRaises(ValidationError, self.do_add, **data)
def test_disallow_name_update_of_glue_A(self): # Glue records should not be allowed to change their name. glue = AddressRecord(label='ns39', domain=self.f_r, ip_str='128.193.1.77', ip_type='4') glue.clean() glue.save() data = {'domain': self.f_r, 'server': 'ns39.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.glue, glue) glue.label = "ns22" self.assertRaises(ValidationError, glue.clean)
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 test2_bad_add_for_a_ptr(self): # PTR and A exist, then try add sreg label = "9988fdfood" domain = self.c ip_str = "1112::11:22:33:44:55:66" kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str} ip_type = '6' a = AddressRecord(label=label, domain=domain, ip_str=ip_str, ip_type=ip_type) a.clean() a.save() ptr = PTR(ip_str=ip_str, ip_type=ip_type, name=a.fqdn) ptr.clean() ptr.save() self.assertRaises(ValidationError, self.do_add, **kwargs)
def test_cleanup_address(self): self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo")) self.assertFalse(Domain.objects.filter(name="y.z.foo.poo")) self.assertFalse(Domain.objects.filter(name="z.foo.poo")) self.assertTrue(Domain.objects.filter(name="foo.poo")) fqdn = "bar.x.y.z.foo.poo" 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() self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo")) self.assertFalse(Domain.objects.filter(name="y.z.foo.poo")) self.assertFalse(Domain.objects.filter(name="z.foo.poo")) self.assertTrue(Domain.objects.filter(name="foo.poo"))
def test_integration2(self): root_domain = create_fake_zone("wee2.wee.mozilla.com", "") res, error = compile_to_django("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 = compile_to_django("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 = compile_to_django("host1.wee2.wee.mozilla.com") self.assertFalse(error) self.assertEqual(len(res['A']), 1) self.assertEqual(len(res['PTR']), 1) res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:A") self.assertFalse(error) self.assertEqual(len(res['A']), 1) self.assertEqual(len(res['PTR']), 0) res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:PTR") self.assertFalse(error) self.assertEqual(len(res['A']), 0) self.assertEqual(len(res['PTR']), 1) res, error = compile_to_django("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 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()
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 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 test_add_ns_in_domain(self): # Use an A record as a glue record. glue = AddressRecord(label='ns2', domain=self.r, ip_str='128.193.1.10', ip_type='4') glue.clean() glue.save() data = {'domain': self.r, 'server': 'ns2.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.server, ns.glue.fqdn) self.assertRaises(ValidationError, glue.delete) glue = AddressRecord(label='ns3', domain=self.f_r, ip_str= '128.193.1.10', ip_type='4') glue.save() data = {'domain': self.f_r, 'server': 'ns3.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.server, ns.glue.fqdn)
def test2(self): ip_start = "10.0.1.0" ip_end = "10.0.1.99" ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type='4') ptr.full_clean() ptr.save() a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.1.3", ip_type='4') a.full_clean() a.save() s = create_fake_host(hostname="foo.mozilla.com") s.save() sreg = StaticReg.objects.create(label="foo", domain=self.domain, ip_str="10.0.1.4", ip_type='4', system=s) istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4') addrs = list( AddressRecord.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) ptrs = list( PTR.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) sregs = list( StaticReg.objects.filter(ipf_q).order_by('ip_lower').order_by( 'ip_upper')) self.assertEqual(a.pk, addrs[0].pk) self.assertEqual(ptr.pk, ptrs[0].pk) self.assertEqual(sreg.pk, sregs[0].pk) range_details = range_usage(ip_start, ip_end, '4') self.assertEqual(98, range_details['unused']) self.assertEqual(2, range_details['used']) self.assertEqual([(int(istart) + 0, int(istart) + 2), (int(istart) + 5, int(istart) + 99)], range_details['free_ranges'])
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 migrate_AAAA(zone, root_domain, soa, views): for (name, ttl, rdata) in zone.iterate_rdatas('AAAA'): name = name.to_text().strip('.') print str(name) + " AAAA " + str(rdata) exists_domain = Domain.objects.filter(name=name) if exists_domain: label = '' domain = exists_domain[0] else: label = name.split('.')[0] if label.startswith('unused'): continue domain_name = '.'.join(name.split('.')[1:]) domain = ensure_domain(domain_name, force=True) ip_upper, ip_lower = ipv6_to_longs(rdata.to_text()) if AddressRecord.objects.filter(label=label, domain=domain, ip_upper=ip_upper, ip_lower=ip_lower, ip_type='6').exists(): a = AddressRecord.objects.get(label=label, domain=domain, ip_type='6', ip_upper=ip_upper, ip_lower=ip_lower) else: a = AddressRecord(label=label, domain=domain, ip_str=rdata.to_text(), ip_type='6', description=rdata.comment, ttl=ttl) a.clean() a.save() for view in views: a.views.add(view) a.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 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 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()
def test_add_ns_in_domain(self): # Use an A record as a glue record. glue = AddressRecord(label='ns2', domain=self.r, ip_str='128.193.1.10', ip_type='4') glue.clean() glue.save() data = {'domain': self.r, 'server': 'ns2.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.server, ns.glue.fqdn) self.assertRaises(ValidationError, glue.delete) glue = AddressRecord(label='ns3', domain=self.f_r, ip_str='128.193.1.10', ip_type='4') glue.save() data = {'domain': self.f_r, 'server': 'ns3.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.server, ns.glue.fqdn)
def test2(self): ip_start = "10.0.1.0" ip_end = "10.0.1.99" ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type='4') ptr.full_clean() ptr.save() a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.1.3", ip_type='4') a.full_clean() a.save() s = System() s.save() intr = StaticInterface( label="foo", domain=self.domain, ip_str="10.0.1.4", ip_type='4', system=s, mac="00:11:22:33:44:55") intr.full_clean() intr.save() istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4') addrs = list(AddressRecord.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) ptrs = list(PTR.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) intrs = list(StaticInterface.objects.filter(ipf_q). order_by('ip_lower').order_by('ip_upper')) self.assertEqual(a.pk, addrs[0].pk) self.assertEqual(ptr.pk, ptrs[0].pk) self.assertEqual(intr.pk, intrs[0].pk) range_details = range_usage(ip_start, ip_end, '4') self.assertEqual(98, range_details['unused']) self.assertEqual(2, range_details['used']) self.assertEqual([(int(istart) + 0, int(istart) + 2), (int(istart) + 5, int(istart) + 99)], range_details['free_ranges'])
def test_manual_assign_of_glue(self): # Test that assigning a different glue record doesn't get overriden by # the auto assinging during the Nameserver's clean function. glue = StaticReg.objects.create(label='ns25', domain=self.f_r, ip_str='128.193.99.10', ip_type='4', system=self.s) data = {'domain': self.f_r, 'server': 'ns25.foo.ru'} ns = self.do_add(**data) self.assertTrue(ns.glue) self.assertEqual(ns.glue, glue) glue2 = AddressRecord(label='ns25', domain=self.f_r, ip_str='128.193.1.78', ip_type='4') glue2.clean() glue2.save() ns.clean() # Make sure things didn't get overriden. self.assertEqual(ns.glue, glue) ns.glue = glue2 ns.save() # Refresh the object ns = Nameserver.objects.get(pk=ns.pk) # Again, Make sure things didn't get overriden. self.assertEqual(ns.glue, glue2) # Make sure we still can't delete. self.assertRaises(ValidationError, glue2.delete) self.assertRaises(ValidationError, ns.glue.delete) # We shuold be able to delelte the other one. glue.delete()
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 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 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)