def test_integration5_ip(self):
root_domain = create_fake_zone("wee5.wee.mozilla.com", "")
create_fake_zone("10.in-addr.arpa", "")
res, error = self.search("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 = self.search(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = self.search("10.0.0.2")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
def test_integration5_ip(self):
root_domain = create_fake_zone("wee5.wee.mozilla.com", "")
create_fake_zone("10.in-addr.arpa", "")
res, error = self.search("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 = self.search(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = self.search("10.0.0.2")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
def test_integration1(self):
create_fake_zone("wee.wee.mozilla.com", "")
res, error = self.search("wee.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("wee1.wee.mozilla.com", "")
res, error = self.search("wee1.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
res, error = self.search("wee1.wee.mozilla.com OR "
"wee.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 2)
self.assertEqual(len(res['NS']), 2)
self.assertEqual(len(res['DOMAIN']), 2)
res, error = self.search("wee1.wee.mozilla.com type=:SOA")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['DOMAIN']), 0)
res, error = self.search("wee1.wee.mozilla.com type=:NS OR "
"wee.wee.mozilla.com type=:DOMAIN")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
def test_integration1(self):
create_fake_zone("wee.wee.mozilla.com", "")
res, error = self.search("wee.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("wee1.wee.mozilla.com", "")
res, error = self.search("wee1.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
res, error = self.search("wee1.wee.mozilla.com OR "
"wee.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 2)
self.assertEqual(len(res['NS']), 2)
self.assertEqual(len(res['DOMAIN']), 2)
res, error = self.search("wee1.wee.mozilla.com type=:SOA")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['DOMAIN']), 0)
res, error = self.search(
"wee1.wee.mozilla.com type=:NS OR "
"wee.wee.mozilla.com type=:DOMAIN")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 1)
self.assertEqual(len(res['DOMAIN']), 1)
def setUp(self):
self.g = create_fake_zone("gz", suffix="")
self.c_g = create_fake_zone("coo.gz", suffix="")
self.d = create_fake_zone("dz", suffix="")
self.r1 = create_fake_zone("10.in-addr.arpa", suffix="")
self.r1.save()
self.s = System()
self.s.save()
def setUp(self):
self.g = create_fake_zone("gz", suffix="")
self.c_g = create_fake_zone("coo.gz", suffix="")
self.d = create_fake_zone("dz", suffix="")
self.r1 = create_fake_zone("10.in-addr.arpa", suffix="")
self.r1.save()
self.s = System()
self.s.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_build_zone(self):
create_fake_zone('asdf1')
b = DNSBuilder(STAGE_DIR=self.stage_dir, PROD_DIR=self.prod_dir,
LOCK_FILE=self.lock_file, LOG_SYSLOG=False,
FIRST_RUN=True, PUSH_TO_PROD=False,
STOP_UPDATE_FILE=self.stop_update_file)
b.build_dns()
create_fake_zone('asdf2')
b.build_dns()
create_fake_zone('asdf3')
create_fake_zone('asdf4')
b.build_dns()
create_fake_zone('asdf5')
b.build_dns()
def generic_check(self, obj, do_label=True, label_prefix=""):
# 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)
if do_label:
# NS records don't like labels
label = label_prefix + label
obj.label = label
obj.domain = the_domain
obj.save()
fqdn = "bar.x.y.xx.foo.foo22"
label, new_domain = ensure_label_domain(fqdn)
obj.domain = new_domain
obj.save()
# The original domain should have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22"))
# Make sure no objects were harmed.
self.assertTrue(obj.__class__.objects.get(pk=obj.pk))
obj.delete()
# The new domain should now have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
def test_bad_nameserver_soa_state_case_3_2(self):
# This is Case 3 ... with ptrs
root_domain = create_fake_zone("32.in-addr.arpa", suffix="")
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.
ptr = PTR(name="asdf", ip_str="32.1.1.1", ip_type="4")
ptr.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_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 setUp(self):
self.system = System()
self.system.save()
d1 = create_fake_zone("oregonstate.com", suffix="")
soa = d1.soa
self.soa = soa
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.oregonstate.com")
d.soa = soa
d.save()
d1, _ = Domain.objects.get_or_create(name="corp.phx1.oregonstate.com")
d1.soa = soa
d1.save()
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.oregonstate.com")
d2.soa = soa
d2.save()
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0", end_str="15.0.0.10",
network=n, ip_type='4')
r.clean()
r.save()
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_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_bad_nameserver_soa_state_case_3_2(self):
# This is Case 3 ... with ptrs
root_domain = create_fake_zone("32.in-addr.arpa", suffix="")
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.
ptr = PTR(name="asdf", ip_str="32.1.1.1", ip_type="4")
ptr.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_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 setUp(self):
self.r1 = create_fake_zone("10.in-addr.arpa", suffix="")
self.sr = self.r1.soa
self.sr.dirty = False
self.sr.save()
self.dom = create_fake_zone("bgaz", suffix="")
self.soa = self.dom.soa
self.soa.dirty = False
self.soa.save()
self.rdom = create_fake_zone("123.in-addr.arpa", suffix="")
self.rsoa = self.r1.soa
self.rsoa.dirty = False
self.rsoa.save()
self.s = System()
self.s.save()
def test_integration2(self):
root_domain = create_fake_zone("wee2.wee.mozilla.com", "")
res, error = self.search("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 = self.search("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 = self.search("host1.wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 1)
res, error = self.search("host1.wee2.wee.mozilla.com type=:A")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 0)
res, error = self.search("host1.wee2.wee.mozilla.com type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 1)
res, error = self.search("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 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.i6_arpa = self.create_domain(name='ip6.arpa')
self.i6_arpa.save()
self.domain = create_fake_zone('foo.mozilla.com', suffix='')
self.s = System.objects.create(name='mozilla.com')
def test_integration2(self):
root_domain = create_fake_zone("wee2.wee.mozilla.com", "")
res, error = self.search("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 = self.search("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 = self.search("host1.wee2.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 1)
res, error = self.search("host1.wee2.wee.mozilla.com type=:A")
self.assertFalse(error)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['PTR']), 0)
res, error = self.search("host1.wee2.wee.mozilla.com type=:PTR")
self.assertFalse(error)
self.assertEqual(len(res['A']), 0)
self.assertEqual(len(res['PTR']), 1)
res, error = self.search("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_basic_add_remove6(self):
# Make sure CNAME record block
f_c = create_fake_zone("foo.foo1", suffix="")
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_1_4(self):
# This is Case 1 ... with StaticInterfaces's
reverse_root_domain = create_fake_zone("14.in-addr.arpa", suffix="")
root_domain = create_fake_zone("asdf14")
for ns in root_domain.nameserver_set.all():
ns.delete()
# At his point we should have a domain at the root of a zone with no
# other records in it.
# Let's create a child domain and try to add a record there.
cdomain = Domain(name="10.14.in-addr.arpa")
cdomain.soa = reverse_root_domain.soa
cdomain.save()
# Adding a record shouldn't be allowed because there is no NS record on
# the zone's root domain.
intr = StaticInterface(
label="asdf", domain=root_domain, ip_str="14.10.1.1", ip_type="4",
mac="11:22:33:44:55:66", system=self.s)
self.assertRaises(ValidationError, intr.save)
def test_too_many_config_lines_changed(self):
create_fake_zone('asdf86')
root_domain1 = create_fake_zone('asdf87')
root_domain2 = create_fake_zone('asdf88')
root_domain3 = create_fake_zone('asdf89')
b = DNSBuilder(STAGE_DIR=self.stage_dir, PROD_DIR=self.prod_dir,
LOCK_FILE=self.lock_file, LOG_SYSLOG=False,
FIRST_RUN=True, PUSH_TO_PROD=True,
STOP_UPDATE_FILE=self.stop_update_file)
b.build_dns()
for ns in root_domain1.nameserver_set.all():
ns.delete()
b.build_dns() # One zone removed should be okay
for ns in root_domain2.nameserver_set.all():
ns.delete()
for ns in root_domain3.nameserver_set.all():
ns.delete()
self.assertRaises(BuildError, b.build_dns)
def test_basic_add_remove7(self):
# try a star record
f_c = create_fake_zone("foo.foo2", suffix="")
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "*.x.y.z.foo.foo2"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual('*', label)
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_1_2(self):
# This is Case 1 ... with ptr's
root_domain = create_fake_zone("12.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.
# 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="12.10.1.1", ip_type="4")
self.assertRaises(ValidationError, ptr.save)
def test_integration4_ip_range(self):
create_fake_zone("wee3.wee.mozilla.com", "")
create_fake_zone("1.2.ip6.arpa", "")
res, error = self.search("1.2.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="2111:0::",
ip_type="6")
ptr.save()
res, error = self.search(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 0)
res, error = self.search("2111:0:0::")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
def test_bad_nameserver_soa_state_case_2_2(self):
# This is Case 2 ... with ptrs
root_domain = create_fake_zone("22.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.
ptr = PTR(name="asdf", ip_str="22.1.1.1", ip_type="4")
ptr.save()
self.assertRaises(ValidationError, ns.delete)
def test_bad_nameserver_soa_state_case_2_2(self):
# This is Case 2 ... with ptrs
root_domain = create_fake_zone("22.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.
ptr = PTR(name="asdf", ip_str="22.1.1.1", ip_type="4")
ptr.save()
self.assertRaises(ValidationError, ns.delete)
def test_bad_nameserver_soa_state_case_1_2(self):
# This is Case 1 ... with ptr's
root_domain = create_fake_zone("12.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.
# 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="12.10.1.1", ip_type="4")
self.assertRaises(ValidationError, ptr.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 test_integration4_ip_range(self):
create_fake_zone("wee3.wee.mozilla.com", "")
create_fake_zone("1.2.ip6.arpa", "")
res, error = self.search("1.2.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="2111:0::",
ip_type="6")
ptr.save()
res, error = self.search(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 0)
res, error = self.search("2111:0:0::")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
def test_bad_nameserver_soa_state_case_1_4(self):
# This is Case 1 ... with StaticInterfaces's
reverse_root_domain = create_fake_zone("14.in-addr.arpa", suffix="")
root_domain = create_fake_zone("asdf14")
for ns in root_domain.nameserver_set.all():
ns.delete()
# At his point we should have a domain at the root of a zone with no
# other records in it.
# Let's create a child domain and try to add a record there.
cdomain = Domain(name="10.14.in-addr.arpa")
cdomain.soa = reverse_root_domain.soa
cdomain.save()
# Adding a record shouldn't be allowed because there is no NS record on
# the zone's root domain.
intr = StaticInterface(label="asdf",
domain=root_domain,
ip_str="14.10.1.1",
ip_type="4",
mac="11:22:33:44:55:66",
system=self.s)
self.assertRaises(ValidationError, intr.save)
def test_bad_nameserver_soa_state_case_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_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 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_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_integration3_zone(self):
root_domain = create_fake_zone("wee3.wee.mozilla.com", "")
res, error = self.search("zone=:wee3.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
cn = CNAME(label="host1", domain=root_domain, target="whop.whop")
cn.save()
res, error = self.search("zone=:wee3.wee.mozilla.com host1")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['CNAME']), 1)
res, error = self.search("zone=:wee3.wee.mozilla.com " "type=:CNAME")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['CNAME']), 1)
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_basic_add_remove4(self):
# Move a record down the tree testing prune's ability to not delete
# stuff.
f_c = create_fake_zone("foo.goo", suffix="")
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_integration3_zone(self):
root_domain = create_fake_zone("wee3.wee.mozilla.com", "")
res, error = self.search("zone=:wee3.wee.mozilla.com")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 1)
self.assertEqual(len(res['NS']), 1)
cn = CNAME(label="host1", domain=root_domain, target="whop.whop")
cn.save()
res, error = self.search("zone=:wee3.wee.mozilla.com host1")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['CNAME']), 1)
res, error = self.search("zone=:wee3.wee.mozilla.com "
"type=:CNAME")
self.assertFalse(error)
self.assertEqual(len(res['SOA']), 0)
self.assertEqual(len(res['NS']), 0)
self.assertEqual(len(res['CNAME']), 1)
def test_basic_add_remove8(self):
# Make sure a record's label is changed to '' when a domain with the
# same name as it's fqdn is created.
f_c = create_fake_zone("foo.foo3", suffix="")
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "www.x.y.z.foo.foo3"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual('www', label)
self.assertEqual('x.y.z.foo.foo3', the_domain.name)
self.assertTrue(the_domain.pk)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
fqdn = "*.www.x.y.z.foo.foo3"
label2, the_domain2 = ensure_label_domain(fqdn)
cname = CNAME.objects.get(fqdn=cname.fqdn)
self.assertEqual('', cname.label)
self.assertEqual('www.x.y.z.foo.foo3', cname.domain.name)
self.assertEqual('*', label2)
self.assertEqual('www.x.y.z.foo.foo3', the_domain2.name)
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
f_c = create_fake_zone("foo.foo", suffix="")
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_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 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 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_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_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()
