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