def test_get_preseed_uses_nodegroup_maas_url(self):
ng_url = 'http://%s' % factory.make_hostname()
maas_url = 'http://%s' % factory.make_hostname()
self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
nodegroup = factory.make_node_group(maas_url=ng_url)
preseed = render_enlistment_preseed(
PRESEED_TYPE.ENLIST, "precise", nodegroup=nodegroup)
self.assertThat(
preseed, MatchesAll(*[Contains(ng_url), Not(Contains(maas_url))]))
def test_get_preseed_uses_nodegroup_maas_url(self):
ng_url = 'http://%s' % factory.make_hostname()
ng = factory.make_node_group(maas_url=ng_url)
maas_url = 'http://%s' % factory.make_hostname()
node = factory.make_node(
nodegroup=ng, status=NODE_STATUS.COMMISSIONING)
self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
preseed = render_preseed(node, self.preseed, "precise")
self.assertThat(
preseed, MatchesAll(*[Contains(ng_url), Not(Contains(maas_url))]))
def test_rejects_invalid_hostname(self):
input = "%s abc-.foo" % factory.make_hostname()
error = self.assertRaises(
ValidationError, HostListFormField().clean, input)
self.assertThat(error.message, Equals(
"Invalid hostname: Label cannot start or end with "
"hyphen: 'abc-'."))
def test_URLOrPPAFormField_catches_bad_PPA_format(self):
bad_url = "ppa:%s" % factory.make_hostname()
error = self.assertRaises(ValidationError,
URLOrPPAFormField().clean, bad_url)
self.assertThat(
error.messages[0],
Equals('Enter a valid repository URL or PPA location.'))
def test_cannot_create_package_repository_bad_ppa(self):
# PackageRepository contains a URLOrPPAField. Make one with bad PPA.
bad_url = "ppa:%s" % factory.make_hostname()
error = self.assertRaises(
ValidationError, factory.make_PackageRepository, url=bad_url)
self.assertThat(error.messages[0], Equals(
'Enter a valid repository URL or PPA location.'))
def test_rejects_invalid_ipv6_address(self):
input = "%s fe80::abcde" % factory.make_hostname()
error = self.assertRaises(ValidationError,
HostListFormField().clean, input)
self.assertThat(
error.message,
Equals("Failed to detect a valid IP address from 'fe80::abcde'."))
def test__add_two_addresses_in_succession(self):
user = factory.make_admin()
handler = DomainHandler(user, {}, None)
domain = factory.make_Domain()
name = factory.make_hostname()
ttl = randint(1, 3600)
handler.create_address_record(
{
"domain": domain.id,
"name": name,
"address_ttl": ttl,
"ip_addresses": ["127.0.0.1"],
}
)
handler.create_address_record(
{
"domain": domain.id,
"name": name,
"address_ttl": ttl,
"ip_addresses": ["127.0.0.2"],
}
)
resource = DNSResource.objects.get(domain=domain, name=name)
self.assertThat(resource.address_ttl, Equals(ttl))
self.assertThat(resource.name, Equals(name))
self.assertThat(
resource.get_addresses(), Equals(["127.0.0.1", "127.0.0.2"])
)
def test_URLOrPPAValidator_catches_bad_PPA_format(self):
validator = URLOrPPAValidator()
bad_ppa = "ppa:%s" % factory.make_hostname()
error = self.assertRaises(ValidationError, validator, bad_ppa)
self.assertThat(
error.message,
Equals('Enter a valid repository URL or PPA location.'))
def test_caches_region_model_object(self):
hostname = factory.make_hostname()
self.set_fake_twisted_dns_reply([hostname])
service = ReverseDNSService()
yield service.startService()
self.assertThat(service.region, Equals(self.region))
service.stopService()
def test__input_url_allows_list(self):
script = factory.make_Script(
parameters={"url": {"type": "url", "allow_list": True}}
)
inputs = ",".join(
[
factory.make_ipv4_address(),
"%s://%s:%d/%s"
% (
self.pick_scheme(),
factory.make_ipv4_address(),
random.randint(0, 65535),
factory.make_name(),
),
factory.make_ipv6_address(),
"%s://[%s]:%d/%s"
% (
self.pick_scheme(),
factory.make_ipv6_address(),
random.randint(0, 65535),
factory.make_name(),
),
factory.make_hostname(),
factory.make_url(scheme=self.pick_scheme()),
]
)
form = ParametersForm(
data={"url": inputs}, script=script, node=factory.make_Node()
)
self.assertTrue(form.is_valid(), form.errors)
self.assertDictEqual(
{"url": {"type": "url", "allow_list": True, "value": inputs}},
form.cleaned_data["input"][0],
)
def test__input_url_allows_list(self):
script = factory.make_Script(
parameters={'url': {
'type': 'url',
'allow_list': True,
}})
inputs = ','.join([
factory.make_ipv4_address(),
"%s://%s:%d/%s" % (self.pick_scheme(), factory.make_ipv4_address(),
random.randint(0, 65535), factory.make_name()),
factory.make_ipv6_address(),
"%s://[%s]:%d/%s" %
(self.pick_scheme(), factory.make_ipv6_address(),
random.randint(0, 65535), factory.make_name()),
factory.make_hostname(),
factory.make_url(scheme=self.pick_scheme()),
])
form = ParametersForm(data={'url': inputs},
script=script,
node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertDictEqual(
{'url': {
'type': 'url',
'allow_list': True,
'value': inputs
}}, form.cleaned_data['input'][0])
def test__creates_node_with_explicit_domain(self):
self.prepare_rack_rpc()
mac_addresses = [factory.make_mac_address() for _ in range(3)]
architecture = make_usable_architecture(self)
hostname = factory.make_hostname()
domain = factory.make_Domain()
node = create_node(architecture,
'manual', {},
mac_addresses,
domain=domain.name,
hostname=hostname)
self.assertEqual((
architecture,
'manual',
{},
domain.id,
hostname,
), (
node.architecture,
node.power_type,
node.power_parameters,
node.domain.id,
node.hostname,
))
self.expectThat(node.id, Not(Is(None)))
self.assertItemsEqual(
mac_addresses,
[nic.mac_address for nic in node.interface_set.all()])
def test_POST_reserve_with_fqdn_and_ip_creates_ip_with_hostname(self):
subnet = factory.make_Subnet()
hostname = factory.make_hostname()
domainname = factory.make_Domain().name
fqdn = "%s.%s" % (hostname, domainname)
ip_in_network = factory.pick_ip_in_Subnet(subnet)
response = self.post_reservation_request(
subnet=subnet,
ip_address=ip_in_network,
hostname="%s.%s" % (hostname, domainname),
)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
returned_address = json_load_bytes(response.content)
[staticipaddress] = StaticIPAddress.objects.all()
self.expectThat(
returned_address["alloc_type"],
Equals(IPADDRESS_TYPE.USER_RESERVED),
)
self.expectThat(returned_address["ip"], Equals(ip_in_network))
self.expectThat(staticipaddress.ip, Equals(ip_in_network))
self.expectThat(
staticipaddress.dnsresource_set.first().fqdn, Equals(fqdn)
)
def test_POST_reserve_with_bad_fqdn_fails(self):
subnet = factory.make_Subnet()
hostname = factory.make_hostname()
domainname = factory.make_name("domain")
fqdn = "%s.%s" % (hostname, domainname)
response = self.post_reservation_request(subnet=subnet, hostname=fqdn)
self.assertEqual(http.client.NOT_FOUND, response.status_code)
def test_prevents_unauthorized_updates(self):
user = factory.make_User()
domain = Domain.objects.get_default_domain()
new_name = factory.make_hostname()
handler = DomainHandler(user, {}, None)
with ExpectedException(HandlerPermissionError):
handler.update({"id": domain.id, "name": new_name})
def test_set_current_entry_updates_existing_hostname_with_log(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
# Place a random hostname in the record at first...
factory.make_RDNS(ip, factory.make_hostname(), region)
# Then expect this function replaces it.
with TwistedLoggerFixture() as logger:
RDNS.objects.set_current_entry(ip, [hostname], region)
result = RDNS.objects.first()
self.assertThat(result.ip, Equals(ip))
self.assertThat(result.hostname, Equals(hostname))
self.assertThat(
logger.output,
DocTestMatches("Reverse DNS entry updated...resolves to..."),
)
def test_input_url_list_requires_allow_list(self):
script = factory.make_Script(parameters={"url": {"type": "url"}})
inputs = ",".join([
factory.make_ipv4_address(),
"%s://%s:%d/%s" % (
self.pick_scheme(),
factory.make_ipv4_address(),
random.randint(0, 65535),
factory.make_name(),
),
factory.make_ipv6_address(),
"%s://[%s]:%d/%s" % (
self.pick_scheme(),
factory.make_ipv6_address(),
random.randint(0, 65535),
factory.make_name(),
),
factory.make_hostname(),
factory.make_url(scheme=self.pick_scheme()),
])
form = ParametersForm(data={"url": inputs},
script=script,
node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertDictEqual({"url": ["Invalid URL"]}, form.errors)
def test_set_config_ntp_server_alias_for_ntp_servers(self):
self.become_admin()
ntp_servers = factory.make_hostname() + " " + factory.make_hostname()
response = self.client.post(reverse('maas_handler'), {
"op": "set_config",
"name": "ntp_server",
"value": ntp_servers,
})
self.assertThat(
response,
MatchesAll(
# An HTTP 200 response,
MatchesStructure(status_code=Equals(http.client.OK),
content=Equals(b"OK")), ))
self.assertThat(Config.objects.get_config("ntp_servers"),
Equals(ntp_servers))
def test_external_only_yields_all_ntp_servers_when_defined(self):
Config.objects.set_config("ntp_external_only", True)
ntp_hosts = factory.make_hostname(), factory.make_hostname()
ntp_addrs = factory.make_ipv4_address(), factory.make_ipv6_address()
ntp_servers = ntp_hosts + ntp_addrs
Config.objects.set_config("ntp_servers", " ".join(ntp_servers))
configuration = generate_ntp_configuration(node=factory.make_Node())
self.assertThat(
dict(configuration),
Equals({
"ntp": {
"servers": sorted(ntp_addrs, key=IPAddress),
"pools": sorted(ntp_hosts),
}
}),
)
def test__exposes_mdns_when_nothing_better_available(self):
rack = factory.make_RackController()
iface = factory.make_Interface(node=rack)
ip = factory.make_ip_address(ipv6=False)
mdns_hostname = factory.make_hostname()
factory.make_Discovery(hostname=mdns_hostname, interface=iface, ip=ip)
discovery = Discovery.objects.first()
self.assertThat(discovery.hostname, Equals(mdns_hostname))
def test_update_returns_model_object(self):
user = factory.make_admin()
domain = Domain.objects.get_default_domain()
new_name = factory.make_hostname()
handler = DomainHandler(user, {}, None)
returned_domain = handler.update({"id": domain.id, "name": new_name})
domain = reload_object(domain)
self.assertThat(self.dehydrate_domain(domain), Equals(returned_domain))
def test_update_allows_domain_name_change(self):
user = factory.make_admin()
domain = Domain.objects.get_default_domain()
new_name = factory.make_hostname()
handler = DomainHandler(user, {}, None)
handler.update({"id": domain.id, "name": new_name})
domain = reload_object(domain)
self.assertThat(domain.name, Equals(new_name))
def test_POST_reserve_with_hostname_creates_ip_with_hostname(self):
subnet = factory.make_Subnet()
hostname = factory.make_hostname()
response = self.post_reservation_request(subnet=subnet,
hostname=hostname)
self.assertEqual(http.client.OK, response.status_code)
[staticipaddress] = StaticIPAddress.objects.all()
self.expectThat(staticipaddress.dnsresource_set.first().name,
Equals(hostname))
def test_get_dns_server_address_resolves_hostname(self):
ip = factory.getRandomIPAddress()
resolver = FakeMethod(result=ip)
self.patch(server_address, 'gethostbyname', resolver)
hostname = factory.make_hostname()
self.patch_DEFAULT_MAAS_URL_with_random_values(hostname=hostname)
self.assertEqual(
(ip, [(hostname, )]),
(dns.get_dns_server_address(), resolver.extract_args()))
def test__delete_current_entry_deletes_and_logs_if_entry_deleted(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
factory.make_RDNS(ip, hostname, region)
RDNS.objects.delete_current_entry(ip, region)
self.assertThat(
self.maaslog.output,
DocTestMatches("Deleted reverse DNS entry...resolved to..."))
def test_get_multiple_with_a_ppa(self):
ppa_arch = 'armhf'
ppa_url = 'ppa:%s/%s' % (factory.make_hostname(),
factory.make_hostname())
ppa_archive = factory.make_PackageRepository(
url=ppa_url, default=False, arches=[ppa_arch,
factory.make_name()])
arch = 'i386'
url = factory.make_url(scheme='http')
archive = factory.make_PackageRepository(
url=url, default=False, arches=[arch, factory.make_name()])
self.assertEquals(
ppa_archive,
PackageRepository.objects.get_additional_repositories(
ppa_arch).first())
self.assertEquals(
archive,
PackageRepository.objects.get_additional_repositories(
arch).first())
def test_get_dns_server_address_uses_nodegroup_maas_url(self):
ip = factory.getRandomIPAddress()
resolver = FakeMethod(result=ip)
self.patch(server_address, 'gethostbyname', resolver)
hostname = factory.make_hostname()
maas_url = 'http://%s' % hostname
nodegroup = factory.make_node_group(maas_url=maas_url)
self.assertEqual(
(ip, [(hostname, )]),
(dns.get_dns_server_address(nodegroup), resolver.extract_args()))
def test_get_dns_server_address_uses_rack_controller_url(self):
ip = factory.make_ipv4_address()
resolver = self.patch(server_address, "resolve_hostname")
resolver.return_value = {IPAddress(ip)}
hostname = factory.make_hostname()
maas_url = "http://%s" % hostname
rack_controller = factory.make_RackController(url=maas_url)
result = get_dns_server_address(rack_controller)
self.expectThat(ip, Equals(result))
self.expectThat(resolver, MockAnyCall(hostname, 0))
def test_preseed_uses_default_proxy(self):
server_host = factory.make_hostname()
url = 'http://%s:%d/%s' % (server_host, factory.getRandomPort(),
factory.getRandomString())
self.patch(settings, 'DEFAULT_MAAS_URL', url)
expected_proxy_statement = ("mirror/http/proxy string http://%s:8000" %
server_host)
preseed = render_preseed(factory.make_node(), PRESEED_TYPE.DEFAULT,
"precise")
self.assertIn(expected_proxy_statement, preseed)
def test_preseed_uses_default_proxy(self):
server_host = factory.make_hostname()
url = 'http://%s:%d/%s' % (
server_host, factory.getRandomPort(), factory.getRandomString())
self.patch(settings, 'DEFAULT_MAAS_URL', url)
expected_proxy_statement = (
"mirror/http/proxy string http://%s:8000" % server_host)
preseed = render_preseed(
factory.make_node(), PRESEED_TYPE.DEFAULT, "precise")
self.assertIn(expected_proxy_statement, preseed)
def test_set_current_entry_updates_updated_time(self):
region = factory.make_RegionController()
hostname = factory.make_hostname()
ip = factory.make_ip_address()
yesterday = datetime.now() - timedelta(days=1)
factory.make_RDNS(ip, hostname, region, updated=yesterday)
# Nothing changed, so expect that only the last updated time changed.
RDNS.objects.set_current_entry(ip, [hostname], region)
result = RDNS.objects.first()
self.assertThat(result.updated, GreaterThan(yesterday))
def test__input_url_allows_hostname(self):
script = factory.make_Script(parameters={"url": {"type": "url"}})
input = factory.make_hostname()
form = ParametersForm(
data={"url": input}, script=script, node=factory.make_Node()
)
self.assertTrue(form.is_valid(), form.errors)
self.assertDictEqual(
{"url": {"type": "url", "value": input}},
form.cleaned_data["input"][0],
)
def test_deletes_rdns_entry(self):
hostname = factory.make_hostname()
self.set_fake_twisted_dns_reply([hostname])
service = ReverseDNSService()
yield service.startService()
ip = factory.make_ip_address(ipv6=False)
yield service.consumeNeighbourEvent("create", "%s/32" % ip)
yield service.consumeNeighbourEvent("delete", "%s/32" % ip)
service.stopService()
result = yield deferToDatabase(RDNS.objects.first)
self.assertThat(result, Is(None))
def test_get_userdata_detects_request_origin(self):
nodegroup_url = 'http://%s' % factory.make_name('host')
maas_url = 'http://%s' % factory.make_hostname()
self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
factory.make_node_group(maas_url=nodegroup_url, network=network)
url = reverse('enlist-metadata-user-data', args=['latest'])
response = self.client.get(url, REMOTE_ADDR=ip)
self.assertThat(
response.content,
MatchesAll(Contains(nodegroup_url), Not(Contains(maas_url))))
def test_pxeconfig_enlistment_preseed_url_detects_request_origin(self):
self.silence_get_ephemeral_name()
hostname = factory.make_hostname()
ng_url = 'http://%s' % hostname
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
self.patch(server_address, 'gethostbyname', Mock(return_value=ip))
factory.make_node_group(maas_url=ng_url, network=network)
params = self.get_default_params()
# Simulate that the request originates from ip by setting
# 'REMOTE_ADDR'.
response = self.client.get(
reverse('pxeconfig'), params, REMOTE_ADDR=ip)
self.assertThat(
json.loads(response.content)["preseed_url"],
StartsWith(ng_url))
def make_hostname(self):
return '%s.example.com' % factory.make_hostname()
def test_get_maas_facing_server_host_returns_nodegroup_maas_url(self):
hostname = factory.make_hostname()
maas_url = 'http://%s' % hostname
nodegroup = factory.make_node_group(maas_url=maas_url)
self.assertEqual(
hostname, server_address.get_maas_facing_server_host(nodegroup))
