def test_class_start_commissioning_with_url_param(self):
node = factory.make_Node(status=NODE_STATUS.READY)
user = factory.make_admin()
commissioning_script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING,
parameters={"url": {
"type": "url"
}},
)
testing_script = factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
parameters={"url": {
"type": "url"
}},
)
mock_start_commissioning = self.patch_autospec(node,
"start_commissioning")
commissioning_input = factory.make_url(scheme="http")
testing_input = factory.make_url(scheme="http")
form = CommissionForm(
instance=node,
user=user,
data={
"commissioning_scripts": commissioning_script.name,
"testing_scripts": testing_script.name,
"%s_url" % commissioning_script.name: commissioning_input,
"%s_url" % testing_script.name: testing_input,
},
)
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertIsNotNone(node)
self.assertThat(
mock_start_commissioning,
MockCalledOnceWith(
user,
False,
False,
False,
False,
[commissioning_script.name],
[testing_script.name],
{
commissioning_script.name: {
"url": commissioning_input
},
testing_script.name: {
"url": testing_input
},
},
),
)
def test_form_saves_info_db(self):
main_url = factory.make_url(scheme="http")
ports_url = factory.make_url(scheme="http")
params = {"main_archive": main_url, "ports_archive": ports_url}
form = UbuntuForm(data=params)
self.assertTrue(form.is_valid(), form._errors)
form.save()
self.assertEqual(
{
"main": urlparse(main_url),
"ports": urlparse(ports_url)
},
get_archive_mirrors(),
)
def test_returns_populated_dict_when_main_and_port_is_set(self):
PackageRepository.objects.all().delete()
main_url = factory.make_url(scheme="http")
ports_url = factory.make_url(scheme="http")
factory.make_PackageRepository(
url=main_url, default=True, arches=["i386", "amd64"]
)
factory.make_PackageRepository(
url=ports_url, default=True, arches=["arm64", "armhf", "powerpc"]
)
self.assertEqual(
{"main": urlparse(main_url), "ports": urlparse(ports_url)},
get_archive_mirrors(),
)
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_URLOrPPAFormField_catches_bad_scheme(self):
bad_url = factory.make_url(scheme='bad_scheme')
error = self.assertRaises(ValidationError,
URLOrPPAFormField().clean, bad_url)
self.assertThat(
error.messages[0],
Equals('Enter a valid repository URL or PPA location.'))
def test_URLOrPPAValidator_catches_bad_scheme(self):
validator = URLOrPPAValidator()
bad_url = factory.make_url(scheme='bad_scheme')
error = self.assertRaises(ValidationError, validator, bad_url)
self.assertThat(
error.message,
Equals('Enter a valid repository URL or PPA location.'))
def test_packages_validate(self):
apt_pkgs = [factory.make_name('apt_pkg') for _ in range(3)]
snap_pkg = {
'name': factory.make_name('snap_pkg'),
'channel': random.choice(['stable', 'edge', 'beta', 'candidate']),
'mode': random.choice(['classic', 'dev', 'jail']),
}
url = factory.make_url()
form = ScriptForm(
data={
'script':
factory.make_script_content({
'name': factory.make_name('name'),
'packages': {
'apt': apt_pkgs,
'snap': snap_pkg,
'url': url
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
'apt': apt_pkgs,
'snap': [snap_pkg],
'url': [url]
}, script.packages)
def test__converts_single_package_to_list(self):
apt_pkg = factory.make_name("apt_pkg")
snap_pkg = factory.make_name("snap_pkg")
url = factory.make_url()
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"packages": {
"apt": apt_pkg,
"snap": snap_pkg,
"url": url,
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
"apt": [apt_pkg],
"snap": [snap_pkg],
"url": [url]
},
script.packages,
)
def test_packages_validate(self):
apt_pkgs = [factory.make_name("apt_pkg") for _ in range(3)]
snap_pkg = {
"name": factory.make_name("snap_pkg"),
"channel": random.choice(["stable", "edge", "beta", "candidate"]),
"mode": random.choice(["classic", "dev", "jail"]),
}
url = factory.make_url()
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"packages": {
"apt": apt_pkgs,
"snap": snap_pkg,
"url": url,
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
"apt": apt_pkgs,
"snap": [snap_pkg],
"url": [url]
},
script.packages,
)
def test_update_admin_only(self):
package_repository = factory.make_PackageRepository()
response = self.client.put(
self.get_package_repository_uri(package_repository),
{'url': factory.make_url(scheme='http')})
self.assertEqual(http.client.FORBIDDEN, response.status_code,
response.content)
def test_get_ports_archive_overrides_to_package_repository(self):
PackageRepository.objects.all().delete()
ports_url = factory.make_url(scheme="http")
factory.make_PackageRepository(url=ports_url,
default=True,
arches=["arm64", "armhf", "powerpc"])
response = self.client.get(
reverse("maas_handler"),
{
"op": "get_config",
"name": "ports_archive"
},
)
self.assertThat(
response,
MatchesAll(
# An HTTP 200 response,
MatchesStructure(status_code=Equals(http.client.OK)),
# with a JSON body,
AfterPreprocessing(itemgetter("Content-Type"),
Equals("application/json")),
# containing the main_archive setting.
AfterPreprocessing(
lambda response: json.loads(
response.content.decode(settings.DEFAULT_CHARSET)),
Equals(ports_url),
),
),
)
def make_valid_repo_params(self, repo=None):
# Helper that creates a valid PackageRepository and parameters for a
# PackageRepositoryForm that will validate.
if repo is None:
repo = factory.make_PackageRepository()
name = factory.make_name("name")
url = factory.make_url(scheme="http")
arch1 = random.choice(PackageRepository.KNOWN_ARCHES)
arch2 = random.choice(PackageRepository.KNOWN_ARCHES)
dist1 = factory.make_name("dist")
dist2 = factory.make_name("dist")
pock1 = "updates"
pock2 = "backports"
comp1 = "universe"
comp2 = "multiverse"
disable_sources = factory.pick_bool()
enabled = factory.pick_bool()
params = {
"name": name,
"url": url,
"distributions": [dist1, dist2],
"disabled_pockets": [pock1, pock2],
"components": [comp1, comp2],
"arches": [arch1, arch2],
"enabled": enabled,
"disable_sources": disable_sources,
}
return params
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_update_ubuntu_mirror_fails_if_components_are_passed(self):
"""Test that updating a Ubuntu mirror fails if specifying
'components'. This is only needed when the repository is not
an Ubuntu repository"""
self.become_admin()
# Create an Ubuntu mirror without components
package_repository = factory.make_PackageRepository(
default=True, components=[]
)
new_values = {
"url": factory.make_url(scheme="http"),
"distributions": [
factory.make_name("distribution%d" % i) for i in range(3)
],
"components": [factory.make_name("comp%d" % i) for i in range(4)],
"disabled_components": [
factory.make_name("comp%d" % i) for i in range(4)
],
"arches": [
random.choice(PackageRepository.KNOWN_ARCHES),
random.choice(PackageRepository.KNOWN_ARCHES),
],
}
response = self.client.put(
self.get_package_repository_uri(package_repository), new_values
)
self.assertEqual(
http.client.BAD_REQUEST, response.status_code, response.content
)
def test_arranges_for_update_on_Config_http_proxy(self):
post_commit_do = self.patch(signals.bootsources, "post_commit_do")
Config.objects.set_config("http_proxy", factory.make_url())
self.assertThat(
post_commit_do,
MockCalledOnceWith(reactor.callLater, 0, cache_boot_sources),
)
def test__raises_PodProblem_for_PodActionFail(self):
pod = factory.make_Pod()
node = factory.make_Node()
token = NodeKey.objects.get_token_for_node(node)
metadata_url = factory.make_url()
error_msg = factory.make_name("error")
client = Mock()
client.return_value = fail(PodActionFail(error_msg))
error = self.assertRaises(
PodProblem,
wait_for_reactor(send_pod_commissioning_results),
client,
pod.id,
pod.name,
pod.power_type,
node.system_id,
pod.power_parameters,
token.consumer.key,
token.key,
token.secret,
metadata_url,
)
self.assertEqual(
f"Unable to send commissioning results for {pod.name}({pod.id}) "
f"because: {error_msg}",
str(error),
)
def test__raises_same_exception(self):
pod = factory.make_Pod()
node = factory.make_Node()
token = NodeKey.objects.get_token_for_node(node)
metadata_url = factory.make_url()
client = Mock()
exception_type = factory.make_exception_type()
exception_msg = factory.make_name("error")
client.return_value = fail(exception_type(exception_msg))
error = self.assertRaises(
exception_type,
wait_for_reactor(send_pod_commissioning_results),
client,
pod.id,
pod.name,
pod.power_type,
node.system_id,
pod.power_parameters,
token.consumer.key,
token.key,
token.secret,
metadata_url,
)
self.assertEqual(exception_msg, str(error))
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_class_start_testing_with_url_param(self):
node = factory.make_Node(status=NODE_STATUS.DEPLOYED)
user = factory.make_admin()
script = factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
parameters={"url": {
"type": "url"
}},
)
mock_start_testing = self.patch_autospec(node, "start_testing")
input = factory.make_url(scheme="http")
form = TestForm(
instance=node,
user=user,
data={
"testing_scripts": script.name,
"url": input
},
)
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertIsNotNone(node)
self.assertThat(
mock_start_testing,
MockCalledOnceWith(user, False, [script.name],
{script.name: {
"url": input
}}),
)
def test_update_ubuntu_mirror(self):
"""Updates a Ubuntu mirror"""
self.become_admin()
# Create an Ubuntu mirror without components
package_repository = factory.make_PackageRepository(
default=True, components=[]
)
new_values = {
"url": factory.make_url(scheme="http"),
"distributions": [
factory.make_name("distribution%d" % i) for i in range(3)
],
"disabled_pockets": ["updates", "security"],
"disabled_components": ["universe", "multiverse"],
"arches": [
random.choice(PackageRepository.KNOWN_ARCHES),
random.choice(PackageRepository.KNOWN_ARCHES),
],
}
response = self.client.put(
self.get_package_repository_uri(package_repository), new_values
)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
package_repository = reload_object(package_repository)
self.assertAttributes(package_repository, new_values)
def test__raises_PodProblem_for_NotImplementedError(self):
pod = factory.make_Pod()
node = factory.make_Node()
token = NodeKey.objects.get_token_for_node(node)
metadata_url = factory.make_url()
client = Mock()
client.return_value = fail(NotImplementedError())
error = self.assertRaises(
PodProblem,
wait_for_reactor(send_pod_commissioning_results),
client,
pod.id,
pod.name,
pod.power_type,
node.system_id,
pod.power_parameters,
token.consumer.key,
token.key,
token.secret,
metadata_url,
)
self.assertEqual(
f"Unable to send commissioning results for {pod.name}({pod.id}) "
f"because `{pod.power_type}` driver does not implement the "
"'send_pod_commissioning_results' method.",
str(error),
)
def make_valid_repo_params(self, repo=None):
# Helper that creates a valid PackageRepository and parameters for a
# PackageRepositoryForm that will validate.
if repo is None:
repo = factory.make_PackageRepository()
name = factory.make_name('name')
url = factory.make_url(scheme='http')
arch1 = random.choice(PackageRepository.KNOWN_ARCHES)
arch2 = random.choice(PackageRepository.KNOWN_ARCHES)
dist1 = factory.make_name('dist')
dist2 = factory.make_name('dist')
pock1 = 'updates'
pock2 = 'backports'
comp1 = 'universe'
comp2 = 'multiverse'
disable_sources = factory.pick_bool()
enabled = factory.pick_bool()
params = {
'name': name,
'url': url,
'distributions': [dist1, dist2],
'disabled_pockets': [pock1, pock2],
'components': [comp1, comp2],
'arches': [arch1, arch2],
'enabled': enabled,
'disable_sources': disable_sources,
}
return params
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__updates_url(self):
package_repository = factory.make_PackageRepository()
url = factory.make_url(scheme='http')
form = PackageRepositoryForm(instance=package_repository,
data={'url': url})
self.assertTrue(form.is_valid(), form.errors)
package_repository = form.save()
self.assertEqual(url, package_repository.url)
def test_update(self):
user = factory.make_admin()
handler = PackageRepositoryHandler(user, {})
package_repository = factory.make_PackageRepository()
url = factory.make_url(scheme='http')
handler.update({'id': package_repository.id, 'url': url})
package_repository = reload_object(package_repository)
self.assertEquals(url, package_repository.url)
def test__class_start_commissioning_with_url_param(self):
node = factory.make_Node(status=NODE_STATUS.READY)
user = factory.make_admin()
commissioning_script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING,
parameters={
'url': {
'type': 'url'
},
})
testing_script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING,
parameters={
'url': {
'type': 'url'
},
})
mock_start_commissioning = self.patch_autospec(node,
'start_commissioning')
commissioning_input = factory.make_url(scheme='http')
testing_input = factory.make_url(scheme='http')
form = CommissionForm(instance=node,
user=user,
data={
'commissioning_scripts':
commissioning_script.name,
'testing_scripts': testing_script.name,
'%s_url' % commissioning_script.name:
commissioning_input,
'%s_url' % testing_script.name:
testing_input,
})
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertIsNotNone(node)
self.assertThat(
mock_start_commissioning,
MockCalledOnceWith(
user, False, False, False, False, [commissioning_script.name],
[testing_script.name], {
commissioning_script.name: {
'url': commissioning_input
},
testing_script.name: {
'url': testing_input
},
}))
def test_update_failure_doesnt_delete_url(self):
package_repository = factory.make_PackageRepository()
url = package_repository.url
form = PackageRepositoryForm(
instance=package_repository,
data={"url": factory.make_url(scheme="fake")},
)
self.assertFalse(form.is_valid())
self.assertEquals(url, reload_object(package_repository).url)
def test_create(self):
user = factory.make_admin()
handler = PackageRepositoryHandler(user, {})
package_repository_name = factory.make_name('package_repository_name')
handler.create({
'name': package_repository_name,
'url': factory.make_url(scheme='http'),
})
self.assertIsNotNone(
PackageRepository.objects.get(name=package_repository_name))
def test__input_url_allows_hostname_url(self):
script = factory.make_Script(parameters={"url": {"type": "url"}})
input = factory.make_url(scheme=self.pick_scheme())
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__updates_url(self):
package_repository = factory.make_PackageRepository()
url = factory.make_url(scheme='http')
form = PackageRepositoryForm(instance=package_repository,
data={'url': url})
self.assertTrue(form.is_valid(), form.errors)
request = HttpRequest()
request.user = factory.make_User()
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
package_repository = form.save(endpoint, request)
self.assertEqual(url, package_repository.url)
