def test_ida_download_bad_uid(self):
compare_interface = CompareDbInterface(config=self.config)
compare_interface.add_compare_result(COMPARE_RESULT)
cid = compare_interface._calculate_compare_result_id(COMPARE_RESULT)
response = self.test_client.get('/ida-download/{cid}'.format(cid=cid))
self.assertIn(b'not found in database', response.data, 'endpoint should dismiss result')
def setUp(self):
self.db_interface = MongoInterfaceCommon(config=self._config)
self.db_interface_backend = BackEndDbInterface(config=self._config)
self.db_interface_compare = CompareDbInterface(config=self._config)
self.db_interface_admin = AdminDbInterface(config=self._config)
self.fw_one = create_test_firmware()
self.fw_two = create_test_firmware()
self.fw_two.set_binary(b'another firmware')
self.compare_dict = self._create_compare_dict()
def test_ida_download(self):
compare_interface = CompareDbInterface(config=self.config)
self.db_backend_interface.add_firmware(self.test_fw)
COMPARE_RESULT['general'] = {'a': {self.test_fw.uid: 'x'}, 'b': {self.test_fw.uid: 'y'}}
compare_interface.add_compare_result(COMPARE_RESULT)
cid = compare_interface._calculate_compare_result_id(COMPARE_RESULT)
response = self.test_client.get('/ida-download/{cid}'.format(cid=cid))
self.assertIn(b'IDA database', response.data, 'mocked ida database not in result')
def __init__(self, config=None, db_interface=None, testing=False, callback=None):
self.config = config
self.db_interface = db_interface if db_interface else CompareDbInterface(config=config)
self.stop_condition = Value('i', 1)
self.in_queue = Queue()
self.callback = callback
self.compare_module = Compare(config=self.config, db_interface=self.db_interface)
self.worker = ExceptionSafeProcess(target=self._compare_scheduler_main)
if not testing:
self.start()
class TestCompare(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls._config = get_config_for_testing()
cls.mongo_server = MongoMgr(config=cls._config)
def setUp(self):
self.db_interface = MongoInterfaceCommon(config=self._config)
self.db_interface_backend = BackEndDbInterface(config=self._config)
self.db_interface_compare = CompareDbInterface(config=self._config)
self.db_interface_admin = AdminDbInterface(config=self._config)
self.fw_one = create_test_firmware()
self.fw_two = create_test_firmware()
self.fw_two.set_binary(b'another firmware')
self.compare_dict = self._create_compare_dict()
def tearDown(self):
self.db_interface_compare.shutdown()
self.db_interface_admin.shutdown()
self.db_interface_backend.shutdown()
self.db_interface.client.drop_database(
self._config.get('data_storage', 'main_database'))
self.db_interface.shutdown()
gc.collect()
@classmethod
def tearDownClass(cls):
cls.mongo_server.shutdown()
def _create_compare_dict(self):
comp_dict = {
'general': {
'hid': {
self.fw_one.uid: 'foo',
self.fw_two.uid: 'bar'
}
},
'plugins': {}
}
comp_dict['general']['virtual_file_path'] = {
self.fw_one.uid: 'dev_one_name',
self.fw_two.uid: 'dev_two_name'
}
return comp_dict
def test_add_and_get_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
retrieved = self.db_interface_compare.get_compare_result(
'{};{}'.format(self.fw_one.uid, self.fw_two.uid))
self.assertEqual(
retrieved['general']['virtual_file_path'][self.fw_one.uid],
'dev_one_name', 'content of retrieval not correct')
def test_get_not_existing_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
result = self.db_interface_compare.get_compare_result('{};{}'.format(
self.fw_one.uid, self.fw_two.uid))
self.assertIsNone(result, 'result not none')
def test_calculate_compare_result_id(self):
comp_id = self.db_interface_compare._calculate_compare_result_id(
self.compare_dict)
self.assertEqual(comp_id, '{};{}'.format(self.fw_one.uid,
self.fw_two.uid))
def test_calculate_compare_result_id__incomplete_entries(self):
compare_dict = {
'general': {
'stat_1': {
'a': None
},
'stat_2': {
'b': None
}
}
}
comp_id = self.db_interface_compare._calculate_compare_result_id(
compare_dict)
self.assertEqual('a;b', comp_id)
def test_check_objects_exist(self):
self.db_interface_backend.add_firmware(self.fw_one)
assert self.db_interface_compare.check_objects_exist(
self.fw_one.uid) is None, 'existing_object not found'
with pytest.raises(FactCompareException):
self.db_interface_compare.check_objects_exist(
'{};none_existing_object'.format(self.fw_one.uid))
def test_get_compare_result_of_nonexistent_uid(self):
self.db_interface_backend.add_firmware(self.fw_one)
try:
self.db_interface_compare.check_objects_exist(
'{};none_existing_object'.format(self.fw_one.uid))
except FactCompareException as exception:
assert exception.get_message(
) == 'none_existing_object not found in database', 'error message not correct'
def test_get_latest_comparisons(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
before = time()
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
for id_, hids, submission_date in result:
self.assertIn(self.fw_one.uid, hids)
self.assertIn(self.fw_two.uid, hids)
self.assertIn(self.fw_one.uid, id_)
self.assertIn(self.fw_two.uid, id_)
self.assertTrue(before <= submission_date <= time())
def test_get_latest_comparisons_removed_firmware(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
self.assertNotEqual(result, [], 'A compare result should be available')
self.db_interface_admin.delete_firmware(self.fw_two.uid)
result = self.db_interface_compare.page_compare_results(limit=10)
self.assertEqual(result, [], 'No compare result should be available')
def test_get_total_number_of_results(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
number = self.db_interface_compare.get_total_number_of_results()
self.assertEqual(number, 1, 'no compare result found in database')
class TestCompare:
@classmethod
def setup_class(cls):
cls._config = get_config_for_testing()
cls.mongo_server = MongoMgr(config=cls._config)
def setup(self):
self.db_interface = MongoInterfaceCommon(config=self._config)
self.db_interface_backend = BackEndDbInterface(config=self._config)
self.db_interface_compare = CompareDbInterface(config=self._config)
self.db_interface_admin = AdminDbInterface(config=self._config)
self.fw_one = create_test_firmware()
self.fw_two = create_test_firmware()
self.fw_two.set_binary(b'another firmware')
self.compare_dict = self._create_compare_dict()
self.compare_id = '{};{}'.format(self.fw_one.uid, self.fw_two.uid)
def teardown(self):
self.db_interface_compare.shutdown()
self.db_interface_admin.shutdown()
self.db_interface_backend.shutdown()
self.db_interface.client.drop_database(
self._config.get('data_storage', 'main_database'))
self.db_interface.shutdown()
gc.collect()
@classmethod
def teardown_class(cls):
cls.mongo_server.shutdown()
def _create_compare_dict(self):
return {
'general': {
'hid': {
self.fw_one.uid: 'foo',
self.fw_two.uid: 'bar'
},
'virtual_file_path': {
self.fw_one.uid: 'dev_one_name',
self.fw_two.uid: 'dev_two_name'
}
},
'plugins': {},
}
def test_add_and_get_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
retrieved = self.db_interface_compare.get_compare_result(
self.compare_id)
assert retrieved['general']['virtual_file_path'][self.fw_one.uid] == 'dev_one_name',\
'content of retrieval not correct'
def test_get_not_existing_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
result = self.db_interface_compare.get_compare_result(self.compare_id)
assert result is None, 'result not none'
def test_calculate_compare_result_id(self):
comp_id = self.db_interface_compare._calculate_compare_result_id(
self.compare_dict)
assert comp_id == self.compare_id
def test_calculate_compare_result_id__incomplete_entries(self):
compare_dict = {
'general': {
'stat_1': {
'a': None
},
'stat_2': {
'b': None
}
}
}
comp_id = self.db_interface_compare._calculate_compare_result_id(
compare_dict)
assert comp_id == 'a;b'
def test_check_objects_exist(self):
self.db_interface_backend.add_firmware(self.fw_one)
assert self.db_interface_compare.check_objects_exist(
self.fw_one.uid) is None, 'existing_object not found'
with pytest.raises(FactCompareException):
self.db_interface_compare.check_objects_exist(
'{};none_existing_object'.format(self.fw_one.uid))
def test_get_compare_result_of_nonexistent_uid(self):
self.db_interface_backend.add_firmware(self.fw_one)
try:
self.db_interface_compare.check_objects_exist(
'{};none_existing_object'.format(self.fw_one.uid))
except FactCompareException as exception:
assert exception.get_message(
) == 'none_existing_object not found in database', 'error message not correct'
def test_get_latest_comparisons(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
before = time()
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
for id_, hids, submission_date in result:
assert self.fw_one.uid in hids
assert self.fw_two.uid in hids
assert self.fw_one.uid in id_
assert self.fw_two.uid in id_
assert before <= submission_date <= time()
def test_get_latest_comparisons_removed_firmware(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
assert result != [], 'A compare result should be available'
self.db_interface_admin.delete_firmware(self.fw_two.uid)
result = self.db_interface_compare.page_compare_results(limit=10)
assert result == [], 'No compare result should be available'
def test_get_total_number_of_results(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
number = self.db_interface_compare.get_total_number_of_results()
assert number == 1, 'no compare result found in database'
@pytest.mark.parametrize('root_uid, expected_result', [
('the_root_uid', ['uid1', 'uid2']),
('some_other_uid', []),
(None, []),
])
def test_get_exclusive_files(self, root_uid, expected_result):
compare_dict = self._create_compare_dict()
compare_dict['plugins'] = {
'File_Coverage': {
'exclusive_files': {
'the_root_uid': ['uid1', 'uid2']
}
}
}
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(compare_dict)
exclusive_files = self.db_interface_compare.get_exclusive_files(
self.compare_id, root_uid)
assert exclusive_files == expected_result
class TestCompare(unittest.TestCase):
def setUp(self):
self._config = get_config_for_testing()
self.mongo_server = MongoMgr(config=self._config)
self.db_interface = MongoInterfaceCommon(config=self._config)
self.db_interface_backend = BackEndDbInterface(config=self._config)
self.db_interface_compare = CompareDbInterface(config=self._config)
self.db_interface_admin = AdminDbInterface(config=self._config)
self.fw_one = create_test_firmware()
self.fw_two = create_test_firmware()
self.fw_two.set_binary(b'another firmware')
self.compare_dict = self._create_compare_dict()
def tearDown(self):
self.db_interface_compare.shutdown()
self.db_interface_admin.shutdown()
self.db_interface_backend.shutdown()
self.db_interface.client.drop_database(
self._config.get('data_storage', 'main_database'))
self.db_interface.shutdown()
self.mongo_server.shutdown()
gc.collect()
def _create_compare_dict(self):
comp_dict = {
'general': {
'hid': {
self.fw_one.get_uid(): 'foo',
self.fw_two.get_uid(): 'bar'
}
},
'plugins': {}
}
comp_dict['general']['virtual_file_path'] = {
self.fw_one.get_uid(): 'dev_one_name',
self.fw_two.get_uid(): 'dev_two_name'
}
return comp_dict
def test_add_and_get_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
retrieved = self.db_interface_compare.get_compare_result(
'{};{}'.format(self.fw_one.get_uid(), self.fw_two.get_uid()))
self.assertEqual(
retrieved['general']['virtual_file_path'][self.fw_one.get_uid()],
'dev_one_name', 'content of retrieval not correct')
def test_get_not_existing_compare_result(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
result = self.db_interface_compare.get_compare_result('{};{}'.format(
self.fw_one.get_uid(), self.fw_two.get_uid()))
self.assertIsNone(result, 'result not none')
def test_calculate_compare_result_id(self):
comp_id = self.db_interface_compare._calculate_compare_result_id(
self.compare_dict)
self.assertEqual(
comp_id, '{};{}'.format(self.fw_one.get_uid(),
self.fw_two.get_uid()))
def test_object_existence_quick_check(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.assertIsNone(
self.db_interface_compare.object_existence_quick_check(
self.fw_one.get_uid()), 'existing_object not found')
self.assertEqual(
self.db_interface_compare.object_existence_quick_check(
'{};none_existing_object'.format(self.fw_one.get_uid())),
'none_existing_object not found in database',
'error message not correct')
def test_get_compare_result_of_none_existing_uid(self):
self.db_interface_backend.add_firmware(self.fw_one)
result = self.db_interface_compare.get_compare_result(
'{};none_existing_uid'.format(self.fw_one.get_uid()))
self.assertEqual(result, 'none_existing_uid not found in database',
'no result not found error')
def test_get_latest_comparisons(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
before = time()
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
for id, hids, submission_date in result:
self.assertIn(self.fw_one.get_uid(), hids)
self.assertIn(self.fw_two.get_uid(), hids)
self.assertIn(self.fw_one.get_uid(), id)
self.assertIn(self.fw_two.get_uid(), id)
self.assertTrue(before <= submission_date <= time())
def test_get_latest_comparisons_removed_firmware(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
result = self.db_interface_compare.page_compare_results(limit=10)
self.assertNotEqual(result, [], 'A compare result should be available')
self.db_interface_admin.delete_firmware(self.fw_two.uid)
result = self.db_interface_compare.page_compare_results(limit=10)
self.assertEqual(result, [], 'No compare result should be available')
def test_get_total_number_of_results(self):
self.db_interface_backend.add_firmware(self.fw_one)
self.db_interface_backend.add_firmware(self.fw_two)
self.db_interface_compare.add_compare_result(self.compare_dict)
number = self.db_interface_compare.get_total_number_of_results()
self.assertEqual(number, 1, 'no compare result found in database')
