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_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"),
])
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_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)]
