def test_form_invalid_does_not_save_into_db(self):
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
request = HttpRequest()
request.user = factory.make_User()
value_too_long = factory.make_string(20)
form = TestOptionForm({"field1": value_too_long, "field2": False})
result = form.save(endpoint, request)
self.assertFalse(result, form._errors)
self.assertIn("field1", form._errors)
self.assertIsNone(Config.objects.get_config("field1"))
self.assertIsNone(Config.objects.get_config("field2"))
def test_PUT_update_updates_pod_default_macvlan_mode(self):
self.patch(pods, "post_commit_do")
pod_info = self.make_pod_info()
pod = factory.make_Pod(pod_type=pod_info["type"])
default_macvlan_mode = factory.pick_choice(MACVLAN_MODE_CHOICES)
self.fake_pod_discovery()
response = self.client.put(
get_pod_uri(pod), {"default_macvlan_mode": default_macvlan_mode})
self.assertEqual(http.client.OK, response.status_code,
response.content)
pod.refresh_from_db()
self.assertEqual(pod.default_macvlan_mode, default_macvlan_mode)
def test__cannt_run_destructive_test_on_non_machine(self):
script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING,
destructive=True)
node = factory.make_Node(node_type=factory.pick_choice(
NODE_TYPE_CHOICES, but_not=[NODE_TYPE.MACHINE]))
user = factory.make_admin()
form = TestForm(instance=node,
user=user,
data={
'testing_scripts': script.name,
})
self.assertFalse(form.is_valid())
def test_create_audit_event_creates_audit_event_with_AnonymousUser(self):
request = HttpRequest()
request.user = AnonymousUser()
request.META = {
"HTTP_USER_AGENT": factory.make_name("user_agent"),
"HTTP_HOST": factory.make_ipv4_address(),
}
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
create_audit_event(EVENT_TYPES.NODE_PXE_REQUEST, endpoint, request)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertIsNone(event.user_id)
def test_creates_audit_event_on_save(self):
user = factory.make_User()
key_string = get_data('data/test_x509_0.pem')
form = SSLKeyForm(
user=user,
data={'key': key_string})
request = HttpRequest()
request.user = user
form.save(factory.pick_choice(ENDPOINT_CHOICES), request)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEquals(event.description, "Created SSL key.")
def test_can_use_parallel(self):
script_parallel = factory.pick_choice(SCRIPT_PARALLEL_CHOICES)
form = ScriptForm(
data={
"name": factory.make_name("name"),
"script": factory.make_script_content(),
"parallel": script_parallel,
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(script_parallel, script.parallel)
def test_default_ports_package_repository_arches(self):
package_repository = PackageRepository.objects.get(
name="ports_archive")
form = PackageRepositoryForm(instance=package_repository,
data={"arches": []})
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.assertItemsEqual(package_repository.arches,
PackageRepository.PORTS_ARCHES)
def test_manager_set_config_creates_audit_event(self):
user = factory.make_User()
request = HttpRequest()
request.user = user
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
Config.objects.set_config("name", "value", endpoint, request)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEqual(
event.description,
"Updated configuration setting 'name' to 'value'.",
)
def test__can_use_script_type_name(self):
script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
form = ScriptForm(
data={
'name': factory.make_name('name'),
'script': factory.make_script_content(),
'type': script_type,
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(script_type, script.script_type)
def test__can_use_hardware_type_name(self):
hardware_type = factory.pick_choice(HARDWARE_TYPE_CHOICES)
form = ScriptForm(
data={
'name': factory.make_name('name'),
'script': factory.make_script_content(),
'hardware_type': hardware_type,
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(hardware_type, script.hardware_type)
def test_abort_fails_for_unsupported_operation(self):
status = factory.pick_choice(
NODE_STATUS_CHOICES, but_not=[
NODE_STATUS.DISK_ERASING,
NODE_STATUS.COMMISSIONING,
NODE_STATUS.DEPLOYING,
NODE_STATUS.TESTING,
])
node = factory.make_Node(status=status)
response = self.client.post(
self.get_node_uri(node), {'op': 'abort'})
self.assertEqual(http.client.CONFLICT, response.status_code)
def test__arches_validation(self):
package_repository = factory.make_PackageRepository()
form = PackageRepositoryForm(instance=package_repository,
data={'arches': ['i286']})
self.assertEqual([
"'i286' is not a valid architecture. Known architectures: "
'amd64, arm64, armhf, i386, ppc64el, s390x'
], form.errors.get('arches'))
request = HttpRequest()
request.user = factory.make_User()
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
self.assertRaises(ValueError, form.save, endpoint, request)
def test_updates_enabled(self):
package_repository = factory.make_PackageRepository()
enabled = not package_repository.enabled
form = PackageRepositoryForm(
instance=package_repository, data={"enabled": enabled}
)
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(enabled, package_repository.enabled)
def test_create_package_repository_defaults_to_enabled(self):
repo = factory.make_PackageRepository()
params = self.make_valid_repo_params(repo)
del params["enabled"]
form = PackageRepositoryForm(data=params)
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.assertAttributes(package_repository, params)
self.assertTrue(package_repository.enabled)
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)
def test_creates_audit_event_for_specified_user_on_save(self):
specified_user = factory.make_User()
request_user = factory.make_User()
key_string = get_data("data/test_rsa0.pub")
form = SSHKeyForm(user=specified_user, data={"key": key_string})
request = HttpRequest()
request.user = request_user
form.save(factory.pick_choice(ENDPOINT_CHOICES), request)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEqual(event.description,
"Created SSH key for %s." % specified_user)
def test__updates_subnet_when_node_set(self):
dhcp_snippet = factory.make_DHCPSnippet(node=factory.make_Node())
subnet = factory.make_Subnet()
form = DHCPSnippetForm(instance=dhcp_snippet,
data={'subnet': subnet.id})
self.assertTrue(form.is_valid(), form.errors)
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
request = HttpRequest()
request.user = factory.make_User()
dhcp_snippet = form.save(endpoint, request)
self.assertIsNone(dhcp_snippet.node)
self.assertEquals(subnet, dhcp_snippet.subnet)
def test__loads_yaml_embedded_attributes(self):
embedded_yaml = {
'name': factory.make_name('name'),
'title': factory.make_name('title'),
'description': factory.make_name('description'),
'tags': [factory.make_name('tag') for _ in range(3)],
'script_type': factory.pick_choice(SCRIPT_TYPE_CHOICES),
'hardware_type': factory.pick_choice(HARDWARE_TYPE_CHOICES),
'parallel': factory.pick_choice(SCRIPT_PARALLEL_CHOICES),
'results': ['write_speed'],
'parameters': [{
'type': 'storage'
}, {
'type': 'runtime'
}],
'packages': {
'apt': [factory.make_name('package')]
},
'timeout': random.randint(0, 1000),
'destructive': factory.pick_bool(),
}
script_content = factory.make_script_content(embedded_yaml)
form = ScriptForm(data={'script': script_content})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(embedded_yaml['name'], script.name)
self.assertEquals(embedded_yaml['title'], script.title)
self.assertEquals(embedded_yaml['description'], script.description)
self.assertThat(script.tags, ContainsAll(embedded_yaml['tags']))
self.assertEquals(embedded_yaml['script_type'], script.script_type)
self.assertEquals(embedded_yaml['hardware_type'], script.hardware_type)
self.assertEquals(embedded_yaml['parallel'], script.parallel)
self.assertItemsEqual(embedded_yaml['results'], script.results)
self.assertItemsEqual(embedded_yaml['parameters'], script.parameters)
self.assertDictEqual(embedded_yaml['packages'], script.packages)
self.assertEquals(timedelta(0, embedded_yaml['timeout']),
script.timeout)
self.assertEquals(embedded_yaml['destructive'], script.destructive)
self.assertFalse(script.default)
self.assertEquals(script_content, script.script.data)
def test__updates_arches(self):
package_repository = factory.make_PackageRepository()
arch1 = random.choice(PackageRepository.KNOWN_ARCHES)
arch2 = random.choice(PackageRepository.KNOWN_ARCHES)
arch3 = random.choice(PackageRepository.KNOWN_ARCHES)
form = PackageRepositoryForm(instance=package_repository,
data={'arches': [arch1, arch2, arch3]})
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([arch1, arch2, arch3], package_repository.arches)
def test_update_service_for_updates_service_status_and_info(self):
controller = factory.make_RegionController()
Service.objects.create_services_for(controller)
service = random.choice(list(REGION_SERVICES))
status = factory.pick_choice(SERVICE_STATUS_CHOICES)
info = factory.make_name("info")
observed = Service.objects.update_service_for(
controller, service, status, info)
self.assertThat(
reload_object(observed),
MatchesStructure.byEquality(
node=controller, name=service,
status=status, status_info=info))
def test_PUT_update_updates_pod_default_macvlan_mode(self):
self.become_admin()
pod_info = self.make_pod_info()
pod = factory.make_Pod(pod_type=pod_info['type'])
default_macvlan_mode = factory.pick_choice(MACVLAN_MODE_CHOICES)
self.fake_pod_discovery()
response = self.client.put(get_pod_uri(pod), {
'default_macvlan_mode': default_macvlan_mode,
})
self.assertEqual(
http.client.OK, response.status_code, response.content)
pod.refresh_from_db()
self.assertEqual(pod.default_macvlan_mode, default_macvlan_mode)
def test__creates_package_repository_defaults_main_arches(self):
repo = factory.make_PackageRepository(arches=[])
params = self.make_valid_repo_params(repo)
del params['arches']
form = PackageRepositoryForm(data=params)
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.assertAttributes(package_repository, params)
self.assertItemsEqual(package_repository.arches,
PackageRepository.MAIN_ARCHES)
def test__updates_value(self):
dhcp_snippet = factory.make_DHCPSnippet()
old_value = dhcp_snippet.value.data
new_value = factory.make_string()
form = DHCPSnippetForm(instance=dhcp_snippet,
data={'value': new_value})
self.assertTrue(form.is_valid(), form.errors)
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
request = HttpRequest()
request.user = factory.make_User()
dhcp_snippet = form.save(endpoint, request)
self.assertEqual(new_value, dhcp_snippet.value.data)
self.assertEqual(old_value, dhcp_snippet.value.previous_version.data)
def test_store_result_only_allows_status_running(self):
# XXX ltrager 2016-12-07 - Only allow SCRIPT_STATUS.RUNNING once
# status tracking is implemented.
script_result = factory.make_ScriptResult(
status=factory.pick_choice(
SCRIPT_STATUS_CHOICES,
[
SCRIPT_STATUS.PENDING,
SCRIPT_STATUS.INSTALLING,
SCRIPT_STATUS.RUNNING,
]))
self.assertRaises(
AssertionError, script_result.store_result, random.randint(0, 255))
def test_GET_filters_by_type(self):
node = factory.make_Node()
result_type = factory.pick_choice(RESULT_TYPE_CHOICES)
script_sets = [
factory.make_ScriptSet(result_type=result_type, node=node)
for _ in range(3)
]
for _ in range(10):
factory.make_ScriptSet(node=node,
result_type=factory.pick_choice(
RESULT_TYPE_CHOICES,
but_not=[result_type]))
response = self.client.get(self.get_script_results_uri(node),
{'type': result_type})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual(
[script_set.id for script_set in script_sets],
[parsed_result['id'] for parsed_result in parsed_results])
def test_GET_filters_by_hardware_type(self):
script = factory.make_Script()
for _ in range(3):
factory.make_Script(hardware_type=factory.pick_choice(
HARDWARE_TYPE_CHOICES, but_not=[script.hardware_type]))
response = self.client.get(self.get_scripts_uri(),
{'hardware_type': script.hardware_type})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual([script.id],
[result['id'] for result in parsed_results])
def test__updates_name(self):
dhcp_snippet = factory.make_DHCPSnippet()
name = factory.make_name('name')
form = DHCPSnippetForm(instance=dhcp_snippet, data={'name': name})
self.assertTrue(form.is_valid(), form.errors)
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
request = HttpRequest()
request.user = factory.make_User()
dhcp_snippet = form.save(endpoint, request)
self.assertEqual(name, dhcp_snippet.name)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEqual(event.description,
"Updated DHCP snippet '%s'." % dhcp_snippet.name)
def test_validates_composite_form(self):
endpoint = factory.pick_choice(ENDPOINT_CHOICES)
request = HttpRequest()
request.user = factory.make_User()
value1 = factory.make_string(5)
value2 = factory.make_string(5)
form = TestCompositeForm({
"maas_name": value1,
"non_config_field": value2
})
result = form.save(endpoint, request)
self.assertTrue(result, form._errors)
self.assertEqual(value1, Config.objects.get_config("maas_name"))
def test__update_prohibits_most_field_updates_on_default_script(self):
script = factory.make_Script(default=True)
for name, field in ScriptForm.base_fields.items():
if name in ['tags', 'timeout']:
continue
elif name == 'type':
value = factory.pick_choice(SCRIPT_TYPE_CHOICES)
elif name == 'destructive':
value = factory.pick_bool()
else:
value = factory.make_string()
form = ScriptForm(data={name: value}, instance=script)
self.assertFalse(form.is_valid())
self.assertEquals(1, VersionedTextFile.objects.all().count())
def test_update_script(self):
load_builtin_scripts()
update_script_values = random.choice(BUILTIN_SCRIPTS)
script = Script.objects.get(name=update_script_values.name)
# Fields which we can update
orig_title = script.title
orig_description = script.description
orig_script_type = script.script_type
orig_results = script.results
orig_parameters = script.parameters
script.title = factory.make_string()
script.description = factory.make_string()
script.script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
script.results = [factory.make_name("result")]
script.script.parameters = {
factory.make_name("param"): {
"type": "storage"
}
}
# Put fake old data in to simulate updating a script.
old_script = VersionedTextFile.objects.create(
data=factory.make_string())
script.script = old_script
# User changeable fields.
user_tags = [factory.make_name("tag") for _ in range(3)]
script.tags = copy.deepcopy(user_tags)
user_timeout = timedelta(random.randint(0, 1000))
script.timeout = user_timeout
script.save()
load_builtin_scripts()
script = reload_object(script)
self.assertEquals(orig_title, script.title, script.name)
self.assertEquals(orig_description, script.description, script.name)
self.assertEquals(orig_script_type, script.script_type, script.name)
self.assertDictEqual(orig_results, script.results, script.name)
self.assertDictEqual(orig_parameters, script.parameters, script.name)
self.assertThat(script.tags, ContainsAll(user_tags))
self.assertEquals(user_timeout, script.timeout)
self.assertEquals(old_script, script.script.previous_version)
self.assertEquals("Updated by maas-%s" % get_maas_version(),
script.script.comment)
self.assertTrue(script.default)
