def test_on_listen_returns_None_if_system_id_not_in_cache(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
script_result = factory.make_ScriptResult()
self.assertIsNone(
handler.on_listen(
sentinel.channel, sentinel.action, script_result.id))
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 get_suppressible_script_results(self, params):
"""Return a dictionary with Nodes system_ids mapped to lists of
ScriptResults that can still be suppressed."""
node_result_handler = NodeResultHandler(self.user, {}, None)
system_ids = params.get("system_ids")
script_results = (
ScriptResult.objects.filter(
status__in=SCRIPT_STATUS_FAILED,
script_set__node__system_id__in=system_ids,
suppressed=False,
)
.defer("output", "stdout", "stderr")
.prefetch_related("script", "script_set", "script_set__node")
.defer("script__parameters", "script__packages")
.defer("script_set__requested_scripts")
)
# Create the node to script result mappings.
script_result_mappings = {}
for script_result in script_results:
if script_result.script_set.node.system_id not in (
script_result_mappings
):
script_result_mappings[
script_result.script_set.node.system_id
] = []
script_result_mappings[
script_result.script_set.node.system_id
].append(
node_result_handler.dehydrate(script_result, {}, for_list=True)
)
return script_result_mappings
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_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_node(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
self.assertEqual(node, handler.get_node({"system_id": node.system_id}))
self.assertDictEqual({node.system_id: node},
handler.cache["system_ids"])
def test_get_result_data_unknown_id(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
id = random.randint(0, 100)
self.assertEquals(
"Unknown ScriptResult id %s" % id,
handler.get_result_data({'id': id}))
def test_get_history(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node(owner=user)
script = factory.make_Script()
script_results = []
for _ in range(10):
script_set = factory.make_ScriptSet(node=node)
script_results.append(factory.make_ScriptResult(
script=script, script_set=script_set,
status=SCRIPT_STATUS.PASSED))
latest_script_result = script_results[-1]
script_results = sorted(
script_results, key=lambda i: i.id, reverse=True)
queries = CountQueries()
with queries:
ret = handler.get_history({'id': latest_script_result.id})
self.assertEqual(4, queries.num_queries)
for script_result, out in zip(script_results, ret):
self.assertDictEqual({
'id': script_result.id,
'updated': dehydrate_datetime(script_result.updated),
'status': script_result.status,
'status_name': script_result.status_name,
'runtime': script_result.runtime,
'starttime': script_result.starttime,
'endtime': script_result.endtime,
'estimated_runtime': script_result.estimated_runtime,
'suppressed': script_result.suppressed,
}, out)
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_redacts_password_parameter(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
string_script = factory.make_Script(
parameters={"string": {
"type": "string"
}})
password_script = factory.make_Script(
parameters={"password": {
"type": "password"
}})
string = factory.make_name("string")
password = factory.make_name("password")
string_script_result = factory.make_ScriptResult(
script_set=script_set,
script=string_script,
parameters={"string": {
"type": "string",
"value": string
}},
)
password_script_result = factory.make_ScriptResult(
script_set=script_set,
script=password_script,
parameters={"password": {
"type": "password",
"value": password
}},
)
for result in handler.list({"system_id": node.system_id}):
if result["id"] == string_script_result.id:
self.assertEqual(
{"string": {
"type": "string",
"value": string
}},
result["parameters"],
)
self.assertEqual(
string,
reload_object(string_script_result).parameters["string"]
["value"],
)
else:
self.assertEqual(
{"password": {
"type": "password",
"value": "REDACTED"
}},
result["parameters"],
)
self.assertEqual(
password,
reload_object(password_script_result).
parameters["password"]["value"],
)
def test_on_listen_returns_None_if_obj_no_longer_exists(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
mock_listen = self.patch(handler, "listen")
mock_listen.side_effect = HandlerDoesNotExistError()
self.assertIsNone(
handler.on_listen(
sentinel.channel, sentinel.action, random.randint(1, 1000)))
def test_get_node_from_cache(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
fake_system_id = factory.make_name("system_id")
fake_node = factory.make_name("node")
handler.cache["system_ids"][fake_system_id] = fake_node
self.assertEquals(
fake_node, handler.get_node({"system_id": fake_system_id}))
def test_on_listen_returns_None_if_listen_returns_None(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
mock_listen = self.patch(handler, "listen")
mock_listen.return_value = None
self.assertIsNone(
handler.on_listen(
sentinel.channel, sentinel.action, random.randint(1, 1000)))
def test_list_adds_to_loaded_pks(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
pks = [
factory.make_ScriptResult(script_set=script_set).id
for _ in range(3)
]
handler.list({"system_id": node.system_id})
self.assertItemsEqual(pks, handler.cache['loaded_pks'])
def test_list_limit(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
for _ in range(6):
factory.make_ScriptResult(script_set=script_set)
limit = random.randint(0, 6)
self.assertEquals(
limit,
len(handler.list({"system_id": node.system_id, "limit": limit})))
def test_on_listen_returns_handler_name_action_and_event(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
script_result = factory.make_ScriptResult()
node = script_result.script_set.node
handler.cache["system_ids"][node.system_id] = node
self.assertEqual(
(handler._meta.handler_name, sentinel.action,
self.dehydrate_script_result(script_result, handler)),
handler.on_listen(sentinel.channel, sentinel.action,
script_result.id))
def test_get_result_data_gets_result(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
result = factory.make_string().encode('utf-8')
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED, result=result,
script_set=factory.make_ScriptSet(node=node))
self.assertEquals(
result.decode(), handler.get_result_data(
{'id': script_result.id, 'data_type': 'result'}))
def test_get_result_data_gets_output(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
combined = factory.make_string().encode('utf-8')
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED, output=combined,
script_set=factory.make_ScriptSet(node=node))
self.assertEquals(
combined.decode(), handler.get_result_data(
{'id': script_result.id, 'data_type': 'combined'}))
def test_list_start(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
script_set = factory.make_ScriptSet(node=node)
for _ in range(6):
factory.make_ScriptResult(script_set=script_set)
start = random.randint(0, 5)
self.assertEquals(
6 - start,
len(handler.list({"system_id": node.system_id, "start": start})))
def test_list_only_returns_script_results_for_node(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
script_results = [
factory.make_ScriptResult(script_set=factory.make_ScriptSet(
node=node)) for _ in range(3)
]
# Other script_results.
for _ in range(3):
factory.make_ScriptResult()
self.assertItemsEqual(
self.dehydrate_script_results(script_results, handler),
handler.list({"system_id": node.system_id}))
def test_get_result_data_gets_unknown_data_type(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
combined = factory.make_string().encode('utf-8')
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED, output=combined,
script_set=factory.make_ScriptSet(node=node))
unknown_data_type = factory.make_name('data_type')
self.assertEquals(
"Unknown data_type %s" % unknown_data_type,
handler.get_result_data({
'id': script_result.id,
'data_type': unknown_data_type,
}))
def get_latest_failed_testing_script_results(self, params):
"""Return a dictionary with Nodes system_ids mapped to a list of
the latest failed ScriptResults."""
node_result_handler = NodeResultHandler(self.user, {}, None)
system_ids = params.get("system_ids")
# Create the node to script result mappings.
script_result_mappings = {}
script_results = (
ScriptResult.objects.filter(
script_set__node__system_id__in=system_ids,
script_set__result_type=RESULT_TYPE.TESTING,
)
.defer("output", "stdout", "stderr")
.prefetch_related("script", "script_set", "script_set__node")
.defer("script__parameters", "script__packages")
.defer("script_set__requested_scripts")
.order_by(
"script_set__node_id",
"script_name",
"physical_blockdevice_id",
"-id",
)
.distinct(
"script_set__node_id", "script_name", "physical_blockdevice_id"
)
)
for system_id in system_ids:
# Need to evaluate QuerySet first to get latest script results,
# then filter by results that have failed
node_script_results = [
s
for s in script_results
if s.status in SCRIPT_STATUS_FAILED
and (s.script_set.node.system_id == system_id)
]
for script_result in node_script_results:
if system_id not in script_result_mappings:
script_result_mappings[system_id] = []
mapping = node_result_handler.dehydrate(
script_result, {}, for_list=True
)
mapping["id"] = script_result.id
script_result_mappings[system_id].append(mapping)
return script_result_mappings
def test_get_node_errors_invalid_system_id(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
self.assertRaises(
HandlerDoesNotExistError,
handler.get_node,
{"system_id": factory.make_name("system_id")})
def test_list_raises_error_if_node_doesnt_exist(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
node.delete()
self.assertRaises(HandlerDoesNotExistError, handler.list,
{"system_id": node.system_id})
def test_get_result_data_gets_result(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
result = factory.make_string().encode("utf-8")
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
result=result,
script_set=factory.make_ScriptSet(node=node),
)
self.assertEquals(
result.decode(),
handler.get_result_data({
"id": script_result.id,
"data_type": "result"
}),
)
def test_get_result_data_gets_unknown_data_type(self):
user = factory.make_User()
handler = NodeResultHandler(user, {}, None)
node = factory.make_Node()
combined = factory.make_string().encode("utf-8")
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
output=combined,
script_set=factory.make_ScriptSet(node=node),
)
unknown_data_type = factory.make_name("data_type")
self.assertEquals(
"Unknown data_type %s" % unknown_data_type,
handler.get_result_data({
"id": script_result.id,
"data_type": unknown_data_type
}),
)
def test_list_has_surfaced(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
script_result = factory.make_ScriptResult(
status=SCRIPT_STATUS.PASSED,
script_set=factory.make_ScriptSet(node=node))
# Create extra script results with different nodes.
for _ in range(3):
factory.make_ScriptResult(
result=b'', 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,
"has_surfaced": True,
}))
def test_clear_removes_system_id_from_cache(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
node = factory.make_Node()
handler.list({'system_id': node.system_id})
handler.clear({'system_id': node.system_id})
self.assertDictEqual({}, handler.cache["system_ids"])
def test_get_node_errors_no_system_id(self):
user = factory.make_User()
handler = NodeResultHandler(user, {})
self.assertRaises(HandlerPKError, handler.get_node, {})
