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_add_still_works(self, entity_class):
# Arrange
observable_repo = ObservableEntityRepo(Mock())
entity = real(entity_class)
# Act
observable_repo.add(entity)
# Assert
assert_equal(observable_repo.get_by_id(entity.id_), entity)
def test_it_notifies_when_one_entity_is_added(self, entity_class):
# Arrange
observer = Mock()
repo = ObservableEntityRepo(observer)
entity = real(entity_class)
# Act
repo.add(entity)
# Assert
observer.on_entity.assert_called_once_with(entity)
def test_it_does_not_notify_if_an_entity_is_added_again(self):
# Arrange
observer = Mock()
repo = ObservableEntityRepo(observer)
module = real('Module')
# Act
repo.add(module)
repo.add(module)
# Assert
observer.on_entity.assert_called_once_with(module)
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_one_function_is_added_to_function_repo(self):
# Arrange
module = real('Module')
module.id_ = 'fake_file_name'
self.model.modules.add(module)
function_modeler = FunctionModeler(self.source_code_parser, EntityIdGenerator('.'), self.model)
node = MagicMock()
node.parent = Mock(spec=astroid.scoped_nodes.Module)
node.parent.file = 'fake_file_name'
node.lineno = 44
# Act
function_modeler.on_function(node)
# Assert
expected_function = Function('fake_file_name:44',
'fake_function_name',
module)
self.model.functions.add.assert_called_once_with(expected_function)
def test_one_method_is_added_to_function_repo(self):
# Arrange
class_mock = real('Class_')
class_mock.id_ = 'fake_file_name:33'
self.model.classes.add(class_mock)
function_modeler = FunctionModeler(self.source_code_parser,
EntityIdGenerator('.'),
self.model)
node = MagicMock()
node.parent = Mock(spec=astroid.scoped_nodes.Class)
node.parent.parent.file = 'fake_file_name'
node.parent.lineno = 33
node.name = 'fake_function_name'
node.lineno = 44
# Act
function_modeler.on_function(node)
# Assert
expected_function = Method('fake_file_name:44',
'fake_function_name',
class_mock)
self.model.functions.add.assert_called_once_with(expected_function)
def test_not_eq_comparison(self):
method1 = unique(real('Method'))
method2 = unique(real('Method'))
assert_not_equal(method1, method2)
def test_add_one_method(self):
class_ = real('Class_')
method = Method('dummy_id', 'dummy_name', class_)
class_.add_method(method)
def test_eq_comparison(self):
class_1 = real('Class_')
class_2 = real('Class_')
assert_equal(class_1, class_2)
def test_non_equal_comparison(self):
function1 = unique(real('Function'))
function2 = unique(real('Function'))
assert_not_equal(function1, function2)
def test_equal_comparison(self):
function1 = real('Function')
function2 = real('Function')
assert_equal(function1, function2)
def test_creation(self):
# Arrange nothing
# Act
real('Class_')
def test_eq_comparison(self):
method1 = real('Method')
method2 = real('Method')
assert_equal(method1, method2)
def test_creation(self):
real('Method')
def test_creation(self):
real('FunctionCall')
def test_not_eq_comparison(self):
class_1 = unique(real('Class_'))
class_2 = unique(real('Class_'))
assert_not_equal(class_1, class_2)
