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 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): 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 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_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)