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_integration4_ip(self):
create_fake_zone("wee3.wee.mozilla.com", "")
create_fake_zone("1.2.ip6.arpa", "")
res, error = compile_to_django("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 = compile_to_django(ptr.ip_str)
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django("2111:0:0::")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django("ip=:2111:0:0::")
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django("ip=:2111:1:0::")
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 = compile_to_django("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 = compile_to_django("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 = compile_to_django("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 = compile_to_django("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 = compile_to_django(
"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):
View.objects.create(name="public")
View.objects.create(name="private")
self.d = create_fake_zone('foo.com', suffix="")
self.rd = create_fake_zone('10.in-addr.arpa', suffix="")
self.client = Client()
self.s = create_fake_host(hostname='exists.mozilla.com')
def setUp(self):
create_fake_zone('10.in-addr.arpa', suffix='')
self.domain = create_fake_zone('foo.mozilla.com', suffix='')
self.s = create_fake_host(hostname='foo.mozilla.com')
self.sreg = StaticReg.objects.create(
label='', domain=self.domain, ip_str='10.0.0.1', ip_type='4',
system=self.s
)
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 = create_fake_host(hostname="foo.mozilla.com")
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 setUp(self):
self.num = 0
create_fake_zone('2.ip6.arpa', suffix="")
self.domain = create_fake_zone('foo.mozilla.com', suffix='')
self.s = create_fake_host(hostname='foo.mozilla.com')
self.sreg = StaticReg.objects.create(
label='', domain=self.domain, ip_str='2222:123::', ip_type='6',
system=self.s
)
self.s = create_fake_host(hostname='foobar.mozilla.com')
self.g = Group.objects.create(name='foobar')
super(HWAdapterTest, self).setUp()
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 setUp(self):
self.system = System()
d1 = create_fake_zone("mozilla.com.com", suffix="")
soa = d1.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.mozilla.com.com")
d.soa = soa
d.save()
d1, _ = Domain.objects.get_or_create(name="corp.phx1.mozilla.com.com")
d1.soa = soa
d1.save()
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.mozilla.com.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="ip6.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="2.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)
r.clean()
r.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_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_extend_doesnt_touch(self):
# When we create a new domain, ensure that things are not touched
root_domain = create_fake_zone("foo.mozilla.com", suffix="")
shouldnt_be_touched = AddressRecord.objects.create(
label='', domain=root_domain, ip_str='10.0.0.1', ip_type='4'
)
# Extend the tree
label, baz_domain = ensure_label_domain('bar.baz.foo.mozilla.com')
AddressRecord.objects.create(
label=label, domain=baz_domain, ip_str='10.0.0.1', ip_type='4'
)
# The update() call will bypass the save/clean method of AddressRecord
# so the fqdn of the A will remain unchanged. If our tree extender
# function is touching this record its label will be changed to ''.
AddressRecord.objects.filter(pk=shouldnt_be_touched.pk).update(
label='shouldnt be touched'
)
ensure_label_domain('wee.boo.bar.baz.foo.mozilla.com')
self.assertEqual(
'shouldnt be touched',
AddressRecord.objects.get(pk=shouldnt_be_touched.pk).label
)
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.factory = RequestFactory()
self.private_view, _ = View.objects.get_or_create(name='private')
self.operating_system = OperatingSystem.objects.create(
name='foo', version='1.1'
)
self.system_status = SystemStatus.objects.create(
status='production', color='burgandy', color_code='wtf?'
)
self.allocation = Allocation.objects.create(name='something')
self.system_type = SystemType.objects.create(
type_name='Virtual Server'
)
self.domain = create_fake_zone('foobar.mozilla.com', suffix='')
self.build_domain = create_fake_zone('build.mozilla.org', suffix='')
self.rdomain = create_fake_zone('10.in-addr.arpa', suffix='')
def get_domain_and_post_data(self):
# This is different for classes that have ips instead of fqdns
domain_name = '11.22.11.in-addr.arpa'
root_domain = create_fake_zone(domain_name, suffix="")
post_data = self.post_data()
# Get the '_' in SRV records
post_data['ip_str'] = '11.22.11.1'
return root_domain, post_data
def setUp(self):
self.c = Client()
create_fake_zone('10.in-addr.arpa', suffix='')
root_domain = create_fake_zone('foobar.mozilla.com', suffix='')
system = create_fake_host(hostname="asdf.mozilla.com")
sreg = StaticReg.objects.create(
label='foo', domain=root_domain, system=system,
ip_type='4', ip_str='10.0.0.0'
)
g = Group.objects.create(name="foo")
self.test_objs = (
('groupkeyvalue', g),
('staticregkeyvalue', sreg),
('keyvalue', system),
)
def test_svn_conflict(self):
"""
This uses tasks as a block box measurement to see if conflicts are
being handled
"""
root_domain = create_fake_zone('conflict')
b1 = 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)
b1.build_dns() # This checked stuff in
# Check the repo out somewhere else
command_str = "svn co file://{0} {1}".format(self.svn_repo,
self.prod_dir2)
b1.shell_out(command_str)
# Calculate the path to the zone file so we can tamper with it.
fm = b1.get_file_meta(View.objects.get(name='public'), root_domain,
root_domain.soa)
# Make local changes
fname = fm['prod_fname'].replace(self.prod_dir, self.prod_dir2)
with open(fname, 'a') as fd:
fd.write(";foobar")
# Check those changes in.
b1.PROD_DIR = self.prod_dir2 # Cheat and swap the dirs
b1.vcs_checkin()
b1.PROD_DIR = self.prod_dir # Fix our little cheat
b1.FORCE_BUILD = True # Force a build
# Add something to the end of the file to cause a collision
a = AddressRecord.objects.create(label="zeenada",
domain=root_domain,
ip_type='4',
ip_str='255.0.0.0')
a.views.add(View.objects.get(name='public'))
# We should have conflicts here. See if we detect it by
# counting how many tasks need to be serviced. If the number remains
# the same that means we aborted the build due to a conflict
pre_task_count = Task.objects.all().count()
b1.build_dns()
post_task_count = Task.objects.all().count()
self.assertEqual(pre_task_count, post_task_count)
# Conflicts should be resolved. Let's see if we build successfully
pre_task_count = Task.objects.all().count()
b1.build_dns()
post_task_count = Task.objects.all().count()
self.assertTrue(pre_task_count != 0)
self.assertEqual(0, post_task_count)
def test_svn_conflict(self):
"""
This uses tasks as a block box measurement to see if conflicts are
being handled
"""
root_domain = create_fake_zone('conflict')
b1 = 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)
b1.build_dns() # This checked stuff in
# Check the repo out somewhere elst
command_str = "svn co file://{0} {1}".format(
self.svn_repo, self.prod_dir2
)
b1.shell_out(command_str)
# Calculate the path to the zone file so we can tamper with it.
fm = b1.get_file_meta(
View.objects.get(name='public'), root_domain,
root_domain.soa
)
# Make local changes
fname = fm['prod_fname'].replace(self.prod_dir, self.prod_dir2)
with open(fname, 'a') as fd:
fd.write(";foobar")
# Check those changes in.
b1.PROD_DIR = self.prod_dir2 # Cheat and swap the dirs
b1.vcs_checkin()
b1.PROD_DIR = self.prod_dir # Fix our little cheat
b1.FORCE = True # Force a build
# Add something to the end of the file to cause a collision
a = AddressRecord.objects.create(
label="zeenada", domain=root_domain, ip_type='4',
ip_str='255.0.0.0'
)
a.views.add(View.objects.get(name='public'))
# Alright, we should have conflicts here. See if we detect it by
# counting how many tasks need to be serviced. If the number remains
# the same that means we aborted the build due to a conflict
pre_task_count = Task.objects.all().count()
b1.build_dns()
post_task_count = Task.objects.all().count()
self.assertEqual(pre_task_count, post_task_count)
# Conflicts should be resolved. Let's see if we build successfully
pre_task_count = Task.objects.all().count()
b1.build_dns()
post_task_count = Task.objects.all().count()
self.assertTrue(pre_task_count != 0)
self.assertEqual(0, post_task_count)
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')
create_fake_zone('asdf90')
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)
self.assertTrue(Task.dns_full.all())
self.assertFalse(Task.dns_incremental.all().count())
b.build_dns()
self.assertFalse(Task.dns_full.all())
self.assertFalse(Task.dns_incremental.all())
# deleting one ns
for ns in root_domain1.nameserver_set.all():
ns.delete()
self.assertTrue(Task.dns_full.all())
self.assertEqual(1, Task.dns_incremental.all().count())
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()
b.PUSH_TO_PROD = True
self.assertRaises(BuildError, b.build_dns)
def get_reverse_domain_and_post_data(self):
# This is different for classes that have ips instead of fqdns
domain_name = "3.ip6.arpa"
root_domain = create_fake_zone(domain_name, suffix="")
post_data = self.post_data()
post_data = self.update_rdtype(post_data)
# Get the '_' in SRV records
post_data['ip_str'] = '3000::df12'
return root_domain, post_data
def setUp(self):
self.test_type.objects.all().delete()
self.rdtype = self.test_type().rdtype
self.create_url = "{0}/create/{1}/".format(self.record_base_url,
self.rdtype)
self.update_url_template = self.create_url + "{1}/"
self.c = Client()
self.factory = RequestFactory()
self.domain = create_fake_zone("{0}.{1}.{2}".format(random_label(),
random_label(), random_label()))
self.second_domain = create_fake_zone("{0}.{1}.{2}".format(
random_label(), random_label(), random_label())
)
self.public_view = View.objects.get_or_create(name='public')[0]
self.private_view = View.objects.get_or_create(name='private')[0]
self.system = create_fake_host(hostname="foo.bar.com")
self.system.save()
def get_reverse_domain_and_post_data(self):
# This is different for classes that have ips instead of fqdns
domain_name = "3.ip6.arpa"
root_domain = create_fake_zone(domain_name, suffix="")
post_data = self.post_data()
post_data = self.update_rdtype(post_data)
# Get the '_' in SRV records
post_data['ip_str'] = '3000::df12'
return root_domain, post_data
def setUp(self):
from reversion.models import Version, Revision
Version.objects.all().delete()
Revision.objects.all().delete()
super(MozdnsAPITests, self).setUp()
self.domain = create_fake_zone(self.__class__.__name__.lower())
self.public_view = View.objects.get_or_create(name='public')[0]
self.private_view = View.objects.get_or_create(name='private')[0]
def setUp(self):
self.c = Client()
create_fake_zone('10.in-addr.arpa', suffix='')
root_domain = create_fake_zone('foobar.mozilla.com', suffix='')
system = create_fake_host(hostname="asdf.mozilla.com")
sreg = StaticReg.objects.create(label='foo',
domain=root_domain,
system=system,
ip_type='4',
ip_str='10.0.0.0')
g = Group.objects.create(name="foo")
self.test_objs = (
('groupkeyvalue', g),
('staticregkeyvalue', sreg),
('keyvalue', system),
)
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 setUp(self):
from reversion.models import Version, Revision
Version.objects.all().delete()
Revision.objects.all().delete()
super(MozdnsAPITests, self).setUp()
self.domain = create_fake_zone(self.__class__.__name__.lower())
self.public_view = View.objects.get_or_create(name='public')[0]
self.private_view = View.objects.get_or_create(name='private')[0]
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 = create_fake_host(hostname="foo.mozilla.com")
self.s.save()
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_new_zone(self):
self.assertFalse(Task.dns_incremental.all())
self.assertFalse(Task.dns_full.all())
root_domain = create_fake_zone("asdfasd.mozilla.com", suffix="")
self.assertEqual(1, Task.dns_full.all().count())
Task.dns_full.all().delete()
domain_name = root_domain.name
delete_zone_helper(domain_name)
self.assertEqual(1, Task.dns_full.all().count())
def test_new_zone(self):
self.assertFalse(Task.dns_incremental.all())
self.assertFalse(Task.dns_full.all())
root_domain = create_fake_zone("asdfasd.mozilla.com", suffix="")
self.assertEqual(1, Task.dns_full.all().count())
Task.dns_full.all().delete()
domain_name = root_domain.name
delete_zone_helper(domain_name)
self.assertEqual(1, Task.dns_full.all().count())
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 = create_fake_host(hostname="foo.mozilla.com")
self.s.save()
Task.dns_full.all().delete()
def get_domain_and_post_data(self):
# This is different for classes that have ips instead of fqdns
domain_name = "{0}.{1}.{2}.{3}.com".format(
random_label(), random_label(), random_label(), random_label()
)
root_domain = create_fake_zone(domain_name, suffix="")
post_data = self.post_data()
# Get the '_' in SRV records
post_data['fqdn'] = post_data['fqdn'][0] + "asdf.asdf." + domain_name
return root_domain, post_data
def create_domains(self):
private = View(name="private")
private.save()
public = View(name="public")
public.save()
d0 = create_fake_zone("dc.mozilla.com", suffix="")
s = d0.soa
d = Domain(name='vlan.dc.mozilla.com')
d.save()
d.soa = s
d.save()
Domain(name='arpa').save()
Domain(name='in-addr.arpa').save()
# Create Reverse Domains
d = create_fake_zone("10.in-addr.arpa", suffix="")
d = create_fake_zone("66.in-addr.arpa", suffix="")
vlan = Vlan(name='vlan', number=99)
vlan.save()
site = Site(name='dc')
site.save()
network = Network(network_str="10.0.0.0/8", ip_type='4')
network2 = Network(network_str="66.66.66.0/24", ip_type='4')
network2.update_network()
network2.save()
network.vlan = vlan
network.site = site
network.update_network()
network.save()
r = Range(
start_str='10.99.99.1',
end_str='10.99.99.254',
network=network,)
r.clean()
r.save()
r = Range(
start_str='66.66.66.1',
end_str='66.66.66.254',
network=network2,)
r.clean()
r.save()
def test_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.objects.create(
name="host1.wee2.wee.mozilla.com", ip_str="10.0.0.1", ip_type="4"
)
AddressRecord.objects.create(
label="host1", domain=root_domain, ip_str="10.0.0.1", ip_type="4"
)
PTR.objects.create(
name="host2.wee2.wee.mozilla.com", ip_str="10.0.0.5", ip_type="4"
)
AddressRecord.objects.create(
label="host2", domain=root_domain, ip_str="10.0.0.5", ip_type="4"
)
vlan1 = Vlan.objects.create(name='vlan-foo', number=1)
vlan2 = Vlan.objects.create(name='vlan-foo', number=2)
site1 = Site.objects.create(full_name='foo-site')
site2 = Site.objects.create(full_name='bar-site')
Network.objects.create(
network_str='10.0.0.0/30', ip_type='4', vlan=vlan1, site=site1
)
Network.objects.create(
network_str='10.0.0.4/30', ip_type='4', vlan=vlan2, site=site2
)
# Don't associate networks and vlans yet
res, error = compile_to_django('ip=:10.0.0.5')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
self.assertEqual(len(res['NET']), 1)
self.assertEqual(len(res['SITE']), 1)
self.assertEqual(len(res['VLAN']), 1)
def get_domain_and_post_data(self):
# This is different for classes that have ips instead of fqdns
domain_name = "{0}.{1}.{2}.{3}.com".format(random_label(),
random_label(),
random_label(),
random_label())
root_domain = create_fake_zone(domain_name, suffix="")
post_data = self.post_data()
# Get the '_' in SRV records
post_data['fqdn'] = post_data['fqdn'][0] + "asdf.asdf." + domain_name
return root_domain, post_data
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 = create_fake_host(hostname='mozilla.com')
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.objects.create(name="asdf", ip_str="22.1.1.1", ip_type="4")
self.assertRaises(ValidationError, ns.delete)
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 StaticRegs'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.
Domain.objects.create(name="10.14.in-addr.arpa",
soa=reverse_root_domain.soa)
# Adding a record shouldn't be allowed because there is no NS record on
# the zone's root domain.
sreg = StaticReg(label="asdf",
domain=root_domain,
ip_str="14.10.1.1",
ip_type="4",
system=self.s)
self.assertRaises(ValidationError, sreg.save)
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_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_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.
AddressRecord.objects.create(label='',
domain=root_domain,
ip_type="6",
ip_str="1::")
self.assertRaises(ValidationError, ns.delete)
def test_extend_does_touch(self):
# When we create a new domain, ensure that things are updated
root_domain = create_fake_zone("foo.mozilla.com", suffix="")
shouldnt_be_touched = AddressRecord.objects.create(
label='baz', domain=root_domain, ip_str='10.0.0.1', ip_type='4'
)
AddressRecord.objects.filter(pk=shouldnt_be_touched.pk).update(
label='shouldnt be touched'
)
# Extend the tree
ensure_label_domain('bar.baz.foo.mozilla.com')
self.assertEqual(
'',
AddressRecord.objects.get(pk=shouldnt_be_touched.pk).label
)
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
Domain.objects.create(name="test." + root_domain.name,
soa=root_domain.soa)
PTR.objects.create(name="asdf", ip_str="23.10.1.1", ip_type="4")
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_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_delete_hanging_domain_1(self):
# What happens when there is a domain hanging off the root_domain that
# isn't in the zone
root_domain = create_fake_zone('foo1.mozilla.com', suffix="")
domain_name = root_domain.name
hang_domain = Domain.objects.create(name='bar.foo1.mozilla.com')
self.assertFalse(hang_domain.soa)
in_domain = Domain.objects.create(
name='baz.foo1.mozilla.com', soa=root_domain.soa
)
in_domain_name = in_domain.name
self.assertTrue(root_domain.has_record_set())
delete_zone_helper(domain_name)
self.assertFalse(root_domain.has_record_set())
self.assertFalse(Domain.objects.filter(name__contains=in_domain_name))
self.assertTrue(Domain.objects.filter(name__contains=root_domain.name))
self.assertTrue(Domain.objects.filter(name__contains=hang_domain.name))
def test_no_ns_in_view(self):
root_domain = create_fake_zone("asdfdjhjd")
ns = root_domain.nameserver_set.all()[0]
cn = CNAME(label='asdf', domain=root_domain, target='test.com')
cn.full_clean()
cn.save()
cn.views.add(self.public_view)
self.assertTrue(ns.domain.soa == cn.domain.soa)
# We now should have a nameserver and a cname in the public view. The
# nameserver should not be allowed to disable it's public view
# Try to remove the public view
self.assertTrue(self.public_view in ns.views.all())
self.assertTrue(self.private_view in ns.views.all())
post_data = self.update_rdtype(self.post_data())
post_data['domain'] = ns.domain.pk
post_data['views'] = [self.private_view.pk]
post_data['record_pk'] = ns.pk
resp = self.c.post('/en-US/mozdns/record/record_ajax/', data=post_data)
self.assertEqual(resp.status_code, 200)
# Make sure it's still there
ns = Nameserver.objects.get(pk=ns.pk) # fetch
# Make sure the view is still there
# The clean method should prevent it from being deleted
self.assertTrue(self.public_view in ns.views.all())
# Try to remove the private view
# This should be allowed
self.assertTrue(self.public_view in ns.views.all())
post_data = self.update_rdtype(self.post_data())
post_data['views'] = [self.public_view.pk]
post_data['record_pk'] = ns.pk
resp = self.c.post('/en-US/mozdns/record/record_ajax/', data=post_data)
self.assertEqual(resp.status_code, 200)
# Make sure it's still there
ns = Nameserver.objects.get(pk=ns.pk) # fetch
# Make sure the view is still there
# The clean method should prevent it from being deleted
self.assertTrue(self.private_view not in ns.views.all())
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_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.objects.create(name="10.33.in-addr.arpa")
# Add a record to the domain.
PTR.objects.create(name="asdf", ip_str="33.10.1.1", ip_type="4")
# 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_integration3_zone(self):
root_domain = create_fake_zone("wee3.wee.mozilla.com", "")
res, error = compile_to_django("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 = compile_to_django("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 = compile_to_django("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_1(self):
# This is Case 2
root_domain = create_fake_zone("asdf21")
self.assertEqual(root_domain.nameserver_set.count(), 1)
ns = root_domain.nameserver_set.all()[0]
# At his point we should have a domain at the root of a zone with one
# ns record associated to the domain.
# Let's create a child domain and add a record there, then try to
# delete the NS record
cdomain = Domain(name="test." + root_domain.name)
cdomain.soa = root_domain.soa
cdomain.save()
AddressRecord.objects.create(label='',
domain=cdomain,
ip_type="6",
ip_str="1::")
self.assertRaises(ValidationError, ns.delete)
def test_basic_add_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_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_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.objects.create(name="test." + root_domain.name)
# Add a record to the domain.
AddressRecord.objects.create(label='',
domain=cdomain,
ip_type="6",
ip_str="1::")
# 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_hanging_domain_2(self):
# What happens when there is a domain hanging off the root_domain that
# isn't in the zone
root_domain = create_fake_zone('foo2.mozilla.com', suffix="")
d1 = Domain.objects.create(
name='bar.foo2.mozilla.com', soa=root_domain.soa
)
soa2 = SOA.objects.create(
primary='foo.com', contact='foo', description='foo'
)
d2 = Domain.objects.create(name='baz.bar.foo2.mozilla.com', soa=soa2)
root_domain_name = root_domain.name
d1_domain_name = d1.name
d2_domain_name = d2.name
self.assertTrue(root_domain.has_record_set())
delete_zone_helper(root_domain_name)
self.assertFalse(root_domain.has_record_set())
self.assertTrue(Domain.objects.get(name=root_domain_name))
self.assertTrue(Domain.objects.get(name=d1_domain_name))
d2 = Domain.objects.get(name=d2_domain_name)
self.assertEquals(d2.soa, soa2)
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')
create_fake_zone('asdf90')
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)
self.assertTrue(Task.dns_full.all())
self.assertFalse(Task.dns_incremental.all().count())
b.build_dns()
self.assertFalse(Task.dns_full.all())
self.assertFalse(Task.dns_incremental.all())
# deleting one ns
for ns in root_domain1.nameserver_set.all():
ns.delete()
self.assertTrue(Task.dns_full.all())
self.assertEqual(1, Task.dns_incremental.all().count())
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()
b.PUSH_TO_PROD = True
self.assertRaises(BuildError, b.build_dns)
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.objects.create(name="host1.wee2.wee.mozilla.com",
ip_str="10.0.0.1",
ip_type="4")
AddressRecord.objects.create(label="host1",
domain=root_domain,
ip_str="10.0.0.1",
ip_type="4")
PTR.objects.create(name="host2.wee2.wee.mozilla.com",
ip_str="10.0.0.5",
ip_type="4")
AddressRecord.objects.create(label="host2",
domain=root_domain,
ip_str="10.0.0.5",
ip_type="4")
vlan1 = Vlan.objects.create(name='vlan-foo', number=1)
vlan2 = Vlan.objects.create(name='vlan-foo', number=2)
net1 = Network.objects.create(network_str='10.0.0.0/30', ip_type='4')
net2 = Network.objects.create(network_str='10.0.0.4/30', ip_type='4')
# Don't associate networks and vlans yet
res, error = compile_to_django('vlan=:vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django('vlan=:vlan-foo,1')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
res, error = compile_to_django('vlan=:1,vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 0)
self.assertEqual(len(res['A']), 0)
net1.vlan = vlan1
net1.save()
net2.vlan = vlan2
net2.save()
res, error = compile_to_django('vlan=:vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 2)
self.assertEqual(len(res['A']), 2)
res, error = compile_to_django('vlan=:vlan-foo,1')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = compile_to_django('vlan=:1,vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = compile_to_django('vlan=:vlan-foo,2')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = compile_to_django('vlan=:2,vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
res, error = compile_to_django('vlan=:1')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
vlan2.name = 'vlan-bar'
vlan2.save()
res, error = compile_to_django('vlan=:vlan-foo')
self.assertFalse(error)
self.assertEqual(len(res['PTR']), 1)
self.assertEqual(len(res['A']), 1)
