def test_list_num_queries_is_the_expected_number(self):
owner = factory.make_admin()
for _ in range(10):
node = factory.make_RegionRackController(owner=owner)
commissioning_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.COMMISSIONING)
testing_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.TESTING)
node.current_commissioning_script_set = commissioning_script_set
node.current_testing_script_set = testing_script_set
node.save()
for __ in range(10):
factory.make_ScriptResult(status=SCRIPT_STATUS.PASSED,
script_set=commissioning_script_set)
factory.make_ScriptResult(status=SCRIPT_STATUS.PASSED,
script_set=testing_script_set)
handler = ControllerHandler(owner, {}, None)
queries_one, _ = count_queries(handler.list, {'limit': 1})
queries_total, _ = count_queries(handler.list, {})
# This check is to notify the developer that a change was made that
# affects the number of queries performed when doing a node listing.
# It is important to keep this number as low as possible. A larger
# number means regiond has to do more work slowing down its process
# and slowing down the client waiting for the response.
self.assertEqual(
queries_one, 3,
"Number of queries has changed; make sure this is expected.")
self.assertEqual(
queries_total, 3,
"Number of queries has changed; make sure this is expected.")
def test_list_hardware_type(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
script=factory.make_Script(
hardware_type=HARDWARE_TYPE.STORAGE),
script_set=factory.make_ScriptSet(node=node))
# Create extra script results with different hardware types.
for _ in range(3):
factory.make_ScriptResult(
script=factory.make_Script(
hardware_type=random.choice([
hardware_type_id
for hardware_type_id, _ in HARDWARE_TYPE_CHOICES
if hardware_type_id != HARDWARE_TYPE.STORAGE])),
script_set=factory.make_ScriptSet(node=node))
expected_output = [self.dehydrate_script_result(
script_result, handler)]
self.assertItemsEqual(expected_output, handler.list(
{
"system_id": node.system_id,
"hardware_type": HARDWARE_TYPE.STORAGE
}))
def test_list_physical_blockdevice_id(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
physical_blockdevice = factory.make_PhysicalBlockDevice(node=node)
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
physical_blockdevice=physical_blockdevice,
script_set=factory.make_ScriptSet(node=node),
)
# Create extra script results with different physical block devices.
for _ in range(3):
factory.make_ScriptResult(
physical_blockdevice=factory.make_PhysicalBlockDevice(
node=node),
script_set=factory.make_ScriptSet(node=node),
)
expected_output = [
self.dehydrate_script_result(script_result, handler)
]
self.assertItemsEqual(
expected_output,
handler.list({
"system_id": node.system_id,
"physical_blockdevice_id": physical_blockdevice.id,
}),
)
def test_list_interface_id(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
interface = factory.make_Interface(node=node)
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
interface=interface,
script_set=factory.make_ScriptSet(node=node),
)
# Create extra script results with different interfaces.
for _ in range(3):
factory.make_ScriptResult(
interface=factory.make_Interface(node=node),
script_set=factory.make_ScriptSet(node=node),
)
expected_output = [
self.dehydrate_script_result(script_result, handler)
]
self.assertItemsEqual(
expected_output,
handler.list({
"system_id": node.system_id,
"interface_id": interface.id
}),
)
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_list_result_type(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
script_set=factory.make_ScriptSet(node=node,
result_type=RESULT_TYPE.TESTING),
)
# Create extra script results with different result types.
for _ in range(3):
factory.make_ScriptResult(script_set=factory.make_ScriptSet(
node=node,
result_type=random.choice([
result_type_id for result_type_id, _ in RESULT_TYPE_CHOICES
if result_type_id != RESULT_TYPE.TESTING
]),
))
expected_output = [
self.dehydrate_script_result(script_result, handler)
]
self.assertItemsEqual(
expected_output,
handler.list({
"system_id": node.system_id,
"result_type": RESULT_TYPE.TESTING,
}),
)
def test_GET_include_output(self):
node = factory.make_Node()
script_set_ids = []
for _ in range(3):
script_set = factory.make_ScriptSet(node=node)
script_set_ids.append(script_set.id)
for _ in range(3):
factory.make_ScriptResult(script_set=script_set)
# Script sets for different nodes.
for _ in range(3):
factory.make_ScriptSet()
response = self.client.get(
self.get_script_results_uri(node), {"include_output": True}
)
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual(
script_set_ids, [result["id"] for result in parsed_results]
)
for script_set in parsed_results:
for result in script_set["results"]:
for key in ["output", "stdout", "stderr", "result"]:
self.assertIn(key, result)
def test_GET_filters(self):
node = factory.make_Node()
scripts = [factory.make_Script() for _ in range(3)]
name_filter_script = random.choice(scripts)
tag_filter_script = random.choice(scripts)
script_set_ids = []
for _ in range(3):
script_set = factory.make_ScriptSet(node=node)
script_set_ids.append(script_set.id)
for script in scripts:
factory.make_ScriptResult(script_set=script_set, script=script)
# Script sets for different nodes.
for _ in range(3):
factory.make_ScriptSet()
response = self.client.get(
self.get_script_results_uri(node),
{'filters': ','.join([
name_filter_script.name,
random.choice(tag_filter_script.tags)])})
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual(
script_set_ids,
[result['id'] for result in parsed_results])
for script_set in parsed_results:
for result in script_set['results']:
self.assertIn(
result['name'],
{name_filter_script.name, tag_filter_script.name})
self.assertNotIn('output', result)
self.assertNotIn('stdout', result)
self.assertNotIn('stderr', result)
def test_GET(self):
node = factory.make_Node()
script_set_ids = []
for _ in range(3):
script_set = factory.make_ScriptSet(node=node)
script_set_ids.append(script_set.id)
for _ in range(3):
factory.make_ScriptResult(script_set=script_set)
# Script sets for different nodes.
for _ in range(3):
factory.make_ScriptSet()
response = self.client.get(self.get_script_results_uri(node))
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual(
script_set_ids,
[result['id'] for result in parsed_results])
for script_set in parsed_results:
for result in script_set['results']:
self.assertNotIn('output', result)
self.assertNotIn('stdout', result)
self.assertNotIn('stderr', result)
def test_save_purges_orphaned_script_results_interface(self):
node = factory.make_Machine_with_Interface_on_Subnet()
iface = node.interface_set.first()
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
old_script_set = factory.make_ScriptSet(node=node)
old_script_result = factory.make_ScriptResult(
script=script,
script_set=old_script_set,
status=factory.pick_choice(SCRIPT_STATUS_CHOICES,
but_not=[SCRIPT_STATUS.PASSED]),
parameters={"interface": {
"type": "interface",
"value": "all"
}},
)
new_script_set = factory.make_ScriptSet(node=node)
new_script_result = factory.make_ScriptResult(
script=script,
script_set=new_script_set,
status=SCRIPT_STATUS.PENDING,
parameters={
"interface": {
"type": "interface",
"value": {
"interface": iface
},
}
},
)
self.assertIsNone(reload_object(old_script_result))
self.assertIsNotNone(reload_object(new_script_result))
def test_save_purges_orphaned_script_results_storage(self):
node = factory.make_Machine()
physical_blockdevice = node.physicalblockdevice_set.first()
script = factory.make_Script(
parameters={"storage": {
"type": "storage"
}})
old_script_set = factory.make_ScriptSet(node=node)
old_script_result = factory.make_ScriptResult(
script=script,
script_set=old_script_set,
status=factory.pick_choice(SCRIPT_STATUS_CHOICES,
but_not=[SCRIPT_STATUS.PASSED]),
parameters={"storage": {
"type": "storage",
"value": "all"
}},
)
new_script_set = factory.make_ScriptSet(node=node)
new_script_result = factory.make_ScriptResult(
script=script,
script_set=new_script_set,
status=SCRIPT_STATUS.PENDING,
parameters={
"storage": {
"type": "storage",
"value": {
"physical_blockdevice": physical_blockdevice
},
}
},
)
self.assertIsNone(reload_object(old_script_result))
self.assertIsNotNone(reload_object(new_script_result))
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))
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))
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)
status = lambda s: get_status_from_qs([s])
status_name = lambda s: 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(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'])
def test_delete_sets_current_testing_script_set_to_older_version(self):
node = factory.make_Node(with_empty_script_sets=True)
previous_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.TESTING)
node.current_testing_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.TESTING)
node.save()
node.current_testing_script_set.delete()
self.assertEquals(previous_script_set,
reload_object(node).current_testing_script_set)
def test_create_installation_script_set_cleans_up_past_limit(self):
script_set_limit = Config.objects.get_config(
'max_node_installation_results')
node = factory.make_Node()
for _ in range(script_set_limit * 2):
factory.make_ScriptSet(node=node,
result_type=RESULT_TYPE.INSTALLATION)
ScriptSet.objects.create_installation_script_set(node)
self.assertEquals(
script_set_limit,
ScriptSet.objects.filter(
node=node, result_type=RESULT_TYPE.INSTALLATION).count())
def test_create_commissioning_script_set_cleans_up_past_limit(self):
script_set_limit = Config.objects.get_config(
'max_node_commissioning_results')
node = factory.make_Node()
for _ in range(script_set_limit * 2):
factory.make_ScriptSet(node=node,
result_type=RESULT_TYPE.COMMISSIONING)
ScriptSet.objects.create_commissioning_script_set(node)
self.assertEquals(
script_set_limit,
ScriptSet.objects.filter(
node=node, result_type=RESULT_TYPE.COMMISSIONING).count())
def test_create_testing_script_set_cleans_up_past_limit(self):
script_set_limit = Config.objects.get_config(
'max_node_testing_results')
node = factory.make_Node()
for _ in range(script_set_limit * 2):
factory.make_ScriptSet(node=node, result_type=RESULT_TYPE.TESTING)
script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING)
ScriptSet.objects.create_testing_script_set(node,
scripts=[script.name])
self.assertEquals(
script_set_limit,
ScriptSet.objects.filter(node=node,
result_type=RESULT_TYPE.TESTING).count())
def test_store_result_runs_builtin_commissioning_hooks(self):
script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING
)
script_result = factory.make_ScriptResult(
script_set=script_set, status=SCRIPT_STATUS.RUNNING
)
exit_status = random.randint(0, 255)
stdout = factory.make_name("stdout").encode()
mock_hook = MagicMock()
scriptresult_module.NODE_INFO_SCRIPTS[script_result.name] = {
"hook": mock_hook
}
self.addCleanup(
scriptresult_module.NODE_INFO_SCRIPTS.pop, script_result.name
)
script_result.store_result(exit_status, stdout=stdout)
self.assertThat(
mock_hook,
MockCalledOnceWith(
node=script_set.node, output=stdout, exit_status=exit_status
),
)
def test_GET_filters_by_hardware_type(self):
hardware_type = factory.pick_choice(HARDWARE_TYPE_CHOICES)
script_set = factory.make_ScriptSet()
scripts = [
factory.make_Script(hardware_type=hardware_type) for _ in range(3)
]
for script in scripts:
factory.make_ScriptResult(script_set=script_set, script=script)
for _ in range(10):
script = factory.make_Script(hardware_type=factory.pick_choice(
HARDWARE_TYPE_CHOICES, but_not=[hardware_type]))
factory.make_ScriptResult(script_set=script_set, script=script)
response = self.client.get(
self.get_script_results_uri(script_set.node),
{"hardware_type": hardware_type},
)
self.assertThat(response, HasStatusCode(http.client.OK))
parsed_results = json_load_bytes(response.content)
self.assertItemsEqual(
[script.id for script in scripts],
[
parsed_result["script_id"]
for parsed_result in parsed_results[0]["results"]
],
)
def test_save_sets_interface_from_parameters(self):
node = factory.make_Machine()
script_set = factory.make_ScriptSet(node=node)
interface = factory.make_Interface(node=node)
script_result = factory.make_ScriptResult(
script_set=script_set,
parameters={
'interface': {
'type': 'interface',
'value': {
'name': interface.name,
'mac_address': str(interface.mac_address),
'vendor': interface.vendor,
'product': interface.product,
'interface': interface,
}
}
})
self.assertEquals(interface, script_result.interface)
self.assertIsNone(script_result.physical_blockdevice)
self.assertDictEqual(
{
'interface': {
'type': 'interface',
'value': {
'name': interface.name,
'mac_address': str(interface.mac_address),
'vendor': interface.vendor,
'product': interface.product,
'interface_id': interface.id,
}
}
}, script_result.parameters)
def test_ended_returns_none_when_not_all_results_finished(self):
script_set = factory.make_ScriptSet()
factory.make_ScriptResult(script_set=script_set,
status=SCRIPT_STATUS.PASSED)
factory.make_ScriptResult(script_set=script_set,
status=SCRIPT_STATUS.RUNNING)
self.assertIsNone(script_set.ended)
def test__script_changed_status_emits_event(self):
old_status = SCRIPT_STATUS.RUNNING
script_result = factory.make_ScriptResult(
status=old_status, script_set=factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING),
script=factory.make_Script())
new_status = SCRIPT_STATUS.PASSED
script_result.status = new_status
script_result.save()
latest_event = Event.objects.last()
self.assertEqual(
(
EVENT_TYPES.SCRIPT_RESULT_CHANGED_STATUS,
EVENT_DETAILS[
EVENT_TYPES.SCRIPT_RESULT_CHANGED_STATUS].description,
"%s changed status from '%s' to '%s'" % (
script_result.name, SCRIPT_STATUS_CHOICES[old_status][1],
SCRIPT_STATUS_CHOICES[new_status][1]),
),
(
latest_event.type.name,
latest_event.type.description,
latest_event.description,
))
def test_estimated_runtime_returns_average_of_previous(self):
script = factory.make_Script()
script_set = factory.make_ScriptSet()
old_results = [
factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
script=script, script_set=script_set)
for _ in range(10)
]
factory.make_ScriptResult(
status=SCRIPT_STATUS.FAILED,
script=script, script_set=script_set)
average_runtime = (old_results[9].ended - old_results[9].started)
for result in reversed(old_results[:-1]):
average_runtime += result.ended - result.started
average_runtime = average_runtime / 2
now = datetime.now()
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.RUNNING, started=now,
script=script, script_set=script_set)
expected = str(
average_runtime - timedelta(
microseconds=average_runtime.microseconds))
self.assertEquals(
expected, script_result.estimated_runtime)
def test_store_result_allows_pod_to_overwrite(self):
pod = factory.make_Pod()
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
script_result = factory.make_ScriptResult(script_set=script_set,
status=SCRIPT_STATUS.PASSED)
pod.hints.nodes.add(node)
exit_status = random.randint(0, 255)
output = factory.make_bytes()
stdout = factory.make_bytes()
stderr = factory.make_bytes()
result = factory.make_bytes()
script_result.store_result(
random.randint(0, 255),
factory.make_bytes(),
factory.make_bytes(),
factory.make_bytes(),
factory.make_bytes(),
)
script_result.store_result(exit_status, output, stdout, stderr, result)
self.assertEqual(exit_status, script_result.exit_status)
self.assertEqual(output, script_result.output)
self.assertEqual(stdout, script_result.stdout)
self.assertEqual(stderr, script_result.stderr)
self.assertEqual(result, script_result.result)
def test_status_POST_files_none_are_ignored(self):
user = factory.make_User()
node = factory.make_Node(interface=True,
status=NODE_STATUS.DEPLOYING,
owner=user)
node.current_installation_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.INSTALLATION)
node.save()
payload = {
"event_type":
"finish",
"result":
"FAILURE",
"origin":
"curtin",
"name":
"cmd-install",
"description":
"Command Install",
"timestamp":
datetime.utcnow(),
"files": [{
"path": CURTIN_INSTALL_LOG,
"encoding": "base64",
"content": None,
}],
}
self.processMessage(node, payload)
self.assertEqual(0, len(list(node.current_installation_script_set)))
def test_store_result_allows_controllers_to_overwrite(self):
node = factory.make_Node(node_type=random.choice([
NODE_TYPE.REGION_AND_RACK_CONTROLLER,
NODE_TYPE.REGION_CONTROLLER,
NODE_TYPE.RACK_CONTROLLER,
]))
script_set = factory.make_ScriptSet(node=node)
script_result = factory.make_ScriptResult(script_set=script_set,
status=SCRIPT_STATUS.PASSED)
exit_status = random.randint(0, 255)
output = factory.make_bytes()
stdout = factory.make_bytes()
stderr = factory.make_bytes()
result = factory.make_bytes()
script_result.store_result(
random.randint(0, 255),
factory.make_bytes(),
factory.make_bytes(),
factory.make_bytes(),
factory.make_bytes(),
)
script_result.store_result(exit_status, output, stdout, stderr, result)
self.assertEqual(exit_status, script_result.exit_status)
self.assertEqual(output, script_result.output)
self.assertEqual(stdout, script_result.stdout)
self.assertEqual(stderr, script_result.stderr)
self.assertEqual(result, script_result.result)
def test_store_result_logs_event_upon_hook_failure(self):
script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING
)
script_result = factory.make_ScriptResult(
script_set=script_set, status=SCRIPT_STATUS.RUNNING
)
def _raise():
raise Exception()
scriptresult_module.NODE_INFO_SCRIPTS[script_result.name] = {
"hook": _raise
}
self.addCleanup(
scriptresult_module.NODE_INFO_SCRIPTS.pop, script_result.name
)
script_result.store_result(0, stdout=b"")
expected_event = Event.objects.first()
self.assertThat(
expected_event.description,
DocTestMatches("...failed during post-processing."),
)
self.assertEquals(
reload_object(script_result).status, SCRIPT_STATUS.FAILED
)
def test_save_sets_physical_blockdevice_from_parameters(self):
node = factory.make_Machine()
script_set = factory.make_ScriptSet(node=node)
physical_blockdevice = node.physicalblockdevice_set.first()
script_result = factory.make_ScriptResult(
script_set=script_set, parameters={'storage': {
'type': 'storage',
'value': {
'name': physical_blockdevice.name,
'id_path': physical_blockdevice.id_path,
'model': physical_blockdevice.model,
'serial': physical_blockdevice.serial,
'physical_blockdevice': physical_blockdevice,
}}})
self.assertEquals(
physical_blockdevice, script_result.physical_blockdevice)
self.assertDictEqual({'storage': {
'type': 'storage',
'value': {
'name': physical_blockdevice.name,
'id_path': physical_blockdevice.id_path,
'model': physical_blockdevice.model,
'serial': physical_blockdevice.serial,
'physical_blockdevice_id': physical_blockdevice.id,
}}}, script_result.parameters)
def test_store_result_on_recommission_script_failure_does_nothing(self):
script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.COMMISSIONING
)
for script_name in NODE_INFO_SCRIPTS.keys():
factory.make_ScriptResult(
script_name=script_name,
script_set=script_set,
status=SCRIPT_STATUS.PASSED,
)
script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING, recommission=True
)
script_result = factory.make_ScriptResult(
script=script, script_set=script_set, status=SCRIPT_STATUS.PENDING
)
script_result.store_result(1)
for script_result in script_set:
if script_result.name in NODE_INFO_SCRIPTS:
self.assertEquals(SCRIPT_STATUS.PASSED, script_result.status)
self.assertIsNotNone(script_result.started)
self.assertIsNotNone(script_result.ended)
else:
self.assertEquals(SCRIPT_STATUS.FAILED, script_result.status)
def test_status_POST_files_none_are_ignored(self):
user = factory.make_User()
node = factory.make_Node(interface=True,
status=NODE_STATUS.DEPLOYING,
owner=user)
node.current_installation_script_set = factory.make_ScriptSet(
node=node, result_type=RESULT_TYPE.INSTALLATION)
node.save()
payload = {
'event_type':
'finish',
'result':
'FAILURE',
'origin':
'curtin',
'name':
'cmd-install',
'description':
'Command Install',
'timestamp':
datetime.utcnow(),
'files': [{
"path": CURTIN_INSTALL_LOG,
"encoding": "base64",
"content": None,
}]
}
self.processMessage(node, payload)
self.assertEqual(0, len(list(node.current_installation_script_set)))
def test__running_or_installing_emits_event_with_nic_disk_param(self):
node = factory.make_Node_with_Interface_on_Subnet()
script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING)
script_set = factory.make_ScriptSet(
result_type=RESULT_TYPE.TESTING, node=node)
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PENDING, script=script, script_set=script_set,
physical_blockdevice=node.boot_disk, interface=node.boot_interface)
script_result.status = random.choice(list(SCRIPT_STATUS_RUNNING))
script_result.save()
latest_event = Event.objects.last()
self.assertEqual(
(
EVENT_TYPES.RUNNING_TEST,
EVENT_DETAILS[EVENT_TYPES.RUNNING_TEST].description,
'%s on %s and %s' % (
script_result.name, node.boot_disk.name,
node.boot_interface.name)
),
(
latest_event.type.name,
latest_event.type.description,
latest_event.description,
))
