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': ['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 setUp(self):
primary = "ns5.oregonstate.edu"
contact = "admin.oregonstate.edu"
retry = 1234
refresh = 1234123
self.soa = SOA(primary=primary, contact=contact,
retry=retry, refresh=refresh)
self.soa.save()
self.g = Domain(name="gz")
self.g.save()
self.c_g = Domain(name="coo.gz")
self.c_g.soa = self.soa
self.c_g.save()
self.d = Domain(name="dz")
self.d.save()
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.r1 = self.create_domain(name="10")
self.r1.save()
self.s = System()
self.s.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"
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_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 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_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_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_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_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 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 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)
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 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)
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 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()
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 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 setUp(self):
s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo",
comment="foo")
self.c = Domain(name='poo')
self.c.save()
self.assertFalse(self.c.purgeable)
self.f_c = Domain(name='foo.poo')
self.f_c.soa = s
self.f_c.save()
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 setUp(self):
s, _ = SOA.objects.get_or_create(primary="foo",
contact="Foo",
comment="foo")
self.c = Domain(name='poo')
self.c.save()
self.assertFalse(self.c.purgeable)
self.f_c = Domain(name='foo.poo')
self.f_c.soa = s
self.f_c.save()
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_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 setUp(self):
self._128 = ReverseDomain( name = '128', ip_type='4')
self._128.save()
boot_strap_ipv6_reverse_domain("8.6.2.0")
self.osu_block = "8620:105:F000:"
self.o = Domain( name = "edu" )
self.o.save()
self.o_e = Domain( name = "oregonstate.edu")
self.o_e.save()
self.b_o_e = Domain( name = "bar.oregonstate.edu")
self.b_o_e.save()
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 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 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_basic_add_remove2(self):
# MAke sure that if a domain is set to not purgeable the prune stops at
# that domain.
c = Domain(name='edu')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.edu')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
description="foo.edu")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.edu"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.edu")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.edu")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.edu"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# See if purgeable stops prune
the_domain.purgeable = False
the_domain.save()
self.assertFalse(prune_tree(the_domain))
the_domain.purgeable = True
the_domain.save()
# Ok, reset
y_z = Domain.objects.get(name="y.z.foo.edu")
y_z.purgeable = False
y_z.save()
# Refresh the domain
the_domain = Domain.objects.get(pk=the_domain.pk)
# This should delete up to and stop at the domain "y.z.foo.edu"
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
# If we delete y.z.foo.com and then call prune on z.foo.com is should
# delete z.foo.com
Domain.objects.get(name="y.z.foo.edu").delete()
self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu")))
self.assertFalse(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
def test2_add_domain(self):
# Some domains have '_' in their name. Make sure validation allows
# this.
c = Domain(name='cz')
c.save()
c1 = Domain(name='_foo.cz')
c1.save()
c2 = Domain(name='moo_foo._foo.cz')
c2.save()
def test_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 allows.
arec1 = AddressRecord(label="ns1",
domain=dom,
ip_str="128.193.100.10",
ip_type='4')
arec1.save()
def setUp(self):
self.r = Domain( name = "ru" )
self.r.save()
self.f_r = Domain( name = "foo.ru" )
self.f_r.save()
self.b_f_r = Domain( name = "bar.foo.ru" )
self.b_f_r.save()
self.f = Domain( name = "fam" )
self.f.save()
self._128 = ReverseDomain( name = '128', ip_type= '4' )
self._128.save()
def setUp(self):
self.d = Domain(name="com")
self.d.save()
Domain(name="arpa").save()
Domain(name="in-addr.arpa").save()
Domain(name="10.in-addr.arpa").save()
self.s = Network(network_str="10.0.0.0/16", ip_type='4')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="10.2.1.0/24", ip_type='4')
self.s1.update_network()
self.s1.save()
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_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_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_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 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 setUp(self):
primary = "ns5.oregonstate.edu"
contact = "admin.oregonstate.edu"
retry = 1234
refresh = 1234123
self.soa = SOA(primary = primary, contact = contact, retry = retry, refresh = refresh)
self.soa.save()
self.g = Domain(name = "gz")
self.g.save()
self.c_g = Domain(name = "coo.gz")
self.c_g.soa = self.soa
self.c_g.save()
self.d = Domain(name = "dz")
self.d.save()
def setUp(self):
self.arpa = self.create_domain(name='arpa')
self.arpa.save()
self.i_arpa = self.create_domain(name='in-addr.arpa')
self.i_arpa.save()
self.c = Domain(name="ccc")
self.c.save()
self.f_c = Domain(name="foo.ccc")
self.f_c.save()
self.r1 = self.create_domain(name="10")
self.r1.save()
self.n = System()
self.n.clean()
self.n.save()
def setUp(self):
self.o = Domain(name="org")
self.o.save()
self.f_o = Domain(name="foo.org")
self.f_o.save()
self.s = System()
Domain.objects.get_or_create(name="arpa")
Domain.objects.get_or_create(name="in-addr.arpa")
Domain.objects.get_or_create(name="10.in-addr.arpa")
Domain.objects.get_or_create(name="172.in-addr.arpa")
Domain.objects.get_or_create(name="192.in-addr.arpa")
self.public, _ = View.objects.get_or_create(name="public")
self.private, _ = View.objects.get_or_create(name="private")
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 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 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 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 setUp(self):
Domain.objects.get_or_create(name="arpa")
Domain.objects.get_or_create(name="in-addr.arpa")
self.r1, _ = Domain.objects.get_or_create(name="10.in-addr.arpa")
Domain.objects.get_or_create(name="edu")
Domain(name="oregonstate.edu")
super(MockBuildScriptTests, self).setUp()
self.stop_update_file = '/tmp/fake/stop.update'
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 setUp(self):
self.arpa = self.create_domain(name='arpa')
self.arpa.save()
self.i_arpa = self.create_domain(name='ip6.arpa', ip_type='6')
self.i_arpa.save()
self.c = Domain(name="ccc")
self.c.save()
self.f_c = Domain(name="foo.ccc")
self.f_c.save()
self.r1 = self.create_domain(name="0", ip_type='6')
self.r1.save()
self.r2 = self.create_domain(name="1", ip_type='6')
self.r2.save()
self.n = System()
self.n.clean()
self.n.save()
def setUp(self):
self.arpa = self.create_domain(name='arpa')
self.arpa.save()
self.i_arpa = self.create_domain(name='ip6.arpa', ip_type='6')
self.i_arpa.save()
self.c = Domain(name="ccc")
self.c.save()
self.f_c = Domain(name="foo.ccc")
self.f_c.save()
self.r1 = self.create_domain(name="0", ip_type='6')
self.r1.save()
self.r2 = self.create_domain(name="1", ip_type='6')
self.r2.save()
self.n = System()
self.n.clean()
self.n.save()
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__name_to_master_domain(self):
self.assertRaises(
ValidationError, Domain.objects.create, name='foo.cn')
Domain(name='cn').save()
d = Domain.objects.create(name='foo.cn')
self.assertRaises(
ValidationError, Domain.objects.create, name='foo.cn')
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))
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)
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()
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)
