def test_bad_nameserver_soa_state_case_3_0(self):
# This is Case 3
root_domain = create_fake_zone("asdf30")
for ns in root_domain.nameserver_set.all():
ns.delete()
soa = ns.domain.soa
ns.domain.soa = None
root_domain.soa = None # Shit's getting cached
ns.domain.save()
soa.delete()
# At his point we should have a domain pointed at no SOA record with no
# records attached to it. It also has no child domains.
# Add a record to the domain.
a = AddressRecord(
label='', domain=root_domain, ip_type="6", ip_str="1::")
a.save()
s = SOA(primary="asdf.asdf", contact="asdf.asdf", description="asdf")
s.save()
root_domain.soa = s
self.assertRaises(ValidationError, root_domain.save)
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_integration5_ip(self):
root_domain = create_fake_zone("wee5.wee.mozilla.com", "")
create_fake_zone("10.in-addr.arpa", "")
res, error = compile_to_django("10.in-addr.arpa OR "
"wee5.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 2)
self.assertEqual(len(res['NS']), 2)
self.assertEqual(len(res['DOMAIN']), 2)
ptr = PTR(name="host1.wee2.wee.mozilla.com", ip_str="10.0.0.1",
ip_type="4")
ptr.save()
addr = AddressRecord(label="host1", domain=root_domain,
ip_str="10.0.0.1", ip_type="4")
addr.save()
res, error = compile_to_django(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = compile_to_django("10.0.0.2")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django("ip=:10.0.0.1")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
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_manual_assign_of_glue(self):
# Test that assigning a different glue record doesn't get overriden by
# the auto assinging during the Nameserver's clean function.
glue = StaticReg.objects.create(
label='ns25', domain=self.f_r, ip_str='128.193.99.10',
ip_type='4', system=self.s
)
data = {'domain': self.f_r, 'server': 'ns25.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.glue, glue)
glue2 = AddressRecord(label='ns25', domain=self.f_r, ip_str=
'128.193.1.78', ip_type='4')
glue2.clean()
glue2.save()
ns.clean()
# Make sure things didn't get overriden.
self.assertEqual(ns.glue, glue)
ns.glue = glue2
ns.save()
# Refresh the object
ns = Nameserver.objects.get(pk=ns.pk)
# Again, Make sure things didn't get overriden.
self.assertEqual(ns.glue, glue2)
# Make sure we still can't delete.
self.assertRaises(ValidationError, glue2.delete)
self.assertRaises(ValidationError, ns.glue.delete)
# We shuold be able to delelte the other one.
glue.delete()
def test2(self):
ip_start = "10.0.1.0"
ip_end = "10.0.1.99"
ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type="4")
ptr.full_clean()
ptr.save()
a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.1.3", ip_type="4")
a.full_clean()
a.save()
s = create_fake_host(hostname="foo.mozilla.com")
s.save()
sreg = StaticReg.objects.create(label="foo", domain=self.domain, ip_str="10.0.1.4", ip_type="4", system=s)
istart, iend, ipf_q = start_end_filter(ip_start, ip_end, "4")
addrs = list(AddressRecord.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper"))
ptrs = list(PTR.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper"))
sregs = list(StaticReg.objects.filter(ipf_q).order_by("ip_lower").order_by("ip_upper"))
self.assertEqual(a.pk, addrs[0].pk)
self.assertEqual(ptr.pk, ptrs[0].pk)
self.assertEqual(sreg.pk, sregs[0].pk)
range_details = range_usage(ip_start, ip_end, "4")
self.assertEqual(98, range_details["unused"])
self.assertEqual(2, range_details["used"])
self.assertEqual(
[(int(istart) + 0, int(istart) + 2), (int(istart) + 5, int(istart) + 99)], range_details["free_ranges"]
)
def test1(self):
ip_start = "10.0.0.10"
ip_end = "10.0.0.19"
ptr = PTR(name="foo.mz", ip_str="10.0.0.15", ip_type='4')
ptr.full_clean()
ptr.save()
a = AddressRecord(
label="foo", domain=self.domain, ip_str="10.0.0.16", ip_type='4')
a.full_clean()
a.save()
istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4')
addrs = list(AddressRecord.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
ptrs = list(PTR.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
intrs = list(StaticInterface.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
self.assertEqual(a.pk, addrs[0].pk)
self.assertEqual(ptr.pk, ptrs[0].pk)
self.assertFalse(intrs)
range_details = range_usage(ip_start, ip_end, '4')
self.assertEqual(8, range_details['unused'])
self.assertEqual(2, range_details['used'])
self.assertEqual([(int(istart), int(istart) + 4),
(int(istart) + 7, int(istart) + 9)],
range_details['free_ranges'])
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_update_glue_to_no_glue(self):
glue = AddressRecord(label='ns3', domain=self.r,
ip_str='128.193.1.10', ip_type='4')
glue.save()
data = {'domain': self.r, 'server': 'ns3.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
ns.server = "ns4.wee"
ns.save()
self.assertTrue(ns.glue is None)
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_basic_add_remove9(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
fqdn = "y.z.foo.foo22"
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))
f_c = create_fake_zone("y.z.foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
def test_delete_ns(self):
glue = AddressRecord(label='ns4', domain=self.f_r,
ip_str='128.196.1.10', ip_type='4')
glue.save()
data = {'domain': self.f_r, 'server': 'ns4.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.server, ns.glue.fqdn)
ns.delete()
nsret = Nameserver.objects.filter(
server='ns2.foo.ru', domain=self.f_r)
self.assertFalse(nsret)
def test_existing_record_new_domain(self):
name = "bo"
b_dom, _ = Domain.objects.get_or_create(name=name, delegated=False)
name = "to.bo"
t_dom, _ = Domain.objects.get_or_create(name=name, delegated=False)
arec1 = AddressRecord(label="no", domain=t_dom, ip_str="128.193.99.9",
ip_type='4')
arec1.save()
name = "no.to.bo"
n_dom = Domain(name=name, delegated=False)
self.assertRaises(ValidationError, n_dom.save)
def test_bad_nameserver_soa_state_case_2_0(self):
# This is Case 2
root_domain = create_fake_zone("asdf20")
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.
a = AddressRecord(
label='', domain=root_domain, ip_type="6", ip_str="1::")
a.save()
self.assertRaises(ValidationError, ns.delete)
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())
def test_basic_add_remove9(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
fqdn = "y.z.foo.foo22"
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))
f_c = create_fake_zone("y.z.foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
def test_invalid_create(self):
glue = AddressRecord(label='ns2', domain=self.r,
ip_str='128.193.1.10', ip_type='4')
glue.save()
data = {'domain': self.r, 'server': 'ns2 .ru'}
self.assertRaises(ValidationError, self.do_add, **data)
data = {'domain': self.r, 'server': 'ns2$.ru'}
self.assertRaises(ValidationError, self.do_add, **data)
data = {'domain': self.r, 'server': 'ns2..ru'}
self.assertRaises(ValidationError, self.do_add, **data)
data = {'domain': self.r, 'server': 'ns2.ru '}
self.assertRaises(ValidationError, self.do_add, **data)
data = {'domain': self.r, 'server': ''}
self.assertRaises(ValidationError, self.do_add, **data)
def test_existing_record_new_domain(self):
name = "bo"
b_dom, _ = Domain.objects.get_or_create(name=name, delegated=False)
name = "to.bo"
t_dom, _ = Domain.objects.get_or_create(name=name, delegated=False)
arec1 = AddressRecord(label="no",
domain=t_dom,
ip_str="128.193.99.9",
ip_type='4')
arec1.save()
name = "no.to.bo"
n_dom = Domain(name=name, delegated=False)
self.assertRaises(ValidationError, n_dom.save)
def test2_bad_add_for_a_ptr(self):
# PTR and A exist, then try add sreg
label = "9988fdfood"
domain = self.c
ip_str = "1112::11:22:33:44:55:66"
kwargs = {'label': label, 'domain': domain,
'ip_str': ip_str}
ip_type = '6'
a = AddressRecord(label=label, domain=domain, ip_str=ip_str,
ip_type=ip_type)
a.clean()
a.save()
ptr = PTR(ip_str=ip_str, ip_type=ip_type, name=a.fqdn)
ptr.clean()
ptr.save()
self.assertRaises(ValidationError, self.do_add, **kwargs)
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())
def test_delegation(self):
name = "boom"
dom = Domain(name=name, delegated=True)
dom.save()
# Creating objects in the domain should be locked.
arec = AddressRecord(label="ns1", domain=dom, ip_str="128.193.99.9",
ip_type='4')
self.assertRaises(ValidationError, arec.save)
ns = Nameserver(domain=dom, server="ns1." + dom.name)
self.assertRaises(ValidationError, ns.save)
cn = CNAME(label="999asdf", domain=dom, target="asdf.asdf")
self.assertRaises(ValidationError, cn.full_clean)
# Undelegate (unlock) the domain.
dom.delegated = False
dom.save()
# Add glue and ns record.
arec.save()
ns.save()
# Re delegate the domain.
dom.delegated = True
dom.save()
# Creation should still be locked
arec1 = AddressRecord(
label="ns2", domain=dom, ip_str="128.193.99.9", ip_type='4')
self.assertRaises(ValidationError, arec1.save)
cn1 = CNAME(label="1000asdf", domain=dom, target="asdf.asdf")
self.assertRaises(ValidationError, cn1.full_clean)
# Editing should be allowed.
arec = AddressRecord.objects.get(pk=arec.pk)
arec.ip_str = "129.193.88.2"
arec.save()
# Adding new A records that have the same name as an NS should
# be allowed.
arec1 = AddressRecord(label="ns1", domain=dom, ip_str="128.193.100.10",
ip_type='4')
arec1.save()
def test_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)
def migrate_AAAA(zone, root_domain, soa, views):
for (name, ttl, rdata) in zone.iterate_rdatas('AAAA'):
name = name.to_text().strip('.')
print str(name) + " AAAA " + str(rdata)
exists_domain = Domain.objects.filter(name=name)
if exists_domain:
label = ''
domain = exists_domain[0]
else:
label = name.split('.')[0]
if label.startswith('unused'):
continue
domain_name = '.'.join(name.split('.')[1:])
domain = ensure_domain(domain_name, force=True)
ip_upper, ip_lower = ipv6_to_longs(rdata.to_text())
if AddressRecord.objects.filter(label=label,
domain=domain, ip_upper=ip_upper, ip_lower=ip_lower,
ip_type='6').exists():
a = AddressRecord.objects.get(
label=label, domain=domain, ip_type='6', ip_upper=ip_upper,
ip_lower=ip_lower
)
else:
a = AddressRecord(
label=label, domain=domain, ip_str=rdata.to_text(),
ip_type='6', description=rdata.comment, ttl=ttl
)
a.clean()
a.save()
for view in views:
a.views.add(view)
a.save()
def test_cleanup_address(self):
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
fqdn = "bar.x.y.z.foo.poo"
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()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
def test_integration2(self):
root_domain = create_fake_zone("wee2.wee.mozilla.com", "")
res, error = compile_to_django("wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
create_fake_zone("1.1.ip6.arpa", "")
res, error = compile_to_django("1.1.ip6.arpa")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
ptr = PTR(name="host1.wee2.wee.mozilla.com",
ip_str="1111::",
ip_type="6")
ptr.save()
addr = AddressRecord(label="host1",
domain=root_domain,
ip_str="11::",
ip_type="6")
addr.save()
res, error = compile_to_django("host1.wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 1)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:A")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 0)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 1)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:A "
"type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 0)
def test_private_view_case_1_addr(self):
a = AddressRecord(label="asf", domain=self.f_o, ip_str="10.0.0.1",
ip_type="4")
a.clean()
a.save()
# Object has to exist before views can be assigned.
a.views.add(self.private)
a.save()
def test_address_record_cname_exists(self):
label = "testyfoo"
data = "wat"
dom, _ = Domain.objects.get_or_create(name="cd")
dom, _ = Domain.objects.get_or_create(name="what.cd")
CNAME.objects.get_or_create(label=label, domain=dom, target=data)
rec = AddressRecord(label=label, domain=dom, ip_str="128.193.1.1")
self.assertRaises(ValidationError, rec.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_integration2(self):
root_domain = create_fake_zone("wee2.wee.mozilla.com", "")
res, error = compile_to_django("wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
create_fake_zone("1.1.ip6.arpa", "")
res, error = compile_to_django("1.1.ip6.arpa")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
ptr = PTR(name="host1.wee2.wee.mozilla.com", ip_str="1111::",
ip_type="6")
ptr.save()
addr = AddressRecord(label="host1", domain=root_domain, ip_str="11::",
ip_type="6")
addr.save()
res, error = compile_to_django("host1.wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 1)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:A")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 0)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 1)
res, error = compile_to_django("host1.wee2.wee.mozilla.com type=:A "
"type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 0)
def test1(self):
ip_start = "10.0.0.10"
ip_end = "10.0.0.19"
ptr = PTR(name="foo.mz", ip_str="10.0.0.15", ip_type='4')
ptr.full_clean()
ptr.save()
a = AddressRecord(label="foo",
domain=self.domain,
ip_str="10.0.0.16",
ip_type='4')
a.full_clean()
a.save()
istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4')
addrs = list(
AddressRecord.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
ptrs = list(
PTR.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
sregs = list(
StaticReg.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
self.assertEqual(a.pk, addrs[0].pk)
self.assertEqual(ptr.pk, ptrs[0].pk)
self.assertFalse(sregs)
range_details = range_usage(ip_start, ip_end, '4')
self.assertEqual(8, range_details['unused'])
self.assertEqual(2, range_details['used'])
self.assertEqual([(int(istart), int(istart) + 4),
(int(istart) + 7, int(istart) + 9)],
range_details['free_ranges'])
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_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 do_add_a(self, label, domain, ip_str, ip_type='4'):
a = AddressRecord(label=label,
domain=domain,
ip_str=ip_str,
ip_type=ip_type)
a.clean()
a.save()
return a
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_basic_add_remove5(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
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_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
})
def test_add_ns_in_domain(self):
# Use an A record as a glue record.
glue = AddressRecord(label='ns2',
domain=self.r,
ip_str='128.193.1.10',
ip_type='4')
glue.clean()
glue.save()
data = {'domain': self.r, 'server': 'ns2.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.server, ns.glue.fqdn)
self.assertRaises(ValidationError, glue.delete)
glue = AddressRecord(label='ns3',
domain=self.f_r,
ip_str='128.193.1.10',
ip_type='4')
glue.save()
data = {'domain': self.f_r, 'server': 'ns3.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.server, ns.glue.fqdn)
def test2(self):
ip_start = "10.0.1.0"
ip_end = "10.0.1.99"
ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type='4')
ptr.full_clean()
ptr.save()
a = AddressRecord(label="foo", domain=self.domain, ip_str="10.0.1.3",
ip_type='4')
a.full_clean()
a.save()
s = System()
s.save()
intr = StaticInterface(
label="foo", domain=self.domain, ip_str="10.0.1.4",
ip_type='4', system=s, mac="00:11:22:33:44:55")
intr.full_clean()
intr.save()
istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4')
addrs = list(AddressRecord.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
ptrs = list(PTR.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
intrs = list(StaticInterface.objects.filter(ipf_q).
order_by('ip_lower').order_by('ip_upper'))
self.assertEqual(a.pk, addrs[0].pk)
self.assertEqual(ptr.pk, ptrs[0].pk)
self.assertEqual(intr.pk, intrs[0].pk)
range_details = range_usage(ip_start, ip_end, '4')
self.assertEqual(98, range_details['unused'])
self.assertEqual(2, range_details['used'])
self.assertEqual([(int(istart) + 0, int(istart) + 2),
(int(istart) + 5, int(istart) + 99)],
range_details['free_ranges'])
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 test_disallow_name_update_of_glue_A(self):
# Glue records should not be allowed to change their name.
glue = AddressRecord(label='ns39',
domain=self.f_r,
ip_str='128.193.1.77',
ip_type='4')
glue.clean()
glue.save()
data = {'domain': self.f_r, 'server': 'ns39.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.glue, glue)
glue.label = "ns22"
self.assertRaises(ValidationError, glue.clean)
def test1_bad_add_for_a_ptr(self):
# sreg exists, then try ptr and A
label = "9988food"
domain = self.c
ip_str = "10.0.0.1"
kwargs = {
'label': label, 'domain': domain, 'ip_str': ip_str,
}
ip_type = '4'
i = self.do_add(**kwargs)
i.clean()
i.save()
a = AddressRecord(label=label, domain=domain, ip_str=ip_str,
ip_type=ip_type)
self.assertRaises(ValidationError, a.save)
ptr = PTR(ip_str=ip_str, ip_type=ip_type, name=i.fqdn)
self.assertRaises(ValidationError, ptr.save)
def test1_bad_add_for_a_ptr(self):
# StaticReg exists, then try ptr and A
label = "9988fooddfdf"
domain = self.c
ip_str = "111::11:22:33:44:55:6e"
kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str}
ip_type = '6'
i = self.do_add(**kwargs)
i.clean()
i.save()
a = AddressRecord(label=label,
domain=domain,
ip_str=ip_str,
ip_type=ip_type)
self.assertRaises(ValidationError, a.clean)
ptr = PTR(ip_str=ip_str, ip_type=ip_type, name=i.fqdn)
self.assertRaises(ValidationError, ptr.clean)
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 test_add_ns_in_domain(self):
# Use an A record as a glue record.
glue = AddressRecord(label='ns2', domain=self.r,
ip_str='128.193.1.10', ip_type='4')
glue.clean()
glue.save()
data = {'domain': self.r, 'server': 'ns2.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.server, ns.glue.fqdn)
self.assertRaises(ValidationError, glue.delete)
glue = AddressRecord(label='ns3', domain=self.f_r, ip_str=
'128.193.1.10', ip_type='4')
glue.save()
data = {'domain': self.f_r, 'server': 'ns3.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.server, ns.glue.fqdn)
def test_bad_nameserver_soa_state_case_1_0(self):
# This is Case 1
root_domain = create_fake_zone("asdf10")
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.
# Adding a record shouldn't be allowed because there is no NS record on
# the zone's root domain.
a = AddressRecord(label='',
domain=root_domain,
ip_type="6",
ip_str="1::")
self.assertRaises(ValidationError, a.save)
cn = CNAME(label='', domain=root_domain, target="asdf")
self.assertRaises(ValidationError, cn.save)
def test_disallow_name_update_of_glue_A(self):
# Glue records should not be allowed to change their name.
glue = AddressRecord(label='ns39', domain=self.f_r, ip_str=
'128.193.1.77', ip_type='4')
glue.clean()
glue.save()
data = {'domain': self.f_r, 'server': 'ns39.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.glue, glue)
glue.label = "ns22"
self.assertRaises(ValidationError, glue.clean)
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 migrate_AAAA(zone, root_domain, soa, views):
for (name, ttl, rdata) in zone.iterate_rdatas('AAAA'):
name = name.to_text().strip('.')
print str(name) + " AAAA " + str(rdata)
exists_domain = Domain.objects.filter(name=name)
if exists_domain:
label = ''
domain = exists_domain[0]
else:
label = name.split('.')[0]
if label.startswith('unused'):
continue
domain_name = '.'.join(name.split('.')[1:])
domain = ensure_domain(domain_name, force=True)
ip_upper, ip_lower = ipv6_to_longs(rdata.to_text())
if AddressRecord.objects.filter(label=label,
domain=domain,
ip_upper=ip_upper,
ip_lower=ip_lower,
ip_type='6').exists():
a = AddressRecord.objects.get(label=label,
domain=domain,
ip_type='6',
ip_upper=ip_upper,
ip_lower=ip_lower)
else:
a = AddressRecord(label=label,
domain=domain,
ip_str=rdata.to_text(),
ip_type='6',
description=rdata.comment,
ttl=ttl)
a.clean()
a.save()
for view in views:
a.views.add(view)
a.save()
def test2_bad_add_for_a_ptr(self):
# PTR and A exist, then try add sreg
label = "9988fdfood"
domain = self.c
ip_str = "1112::11:22:33:44:55:66"
kwargs = {'label': label, 'domain': domain, 'ip_str': ip_str}
ip_type = '6'
a = AddressRecord(label=label,
domain=domain,
ip_str=ip_str,
ip_type=ip_type)
a.clean()
a.save()
ptr = PTR(ip_str=ip_str, ip_type=ip_type, name=a.fqdn)
ptr.clean()
ptr.save()
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test_basic_add_remove5(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
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 test2(self):
ip_start = "10.0.1.0"
ip_end = "10.0.1.99"
ptr = PTR(name="foo.mz", ip_str="10.0.1.3", ip_type='4')
ptr.full_clean()
ptr.save()
a = AddressRecord(label="foo",
domain=self.domain,
ip_str="10.0.1.3",
ip_type='4')
a.full_clean()
a.save()
s = create_fake_host(hostname="foo.mozilla.com")
s.save()
sreg = StaticReg.objects.create(label="foo",
domain=self.domain,
ip_str="10.0.1.4",
ip_type='4',
system=s)
istart, iend, ipf_q = start_end_filter(ip_start, ip_end, '4')
addrs = list(
AddressRecord.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
ptrs = list(
PTR.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
sregs = list(
StaticReg.objects.filter(ipf_q).order_by('ip_lower').order_by(
'ip_upper'))
self.assertEqual(a.pk, addrs[0].pk)
self.assertEqual(ptr.pk, ptrs[0].pk)
self.assertEqual(sreg.pk, sregs[0].pk)
range_details = range_usage(ip_start, ip_end, '4')
self.assertEqual(98, range_details['unused'])
self.assertEqual(2, range_details['used'])
self.assertEqual([(int(istart) + 0, int(istart) + 2),
(int(istart) + 5, int(istart) + 99)],
range_details['free_ranges'])
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_manual_assign_of_glue(self):
# Test that assigning a different glue record doesn't get overriden by
# the auto assinging during the Nameserver's clean function.
glue = StaticReg.objects.create(label='ns25',
domain=self.f_r,
ip_str='128.193.99.10',
ip_type='4',
system=self.s)
data = {'domain': self.f_r, 'server': 'ns25.foo.ru'}
ns = self.do_add(**data)
self.assertTrue(ns.glue)
self.assertEqual(ns.glue, glue)
glue2 = AddressRecord(label='ns25',
domain=self.f_r,
ip_str='128.193.1.78',
ip_type='4')
glue2.clean()
glue2.save()
ns.clean()
# Make sure things didn't get overriden.
self.assertEqual(ns.glue, glue)
ns.glue = glue2
ns.save()
# Refresh the object
ns = Nameserver.objects.get(pk=ns.pk)
# Again, Make sure things didn't get overriden.
self.assertEqual(ns.glue, glue2)
# Make sure we still can't delete.
self.assertRaises(ValidationError, glue2.delete)
self.assertRaises(ValidationError, ns.glue.delete)
# We shuold be able to delelte the other one.
glue.delete()
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)
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_addrees_record_update(self):
addr = AddressRecord(ip_type='4', ip_str="10.2.3.4")
self.generic_check(addr)
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_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_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)
