def initialize_config(tmp_dir): config = get_config_for_testing(temp_dir=tmp_dir) # Database config.set('data_storage', 'main_database', 'tmp_integration_tests') config.set('data_storage', 'intercom_database_prefix', 'tmp_integration_tests') config.set('data_storage', 'statistic_database', 'tmp_integration_tests') config.set('data_storage', 'view_storage', 'tmp_view_storage') # Analysis config.add_section('ip_and_uri_finder') config.set('ip_and_uri_finder', 'signature_directory', 'analysis/signatures/ip_and_uri_finder/') config.set('default_plugins', 'plugins', 'file_hashes') # Unpacker config.set('unpack', 'threads', '1') config.set('ExpertSettings', 'unpack_throttle_limit', '20') # Compare config.set('ExpertSettings', 'ssdeep_ignore', '80') config.set('ExpertSettings', 'block_delay', '1') config.set('ExpertSettings', 'throw_exceptions', 'true') return config
def setUp(self): config = get_config_for_testing(TMP_DIR) self.test_queue = Queue() self.interface = InterComBackEndBinding( config=config, testing=True, analysis_service=AnalysisServiceMock(), compare_service=ServiceMock(self.test_queue), unpacking_service=ServiceMock(self.test_queue) ) self.interface.WAIT_TIME = 2 self.db = MongoMgr(config=config)
def test_get_radare_endpoint(): config = get_config_for_testing() assert config.get('ExpertSettings', 'nginx') == 'false' assert get_radare_endpoint(config) == 'http://localhost:8000' config.set('ExpertSettings', 'nginx', 'true') assert get_radare_endpoint(config) == 'https://localhost/radare'
def binary_service(): with TemporaryDirectory(prefix='fact_test_') as tmp_dir: config = get_config_for_testing(temp_dir=tmp_dir) mongo_server = MongoMgr(config=config) _init_test_data(config, tmp_dir) yield BinaryService(config=config) mongo_server.shutdown() gc.collect()
def test_get_radare_endpoint(): config = get_config_for_testing() assert config.get('ExpertSettings', 'nginx') == 'false' assert IORoutes._get_radare_endpoint(config) == 'http://localhost:8000' # pylint: disable=protected-access config.set('ExpertSettings', 'nginx', 'true') assert IORoutes._get_radare_endpoint(config) == 'https://localhost/radare' # pylint: disable=protected-access
def setUp(self): self.config = get_config_for_testing() self.enter_patch = unittest.mock.patch(target='web_interface.frontend_main.add_flask_security_to_app', new=add_security_get_mocked) self.enter_patch.start() self.frontend = frontend_main.WebFrontEnd(config=self.config) self.frontend.app.config['TESTING'] = True self.test_client = self.frontend.app.test_client()
def setUp(self): routes.FrontEndDbInterface = DbInterfaceMock app = Flask(__name__) app.config.from_object(__name__) app.config['TESTING'] = True app.jinja_env.filters['replace_uid_with_hid'] = lambda x: x app.jinja_env.filters['nice_unix_time'] = lambda x: x config = get_config_for_testing() self.plugin_routes = routes.PluginRoutes(app, config) self.test_client = app.test_client()
def setUp(self, db_mock=DatabaseMock): # pylint: disable=arguments-differ self.mocked_interface = db_mock() self.enter_patch = unittest.mock.patch(target='helperFunctions.database.ConnectTo.__enter__', new=lambda _: self.mocked_interface) self.enter_patch.start() self.exit_patch = unittest.mock.patch(target='helperFunctions.database.ConnectTo.__exit__', new=fake_exit) self.exit_patch.start() self.config = get_config_for_testing(TMP_DIR) self.frontend = WebFrontEnd(config=self.config) self.frontend.app.config['TESTING'] = True self.test_client = self.frontend.app.test_client()
def setUp(self): self.mocked_interface = DatabaseMock() self.enter_patch = mock.patch(target='helperFunctions.database.ConnectTo.__enter__', new=lambda _: self.mocked_interface) self.enter_patch.start() self.exit_patch = mock.patch(target='helperFunctions.database.ConnectTo.__exit__', new=fake_exit) self.exit_patch.start() config = get_config_for_testing() config.add_section('ip_and_uri_finder') config.set('ip_and_uri_finder', 'signature_directory', 'analysis/signatures/ip_and_uri_finder/') config.set('default_plugins', 'default', 'file_hashes') self.tmp_queue = Queue() self.sched = AnalysisScheduler(config=config, pre_analysis=lambda *_: None, post_analysis=self.dummy_callback, db_interface=self.mocked_interface)
def setUp(self): routes.FrontEndDbInterface = DbInterfaceMock app = Flask(__name__) app.config.from_object(__name__) app.config['TESTING'] = True config = get_config_for_testing() api = Api(app) endpoint, methods = routes.FSMetadataRoutesRest.ENDPOINTS[0] api.add_resource(routes.FSMetadataRoutesRest, endpoint, methods=methods, resource_class_kwargs={'config': config}) self.test_client = app.test_client()
def test_check_worker_exceptions(): config = get_config_for_testing() config.set('ExpertSettings', 'throw_exceptions', 'true') process_list = [ExceptionSafeProcess(target=breaking_process, args=(True, ))] process_list[0].start() result = check_worker_exceptions(process_list, 'foo', config=config) assert not result assert len(process_list) == 1 sleep(1) result = check_worker_exceptions(process_list, 'foo', config=config) assert result assert len(process_list) == 0
def setUp(self): self.config = get_config_for_testing() self.fw_one = create_test_firmware(device_name='dev_1', all_files_included_set=True) self.fw_one.processed_analysis['file_hashes'] = { 'ssdeep': get_ssdeep(self.fw_one.binary) } self.fw_two = create_test_firmware(device_name='dev_2', bin_path='container/test.7z', all_files_included_set=True) self.fw_two.processed_analysis['file_hashes'] = { 'ssdeep': get_ssdeep(self.fw_two.binary) } self.compare_system = Compare(db_interface=MockDbInterface(), config=self.config)
def get_intercom_for_testing(): with TemporaryDirectory(prefix='fact_test_') as tmp_dir: config = get_config_for_testing(tmp_dir) test_queue = Queue() interface = InterComBackEndBinding( config=config, testing=True, analysis_service=AnalysisServiceMock(), compare_service=ServiceMock(test_queue), unpacking_service=ServiceMock(test_queue)) interface.WAIT_TIME = 2 db = MongoMgr(config=config) yield interface interface.shutdown() test_queue.close() db.shutdown() gc.collect()
def test_check_worker_restart(caplog): config = get_config_for_testing() config.set('ExpertSettings', 'throw_exceptions', 'false') worker = ExceptionSafeProcess(target=breaking_process, args=(True, )) process_list = [worker] worker.start() sleep(1) with caplog.at_level(logging.INFO): result = check_worker_exceptions(process_list, 'foo', config, worker_function=lambda _: None) assert not result assert len(process_list) == 1 assert process_list[0] != worker assert 'Exception in foo' in caplog.messages[0] assert 'restarting foo' in caplog.messages[-1] process_list[0].join()
def setUpClass(cls): cls._config = get_config_for_testing(TMP_DIR) cls._config.set('data_storage', 'report_threshold', '32') cls._config.set('data_storage', 'sanitize_database', 'tmp_sanitize') cls.mongo_server = MongoMgr(config=cls._config)
def setUp(self): self.config = get_config_for_testing() self.mongo_server = MongoMgr(config=self.config) self.workload_stat = WorkLoadStatistic(config=self.config, component='test') self.frontend_db_interface = StatisticDbViewer(config=self.config)
def test_config(): return get_config_for_testing()
def setUpClass(cls): cls._config = get_config_for_testing(TMP_DIR) cls.mongo_server = MongoMgr(config=cls._config)
def setUp(self): self.name_prefix = 'FACT_plugin_qemu' self.config = get_config_for_testing() self.unpacker = qemu_exec.Unpacker(config=self.config) qemu_exec.BinaryServiceDbInterface = MockBinaryService
def test_config(): return get_config_for_testing(TemporaryDirectory())
def setUpClass(cls): cls.config = get_config_for_testing(TMP_DIR) cls.mongo_mgr = MongoMgr(cls.config)
def setUp(self): yara_binary_search.YaraBinarySearchScannerDbInterface.__bases__ = ( MockCommonDbInterface, ) self.db_interface = yara_binary_search.YaraBinarySearchScannerDbInterface( get_config_for_testing())
def setUp(self): self.config = get_config_for_testing() routes.FsMetadataDbInterface.__bases__ = (DbInterfaceMock, )
def setUp(self): self.config = get_config_for_testing() routes.FrontEndDbInterface = DbInterfaceMock
def setUp(self): self.config = get_config_for_testing() self.repack_service = TarRepack(config=self.config)
def setup(self): self.sched.config = get_config_for_testing()
def setUp(self): self.app = Flask(__name__) self.app.config.from_object(__name__) self.api = Api(self.app) self.config = get_config_for_testing()
def setUp(self): self._config = get_config_for_testing(TMP_DIR) self.mongo_server = MongoMgr(config=self._config) self.db_interface = MongoInterfaceCommon(config=self._config) self.db_interface_backend = BackEndDbInterface(config=self._config)
def setUpClass(cls): cls.tmp_dir = TemporaryDirectory(prefix='fact_test_') cls.config = get_config_for_testing(temp_dir=cls.tmp_dir) cls.config.set('ExpertSettings', 'communication_timeout', '1') cls.mongo_server = MongoMgr(config=cls.config)
def setup_class(cls): cls.tmp_dir = TemporaryDirectory(prefix='fact_test_') cls.config = get_config_for_testing(cls.tmp_dir) cls.mongo_mgr = MongoMgr(cls.config)