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