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)
