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, {})