def test_then(self):
callback = PromiseMock(name='callback')
x = http.Request('http://foo')
x.then(callback)
x.on_ready(1)
callback.assert_called_with(1)
def test_getresponse__real_response(self):
client = Mock(name='client')
client.add_request = passthrough(name='client.add_request')
callback = PromiseMock(name='callback')
x = AsyncHTTPConnection('aws.vandelay.com', http_client=client)
request = x.getresponse(callback)
x.http_client.add_request.assert_called_with(request)
buf = WhateverIO()
buf.write('The quick brown fox jumps')
headers = http.Headers({'X-Foo': 'Hello', 'X-Bar': 'World'})
response = http.Response(request, 200, headers, buf)
request.on_ready(response)
callback.assert_called()
wresponse = callback.call_args[0][0]
self.assertEqual(wresponse.read(), 'The quick brown fox jumps')
self.assertEqual(wresponse.status, 200)
self.assertEqual(wresponse.getheader('X-Foo'), 'Hello')
self.assertDictEqual(dict(wresponse.getheaders()), headers)
self.assertTrue(wresponse.msg)
self.assertTrue(wresponse.msg)
self.assertTrue(repr(wresponse))
def test_getresponse__real_response(self):
client = Mock(name='client')
client.add_request = passthrough(name='client.add_request')
callback = PromiseMock(name='callback')
x = AsyncHTTPConnection('aws.vandelay.com', http_client=client)
request = x.getresponse(callback)
x.http_client.add_request.assert_called_with(request)
buf = WhateverIO()
buf.write('The quick brown fox jumps')
headers = http.Headers({'X-Foo': 'Hello', 'X-Bar': 'World'})
response = http.Response(request, 200, headers, buf)
request.on_ready(response)
callback.assert_called()
wresponse = callback.call_args[0][0]
self.assertEqual(wresponse.read(), 'The quick brown fox jumps')
self.assertEqual(wresponse.status, 200)
self.assertEqual(wresponse.getheader('X-Foo'), 'Hello')
self.assertDictEqual(dict(wresponse.getheaders()), headers)
self.assertTrue(wresponse.msg)
self.assertTrue(wresponse.msg)
self.assertTrue(repr(wresponse))
def test_then(self):
callback = PromiseMock(name='callback')
x = http.Request('http://foo')
x.then(callback)
x.on_ready(1)
callback.assert_called_with(1)
def test_make_request(self, _):
x = AsyncAWSAuthConnection('aws.vandelay.com',
http_client=Mock(name='client'))
Conn = x.get_http_connection = Mock(name='get_http_connection')
callback = PromiseMock(name='callback')
ret = x.make_request('GET', '/foo', callback=callback)
self.assertIs(ret, callback)
Conn.return_value.request.assert_called()
Conn.return_value.getresponse.assert_called_with(callback=callback, )
def test_make_request__no_action(self, _):
self.x._mexe = Mock(name='_mexe')
self.x.get_http_connection = Mock(name='get_http_connection')
callback = PromiseMock(name='callback')
self.x.make_request(
None,
{'foo': 1},
'/',
'GET',
callback=callback,
)
self.x._mexe.assert_called()
request = self.x._mexe.call_args[0][0]
self.assertNotIn('Action', request.params)
self.assertEqual(request.params['Version'], self.x.APIVersion)
def test_mexe__with_sender(self, _):
x = AsyncAWSAuthConnection('aws.vandelay.com',
http_client=Mock(name='client'))
Conn = x.get_http_connection = Mock(name='get_http_connection')
request = x.build_base_http_request('GET', 'foo', '/auth')
sender = Mock(name='sender')
callback = PromiseMock(name='callback')
x._mexe(request, sender=sender, callback=callback)
sender.assert_called_with(
Conn.return_value,
request.method,
request.path,
request.body,
request.headers,
callback,
)
def test_make_request(self, _):
_mexe, self.x._mexe = self.x._mexe, Mock(name='_mexe')
Conn = self.x.get_http_connection = Mock(name='get_http_connection')
callback = PromiseMock(name='callback')
self.x.make_request(
'action',
{'foo': 1},
'/',
'GET',
callback=callback,
)
self.x._mexe.assert_called()
request = self.x._mexe.call_args[0][0]
self.assertEqual(request.params['Action'], 'action')
self.assertEqual(request.params['Version'], self.x.APIVersion)
ret = _mexe(request, callback=callback)
self.assertIs(ret, callback)
Conn.return_value.request.assert_called()
Conn.return_value.getresponse.assert_called_with(callback=callback, )
def test_mexe(self, _):
x = AsyncAWSAuthConnection('aws.vandelay.com',
http_client=Mock(name='client'))
Conn = x.get_http_connection = Mock(name='get_http_connection')
request = x.build_base_http_request('GET', 'foo', '/auth')
callback = PromiseMock(name='callback')
x._mexe(request, callback=callback)
Conn.return_value.request.assert_called_with(
request.method,
request.path,
request.body,
request.headers,
)
Conn.return_value.getresponse.assert_called_with(callback=callback, )
no_callback_ret = x._mexe(request)
self.assertIsInstance(
no_callback_ret,
Thenable,
'_mexe always returns promise',
)
def setup(self):
self.x = AsyncSQSConnection('ak', 'sk')
self.x.get_object = Mock(name='X.get_object')
self.x.get_status = Mock(name='X.get_status')
self.x.get_list = Mock(nanme='X.get_list')
self.callback = PromiseMock(name='callback')
class test_AsyncSQSConnection(AWSCase):
def setup(self):
self.x = AsyncSQSConnection('ak', 'sk')
self.x.get_object = Mock(name='X.get_object')
self.x.get_status = Mock(name='X.get_status')
self.x.get_list = Mock(nanme='X.get_list')
self.callback = PromiseMock(name='callback')
def test_default_region(self):
self.assertTrue(self.x.region)
self.assertTrue(
issubclass(
self.x.region.connection_cls,
AsyncSQSConnection,
))
def test_create_queue(self):
self.x.create_queue('foo', callback=self.callback)
self.x.get_object.assert_called_with(
'CreateQueue',
{'QueueName': 'foo'},
AsyncQueue,
callback=self.callback,
)
def test_create_queue__with_visibility_timeout(self):
self.x.create_queue(
'foo',
visibility_timeout=33,
callback=self.callback,
)
self.x.get_object.assert_called_with('CreateQueue', {
'QueueName': 'foo',
'DefaultVisibilityTimeout': '33'
},
AsyncQueue,
callback=self.callback)
def test_delete_queue(self):
queue = Mock(name='queue')
self.x.delete_queue(queue, callback=self.callback)
self.x.get_status.assert_called_with(
'DeleteQueue',
None,
queue.id,
callback=self.callback,
)
def test_get_queue_attributes(self):
queue = Mock(name='queue')
self.x.get_queue_attributes(
queue,
attribute='QueueSize',
callback=self.callback,
)
self.x.get_object.assert_called_with(
'GetQueueAttributes',
{'AttributeName': 'QueueSize'},
Attributes,
queue.id,
callback=self.callback,
)
def test_set_queue_attribute(self):
queue = Mock(name='queue')
self.x.set_queue_attribute(
queue,
'Expires',
'3600',
callback=self.callback,
)
self.x.get_status.assert_called_with(
'SetQueueAttribute',
{
'Attribute.Name': 'Expires',
'Attribute.Value': '3600',
},
queue.id,
callback=self.callback,
)
def test_receive_message(self):
queue = Mock(name='queue')
self.x.receive_message(queue, 4, callback=self.callback)
self.x.get_list.assert_called_with(
'ReceiveMessage',
{'MaxNumberOfMessages': 4},
[('Message', queue.message_class)],
queue.id,
callback=self.callback,
)
def test_receive_message__with_visibility_timeout(self):
queue = Mock(name='queue')
self.x.receive_message(queue, 4, 3666, callback=self.callback)
self.x.get_list.assert_called_with(
'ReceiveMessage',
{
'MaxNumberOfMessages': 4,
'VisibilityTimeout': 3666,
},
[('Message', queue.message_class)],
queue.id,
callback=self.callback,
)
def test_receive_message__with_wait_time_seconds(self):
queue = Mock(name='queue')
self.x.receive_message(
queue,
4,
wait_time_seconds=303,
callback=self.callback,
)
self.x.get_list.assert_called_with(
'ReceiveMessage',
{
'MaxNumberOfMessages': 4,
'WaitTimeSeconds': 303,
},
[('Message', queue.message_class)],
queue.id,
callback=self.callback,
)
def test_receive_message__with_attributes(self):
queue = Mock(name='queue')
self.x.receive_message(
queue,
4,
attributes=['foo', 'bar'],
callback=self.callback,
)
self.x.get_list.assert_called_with(
'ReceiveMessage',
{
'AttributeName.1': 'foo',
'AttributeName.2': 'bar',
'MaxNumberOfMessages': 4,
},
[('Message', queue.message_class)],
queue.id,
callback=self.callback,
)
def MockMessage(self, id=None, receipt_handle=None, body=None):
m = Mock(name='message')
m.id = id or uuid()
m.receipt_handle = receipt_handle or uuid()
m._body = body
def _get_body():
return m._body
m.get_body.side_effect = _get_body
def _set_body(value):
m._body = value
m.set_body.side_effect = _set_body
return m
def test_delete_message(self):
queue = Mock(name='queue')
message = self.MockMessage()
self.x.delete_message(queue, message, callback=self.callback)
self.x.get_status.assert_called_with(
'DeleteMessage',
{'ReceiptHandle': message.receipt_handle},
queue.id,
callback=self.callback,
)
def test_delete_message_batch(self):
queue = Mock(name='queue')
messages = [self.MockMessage('1', 'r1'), self.MockMessage('2', 'r2')]
self.x.delete_message_batch(queue, messages, callback=self.callback)
self.x.get_object.assert_called_with(
'DeleteMessageBatch',
{
'DeleteMessageBatchRequestEntry.1.Id': '1',
'DeleteMessageBatchRequestEntry.1.ReceiptHandle': 'r1',
'DeleteMessageBatchRequestEntry.2.Id': '2',
'DeleteMessageBatchRequestEntry.2.ReceiptHandle': 'r2',
},
BatchResults,
queue.id,
verb='POST',
callback=self.callback,
)
def test_send_message(self):
queue = Mock(name='queue')
self.x.send_message(queue, 'hello', callback=self.callback)
self.x.get_object.assert_called_with(
'SendMessage',
{'MessageBody': 'hello'},
AsyncMessage,
queue.id,
verb='POST',
callback=self.callback,
)
def test_send_message__with_delay_seconds(self):
queue = Mock(name='queue')
self.x.send_message(
queue,
'hello',
delay_seconds='303',
callback=self.callback,
)
self.x.get_object.assert_called_with(
'SendMessage',
{
'MessageBody': 'hello',
'DelaySeconds': 303
},
AsyncMessage,
queue.id,
verb='POST',
callback=self.callback,
)
def test_send_message_batch(self):
queue = Mock(name='queue')
messages = [
self.MockMessage('1', 'r1', 'A'),
self.MockMessage('2', 'r2', 'B')
]
self.x.send_message_batch(queue, [(m.id, m.get_body(), 303)
for m in messages],
callback=self.callback)
self.x.get_object.assert_called_with(
'SendMessageBatch',
{
'SendMessageBatchRequestEntry.1.Id': '1',
'SendMessageBatchRequestEntry.1.MessageBody': 'A',
'SendMessageBatchRequestEntry.1.DelaySeconds': 303,
'SendMessageBatchRequestEntry.2.Id': '2',
'SendMessageBatchRequestEntry.2.MessageBody': 'B',
'SendMessageBatchRequestEntry.2.DelaySeconds': 303,
},
BatchResults,
queue.id,
verb='POST',
callback=self.callback,
)
def test_change_message_visibility(self):
queue = Mock(name='queue')
self.x.change_message_visibility(
queue,
'rcpt',
33,
callback=self.callback,
)
self.x.get_status.assert_called_with(
'ChangeMessageVisibility',
{
'ReceiptHandle': 'rcpt',
'VisibilityTimeout': 33,
},
queue.id,
callback=self.callback,
)
def test_change_message_visibility_batch(self):
queue = Mock(name='queue')
messages = [
(self.MockMessage('1', 'r1'), 303),
(self.MockMessage('2', 'r2'), 909),
]
self.x.change_message_visibility_batch(
queue,
messages,
callback=self.callback,
)
def preamble(n):
return '.'.join(['ChangeMessageVisibilityBatchRequestEntry', n])
self.x.get_object.assert_called_with(
'ChangeMessageVisibilityBatch',
{
preamble('1.Id'): '1',
preamble('1.ReceiptHandle'): 'r1',
preamble('1.VisibilityTimeout'): 303,
preamble('2.Id'): '2',
preamble('2.ReceiptHandle'): 'r2',
preamble('2.VisibilityTimeout'): 909,
},
BatchResults,
queue.id,
verb='POST',
callback=self.callback,
)
def test_get_all_queues(self):
self.x.get_all_queues(callback=self.callback)
self.x.get_list.assert_called_with(
'ListQueues',
{},
[('QueueUrl', AsyncQueue)],
callback=self.callback,
)
def test_get_all_queues__with_prefix(self):
self.x.get_all_queues(prefix='kombu.', callback=self.callback)
self.x.get_list.assert_called_with(
'ListQueues',
{'QueueNamePrefix': 'kombu.'},
[('QueueUrl', AsyncQueue)],
callback=self.callback,
)
def MockQueue(self, url):
q = Mock(name='Queue')
q.url = url
return q
def test_get_queue(self):
self.x.get_queue('foo', callback=self.callback)
self.assertTrue(self.x.get_list.called)
on_ready = self.x.get_list.call_args[1]['callback']
queues = [
self.MockQueue('/queues/bar'),
self.MockQueue('/queues/baz'),
self.MockQueue('/queues/foo'),
]
on_ready(queues)
self.callback.assert_called_with(queues[-1])
self.x.get_list.assert_called_with(
'ListQueues',
{'QueueNamePrefix': 'foo'},
[('QueueUrl', AsyncQueue)],
callback=on_ready,
)
def test_get_dead_letter_source_queues(self):
queue = Mock(name='queue')
self.x.get_dead_letter_source_queues(queue, callback=self.callback)
self.x.get_list.assert_called_with(
'ListDeadLetterSourceQueues',
{'QueueUrl': queue.url},
[('QueueUrl', AsyncQueue)],
callback=self.callback,
)
def test_add_permission(self):
queue = Mock(name='queue')
self.x.add_permission(
queue,
'label',
'accid',
'action',
callback=self.callback,
)
self.x.get_status.assert_called_with(
'AddPermission',
{
'Label': 'label',
'AWSAccountId': 'accid',
'ActionName': 'action',
},
queue.id,
callback=self.callback,
)
def test_remove_permission(self):
queue = Mock(name='queue')
self.x.remove_permission(queue, 'label', callback=self.callback)
self.x.get_status.assert_called_with(
'RemovePermission',
{'Label': 'label'},
queue.id,
callback=self.callback,
)
def setup(self):
self.queue = Mock(name='queue')
self.callback = PromiseMock(name='callback')
self.x = AsyncMessage(self.queue, 'body')
self.x.receipt_handle = uuid()
def mock_make_request(self):
self.x.make_request = Mock(name='make_request')
callback = PromiseMock(name='callback')
yield callback
class test_AsyncSQSConnection(AWSCase):
def setup(self):
self.x = AsyncSQSConnection('ak', 'sk', http_client=Mock())
self.x.get_object = Mock(name='X.get_object')
self.x.get_status = Mock(name='X.get_status')
self.x.get_list = Mock(nanme='X.get_list')
self.callback = PromiseMock(name='callback')
def test_without_boto(self):
from kombu.async.aws.sqs import connection
prev, connection.boto = connection.boto, None
try:
with self.assertRaises(ImportError):
AsyncSQSConnection('ak', 'sk', http_client=Mock())
finally:
connection.boto = prev
def test_default_region(self):
self.assertTrue(self.x.region)
self.assertTrue(issubclass(
self.x.region.connection_cls, AsyncSQSConnection,
))
def test_create_queue(self):
self.x.create_queue('foo', callback=self.callback)
self.x.get_object.assert_called_with(
'CreateQueue', {'QueueName': 'foo'}, AsyncQueue,
callback=self.callback,
)
def test_create_queue__with_visibility_timeout(self):
self.x.create_queue(
'foo', visibility_timeout=33, callback=self.callback,
)
self.x.get_object.assert_called_with(
'CreateQueue', {
'QueueName': 'foo',
'DefaultVisibilityTimeout': '33'
},
AsyncQueue, callback=self.callback
)
def test_delete_queue(self):
queue = Mock(name='queue')
self.x.delete_queue(queue, callback=self.callback)
self.x.get_status.assert_called_with(
'DeleteQueue', None, queue.id, callback=self.callback,
)
def test_get_queue_attributes(self):
queue = Mock(name='queue')
self.x.get_queue_attributes(
queue, attribute='QueueSize', callback=self.callback,
)
self.x.get_object.assert_called_with(
'GetQueueAttributes', {'AttributeName': 'QueueSize'},
Attributes, queue.id, callback=self.callback,
)
def test_set_queue_attribute(self):
queue = Mock(name='queue')
self.x.set_queue_attribute(
queue, 'Expires', '3600', callback=self.callback,
)
self.x.get_status.assert_called_with(
'SetQueueAttribute', {
'Attribute.Name': 'Expires',
'Attribute.Value': '3600',
},
queue.id, callback=self.callback,
)
def test_receive_message(self):
queue = Mock(name='queue')
self.x.receive_message(queue, 4, callback=self.callback)
self.x.get_list.assert_called_with(
'ReceiveMessage', {'MaxNumberOfMessages': 4},
[('Message', queue.message_class)],
queue.id, callback=self.callback,
)
def test_receive_message__with_visibility_timeout(self):
queue = Mock(name='queue')
self.x.receive_message(queue, 4, 3666, callback=self.callback)
self.x.get_list.assert_called_with(
'ReceiveMessage', {
'MaxNumberOfMessages': 4,
'VisibilityTimeout': 3666,
},
[('Message', queue.message_class)],
queue.id, callback=self.callback,
)
def test_receive_message__with_wait_time_seconds(self):
queue = Mock(name='queue')
self.x.receive_message(
queue, 4, wait_time_seconds=303, callback=self.callback,
)
self.x.get_list.assert_called_with(
'ReceiveMessage', {
'MaxNumberOfMessages': 4,
'WaitTimeSeconds': 303,
},
[('Message', queue.message_class)],
queue.id, callback=self.callback,
)
def test_receive_message__with_attributes(self):
queue = Mock(name='queue')
self.x.receive_message(
queue, 4, attributes=['foo', 'bar'], callback=self.callback,
)
self.x.get_list.assert_called_with(
'ReceiveMessage', {
'AttributeName.1': 'foo',
'AttributeName.2': 'bar',
'MaxNumberOfMessages': 4,
},
[('Message', queue.message_class)],
queue.id, callback=self.callback,
)
def MockMessage(self, id=None, receipt_handle=None, body=None):
m = Mock(name='message')
m.id = id or uuid()
m.receipt_handle = receipt_handle or uuid()
m._body = body
def _get_body():
return m._body
m.get_body.side_effect = _get_body
def _set_body(value):
m._body = value
m.set_body.side_effect = _set_body
return m
def test_delete_message(self):
queue = Mock(name='queue')
message = self.MockMessage()
self.x.delete_message(queue, message, callback=self.callback)
self.x.get_status.assert_called_with(
'DeleteMessage', {'ReceiptHandle': message.receipt_handle},
queue.id, callback=self.callback,
)
def test_delete_message_batch(self):
queue = Mock(name='queue')
messages = [self.MockMessage('1', 'r1'),
self.MockMessage('2', 'r2')]
self.x.delete_message_batch(queue, messages, callback=self.callback)
self.x.get_object.assert_called_with(
'DeleteMessageBatch', {
'DeleteMessageBatchRequestEntry.1.Id': '1',
'DeleteMessageBatchRequestEntry.1.ReceiptHandle': 'r1',
'DeleteMessageBatchRequestEntry.2.Id': '2',
'DeleteMessageBatchRequestEntry.2.ReceiptHandle': 'r2',
},
BatchResults, queue.id, verb='POST', callback=self.callback,
)
def test_send_message(self):
queue = Mock(name='queue')
self.x.send_message(queue, 'hello', callback=self.callback)
self.x.get_object.assert_called_with(
'SendMessage', {'MessageBody': 'hello'},
AsyncMessage, queue.id, verb='POST', callback=self.callback,
)
def test_send_message__with_delay_seconds(self):
queue = Mock(name='queue')
self.x.send_message(
queue, 'hello', delay_seconds='303', callback=self.callback,
)
self.x.get_object.assert_called_with(
'SendMessage', {'MessageBody': 'hello', 'DelaySeconds': 303},
AsyncMessage, queue.id, verb='POST', callback=self.callback,
)
def test_send_message_batch(self):
queue = Mock(name='queue')
messages = [self.MockMessage('1', 'r1', 'A'),
self.MockMessage('2', 'r2', 'B')]
self.x.send_message_batch(
queue, [(m.id, m.get_body(), 303) for m in messages],
callback=self.callback
)
self.x.get_object.assert_called_with(
'SendMessageBatch', {
'SendMessageBatchRequestEntry.1.Id': '1',
'SendMessageBatchRequestEntry.1.MessageBody': 'A',
'SendMessageBatchRequestEntry.1.DelaySeconds': 303,
'SendMessageBatchRequestEntry.2.Id': '2',
'SendMessageBatchRequestEntry.2.MessageBody': 'B',
'SendMessageBatchRequestEntry.2.DelaySeconds': 303,
},
BatchResults, queue.id, verb='POST', callback=self.callback,
)
def test_change_message_visibility(self):
queue = Mock(name='queue')
self.x.change_message_visibility(
queue, 'rcpt', 33, callback=self.callback,
)
self.x.get_status.assert_called_with(
'ChangeMessageVisibility', {
'ReceiptHandle': 'rcpt',
'VisibilityTimeout': 33,
},
queue.id, callback=self.callback,
)
def test_change_message_visibility_batch(self):
queue = Mock(name='queue')
messages = [
(self.MockMessage('1', 'r1'), 303),
(self.MockMessage('2', 'r2'), 909),
]
self.x.change_message_visibility_batch(
queue, messages, callback=self.callback,
)
def preamble(n):
return '.'.join(['ChangeMessageVisibilityBatchRequestEntry', n])
self.x.get_object.assert_called_with(
'ChangeMessageVisibilityBatch', {
preamble('1.Id'): '1',
preamble('1.ReceiptHandle'): 'r1',
preamble('1.VisibilityTimeout'): 303,
preamble('2.Id'): '2',
preamble('2.ReceiptHandle'): 'r2',
preamble('2.VisibilityTimeout'): 909,
},
BatchResults, queue.id, verb='POST', callback=self.callback,
)
def test_get_all_queues(self):
self.x.get_all_queues(callback=self.callback)
self.x.get_list.assert_called_with(
'ListQueues', {}, [('QueueUrl', AsyncQueue)],
callback=self.callback,
)
def test_get_all_queues__with_prefix(self):
self.x.get_all_queues(prefix='kombu.', callback=self.callback)
self.x.get_list.assert_called_with(
'ListQueues', {'QueueNamePrefix': 'kombu.'},
[('QueueUrl', AsyncQueue)],
callback=self.callback,
)
def MockQueue(self, url):
q = Mock(name='Queue')
q.url = url
return q
def test_get_queue(self):
self.x.get_queue('foo', callback=self.callback)
self.assertTrue(self.x.get_list.called)
on_ready = self.x.get_list.call_args[1]['callback']
queues = [
self.MockQueue('/queues/bar'),
self.MockQueue('/queues/baz'),
self.MockQueue('/queues/foo'),
]
on_ready(queues)
self.callback.assert_called_with(queues[-1])
self.x.get_list.assert_called_with(
'ListQueues', {'QueueNamePrefix': 'foo'},
[('QueueUrl', AsyncQueue)],
callback=on_ready,
)
def test_get_dead_letter_source_queues(self):
queue = Mock(name='queue')
self.x.get_dead_letter_source_queues(queue, callback=self.callback)
self.x.get_list.assert_called_with(
'ListDeadLetterSourceQueues', {'QueueUrl': queue.url},
[('QueueUrl', AsyncQueue)], callback=self.callback,
)
def test_add_permission(self):
queue = Mock(name='queue')
self.x.add_permission(
queue, 'label', 'accid', 'action', callback=self.callback,
)
self.x.get_status.assert_called_with(
'AddPermission', {
'Label': 'label',
'AWSAccountId': 'accid',
'ActionName': 'action',
},
queue.id, callback=self.callback,
)
def test_remove_permission(self):
queue = Mock(name='queue')
self.x.remove_permission(queue, 'label', callback=self.callback)
self.x.get_status.assert_called_with(
'RemovePermission', {'Label': 'label'}, queue.id,
callback=self.callback,
)
def setup(self):
self.conn = Mock(name='connection')
self.x = AsyncQueue(self.conn, '/url')
self.callback = PromiseMock(name='callback')
class test_AsyncQueue(AWSCase):
def setup(self):
self.conn = Mock(name='connection')
self.x = AsyncQueue(self.conn, '/url')
self.callback = PromiseMock(name='callback')
def test_message_class(self):
self.assertTrue(issubclass(self.x.message_class, AsyncMessage))
def test_get_attributes(self):
self.x.get_attributes(attributes='QueueSize', callback=self.callback)
self.x.connection.get_queue_attributes.assert_called_with(
self.x, 'QueueSize', self.callback,
)
def test_set_attribute(self):
self.x.set_attribute('key', 'value', callback=self.callback)
self.x.connection.set_queue_attribute.assert_called_with(
self.x, 'key', 'value', self.callback,
)
def test_get_timeout(self):
self.x.get_timeout(callback=self.callback)
self.x.connection.get_queue_attributes.assert_called()
on_ready = self.x.connection.get_queue_attributes.call_args[0][2]
self.x.connection.get_queue_attributes.assert_called_with(
self.x, 'VisibilityTimeout', on_ready,
)
on_ready({'VisibilityTimeout': '303'})
self.callback.assert_called_with(303)
def test_set_timeout(self):
self.x.set_timeout(808, callback=self.callback)
self.x.connection.set_queue_attribute.assert_called()
on_ready = self.x.connection.set_queue_attribute.call_args[0][3]
self.x.connection.set_queue_attribute.assert_called_with(
self.x, 'VisibilityTimeout', 808, on_ready,
)
on_ready(808)
self.callback.assert_called_with(808)
self.assertEqual(self.x.visibility_timeout, 808)
on_ready(None)
self.assertEqual(self.x.visibility_timeout, 808)
def test_add_permission(self):
self.x.add_permission(
'label', 'accid', 'action', callback=self.callback,
)
self.x.connection.add_permission.assert_called_with(
self.x, 'label', 'accid', 'action', self.callback,
)
def test_remove_permission(self):
self.x.remove_permission('label', callback=self.callback)
self.x.connection.remove_permission.assert_called_with(
self.x, 'label', self.callback,
)
def test_read(self):
self.x.read(visibility_timeout=909, callback=self.callback)
self.x.connection.receive_message.assert_called()
on_ready = self.x.connection.receive_message.call_args[1]['callback']
self.x.connection.receive_message.assert_called_with(
self.x, number_messages=1, visibility_timeout=909,
attributes=None, wait_time_seconds=None, callback=on_ready,
)
messages = [Mock(name='message1')]
on_ready(messages)
self.callback.assert_called_with(messages[0])
def MockMessage(self, id, md5):
m = Mock(name='Message-{0}'.format(id))
m.id = id
m.md5 = md5
return m
def test_write(self):
message = self.MockMessage('id1', 'digest1')
self.x.write(message, delay_seconds=303, callback=self.callback)
self.x.connection.send_message.assert_called()
on_ready = self.x.connection.send_message.call_args[1]['callback']
self.x.connection.send_message.assert_called_with(
self.x, message.get_body_encoded(), 303,
callback=on_ready,
)
new_message = self.MockMessage('id2', 'digest2')
on_ready(new_message)
self.assertEqual(message.id, 'id2')
self.assertEqual(message.md5, 'digest2')
def test_write_batch(self):
messages = [('id1', 'A', 0), ('id2', 'B', 303)]
self.x.write_batch(messages, callback=self.callback)
self.x.connection.send_message_batch.assert_called_with(
self.x, messages, callback=self.callback,
)
def test_delete_message(self):
message = self.MockMessage('id1', 'digest1')
self.x.delete_message(message, callback=self.callback)
self.x.connection.delete_message.assert_called_with(
self.x, message, self.callback,
)
def test_delete_message_batch(self):
messages = [
self.MockMessage('id1', 'r1'),
self.MockMessage('id2', 'r2'),
]
self.x.delete_message_batch(messages, callback=self.callback)
self.x.connection.delete_message_batch.assert_called_with(
self.x, messages, callback=self.callback,
)
def test_change_message_visibility_batch(self):
messages = [
(self.MockMessage('id1', 'r1'), 303),
(self.MockMessage('id2', 'r2'), 909),
]
self.x.change_message_visibility_batch(
messages, callback=self.callback,
)
self.x.connection.change_message_visibility_batch.assert_called_with(
self.x, messages, callback=self.callback,
)
def test_delete(self):
self.x.delete(callback=self.callback)
self.x.connection.delete_queue.assert_called_with(
self.x, callback=self.callback,
)
def test_count(self):
self.x.count(callback=self.callback)
self.x.connection.get_queue_attributes.assert_called()
on_ready = self.x.connection.get_queue_attributes.call_args[0][2]
self.x.connection.get_queue_attributes.assert_called_with(
self.x, 'ApproximateNumberOfMessages', on_ready,
)
on_ready({'ApproximateNumberOfMessages': '909'})
self.callback.assert_called_with(909)
def test_interface__count_slow(self):
with self.assertRaises(NotImplementedError):
self.x.count_slow()
def test_interface__dump(self):
with self.assertRaises(NotImplementedError):
self.x.dump()
def test_interface__save_to_file(self):
with self.assertRaises(NotImplementedError):
self.x.save_to_file()
def test_interface__save_to_filename(self):
with self.assertRaises(NotImplementedError):
self.x.save_to_filename()
def test_interface__save(self):
with self.assertRaises(NotImplementedError):
self.x.save()
def test_interface__save_to_s3(self):
with self.assertRaises(NotImplementedError):
self.x.save_to_s3()
def test_interface__load_from_s3(self):
with self.assertRaises(NotImplementedError):
self.x.load_from_s3()
def test_interface__load_from_file(self):
with self.assertRaises(NotImplementedError):
self.x.load_from_file()
def test_interface__load_from_filename(self):
with self.assertRaises(NotImplementedError):
self.x.load_from_filename()
def test_interface__load(self):
with self.assertRaises(NotImplementedError):
self.x.load()
def test_interface__clear(self):
with self.assertRaises(NotImplementedError):
self.x.clear()
def setup(self):
self.x = AsyncSQSConnection('ak', 'sk', http_client=Mock())
self.x.get_object = Mock(name='X.get_object')
self.x.get_status = Mock(name='X.get_status')
self.x.get_list = Mock(nanme='X.get_list')
self.callback = PromiseMock(name='callback')
