def test_read_404_when_bad_id(self):
uri = reverse('discovery_handler', args=[random.randint(10000, 20000)])
response = self.client.get(uri)
self.assertThat(response, HasStatusCode(http.client.NOT_FOUND))
def test_read_notification_for_admins(self):
notification = factory.make_Notification(admins=True)
uri = get_notification_uri(notification)
response = self.client.get(uri)
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test_delete_is_for_admins_only(self):
notification = factory.make_Notification()
uri = get_notification_uri(notification)
response = self.client.delete(uri)
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test_create(self):
uri = get_notifications_uri()
response = self.client.post(uri, {"message": factory.make_name()})
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test_dismiss_notification_for_other(self):
other = factory.make_User()
notification = factory.make_Notification(user=other)
uri = get_notification_uri(notification)
response = self.client.post(uri, {"op": "dismiss"})
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_PUT_admin_only(self):
script_set = self.make_scriptset()
response = self.client.put(self.get_script_result_uri(script_set))
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
self.assertIsNotNone(reload_object(script_set))
def test_PUT_filters(self):
self.become_admin()
scripts = [factory.make_Script() for _ in range(10)]
script_set = self.make_scriptset()
script_results = {}
for script in scripts:
script_result = factory.make_ScriptResult(script_set=script_set,
script=script)
script_results[script_result.name] = script_result
results_list = list(script_results.values())
filtered_results = [random.choice(results_list) for _ in range(3)]
response = self.client.get(
self.get_script_result_uri(script_set),
{
"filters":
"%s,%s,%d" % (
filtered_results[0].name,
random.choice([
tag for tag in filtered_results[1].script.tags
if "tag" in tag
]),
filtered_results[2].id,
)
},
)
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop("results")
self.assertDictEqual(
{
"id":
script_set.id,
"system_id":
script_set.node.system_id,
"type":
script_set.result_type,
"type_name":
script_set.result_type_name,
"last_ping":
fmt_time(script_set.last_ping),
"status":
script_set.status,
"status_name":
script_set.status_name,
"started":
fmt_time(script_set.started),
"ended":
fmt_time(script_set.ended),
"runtime":
script_set.runtime,
"resource_uri":
"/MAAS/api/2.0/nodes/%s/results/%d/" %
(script_set.node.system_id, script_set.id),
},
parsed_result,
)
for result in results:
self.assertIn(
result["name"],
[script_result.name for script_result in filtered_results],
)
script_result = script_results[result["name"]]
self.assertDictEqual(
{
"id": script_result.id,
"name": script_result.name,
"created": fmt_time(script_result.created),
"updated": fmt_time(script_result.updated),
"status": script_result.status,
"status_name": script_result.status_name,
"exit_status": script_result.exit_status,
"started": fmt_time(script_result.started),
"ended": fmt_time(script_result.ended),
"runtime": script_result.runtime,
"starttime": script_result.starttime,
"endtime": script_result.endtime,
"estimated_runtime": script_result.estimated_runtime,
"parameters": script_result.parameters,
"script_id": script_result.script_id,
"script_revision_id": script_result.script_version_id,
"suppressed": script_result.suppressed,
},
result,
)
def test_PUT_admin_only(self):
script = factory.make_Script()
response = self.client.put(self.get_script_uri(script))
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_revert_admin_only(self):
script = factory.make_Script()
response = self.client.post(self.get_script_uri(script),
{'op': 'revert'})
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_DELETE_admin_only(self):
script = factory.make_Script()
response = self.client.delete(self.get_script_uri(script))
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
self.assertIsNotNone(reload_object(script))
def test_DELETE_prevents_deleting_default(self):
self.become_admin()
script = factory.make_Script(default=True)
response = self.client.delete(self.get_script_uri(script))
self.assertThat(response, HasStatusCode(http.client.BAD_REQUEST))
self.assertIsNotNone(reload_object(script))
def test_POST_requires_admin(self):
response = self.client.post(self.get_scripts_uri())
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_get_api_version(self):
response = self.client.get(reverse('api_version'))
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertIn('text/plain', response['Content-Type'])
self.assertEqual(b'2.0', response.content)
def get_api_results(self, *args, **kwargs):
uri = get_discoveries_uri()
response = self.client.get(uri, *args, **kwargs)
self.assertThat(response, HasStatusCode(http.client.OK))
results = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
return results
def test__method_not_allowed_on_delete(self):
response = self.client.delete(reverse("csrf"))
self.assertThat(response, HasStatusCode(HTTPStatus.METHOD_NOT_ALLOWED))
def test_revert_requires_to(self):
self.become_admin()
script = factory.make_Script()
response = self.client.post(self.get_script_uri(script),
{'op': 'revert'})
self.assertThat(response, HasStatusCode(http.client.BAD_REQUEST))
def test__forbidden_when_not_authenticated(self):
response = self.client.post(reverse("csrf"))
self.assertThat(response, HasStatusCode(HTTPStatus.FORBIDDEN))
def test_api_doc_accessibility(self):
self.patch(sys, "stderr", StringIO())
response = self.client.get(reverse('api-doc'))
self.assertThat(response, HasStatusCode(http.client.OK))
# No error or warning are emitted by docutils.
self.assertEqual("", sys.stderr.getvalue())
def test_PUT_include_output(self):
self.become_admin()
script_set = self.make_scriptset()
script_results = {}
for _ in range(3):
script_result = factory.make_ScriptResult(script_set=script_set)
script_results[script_result.name] = script_result
response = self.client.put(self.get_script_result_uri(script_set),
{"include_output": True})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_result = json_load_bytes(response.content)
results = parsed_result.pop("results")
self.assertDictEqual(
{
"id":
script_set.id,
"system_id":
script_set.node.system_id,
"type":
script_set.result_type,
"type_name":
script_set.result_type_name,
"last_ping":
fmt_time(script_set.last_ping),
"status":
script_set.status,
"status_name":
script_set.status_name,
"started":
fmt_time(script_set.started),
"ended":
fmt_time(script_set.ended),
"runtime":
script_set.runtime,
"resource_uri":
"/MAAS/api/2.0/nodes/%s/results/%d/" %
(script_set.node.system_id, script_set.id),
},
parsed_result,
)
for result in results:
script_result = script_results[result["name"]]
self.assertDictEqual(
{
"id": script_result.id,
"name": script_result.name,
"created": fmt_time(script_result.created),
"updated": fmt_time(script_result.updated),
"status": script_result.status,
"status_name": script_result.status_name,
"exit_status": script_result.exit_status,
"started": fmt_time(script_result.started),
"ended": fmt_time(script_result.ended),
"runtime": script_result.runtime,
"starttime": script_result.starttime,
"endtime": script_result.endtime,
"estimated_runtime": script_result.estimated_runtime,
"parameters": script_result.parameters,
"script_id": script_result.script_id,
"script_revision_id": script_result.script_version_id,
"suppressed": script_result.suppressed,
"output": b64encode(script_result.output).decode(),
"stdout": b64encode(script_result.stdout).decode(),
"stderr": b64encode(script_result.stderr).decode(),
"result": b64encode(script_result.result).decode(),
},
result,
)
def test_POST_is_forbidden(self):
response = self.client.post(self.get_url(),
{"name": factory.make_name("script")})
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_read(self):
uri = get_notifications_uri()
response = self.client.get(uri)
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test_GET_returns_script_contents(self):
script = factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING)
response = self.client.get(self.get_url(script.name))
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertEqual(script.script.data, response.content.decode("utf-8"))
def test_dismiss_notification_for_self(self):
notification = factory.make_Notification(user=self.user)
uri = get_notification_uri(notification)
response = self.client.post(uri, {"op": "dismiss"})
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertThat(notification, HasBeenDismissedBy(self.user))
def test_DELETE_is_forbidden(self):
script = factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING)
response = self.client.put(self.get_url(script.name))
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_read_notification_for_other(self):
other = factory.make_User()
notification = factory.make_Notification(user=other)
uri = get_notification_uri(notification)
response = self.client.get(uri)
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test_GET_is_forbidden(self):
response = self.client.get(self.get_url())
self.assertThat(response, HasStatusCode(http.client.FORBIDDEN))
def test_update_is_for_admins_only(self):
notification = factory.make_Notification()
message_new = factory.make_name("message")
uri = get_notification_uri(notification)
response = self.client.put(uri, {"message": message_new})
self.assertThat(response, HasStatusCode(http.client.UNAUTHORIZED))
def test__rejects_GET(self):
response = self.client.get(reverse("authenticate"))
self.assertThat(response, HasStatusCode(HTTPStatus.METHOD_NOT_ALLOWED))
self.assertThat(response["Allow"], Equals("POST"))
def test_health_status(self):
self.become_admin()
machine = factory.make_Machine(owner=self.user)
commissioning_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING, node=machine)
testing_script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.TESTING, node=machine)
make_script_result = partial(
factory.make_ScriptResult,
script_set=testing_script_set,
status=factory.pick_choice(SCRIPT_STATUS_CHOICES,
but_not=[SCRIPT_STATUS.ABORTED]),
)
commissioning_script_result = make_script_result(
script_set=commissioning_script_set,
script=factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
)
cpu_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.CPU,
))
memory_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.MEMORY,
))
network_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NETWORK,
))
storage_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.STORAGE,
))
node_script_result = make_script_result(script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NODE,
))
interface_script_result = make_script_result(
script=factory.make_Script(
script_type=SCRIPT_TYPE.TESTING,
hardware_type=HARDWARE_TYPE.NETWORK,
))
testing_script_results = (
machine.get_latest_testing_script_results.exclude(
status=SCRIPT_STATUS.ABORTED))
testing_status = get_status_from_qs(testing_script_results)
response = self.client.get(self.get_node_uri(machine))
parsed_result = json_load_bytes(response.content)
def status(s):
return get_status_from_qs([s])
def status_name(s):
return SCRIPT_STATUS_CHOICES[status(s)][1]
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertEquals(
status(commissioning_script_result),
parsed_result["commissioning_status"],
)
self.assertEquals(
status_name(commissioning_script_result),
parsed_result["commissioning_status_name"],
)
self.assertEquals(testing_status, parsed_result["testing_status"])
self.assertEquals(
SCRIPT_STATUS_CHOICES[testing_status][1],
parsed_result["testing_status_name"],
)
self.assertEquals(status(cpu_script_result),
parsed_result["cpu_test_status"])
self.assertEquals(
status_name(cpu_script_result),
parsed_result["cpu_test_status_name"],
)
self.assertEquals(status(memory_script_result),
parsed_result["memory_test_status"])
self.assertEquals(
status_name(memory_script_result),
parsed_result["memory_test_status_name"],
)
self.assertEquals(status(network_script_result),
parsed_result["network_test_status"])
self.assertEquals(
status_name(network_script_result),
parsed_result["network_test_status_name"],
)
self.assertEquals(status(storage_script_result),
parsed_result["storage_test_status"])
self.assertEquals(
status_name(storage_script_result),
parsed_result["storage_test_status_name"],
)
self.assertEquals(status(node_script_result),
parsed_result["other_test_status"])
self.assertEquals(
status_name(node_script_result),
parsed_result["other_test_status_name"],
)
self.assertEquals(
status(interface_script_result),
parsed_result["interface_test_status"],
)
self.assertEquals(
status_name(interface_script_result),
parsed_result["interface_test_status_name"],
)
def test__scan__with_no_cidrs_does_not_call_scan_all_networks(self):
response = self.post_api_response({'op': 'scan'})
self.assertThat(response, HasStatusCode(http.client.BAD_REQUEST))
