def test_on_user_contact_attribute_change_update_subitem( user_manager, user, method_name, attr_name, dynamo_lib_name): # test adding for the first time new_item = {**user.item, attr_name: 'the-value'} with patch.object(user_manager, dynamo_lib_name) as dynamo_lib_mock: getattr(user_manager, method_name)(user.id, new_item=new_item) assert dynamo_lib_mock.mock_calls == [call.add('the-value', user.id)] # test changing to a different value old_item = new_item.copy() new_item = {**old_item, attr_name: 'new-value'} with patch.object(user_manager, dynamo_lib_name) as dynamo_lib_mock: getattr(user_manager, method_name)(user.id, new_item=new_item, old_item=old_item) assert dynamo_lib_mock.mock_calls == [ call.add('new-value', user.id), call.delete('the-value', user.id) ] # test deleting the value old_item = new_item.copy() with patch.object(user_manager, dynamo_lib_name) as dynamo_lib_mock: getattr(user_manager, method_name)(user.id, old_item=old_item) assert dynamo_lib_mock.mock_calls == [call.delete('new-value', user.id)]
def test_uninstall(self, mock_commands): """Verify 'clean' can be called with force.""" plugin.main(['--uninstall', '--force']) assert [ call.delete(root=None, force=True), call.delete().__bool__(), # command status check ] == mock_commands.mock_calls
def test_uninstall(self, mock_commands): """Verify 'clean' can be called with force.""" mock_commands.delete.__name__ = 'mock' plugin.main(['--uninstall', '--force']) assert [ call.delete(root=None, force=True, keep_location=False), call.delete().__bool__(), # command status check ] == mock_commands.mock_calls
def test_delete_gauge(self): """Tests deltion of a gauge.""" self.r.delete_gauge("test-gauge") self.redis.assert_has_calls([ call.delete('g:test-gauge'), call.srem(self.r._gauge_slugs_key, "test-gauge"), ])
async def test_delete_expense(self, get_repository_mock, verify_if_exists_and_is_not_deleted_mock): #Arrange verify_if_exists_and_is_not_deleted_mock.return_value = True expense_mock = Mock() repository_mock = Mock() get_repository_mock.side_effect = [repository_mock] repository_mock.get_by_id = Mock(return_value=expense_mock) #Action await delete_expense('id') #Asserts repository_mock_calls = repository_mock.mock_calls self.assertEqual(len(repository_mock_calls), 2) repository_mock.assert_has_calls([ call.get_by_id(Expense, 'id'), call.save(expense_mock), ]) expense_mock_calls = expense_mock.mock_calls self.assertEqual(len(expense_mock_calls), 1) expense_mock.assert_has_calls([call.delete()]) get_repository_mock_calls = get_repository_mock.mock_calls self.assertEqual(len(get_repository_mock_calls), 1) get_repository_mock.assert_has_calls([call()])
def test_sqs_message_processor(self): mock = MagicMock() mock.body = '{"Records":[{"s3":{"bucket":{"name":"name"},"object":{"key":"key"}}}]}' processor = SQSMessageProcessor() with patch.object(SQSMessageProcessor, 'processor_class', create=True) as mock_processor_class: processor.process(mock) mock_processor_class.assert_has_calls([ call(), call().process({ 'Records': [{ 's3': { 'bucket': { 'name': 'name' }, 'object': { 'key': 'key' } } }] }) ]) mock.assert_has_calls([call.delete()])
def test_remove_members(self, room_cls, membership_cls): room_mock = room_cls() membership_mock = membership_cls() ids = [ ValidMemberID, ModMemberID, ExtraMemberID ] uut = Client(room_mock, membership_mock) uut.remove_members(ValidRoomID, ids) self.assertListEqual(membership_mock.mock_calls, [ call.delete(membershipId=ValidMemberID), call.delete(membershipId=ModMemberID), call.delete(membershipId=ExtraMemberID) ], "only three calls to create") self.assertListEqual(room_mock.method_calls, [], "rooms should not be touched")
def test_delete_room(self, room_cls, membership_cls): room_mock = room_cls() membership_mock = membership_cls() uut = Client(room_mock, membership_mock) uut.delete_room(ValidRoomID) assert membership_mock.mock_calls == [] assert room_mock.method_calls == [ call.delete(str(ValidRoomID)) ]
def test_sqs_message_processor(self): mock = MagicMock() mock.body = '{"Records":[{"s3":{"bucket":{"name":"name"},"object":{"key":"key"}}}]}' processor = SQSMessageProcessor() with patch.object(SQSMessageProcessor, 'processor_class', create=True) as mock_processor_class: processor.process(mock) mock_processor_class.assert_has_calls([ call(), call().process({'Records': [{'s3': {'bucket': {'name': 'name'}, 'object': {'key': 'key'}}}]})]) mock.assert_has_calls([call.delete()])
def test_reorder_from_index_delete(self): """Verify items can be deleted when reordering from an index.""" data = { 'initial': 2.0, 'outline': [{ 'a': None }, { 'b': [{ 'ba': [{ 'baa': None }, { 'bab': None }, { 'bac': None }] }, { 'bb': [{ 'bba': None }] }] }, { 'c': None }] } expected = [ Level('2'), Level('3.0'), Level('3.1.0'), Level('3.1.1'), Level('3.1.2'), Level('3.1.3'), Level('3.2.0'), Level('3.2.1'), Level('4') ] mock_item = self.document.add_item() # Act self.document._read_index = MagicMock(return_value=data) Document._reorder_from_index(self.document, 'mock_path') # Assert self.document._read_index.assert_called_once_with('mock_path') items = [] for item in self.document.items: if item is not mock_item: items.append(item) actual = [item.level for item in items] self.assertListEqual(expected, actual) self.assertEqual(mock_item.method_calls, [call.delete()])
def test_delete_metric(self): """Verify that ``R.delete_metric`` deletes all keys and removes keys from the set of metric slugs.""" # Make sure KEYS returns some data self.redis.keys.return_value = ["m:slug:0", "m:slug:1"] self.r.delete_metric('slug') # call delete_metric # Verify that the metric data is removed as are the keys from the set self.redis.assert_has_calls([ call.keys("m:slug:*"), call.delete("m:slug:0", "m:slug:1"), call.srem(self.r._metric_slugs_key, "slug") ])
def test_reorder_from_index_delete(self): """Verify items can be deleted when reordering from an index.""" data = {'initial': 2.0, 'outline': [ {'a': None}, {'b': [ {'ba': [ {'baa': None}, {'bab': None}, {'bac': None}]}, {'bb': [ {'bba': None}]}]}, {'c': None}]} expected = [Level('2'), Level('3.0'), Level('3.1.0'), Level('3.1.1'), Level('3.1.2'), Level('3.1.3'), Level('3.2.0'), Level('3.2.1'), Level('4')] mock_item = self.document.add_item() # Act self.document._read_index = MagicMock(return_value=data) Document._reorder_from_index(self.document, 'mock_path') # Assert self.document._read_index.assert_called_once_with('mock_path') items = [] for item in self.document.items: if item is not mock_item: items.append(item) actual = [item.level for item in items] self.assertListEqual(expected, actual) self.assertEqual(mock_item.method_calls, [call.delete()])
def test_ElasticBlastAws_delete(ElasticBlastAws, s3, mocker): """Test elb.ElasticBlastAws.delete function""" eb = ElasticBlastAws # create results bucket and upload a query batch bucket_name, _ = parse_bucket_name_key(eb.cfg.cluster.results) bucket = s3.Bucket(bucket_name) bucket.create(ACL='public-read') query_batch = 'query_batches/batch_000.fa' bucket.put_object(ACL='public-read', Body=b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', Key=query_batch) # test that a query batch exists in the mocked S3 bucket assert query_batch in [s.key for s in list(bucket.objects.all())] # put a fake results file in the S3 bucket results_key = 'batch-blastn-000.out.gz' bucket.put_object(ACL='public-read', Body=b'Some content', Key=results_key) assert results_key in [s.key for s in list(bucket.objects.all())] # the mock library has holes, so we need to mock eb.cf and eb.cf_stack # objects ourselves mocker.patch.object(eb, 'cf') mocked_stack = mocker.patch.object(eb, 'cf_stack') # test ElasticBlastAws deletion eb.delete() # test thest cloudformation stack delete method was called assert mocked_stack.method_calls == [call.delete()] # test that query batch was deleted and results were not assert query_batch not in [s.key for s in list(bucket.objects.all())] assert results_key in [s.key for s in list(bucket.objects.all())]
def test_main(self, worker_cls, api_cls, room_cls, member_cls): self.maxDiff = None room_api = room_cls() room_api.get.return_value = MagicMock(id="validroomid", title="validtitle") member_api = member_cls() api = api_cls() type(api).rooms = PropertyMock(return_value=room_api) type(api).memberships = PropertyMock(return_value=member_api) seal(api) api_cls.return_value = api worker = worker_cls.return_value worker.get_param.side_effect = [ "bottoken", "Delete room", "validroomid", "validroomid", ] main() self.assertListEqual(member_api.method_calls, []) self.assertListEqual( room_api.method_calls, [call.get(roomId='validroomid'), call.delete('validroomid')]) self.assertListEqual(worker_cls.method_calls, [ call().get_param('config.webex_bot_token', default=None), call().get_param('data.customFields.webexteams.string', default=None), call().get_param('data.customFields.webexroomid.string', default=None), call().get_param('data.customFields.webexroomid.string', default=None), call().report(output={ 'success': True, 'full': { 'message': 'Room deleted validroomid', 'fields': { 'roomid': '' }, 'tags': [], 'events': [{ 'room found': { 'ID': 'validroomid', 'Title': 'validtitle' } }, { 'room deleted': { 'ID': 'validroomid', 'Title': 'validtitle' } }] }, 'operations': [{ 'type': 'AddCustomFields', 'name': 'webexroomid', 'value': '', 'tpe': 'string' }] }, ensure_ascii=False) ])
def it_adds_a_delete_method(utilities, mixed_instance): mixed_instance.delete() expect(utilities.mock_calls) == [ call.delete(mixed_instance) ]
def it_adds_a_delete_method(utilities, mixed_instance): mixed_instance.delete() expect(utilities.mock_calls) == [call.delete(mixed_instance)]