def test__delete_address_deletes_single_address(self): user = factory.make_admin() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() name = factory.make_hostname() resource = factory.make_DNSResource( domain=domain, name=name, ip_addresses=["127.0.0.1", "127.0.0.2"]) handler.delete_address_record({ 'domain': domain.id, 'dnsresource_id': resource.id, 'rrdata': "127.0.0.1" }) self.assertThat(resource.get_addresses(), Equals(["127.0.0.2"]))
def test__add_address_as_non_admin_fails(self): user = factory.make_User() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() name = factory.make_hostname() ttl = randint(1, 3600) with ExpectedException(HandlerPermissionError): handler.create_address_record({ 'domain': domain.id, 'name': name, 'address_ttl': ttl, 'ip_addresses': ['127.0.0.1'] })
def test_rejects_addresses_if_underscore_in_name(self): name = factory.make_name("n_me") domain = factory.make_Domain() dnsresource = DNSResource(name=name, domain=domain) dnsresource.save() sip = factory.make_StaticIPAddress() dnsresource.ip_addresses.add(sip) with ExpectedException( ValidationError, re.escape("{'__all__': ['Invalid dnsresource name: %s." % (name, )), ): dnsresource.save(force_update=True)
def test__delete_dnsdata_fails_for_non_admin(self): user = factory.make_User() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() dnsresource = factory.make_DNSResource(domain=domain) dnsdata = factory.make_DNSData(dnsresource) with ExpectedException(HandlerPermissionError): handler.delete_dnsdata({ 'domain': domain.id, 'dnsdata_id': dnsdata.id, }) dnsdata = reload_object(dnsdata) self.assertThat(dnsdata, Not(Is(None)))
def test_set_default(self): self.become_admin() domain = factory.make_Domain() self.assertEqual(False, domain.is_default()) uri = get_domain_uri(domain) response = self.client.post(uri, {"op": "set_default"}) self.assertEqual( http.client.OK, response.status_code, response.content ) ret = json.loads(response.content.decode(settings.DEFAULT_CHARSET)) domain = reload_object(domain) self.assertEqual(True, ret["is_default"]) self.assertEqual(True, domain.is_default())
def test_add_address_as_non_admin_fails(self): user = factory.make_User() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() name = factory.make_hostname() ttl = randint(1, 3600) with ExpectedException(HandlerPermissionError): handler.create_address_record({ "domain": domain.id, "name": name, "address_ttl": ttl, "ip_addresses": ["127.0.0.1"], })
def test_with_child_domain_yields_delegation(self): default_domain = Domain.objects.get_default_domain().name domain = factory.make_Domain(name="henry") factory.make_Domain(name="john.henry") subnet = factory.make_Subnet(cidr=str(IPNetwork("10/29").cidr)) factory.make_Node_with_Interface_on_Subnet(subnet=subnet, vlan=subnet.vlan, fabric=subnet.vlan.fabric) zones = ZoneGenerator(domain, subnet, serial=random.randint(0, 65535)).as_list() self.assertThat( zones, MatchesSetwise( forward_zone("henry"), reverse_zone(default_domain, "10/29"), reverse_zone(default_domain, "10/24"), ), ) expected_map = { "john": HostnameRRsetMapping(None, {(30, "NS", default_domain)}) } self.assertEqual(expected_map, zones[0]._other_mapping)
def test_rejects_multiple_dnsresource_with_same_name(self): name = factory.make_name("name") domain = factory.make_Domain() dnsresource = DNSResource(name=name, domain=domain) dnsresource.save() dnsresource2 = DNSResource(name=name, domain=domain) with ExpectedException( ValidationError, re.escape( "{'__all__': " "['Labels must be unique within their zone.']" ), ): dnsresource2.save(force_update=True)
def test_nodes_with_previous_default_domain_keep_domain_if_ephemeral(self): global_defaults = GlobalDefault.objects.instance() node = factory.make_Node(status=random.choice([ NODE_STATUS.COMMISSIONING, NODE_STATUS.TESTING, NODE_STATUS.RESCUE_MODE, ])) old_default = Domain.objects.get_default_domain() self.assertThat(node.domain, Equals(old_default)) global_defaults.domain = factory.make_Domain() global_defaults.save() node = reload_object(node) self.assertThat(node.domain, Equals(old_default))
def test_update_kms_srv_deletes_srv_records(self): domain = factory.make_Domain() target = "%s.%s" % (factory.make_name(), factory.make_name()) factory.make_DNSData( domain=domain, name="_vlmcs._tcp", rrtype="SRV", rrdata="0 0 1688 %s." % target, ) domain.update_kms_srv("") # We would restrict it more, but we just deleted it... rrset = DNSData.objects.filter(rrtype="SRV") self.assertEqual(0, rrset.count())
def test_accepts_domain_by_id(self): machine = factory.make_Node() domain = factory.make_Domain() patch_usable_architectures(self, [machine.architecture]) form = NodeForm( data={ 'domain': domain.id, }, instance=machine) form.save() self.assertEqual(domain.name, machine.domain.name)
def test_returns_interface_ips_but_no_nulls(self): default_domain = Domain.objects.get_default_domain().name domain = factory.make_Domain(name='henry') subnet = factory.make_Subnet(cidr=str(IPNetwork("10/29").cidr)) subnet.gateway_ip = str(IPAddress(IPNetwork(subnet.cidr).ip + 1)) subnet.save() # Create a node with two interfaces, with NULL ips node = factory.make_Node_with_Interface_on_Subnet( subnet=subnet, vlan=subnet.vlan, fabric=subnet.vlan.fabric, domain=domain, interface_count=3) dnsdata = factory.make_DNSData(domain=domain) boot_iface = node.boot_interface interfaces = list(node.interface_set.all().exclude(id=boot_iface.id)) # Now go add IP addresses to the boot interface, and one other boot_ip = factory.make_StaticIPAddress( interface=boot_iface, subnet=subnet) sip = factory.make_StaticIPAddress( interface=interfaces[0], subnet=subnet) default_ttl = random.randint(10, 300) Config.objects.set_config('default_dns_ttl', default_ttl) zones = ZoneGenerator( domain, subnet, default_ttl=default_ttl, serial=random.randint(0, 65535)).as_list() self.assertThat( zones, MatchesSetwise( forward_zone("henry"), reverse_zone(default_domain, "10/29"), reverse_zone(default_domain, "10/24"))) self.assertEqual({ node.hostname: HostnameIPMapping( node.system_id, default_ttl, {'%s' % boot_ip.ip}, node.node_type), "%s.%s" % (interfaces[0].name, node.hostname): HostnameIPMapping( node.system_id, default_ttl, {'%s' % sip.ip}, node.node_type)}, zones[0]._mapping) self.assertEqual( {dnsdata.dnsresource.name: HostnameRRsetMapping( None, {(default_ttl, dnsdata.rrtype, dnsdata.rrdata)})}.items(), zones[0]._other_mapping.items()) self.assertEqual({ node.fqdn: HostnameIPMapping( node.system_id, default_ttl, {'%s' % boot_ip.ip}, node.node_type), '%s.%s' % (interfaces[0].name, node.fqdn): HostnameIPMapping( node.system_id, default_ttl, {'%s' % sip.ip}, node.node_type)}, zones[1]._mapping) self.assertEqual({}, zones[2]._mapping)
def test_dnsresource_address_overrides_domain(self): # DNSResource.address_ttl _does_, however, override Domain.ttl for # addresses that do not have nodes associated with them. global_ttl = random.randint(100, 199) Config.objects.set_config("default_dns_ttl", global_ttl) subnet = factory.make_Subnet(cidr="10.0.0.0/23") domain = factory.make_Domain(ttl=random.randint(200, 299)) node = factory.make_Node_with_Interface_on_Subnet( status=NODE_STATUS.READY, subnet=subnet, domain=domain, address_ttl=random.randint(300, 399), ) boot_iface = node.get_boot_interface() [boot_ip] = boot_iface.claim_auto_ips() dnsrr = factory.make_DNSResource(domain=domain, address_ttl=random.randint(400, 499)) node_ips = {boot_ip.ip} dnsrr_ips = { ip.ip for ip in dnsrr.ip_addresses.all() if ip is not None } expected_forward = { node.hostname: HostnameIPMapping(node.system_id, node.address_ttl, node_ips, node.node_type), dnsrr.name: HostnameIPMapping(None, dnsrr.address_ttl, dnsrr_ips, None, dnsrr.id), } expected_reverse = { node.fqdn: HostnameIPMapping( node.system_id, node.address_ttl, node_ips, node.node_type, None, ), dnsrr.fqdn: HostnameIPMapping(None, dnsrr.address_ttl, dnsrr_ips, None, dnsrr.id), } zones = ZoneGenerator( domain, subnet, default_ttl=global_ttl, serial=random.randint(0, 65535), ).as_list() self.assertEqual(expected_forward, zones[0]._mapping) self.assertEqual(expected_reverse, zones[1]._mapping)
def test__add_address_without_ip_addresses_fails(self): user = factory.make_admin() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() name = factory.make_hostname() with ExpectedException(ValidationError): handler.create_address_record( { "domain": domain.id, "name": name, "rrtype": choice(["A", "AAAA"]), "ip_addresses": [""], } )
def test_rejects_cname_with_other_data(self): name = factory.make_name("name") target = factory.make_name("target") domain = factory.make_Domain() rrtype = random.choice(["MX", "NS", "TXT"]) dnsrr = factory.make_DNSData( name=name, domain=domain, no_ip_addresses=True, rrtype=rrtype ).dnsresource dnsdata = DNSData(dnsresource=dnsrr, rrtype="CNAME", rrdata=target) with ExpectedException( ValidationError, re.escape("{'__all__': ['%s']}" % CNAME_AND_OTHER_MSG), ): dnsdata.save()
def test_renders_as_dictionary(self): domain = factory.make_Domain() name1 = factory.make_name(prefix='a') name2 = factory.make_name(prefix='b') factory.make_DNSData(name=name1, domain=domain, rrtype='MX') rrdata_list = domain.render_json_for_related_rrdata(as_dict=False) rrdata_dict = domain.render_json_for_related_rrdata(as_dict=True) self.assertThat(rrdata_dict[name1], Equals([rrdata_list[0]])) self.assertThat(rrdata_dict[name1], HasLength(1)) factory.make_DNSData(name=name1, domain=domain, rrtype='MX') factory.make_DNSData(name=name2, domain=domain, rrtype='NS') rrdata_dict = domain.render_json_for_related_rrdata(as_dict=True) self.assertThat(rrdata_dict[name1], HasLength(2)) self.assertThat(rrdata_dict[name2], HasLength(1))
def test_render_json_for_related_rrdata_includes_user_id(self): domain = factory.make_Domain() node_name = factory.make_name('node') user = factory.make_User() factory.make_Node_with_Interface_on_Subnet(hostname=node_name, domain=domain, owner=user) dnsrr = factory.make_DNSResource(domain=domain, name=node_name) factory.make_DNSData(dnsresource=dnsrr, ip_addresses=True) expected = self.render_rrdata(domain, for_list=False) actual = domain.render_json_for_related_rrdata(for_list=True) self.assertEqual(actual, expected) for record in actual: self.assertEqual(record['user_id'], user.id)
def test_render_json_for_related_rrdata_returns_correct_values(self): domain = factory.make_Domain() factory.make_DNSData(domain=domain, rrtype='NS') dnsdata = factory.make_DNSData(domain=domain, rrtype='MX') factory.make_DNSData(dnsresource=dnsdata.dnsresource, rrtype='MX') factory.make_DNSResource(domain=domain) node = factory.make_Node_with_Interface_on_Subnet(domain=domain) factory.make_DNSResource(name=node.hostname, domain=domain) expected = self.render_rrdata(domain, for_list=True) actual = domain.render_json_for_related_rrdata(for_list=True) self.assertItemsEqual(expected, actual) expected = self.render_rrdata(domain, for_list=False) actual = domain.render_json_for_related_rrdata(for_list=False) self.assertItemsEqual(expected, actual)
def test_yields_forward_and_reverse_zone(self): default_domain = Domain.objects.get_default_domain().name domain = factory.make_Domain(name="henry") subnet = factory.make_Subnet(cidr=str(IPNetwork("10/29").cidr)) zones = ZoneGenerator(domain, subnet, serial=random.randint(0, 65535)).as_list() self.assertThat( zones, MatchesSetwise( forward_zone("henry"), reverse_zone(default_domain, "10/29"), reverse_zone(default_domain, "10/24"), ), )
def test__accepts_string_for_ip_addresses(self): name = factory.make_name("dnsresource") sip = factory.make_StaticIPAddress() domain = factory.make_Domain() form = DNSResourceForm({ "name": name, "domain": domain.id, "ip_addresses": str(sip.id) }) self.assertTrue(form.is_valid(), form.errors) dnsresource = form.save() self.assertEqual(name, dnsresource.name) self.assertEqual(domain.id, dnsresource.domain.id) self.assertEqual(sip.id, dnsresource.ip_addresses.first().id)
def test_with_node_yields_fwd_and_rev_zone(self): default_domain = Domain.objects.get_default_domain().name domain = factory.make_Domain(name='henry') subnet = factory.make_Subnet(cidr=str(IPNetwork("10/29").cidr)) factory.make_Node_with_Interface_on_Subnet(subnet=subnet, vlan=subnet.vlan, fabric=subnet.vlan.fabric) zones = ZoneGenerator(domain, subnet, serial=random.randint(0, 65535)).as_list() self.assertThat( zones, MatchesSetwise(forward_zone("henry"), reverse_zone(default_domain, "10/29"), reverse_zone(default_domain, "10/24")))
def test_accepts_address_ttl(self): name = factory.make_name("dnsresource") domain = factory.make_Domain() ttl = random.randint(1, 1000) form = DNSResourceForm({ "name": name, "domain": domain.id, "address_ttl": ttl }) self.assertTrue(form.is_valid(), form.errors) dnsresource = form.save() self.assertEqual(name, dnsresource.name) self.assertEqual(domain.id, dnsresource.domain.id) self.assertEqual(ttl, dnsresource.address_ttl)
def test_rejects_cname_with_other_data(self): name = factory.make_name('name') target = factory.make_name('target') domain = factory.make_Domain() rrtype = random.choice(['MX', 'NS', 'TXT']) dnsrr = factory.make_DNSData(name=name, domain=domain, no_ip_addresses=True, rrtype=rrtype).dnsresource dnsdata = DNSData(dnsresource=dnsrr, rrtype='CNAME', rrdata=target) with ExpectedException( ValidationError, re.escape("{'__all__': ['%s']}" % CNAME_AND_OTHER_MSG)): dnsdata.save()
def test_POST_reserve_with_fqdn_creates_ip_with_hostname(self): subnet = factory.make_Subnet() hostname = factory.make_hostname() domainname = factory.make_Domain().name fqdn = "%s.%s" % (hostname, domainname) response = self.post_reservation_request(subnet=subnet, hostname="%s.%s" % (hostname, domainname)) self.assertEqual(http.client.OK, response.status_code) [staticipaddress] = StaticIPAddress.objects.all() self.expectThat(staticipaddress.dnsresource_set.first().name, Equals(hostname)) self.expectThat(staticipaddress.dnsresource_set.first().fqdn, Equals(fqdn))
def test_create_fails_with_no_name(self): self.become_admin() domain = factory.make_Domain() uri = get_dnsresourcerecords_uri() response = self.client.post( uri, { "domain": domain.name, "rrtype": "TXT", "rrdata": "Sample Text." }, ) self.assertEqual(http.client.BAD_REQUEST, response.status_code, response.content)
def test_reuses_rackcontroller_domain(self): # If a domain name already exists for a FQDN hostname, it is # not modified. factory.make_Domain("example.com", authoritative=True) hostname = "newcontroller.example.com" interfaces = { factory.make_name("eth0"): { "type": "physical", "mac_address": factory.make_mac_address(), "parents": [], "links": [], "enabled": True, } } url = 'http://%s/MAAS' % factory.make_name('host') rack_registered = register("rack-id-foo", interfaces=interfaces, url=urlparse(url), is_loopback=False, hostname=hostname) self.assertEqual("newcontroller", rack_registered.hostname) self.assertEqual("example.com", rack_registered.domain.name) self.assertTrue(rack_registered.domain.authoritative)
def test_dnsresources_are_in_the_dns(self): self.patch(settings, "DNS_CONNECT", True) domain = factory.make_Domain() subnet = factory.make_ipv4_Subnet_with_IPRanges() dynamic_range = subnet.get_dynamic_ranges()[0] ip = factory.pick_ip_in_IPRange(dynamic_range) ip_obj = factory.make_StaticIPAddress( alloc_type=IPADDRESS_TYPE.USER_RESERVED, ip=ip, subnet=subnet) rrname = factory.make_name("label") dnsrr = factory.make_DNSResource(name=rrname, domain=domain, ip_addresses=[ip_obj]) dns_update_all_zones() self.assertDNSMatches(dnsrr.name, domain.name, ip_obj.ip)
def test_rejects_address_with_cname(self): name = factory.make_name('name') domain = factory.make_Domain() dnsdata = factory.make_DNSData( rrtype='CNAME', name=name, domain=domain) ipaddress = factory.make_StaticIPAddress() dnsrr = dnsdata.dnsresource dnsrr.ip_addresses.add(ipaddress) with ExpectedException( ValidationError, re.escape( "{'__all__': " "['Cannot add address: CNAME present.']")): dnsrr.save(force_update=True)
def test_update_resource_validation_error(self): user = factory.make_admin() handler = DomainHandler(user, {}, None) domain = factory.make_Domain() resource = factory.make_DNSResource(domain=domain) self.assertRaises( ValidationError, handler.update_dnsresource, { "domain": domain.id, "dnsresource_id": resource.id, "address_ttl": "invalid", }, )
def test__splits_domain_from_node_hostname(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() host = factory.make_name('host') domainname = factory.make_name('domain') domain = factory.make_Domain(name=domainname) full_hostname = '.'.join([host, domainname]) node = self.make_node(hostname=full_hostname, domain=domain) interface = node.get_boot_interface() mac = interface.mac_address observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, mac=mac) self.assertEqual(host, observed_config.get('hostname')) self.assertEqual(domainname, observed_config.get('domain'))