Ejemplo n.º 1
0
 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))]))
Ejemplo n.º 2
0
 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))]))
Ejemplo n.º 3
0
 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-'."))
Ejemplo n.º 4
0
 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.'))
Ejemplo n.º 5
0
 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.'))
Ejemplo n.º 6
0
 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'."))
Ejemplo n.º 7
0
 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"])
     )
Ejemplo n.º 8
0
 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.'))
Ejemplo n.º 9
0
 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()
Ejemplo n.º 10
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],
     )
Ejemplo n.º 11
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])
Ejemplo n.º 12
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()])
Ejemplo n.º 13
0
 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)
     )
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
 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})
Ejemplo n.º 16
0
 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..."),
     )
Ejemplo n.º 17
0
 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)
Ejemplo n.º 18
0
 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))
Ejemplo n.º 19
0
 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),
             }
         }),
     )
Ejemplo n.º 20
0
 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))
Ejemplo n.º 21
0
 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))
Ejemplo n.º 22
0
 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))
Ejemplo n.º 23
0
 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))
Ejemplo n.º 24
0
 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()))
Ejemplo n.º 25
0
 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..."))
Ejemplo n.º 26
0
 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())
Ejemplo n.º 27
0
 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()))
Ejemplo n.º 28
0
 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))
Ejemplo n.º 29
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)
Ejemplo n.º 30
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)
Ejemplo n.º 31
0
 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))
Ejemplo n.º 32
0
 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],
     )
Ejemplo n.º 33
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))
Ejemplo n.º 34
0
 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))))
Ejemplo n.º 35
0
    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))
Ejemplo n.º 36
0
 def make_hostname(self):
     return '%s.example.com' % factory.make_hostname()
Ejemplo n.º 37
0
 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))