def setUp(self): self.source_code_parser = fake('SourceCodeParser') self.entity_id_generator = fake('EntityIdGenerator') self.model = fake('Model') self.function_modeler = FunctionModeler(self.source_code_parser, self.entity_id_generator, self.model)
def test_it_creates_the_included_modelers(self, _, __): # Arrange orchestrator = Orchestrator(fake('base_path'), fake('Model')) # Act orchestrator.include(self.generic_modeler_class) orchestrator.process('file_name') # Assert self.generic_modeler_class.assert_called_once_with(ANY, ANY, ANY)
def test_it_relates_nested_function_calls(self, _): # Arrange thread_exec_modeler = ThreadModeler(self.entity_id_generator, self.model) # Act parent_function_call = thread_exec_modeler.on_call(fake('FrameDigest')) child_function_call = thread_exec_modeler.on_call(fake('FrameDigest')) # Assert assert_equal(child_function_call.parent, parent_function_call)
def test_function_notifications_are_suitable_for_the_function_defs_collector(self): # Arrange function_def_collector = fake('FunctionModeler') node = fake('NodeNG') defs_visitor = DefsVisitor([function_def_collector]) # Act defs_visitor.visit_function(node) # Assert function_def_collector.on_function.assert_called_once_with(node)
def test_it_considers_returns_when_relating_nested_function_calls(self, _): # Arrange thread_exec_modeler = ThreadModeler(self.entity_id_generator, self.model) # Act thread_exec_modeler.on_call(fake('FrameDigest')) child_function_call1 = thread_exec_modeler.on_call(fake('FrameDigest')) thread_exec_modeler.on_return(Mock()) child_function_call2 = thread_exec_modeler.on_call(fake('FrameDigest')) # Assert assert_equal(child_function_call1.parent, child_function_call2.parent)
def test_it_invokes_the_callback_for_two_entities(self): # Given callback = Mock() fake_class = fake("Class_") fake_function = fake("Function") async_publisher = AsyncPublisher(callback) async_publisher.start() # When async_publisher.on_entity(fake_class) async_publisher.on_entity(fake_function) async_publisher.stop() # Then callback.assert_has_calls([call(fake_class), call(fake_function)])
def test_process_raises_exception_if_all_files_had_been_processed(self, source_code_parser_class_mock, _): # Arrange source_code_parser_mock = fake('SourceCodeParser') source_code_parser_mock.add_files.side_effect = [True, False] source_code_parser_class_mock.return_value = source_code_parser_mock orchestrator = Orchestrator(fake('base_path'), fake('Model')) # Act orchestrator.include(self.generic_modeler_class) orchestrator.process('file_name') # Assert assert_raises(AlreadyProcessed, orchestrator.process, 'file_name')
def setUp(self): self.model = fake('Model') self.module_modeler = ModuleModeler(fake('SourceCodeParser'), fake('EntityIdGenerator'), self.model) self.fake_importer = real('Module') self.fake_importer.name = 'importer' self.importer_module = Mock() self.dependency1 = real('Module') self.dependency2 = real('Module') self.model.modules.get_by_name.side_effect = lambda name: { 'importer': self.importer_module, 'some.module': self.dependency1, 'some.other.module': self.dependency2}[name]
def test_it_ignores_already_processed_exception_for_static_data(self): # Arrange self.orchestrator.process.side_effect = AlreadyProcessed # Act driver = Driver(*self.init_args) driver.on_call(fake('FrameDigest'))
def setUp(self): self.thread_scoped_tracer_patcher = patch('dissect.modeling.dynamic.driver.ProcessScopedTracer', autospec=True) self.thread_scoped_tracer = fake('ProcessScopedTracer') self.thread_scoped_tracer_class = self.thread_scoped_tracer_patcher.start() self.thread_scoped_tracer_class.return_value = self.thread_scoped_tracer self.function_call_patcher = patch('dissect.modeling.dynamic.driver.ProcessModeler', autospec=True) self.function_call_modeler = fake('ProcessModeler') self.function_call_class = self.function_call_patcher.start() self.function_call_class.return_value = self.function_call_modeler self.observer = Mock() self.orchestrator = fake('Orchestrator') self.init_args = (self.observer, fake('EntityIdGenerator'), self.orchestrator)
def setUp(self): self.patcher = patch('dissect.modeling.static.driver.Orchestrator') self.orchestrator_mock = Mock() self.orchestrator_class = self.patcher.start() self.orchestrator_class.return_value = self.orchestrator_mock self.file_set = fake('FileSet') self.observer = Mock() self.static_driver = StaticDriver(self.file_set)
def test_it_passes_all_calls_from_the_same_thread_to_the_same_modeler(self, thread_modeler, threading): # Arrange process_modeler = Process('fake_entityid_gen', 'fake_model') fake_frame_digest_1 = fake('FrameDigest') fake_frame_digest_2 = fake('FrameDigest') # Act threading.current_thread.return_value.name = 'MainThread' process_modeler.on_call(fake_frame_digest_1) threading.current_thread.return_value.name = 'Thread-1' process_modeler.on_call(fake_frame_digest_2) # Assert thread_modeler.return_value assert_equal(thread_modeler.call_count, 2)
def test_registers_dependency_with_other_module_due_to_from_import(self): # Arrange: emulate 'from some.module import x' fake_from_node = fake('NodeNG', spec_set=False) fake_from_node.modname = 'some.module' # Act self.module_modeler.on_from(self.fake_importer, fake_from_node) # Assert self.importer_module.depends_on.assert_called_once_with(self.dependency1)
def test_it_passes_all_calls_from_the_same_thread_to_the_same_modeler(self, thread_modeler, threading): # Arrange process_modeler = Process('fake_entityid_gen', 'fake_model') fake_frame_digest_1 = fake('FrameDigest') fake_frame_digest_2 = fake('FrameDigest') threading.current_thread.return_value.name = 'MainThread' # Act process_modeler.on_call(fake_frame_digest_1) process_modeler.on_call(fake_frame_digest_2) # Assert thread_modeler.return_value assert_equal(thread_modeler.call_count, 1) expected_calls = [call(fake_frame_digest_1), call(fake_frame_digest_2)] modeler = thread_modeler.return_value modeler.on_call.assert_has_calls(expected_calls)
def test_registers_dependency_with_other_modules_due_to_import(self): # Arrange: emulate 'import some.module, some.other.module' fake_import_node = fake('NodeNG', spec_set=False) fake_import_node.names = [('some.module', None), ('some.other.module', None)] # Act self.module_modeler.on_import(self.fake_importer, fake_import_node) # Assert self.importer_module.depends_on.assert_has_calls([call(self.dependency1), call(self.dependency2)])
def test_on_call_it_ignores_it_if_the_function_is_unknown(self, _): # Arrange frame_digest = fake('FrameDigest', spec_set=False) self.model.functions.get_by_id.side_effect = KeyError thread_exec_modeler = ThreadModeler(self.entity_id_generator, self.model) # Act function_call = thread_exec_modeler.on_call(frame_digest) # Assert assert_is_none(function_call)
def test_it_invokes_the_callback_for_one_entity(self): # Given callback = Mock() fake_entity = fake("Function") async_publisher = AsyncPublisher(callback) async_publisher.start() # When async_publisher.on_entity(fake_entity) async_publisher.stop() # Then callback.assert_called_once_with(fake_entity)
def test_it_processes_static_data_for_each_call(self): # Arrange frame_digest = fake('FrameDigest') frame_digest.function_name = 'fake_function_name' frame_digest.file_name = 'fake_file_name' frame_digest.line_number = 1 # Act driver = Driver(*self.init_args) driver.on_call(frame_digest) # Assert self.orchestrator.process.assert_called_once_with('fake_file_name')
def test_it_creates_a_thread_modeler_for_the_main_thread(self, thread_modeler, threading): # Arrange process_modeler = Process('fake_entityid_gen', 'fake_model') # Act threading.current_thread.return_value.name = 'MainThread' process_modeler.on_call(fake('FrameDigest')) # Assert thread_modeler.assert_called_once_with('fake_entityid_gen', 'fake_model')
def test_it_passes_the_frame_digest_to_the_thread_modeler(self, thread_modeler, threading): # Arrange process_modeler = Process('fake_entityid_gen', 'fake_model') # Act fake_frame_digest = fake('FrameDigest') threading.current_thread.return_value.name = 'MainThread' process_modeler.on_call(fake_frame_digest) # Assert thread_modeler.return_value.on_call.assert_called_once_with( fake_frame_digest)
def test_on_call_notifies_function_call_to_the_observer(self): # Arrange frame_digest = fake('FrameDigest', spec_set=False) expected_function_call = real('FunctionCall') self.function_call_modeler.on_call.return_value = expected_function_call # Act driver = Driver(*self.init_args) driver.on_call(frame_digest) # Assert self.observer.on_call.assert_called_once_with(ANY) actual_function_call = self.observer.on_call.call_args[0][0] assert_equal(actual_function_call.function, expected_function_call.function)
def test_adds_one_module_to_the_model(self): # Arrange fake_node = fake('NodeNG', spec_set=False) fake_node.file = 'path/to/file.py' fake_node.name = 'path.to.file' self.entity_id_generator.create.return_value = 'to/file.py' # Act self.module_modeler.on_module(fake_node) # Assert expected_module = Module('to/file.py', 'path.to.file') self.entity_id_generator.create.assert_called_once_with('path/to/file.py') self.model.modules.add.assert_called_once_with(expected_module)
def test_on_entity_returns_before_the_callback_completes(self): # Given finish = threading.Event() callback = Mock() callback.side_effect = lambda entity: finish.wait() fake_entity = fake("Function") async_publisher = AsyncPublisher(callback) async_publisher.start() # When async_publisher.on_entity(fake_entity) finish.set() # Then async_publisher.stop()
def test_other_function_calls_are_proxied_if_one_exceeds_the_call_rate( self): # Arrange call_filter = CallsPerTimePeriod(1, 1, self.handler) another_frame_digest = fake('FrameDigest') another_frame_digest.function_name = 'another_function' # Act proxied_result = call_filter.on_call(self.frame_digest) another_result = call_filter.on_call(another_frame_digest) discarded_result = call_filter.on_call(self.frame_digest) # Assert assert_true(proxied_result) assert_true(another_result) assert_false(discarded_result)
def setUp(self): self.handler = Mock() self.frame_digest = fake('FrameDigest')
def test_creation(self): fake('Function')
def setUp(self): self.entity_id_generator = fake('EntityIdGenerator') self.model = fake('Model')