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, ip_type='4') 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_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 c = Domain(name='foo') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo") f_c.soa = s f_c.save() 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_domain_records_perms(self): """ Test common domain record perms (cname, mx, txt, srv, ns) """ self.setup_request() perm_table = { 'cyder_admin': ['all'], 'admin': ['all'], 'user': ['all'], 'guest': ['view'], } # Initialize objs into ctnrs. domain = Domain(id=None, name='foo') domain.save() self.ctnr_admin.domains.add(domain) self.ctnr_user.domains.add(domain) self.ctnr_guest.domains.add(domain) self.save_all_ctnrs() domain_records = [] domain_records.append(AddressRecord(domain=domain)) domain_records.append(CNAME(domain=domain)) domain_records.append(MX(domain=domain)) domain_records.append(SRV(domain=domain)) domain_records.append(TXT(domain=domain)) domain_records.append(Nameserver(domain=domain)) for obj in domain_records: self.check_perms_each_user(obj, perm_table)
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" default_domain = d network = s rtype = 's' ip_type = '4' 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_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, ip_type='4') 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)
def test_cleanup_cname(self): # Make sure CNAME record block c = Domain(name='foo1') c.save() self.assertFalse(c.purgeable) s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", comment="dddfoo") f_c = Domain(name='foo.foo1') f_c.soa = s f_c.save() 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_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" default_domain = d network = s rtype = 's' ip_type = '4' 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)
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_cleanup_cname(self): # Make sure CNAME record block c = Domain(name='foo1') c.save() self.assertFalse(c.purgeable) s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", comment="dddfoo") f_c = Domain(name='foo.foo1') f_c.soa = s f_c.save() 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_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 c = Domain(name='foo') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo") f_c.soa = s f_c.save() 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_soa_perms(self): """ Test SOA perms """ self.setup_request() perm_table = { 'cyder_admin': ['all'], 'admin': [cy.ACTION_VIEW], 'user': [cy.ACTION_VIEW], 'guest': [cy.ACTION_VIEW], } # initialize obj into ctnrs obj = SOA() obj.primary = '192.168.1.1' obj.contact = '192.168.1.1' obj.save() domain = Domain(id=None, name='foo') domain.soa = obj domain.save() self.ctnr_admin.domains.add(domain) self.ctnr_user.domains.add(domain) self.ctnr_guest.domains.add(domain) self.save_all_ctnrs() self.check_perms_each_user(obj, perm_table)
def gen_domain( self, domain, dname ): self.cur.execute("SELECT * FROM `zone_mx` WHERE `domain`='%s' ORDER BY `name`;" % (domain)) bad_dnames = ['', '.', '_'] cdomain = None if dname not in bad_dnames: # Other baddies if dname.find('in-addr.arpa') >= 0: return None else: # IT's a good domain. First see if it exists already. Else create it. cdomain = Domain( name = dname ) try: cdomain.save() except ValidationError, e: arecs = AddressRecord.objects.filter(fqdn=dname) ip_strs = [] mxs = MX.objects.filter(fqdn=dname) mx_data = [] for arec in arecs: ip_strs.append(arec.ip_str) print "Re-Adding A record {0} to domain {1}".format(arec, dname) arec.delete() for mx in mxs: print "Re-Adding MX record {0} to domain {1}".format(mx, dname) mx_data.append((mx.server, mx.priority, mx.ttl)) mx.delete() cdomain.save() for ip_str in ip_strs: AddressRecord(label="", domain=cdomain, ip_str=ip_str, ip_type='4').save() for server, prio, ttl in mx_data: mx = MX(label="", domain=cdomain, server=server, priority=prio, ttl=ttl) mx.save() print "Adding: {0} MX {1}".format(mx.fqdn, mx.server)
def test_soa_perms(self): """ Test SOA perms """ self.setup_request() perm_table = { 'cyder_admin': ['all'], 'admin': ['view'], 'user': ['view'], 'guest': ['view'], } # initialize obj into ctnrs obj = SOA() obj.primary = '192.168.1.1' obj.contact = '192.168.1.1' obj.save() domain = Domain(id=None, name='foo') domain.soa = obj domain.save() self.ctnr_admin.domains.add(domain) self.ctnr_user.domains.add(domain) self.ctnr_guest.domains.add(domain) self.save_all_ctnrs() self.check_perms_each_user(obj, perm_table)
def test_domain_records_perms(self): """ Test common domain record perms (cname, mx, txt, srv, ns) """ self.setup_request() perm_table = { 'cyder_admin': ['all'], 'admin': ['all'], 'user': ['all'], 'guest': [cy.ACTION_VIEW], } # Initialize objs into ctnrs. domain = Domain(id=None, name='foo') domain.save() self.ctnr_admin.domains.add(domain) self.ctnr_user.domains.add(domain) self.ctnr_guest.domains.add(domain) self.save_all_ctnrs() domain_records = [] domain_records.append(AddressRecord(domain=domain)) domain_records.append(CNAME(domain=domain)) domain_records.append(MX(domain=domain)) domain_records.append(SRV(domain=domain)) domain_records.append(TXT(domain=domain)) domain_records.append(Nameserver(domain=domain)) for obj in domain_records: self.check_perms_each_user(obj, perm_table)
def test_domain_records_perms(self): """Test common domain record perms (CNAME, MX, TXT, SRV, NS)""" self.setup_request() perm_table = { 'cyder_admin': ['all'], 'admin': ['all'], 'user': ['all'], 'guest': [ACTION_VIEW], } ns_perm_table = { 'cyder_admin': ['all'], 'admin': [ACTION_VIEW], 'user': [ACTION_VIEW], 'guest': [ACTION_VIEW], } # Initialize objs into ctnrs. domain = Domain(id=None, name='foo') domain.save() self.ctnr_admin.domains.add(domain) self.ctnr_user.domains.add(domain) self.ctnr_guest.domains.add(domain) self.save_all_ctnrs() domain_records = [] domain_records.append(AddressRecord(domain=domain)) domain_records.append(CNAME(domain=domain)) domain_records.append(MX(domain=domain)) domain_records.append(SRV(domain=domain)) domain_records.append(TXT(domain=domain)) self.check_perms_each_user(Nameserver(domain=domain), ns_perm_table) for obj in domain_records: self.check_perms_each_user(obj, perm_table, set_same_ctnr=True)
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 DeleteStaticInterTests(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', 'ipv6.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() View.objects.get_or_create(name="private") def do_add(self, mac, label, domain, ip_str, system, ip_type='4'): r = StaticInterface(mac=mac, 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? mac = "11:22:33:44:55:66" label = "foo" domain = self.f_c ip_str = "10.0.0.2" system = System(hostname="foo") system.save() kwargs = {'mac': mac, 'label': label, 'domain': domain, 'ip_str': ip_str, 'system': system} i = self.do_add(**kwargs) intr_pk = i.pk self.assertTrue(StaticInterface.objects.filter(**kwargs)) system.delete() self.assertFalse(StaticInterface.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_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_detail_url()) self.assertTrue(sshfp.get_update_url()) self.assertTrue(sshfp.get_delete_url()) rsshfp = SSHFP.objects.filter(**data) self.assertTrue(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" data = "asdf" s_type = 1 a_type = 1 data = {'label': label, 'key': data, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} sshfp1 = self.do_generic_add(data) label = "asdf" data = "asdfasfd" s_type = 1 a_type = 1 data = {'label': label, 'key': data, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} sshfp1 = self.do_generic_add(data) label = "df" data = "aasdf" s_type = 1 a_type = 1 data = {'label': label, 'key': data, 'domain': self.o_e, 'algorithm_number': a_type, 'fingerprint_type': s_type} sshfp1 = self.do_generic_add(data) label = "12314" data = "dd" s_type = 1 a_type = 1 data = {'label': label, 'key': data, 'domain': self.o, 'algorithm_number': a_type, 'fingerprint_type': s_type} sshfp1 = self.do_generic_add(data)
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 DomainViewTests(cyder.base.tests.TestCase): def setUp(self): soa = SOA(primary=random_label(), contact=random_label(), comment=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_cydns_app_domain(self): resp = self.client.get(reverse('domain-list'), follow=True) self.assertEqual(resp.status_code, 200) def test_get_create_domain(self): resp = self.client.get(reverse('domain-create'), follow=True) self.assertEqual(resp.status_code, 200) def test_post_create_domain(self): resp = self.client.post(reverse('domain-create'), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_update_domain(self): resp = self.client.get(reverse('domain-update', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def test_post_object_update_domain(self): resp = self.client.post(reverse('domain-update', args=[self.test_obj.pk]), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_post_object_update_domain(self): resp = self.client.post(reverse('domain-update', args=[self.test_obj.pk]), {'soa': ''}, follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_details_domain(self): resp = self.client.get(reverse('domain-detail', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def test_get_object_delete_domain(self): resp = self.client.get(reverse('domain-delete', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def post_data(self): return {'name': random_label()}
class DomainViewTests(cyder.base.tests.TestCase): def setUp(self): soa = SOA(primary=random_label( ), contact=random_label(), comment=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_cydns_app_domain(self): resp = self.client.get(reverse('domain-list'), follow=True) self.assertEqual(resp.status_code, 200) def test_get_create_domain(self): resp = self.client.get(reverse('domain-create'), follow=True) self.assertEqual(resp.status_code, 200) def test_post_create_domain(self): resp = self.client.post(reverse('domain-create'), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_update_domain(self): resp = self.client.get(reverse('domain-update', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def test_post_object_update_domain(self): resp = self.client.post(reverse('domain-update', args=[self.test_obj.pk]), self.post_data(), follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_post_object_update_domain(self): resp = self.client.post(reverse('domain-update', args=[self.test_obj.pk]), {'soa': ''}, follow=True) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_details_domain(self): resp = self.client.get(reverse('domain-detail', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def test_get_object_delete_domain(self): resp = self.client.get(reverse('domain-delete', args=[self.test_obj.pk]), follow=True) self.assertEqual(resp.status_code, 200) def post_data(self): return { 'name': random_label() }
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", comment=random_label()) soa.save() domain.soa = soa domain.save() return domain
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", comment=random_label()) soa.save() domain.soa = soa domain.save() return domain
def test_add_address_underscydhcp_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_address_underscydhcp_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_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)
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)
def test_basic_add_remove5(self): # Make sure all record types block c = Domain(name='foo22') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo22') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo22") f_c.soa = s f_c.save() 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_resize(self): s = Network.objects.create(network_str='129.0.0.0/24', ip_type='4') d = Domain(name="asdf") d.save() r = Range.objects.create( start_str='129.0.0.1', end_str='129.0.0.255', network=s) self.assertEqual(r.network, s) self.assertEqual(s.range_set.count(), 1) s.network_str = '129.0.0.0/25' self.assertRaises(ValidationError, s.save)
def test_basic_add_remove4(self): # Move a record down the tree testing prune's ability to not delete # stuff. c = Domain(name='goo') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.goo') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.goo") f_c.soa = s f_c.save() 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_bad_resize(self): s = Network.objects.create(network_str='129.0.0.0/24', ip_type='4') d = Domain(name="asdf") d.save() r = Range.objects.create( start_str='129.0.0.1', end_str='129.0.0.255', network=s) self.assertEqual(r.network, s) self.assertEqual(s.range_set.count(), 1) s.network_str = '129.0.0.0/25' self.assertRaises(ValidationError, s.save)
def test_basic_add_remove4(self): # Move a record down the tree testing prune's ability to not delete # stuff. c = Domain(name='goo') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.goo') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.goo") f_c.soa = s f_c.save() 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_ctnr_domain_records(self): """ Test being in ctnr /w common domain records gives appropriate perms common domain records: cname, mx, txt, srv """ request = HttpRequest() request.user = self.test_user request.session = SessionStore() request.session['ctnr'] = self.ctnr # create domain, add domain to ctnr domain = Domain(id=None, name='foo') domain.save() self.ctnr.domains.add(domain) self.ctnr.save() self.ctnr_admin.domains.add(domain) self.ctnr_admin.save() domain_records = [] domain_records.append(AddressRecord(domain=domain)) domain_records.append(CNAME(domain=domain)) domain_records.append(MX(domain=domain)) domain_records.append(Nameserver(domain=domain)) domain_records.append(SRV(domain=domain)) domain_records.append(TXT(domain=domain)) for record in domain_records: # checks where user is not admin request.session = {'ctnr': self.ctnr} has_perm = self.test_user.get_profile().has_perm(request, record, write=False) self.assertTrue(has_perm, 'user should have read access') has_perm = self.test_user.get_profile().has_perm(request, record, write=True) self.assertFalse(has_perm, 'user should not have write access') # checks where user is admin request.session = {'ctnr': self.ctnr_admin} has_perm = self.test_user.get_profile().has_perm(request, record, write=False) self.assertTrue(has_perm, 'user should have read access') has_perm = self.test_user.get_profile().has_perm(request, record, write=True) self.assertTrue(has_perm, 'user should have write access') # checks where obj not in ctnr request.session = {'ctnr': self.ctnr_empty} has_perm = self.test_user.get_profile().has_perm(request, record, write=False) self.assertFalse(has_perm, 'user should not have read access') has_perm = self.test_user.get_profile().has_perm(request, record, write=True) self.assertFalse(has_perm, 'user should not have write access')
def test_delegation_block(self): s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", comment="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_delegation_block(self): s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", comment="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)
class DomainViewTests(TestCase): def setUp(self): self.url_slug = 'domain' soa = SOA(primary=random_label(), contact=random_label(), comment=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_app_domain(self): resp = self.client.get(CYDNS_BASE_URL+"/%s/" % (self.url_slug)) self.assertEqual(resp.status_code, 200) # url(r'^cyder/cydns/nameserver/create$', NSCreateView.as_view()), def test_get_create_domain(self): resp = self.client.get(CYDNS_BASE_URL+"/%s/create/" % (self.url_slug)) self.assertEqual(resp.status_code, 200) def test_post_create_domain(self): resp = self.client.post(CYDNS_BASE_URL+"/%s/create/" % (self.url_slug), self.post_data()) self.assertTrue(resp.status_code in (302, 200)) # url(r'^cyder/cydns/nameserver/(?P<pk>[\w-]+)/update$', NSUpdateView.as_view() ), def test_get_object_update_domain(self): resp = self.client.get(CYDNS_BASE_URL+"/%s/%s/update/" % (self.url_slug, self.test_obj.pk)) self.assertEqual(resp.status_code, 200) def test_post_object_update_domain(self): resp = self.client.post(CYDNS_BASE_URL+"/%s/%s/update/" % (self.url_slug,self.test_obj.pk), self.post_data()) self.assertTrue(resp.status_code in (302, 200)) def test_post_object_update_domain(self): resp = self.client.post(CYDNS_BASE_URL+"/%s/%s/update/" % (self.url_slug,self.test_obj.pk), {'soa':''}) self.assertTrue(resp.status_code in (302, 200)) def test_get_object_details_domain(self): resp = self.client.get(CYDNS_BASE_URL+"/%s/%s/" % (self.url_slug, self.test_obj.pk)) self.assertEqual(resp.status_code, 200) def test_get_object_delete_domain(self): resp = self.client.get(CYDNS_BASE_URL+"/%s/%s/delete/" % (self.url_slug, self.test_obj.pk)) self.assertEqual(resp.status_code, 200) def post_data(self): return {'name':random_label()}
def test_basic_add_remove5(self): # Make sure all record types block c = Domain(name='foo22') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo22') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo22") f_c.soa = s f_c.save() 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()
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_detail_url()) self.assertTrue(txt.get_update_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} txt1 = self.do_generic_add(data) label = "asdf" data = "asdfasfd" data = {'label': label, 'txt_data': data, 'domain': self.o_e} txt1 = self.do_generic_add(data) label = "df" data = "aasdf" data = {'label': label, 'txt_data': data, 'domain': self.o_e} txt1 = self.do_generic_add(data) label = "12314" data = "dd" data = {'label': label, 'txt_data': data, 'domain': self.o} txt1 = self.do_generic_add(data)
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 } txt1 = self.do_generic_add( data ) label = "asdf" data = "asdfasfd" data = { 'label':label, 'txt_data':data ,'domain':self.o_e } txt1 = self.do_generic_add( data ) label = "df" data = "aasdf" data = { 'label':label, 'txt_data':data ,'domain':self.o_e } txt1 = self.do_generic_add( data ) label = "12314" data = "dd" data = { 'label':label, 'txt_data':data ,'domain':self.o } txt1 = self.do_generic_add( data )
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_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_basic_add_remove6(self): # Make sure CNAME record block c = Domain(name='foo1') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo1') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo1") f_c.soa = s 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_ctnr_soa(self): """ Test being in ctnr /w soa record gives appropriate perms """ request = HttpRequest() request.user = self.test_user request.session = SessionStore() request.session['ctnr'] = self.ctnr # create domain with soa, add domain to ctnr soa = SOA() soa.primary = '192.168.1.1' soa.contact = '192.168.1.1' soa.save() domain = Domain(id=None, name='foo') domain.soa = soa domain.save() self.ctnr.domains.add(domain) self.ctnr.save() self.ctnr_admin.domains.add(domain) self.ctnr_admin.save() # checks where user is not admin has_perm = self.test_user.get_profile().has_perm(request, soa, write=False) self.assertTrue(has_perm, 'user should have read access') has_perm = self.test_user.get_profile().has_perm(request, soa, write=True) self.assertFalse(has_perm, 'user should not have write access') # checks where user is admin request.session = {'ctnr': self.ctnr_admin} has_perm = self.test_user.get_profile().has_perm(request, soa, write=False) self.assertTrue(has_perm, 'user should have read access') has_perm = self.test_user.get_profile().has_perm(request, soa, write=True) self.assertTrue(has_perm, 'user should have write access') # checks where obj not in ctnr request.session = {'ctnr': self.ctnr_empty} has_perm = self.test_user.get_profile().has_perm(request, soa, write=False) self.assertFalse(has_perm, 'user should not have read access') has_perm = self.test_user.get_profile().has_perm(request, soa, write=True) self.assertFalse(has_perm, 'user should not have write access')
def test_basic_add_remove6(self): # Make sure CNAME record block c = Domain(name='foo1') c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.foo1') s, _ = SOA.objects.get_or_create(primary="foo", contact="foo", comment="foo.foo1") f_c.soa = s 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_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_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_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_domain_perms(self): """Test domain perms""" self.setup_request() perm_table = { 'cyder_admin': [ACTION_VIEW, ACTION_UPDATE], 'admin': [ACTION_VIEW], 'user': [ACTION_VIEW], 'guest': [ACTION_VIEW], } # Initialize obj into ctnrs. obj = Domain(id=None, name='foo') obj.save() self.ctnr_admin.domains.add(obj) self.ctnr_user.domains.add(obj) self.ctnr_guest.domains.add(obj) self.save_all_ctnrs() self.check_perms_each_user(obj, perm_table)
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)
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_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 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.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)