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'))
