def setUp(self): self.o = Domain(name="org") self.o.save() self.o_e = Domain(name="oregonstate.org") self.o_e.save() self.b_o_e = Domain(name="bar.oregonstate.org") self.b_o_e.save()
def setUp(self): Domain.objects.all().delete() self.c = Client() Domain(name="com").save() Domain(name="mozilla.com").save() self.private_view, _ = View.objects.get_or_create(name='private') self.public_view, _ = View.objects.get_or_create(name='public')
def test_update_has_child_domain(self): Domain(name='com99').save() f_c = Domain(name='foo.com99') f_c.save() Domain(name='boo.foo.com99').save() f_c.name = 'foobar.com99' self.assertRaises(ValidationError, f_c.save)
def test_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 test2_add_domain(self): # Some domains have '_' in their name. Make sure validation allows # this. c = Domain(name='cz') c.save() c1 = Domain(name='_foo.cz') c1.save() c2 = Domain(name='moo_foo._foo.cz') c2.save()
def test_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__()
def test_remove_has_child_records(self): Domain(name='com').save() f_c = Domain(name='foo.com') f_c.save() cn = CNAME(domain=f_c, label="no", target="asdf") cn.full_clean() cn.save() self.assertRaises(ValidationError, f_c.delete)
def test_delete_with_domains(self): data = {'primary': "ns1asfdadsf.foo.com", 'contact': "email.foo.com"} soa = SOA(**data) soa.save() d0 = Domain(name='com') d0.save() d1 = Domain(name='foo.com', soa=soa) d1.soa = soa d1.save() self.assertRaises(ValidationError, soa.delete)
def test_no_soa_block2(self): c = Domain(name='moo') c.save() f_c = Domain(name='foo.moo') f_c.save() s, _ = SOA.objects.get_or_create(primary="bar23", contact="Foo", description="bar") f_c.soa = s f_c.save() self.assertRaises(ValidationError, ensure_label_domain, "baz.moo")
def test_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_delegation_block(self): s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo", description="foo") c = Domain(name='com') c.soa = s c.save() self.assertFalse(c.purgeable) f_c = Domain(name='foo.com') f_c.delegated = True f_c.save() self.assertFalse(f_c.purgeable) self.assertTrue(f_c.delegated) fqdn = "z.baz.foo.com" self.assertRaises(ValidationError, ensure_label_domain, fqdn)
def setUp(self): self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='in-addr.arpa') self.i_arpa.save() self.c = Domain(name="ccc") self.c.save() self.f_c = Domain(name="foo.ccc") self.f_c.save() self.r1 = self.create_domain(name="10") self.r1.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save()
def test_bad_delete(self): network = "129.0.0.0" prefixlen = "24" kwargs = {'network': network, 'prefixlen': prefixlen, 'ip_type': '4'} s = self.do_basic_add(**kwargs) s_pk = s.pk self.assertTrue(s) d = Domain(name="asdf") d.save() start_str = "129.0.0.1" end_str = "129.0.0.255" network = s r = Range(start_str=start_str, end_str=end_str, network=network) r.clean() r.save() self.assertEqual(r.network, s) self.assertTrue(len(s.range_set.all()) == 1) self.assertRaises(ValidationError, s.delete) self.assertTrue(Network.objects.get(pk=s_pk)) r.delete() s.delete() self.assertEqual(len(Network.objects.filter(pk=s_pk)), 0)
def setUp(self): self.arpa = self.create_domain(name='arpa') self.arpa.save() self.i_arpa = self.create_domain(name='ip6.arpa', ip_type='6') 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="0", ip_type='6') self.r1.save() self.r2 = self.create_domain(name="1", ip_type='6') self.r2.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save()
def setUp(self): self.url_slug = 'domain' soa = SOA(primary=random_label(), contact=random_label(), description=random_label()) self.test_obj = Domain(name=random_label()) self.test_obj.save() self.test_obj.soa = soa self.test_obj.save()
def 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.r2 = self.create_domain(name="128") self.r2.save() self.n = create_fake_host(hostname="foo.mozilla.com") self.n.clean() self.n.save() View.objects.get_or_create(name="private")
def test1_add_domain(self): c = Domain(name='com') c.save() f_c = Domain(name='foo.com') f_c.save() f_c.save() f_c.details() self.assertTrue(f_c.get_absolute_url()) self.assertTrue(f_c.get_edit_url()) self.assertTrue(f_c.get_delete_url()) self.assertTrue(f_c.master_domain == c) b_c = Domain(name='bar.com') b_c.save() self.assertTrue(b_c.master_domain == c) b_b_c = Domain(name='baz.bar.com') b_b_c.save() self.assertTrue(b_b_c.master_domain == b_c)
def create_domain(self, name, ip_type=None, delegated=False): if ip_type is None: ip_type = '4' if name in ('arpa', 'in-addr.arpa', 'ip6.arpa'): pass else: name = ip_to_domain_name(name, ip_type=ip_type) d = Domain(name=name, delegated=delegated) d.clean() self.assertTrue(d.is_reverse) return d
def test_add_address_underscore_in_name_domain(self): d = Domain(name="_mssucks.edu") d.save() data = {'label': '*', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data) data = {'label': 'foo', 'domain': d, 'ip': "128.193.0.10"} a = self.do_add_record(data) a.save() data = {'label': 'noop', 'domain': d, 'ip': "128.193.0.10"} self.do_add_record(data)
def test_invalid_add(self): bad = "asfda.as df" dom = Domain(name=bad) self.assertRaises(ValidationError, dom.save) bad = "." dom = Domain(name=bad) self.assertRaises(ValidationError, dom.save) bad = "edu. " dom = Domain(name=bad) self.assertRaises(ValidationError, dom.save) bad = "" dom = Domain(name=bad) self.assertRaises(ValidationError, dom.save) bad = "!@#$" dom = Domain(name=bad) self.assertRaises(ValidationError, dom.save)
def test_chain_soa_domain_add(self): data = {'primary': "ns1.foo.com", 'contact': "email.foo.com"} soa = SOA(**data) soa.save() d0 = Domain(name='com') d0.save() d1 = Domain(name='foo.com', soa=soa) d1.save() self.assertTrue(soa == d1.soa) d2 = Domain(name='bar.foo.com', soa=soa) d2.save() self.assertTrue(soa == d2.soa) d3 = Domain(name='new.foo.com', soa=soa) d3.save() self.assertTrue(soa == d3.soa) d4 = Domain(name='far.bar.foo.com', soa=soa) d4.save() self.assertTrue(soa == d4.soa) d5 = Domain(name='tee.new.foo.com', soa=soa) d5.save() self.assertTrue(soa == d5.soa) d5.delete() d4.delete() self.assertTrue(soa == d1.soa) self.assertTrue(soa == d2.soa) self.assertTrue(soa == d3.soa)
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_soa_validators(self): m = Domain(name='moo') m.save() f_m = Domain(name='foo.moo') f_m.save() n_f_m = Domain(name='noo.foo.moo') n_f_m.save() b_m = Domain(name='baz.moo') b_m.save() s = SOA(primary="ns1.foo.com", contact="asdf", description="test") s.save() f_m.soa = s f_m.save() b_m.soa = s self.assertRaises(ValidationError, b_m.save) n_f_m = Domain.objects.get(pk=n_f_m.pk) # Refresh object n_f_m.soa = s n_f_m.save() m.soa = s m.save() b_m.soa = s b_m.save() m.soa = None self.assertRaises(ValidationError, m.save) s2 = SOA(primary="ns1.foo.com", contact="asdf", description="test2") s2.save() m.soa = s2 self.assertRaises(ValidationError, m.save)
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_existing_cname_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) cn = CNAME(domain=t_dom, label="no", target="asdf") cn.full_clean() cn.save() name = "no.to.bo" n_dom = Domain(name=name, delegated=False) self.assertRaises(ValidationError, n_dom.save)
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 setUp(self): self.d = Domain(name="com") self.s = Network(network_str="1234:1234:1234::/16", ip_type='6') self.s.update_network() self.s.save() self.s1 = Network(network_str="1234:1134:1234::/32", ip_type='6') self.s1.update_network() self.s1.save() self.s2 = Network(network_str="fff::/4", ip_type='6') self.s2.update_network() self.s2.save() self.s3 = Network(network_str="ffff::/4", ip_type='6') self.s3.update_network() self.s3.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_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)