def test_store_result_sets_status_to_passed_with_exit_code_zero(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.RUNNING)
script_result.store_result(0)
self.assertEqual(SCRIPT_STATUS.PASSED, script_result.status)
self.assertEqual(0, script_result.exit_status)
def test_GET_filters(self):
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,
}, result)
def test_store_result_sets_status_to_timedout_with_timedout_true(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.RUNNING)
script_result.store_result(random.randint(0, 255), timedout=True)
self.assertEqual(SCRIPT_STATUS.TIMEDOUT, script_result.status)
def test_get_endtime(self):
now = datetime.now()
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.PASSED,
started=now,
ended=now)
self.assertEqual(now.timestamp(), script_result.endtime)
def test_read_results_ignores_empty(self):
script_result = factory.make_ScriptResult(result=b"")
self.assertDictEqual({}, script_result.read_results())
def test_name_returns_model_script_name_when_no_script(self):
script_result = factory.make_ScriptResult()
script_result.script = None
script_name = factory.make_name("script_name")
script_result.script_name = script_name
self.assertEqual(script_name, script_result.name)
def test_name_returns_unknown_when_no_script_or_model_script_name(self):
script_result = factory.make_ScriptResult()
script_result.script = None
script_result.script_name = None
self.assertEqual("Unknown", script_result.name)
def test_not_suppressed_by_default(self):
script_result = factory.make_ScriptResult()
self.assertFalse(script_result.suppressed)
def test_suppressed(self):
script_result = factory.make_ScriptResult(suppressed=True)
self.assertTrue(script_result.suppressed)
def test_get_runtime_blank_when_missing(self):
script_set = factory.make_ScriptSet()
factory.make_ScriptResult(script_set=script_set,
status=SCRIPT_STATUS.PENDING)
self.assertEquals('', script_set.runtime)
def test_read_results_does_not_require_results(self):
result = {'status': random.choice(
['passed', 'failed', 'degraded', 'timedout'])}
script_result = factory.make_ScriptResult(
result=yaml.safe_dump(result).encode())
self.assertDictEqual(result, script_result.read_results())
def test_regenerate(self):
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
passed_storage_script = factory.make_Script(
parameters={'storage': {
'type': 'storage'
}})
passed_storage_parameters = {
'storage': {
'type': 'storage',
'value': {
'name': factory.make_name('name'),
'model': factory.make_name('model'),
'serial': factory.make_name('serial'),
'id_path': '/dev/%s' % factory.make_name('id_path'),
},
}
}
passed_storage_script_result = factory.make_ScriptResult(
script_set=script_set,
status=SCRIPT_STATUS.PASSED,
script=passed_storage_script,
parameters=passed_storage_parameters)
pending_storage_script = factory.make_Script(
parameters={'storage': {
'type': 'storage'
}})
pending_storage_parameters = {
'storage': {
'type': 'storage',
'value': {
'name': factory.make_name('name'),
'model': factory.make_name('model'),
'serial': factory.make_name('serial'),
'id_path': '/dev/%s' % factory.make_name('id_path'),
},
}
}
pending_storage_script_result = factory.make_ScriptResult(
script_set=script_set,
status=SCRIPT_STATUS.PENDING,
script=pending_storage_script,
parameters=pending_storage_parameters)
pending_other_script = factory.make_ScriptResult(script_set=script_set)
script_set.regenerate()
passed_storage_script_result = reload_object(
passed_storage_script_result)
self.assertIsNotNone(passed_storage_script_result)
self.assertDictEqual(passed_storage_parameters,
passed_storage_script_result.parameters)
self.assertIsNone(reload_object(pending_storage_script_result))
self.assertIsNotNone(reload_object(pending_other_script))
new_storage_script_result = script_set.scriptresult_set.get(
script=pending_storage_script)
bd = node.physicalblockdevice_set.first()
self.assertDictEqual(
{
'storage': {
'type': 'storage',
'value': {
'name': bd.name,
'model': bd.model,
'serial': bd.serial,
'id_path': bd.id_path,
'physical_blockdevice_id': bd.id,
}
}
}, new_storage_script_result.parameters)
def test_store_result_only_allows_when_result_is_blank(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.RUNNING,
result=factory.make_bytes())
self.assertRaises(AssertionError, script_result.store_result,
random.randint(0, 255))
def test_read_results_ignores_empty(self):
script_result = factory.make_ScriptResult(result=b'')
self.assertIsNone(script_result.read_results())
def test_store_result_sets_status_to_failed_with_exit_code_non_zero(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.RUNNING)
exit_status = random.randint(1, 255)
script_result.store_result(exit_status)
self.assertEqual(SCRIPT_STATUS.FAILED, script_result.status)
self.assertEqual(exit_status, script_result.exit_status)
def test_read_results_errors_when_not_dict(self):
script_result = factory.make_ScriptResult(
result=factory.make_name('invalid').encode())
with self.assertRaisesRegex(ValidationError,
'YAML must be a dictionary.'):
script_result.read_results()
def test_name_returns_script_name(self):
script_result = factory.make_ScriptResult()
self.assertEqual(script_result.script.name, script_result.name)
def test_mark_nodes_failed_after_script_overrun(self):
node, script_set = self.make_node()
current_time = now()
script_set.last_ping = current_time
script_set.save()
passed_script_result = factory.make_ScriptResult(
script_set=script_set, status=SCRIPT_STATUS.PASSED
)
failed_script_result = factory.make_ScriptResult(
script_set=script_set, status=SCRIPT_STATUS.FAILED
)
pending_script_result = factory.make_ScriptResult(
script_set=script_set, status=SCRIPT_STATUS.PENDING
)
script = factory.make_Script(timeout=timedelta(seconds=60))
running_script_result = factory.make_ScriptResult(
script_set=script_set,
status=SCRIPT_STATUS.RUNNING,
script=script,
started=current_time - timedelta(minutes=10),
)
mark_nodes_failed_after_missing_script_timeout(current_time, 20)
node = reload_object(node)
self.assertEquals(self.failed_status, node.status)
self.assertEquals(
"%s has run past it's timeout(%s)"
% (
running_script_result.name,
str(running_script_result.script.timeout),
),
node.error_description,
)
self.assertIn(
call(
"%s: %s has run past it's timeout(%s)"
% (
node.hostname,
running_script_result.name,
str(running_script_result.script.timeout),
)
),
self.maaslog.call_args_list,
)
if node.enable_ssh:
self.assertThat(self.mock_stop, MockNotCalled())
else:
self.assertThat(self.mock_stop, MockCalledOnce())
self.assertIn(
call("%s: Stopped because SSH is disabled" % node.hostname),
self.maaslog.call_args_list,
)
self.assertEquals(
SCRIPT_STATUS.PASSED, reload_object(passed_script_result).status
)
self.assertEquals(
SCRIPT_STATUS.FAILED, reload_object(failed_script_result).status
)
self.assertEquals(
SCRIPT_STATUS.ABORTED, reload_object(pending_script_result).status
)
self.assertEquals(
SCRIPT_STATUS.TIMEDOUT, reload_object(running_script_result).status
)
def test_save_stores_start_time(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.PENDING)
script_result.status = SCRIPT_STATUS.RUNNING
script_result.save(update_fields=["status"])
self.assertIsNotNone(reload_object(script_result).started)
def create_scriptresult(self, script_set, params=None):
if params is None:
params = {}
return factory.make_ScriptResult(script_set=script_set, **params)
def test_get_runtime_blank_when_missing(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.PENDING)
self.assertEqual("", script_result.runtime)
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_get_endtime_None(self):
script_result = factory.make_ScriptResult(status=SCRIPT_STATUS.PENDING)
self.assertEqual("", script_result.endtime)
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_read_results_errors_when_invalid_yaml(self):
script_result = factory.make_ScriptResult(result=b"{")
self.assertRaises(ValidationError, script_result.read_results)
def test_GET_include_output(self):
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.get(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,
'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)
