def test_add_remove_readers(self):
P = self.hub.poller = Mock()
read_A = Mock()
read_B = Mock()
self.hub.add_reader(10, read_A, 10)
self.hub.add_reader(File(11), read_B, 11)
P.register.assert_has_calls([
call(10, self.hub.READ | self.hub.ERR),
call(11, self.hub.READ | self.hub.ERR),
], any_order=True)
self.assertEqual(self.hub.readers[10], (read_A, (10,)))
self.assertEqual(self.hub.readers[11], (read_B, (11,)))
self.hub.remove(10)
self.assertNotIn(10, self.hub.readers)
self.hub.remove(File(11))
self.assertNotIn(11, self.hub.readers)
P.unregister.assert_has_calls([
call(10), call(11),
])
def test_collect__with_conn(self):
self.T.client.drain_events = 1234
conn = Mock(name='connection')
chans = conn.channels = {1: Mock(name='chan1'), 2: Mock(name='chan2')}
conn.callbacks = {'foo': Mock(name='cb1'), 'bar': Mock(name='cb2')}
for i, chan in enumerate(conn.channels.values()):
chan.connection = i
with patch('os.close') as close:
self.T._collect(conn)
close.assert_called_with(conn.fileno())
self.assertFalse(conn.channels)
self.assertFalse(conn.callbacks)
for chan in chans.values():
self.assertIsNone(chan.connection)
self.assertIsNone(self.client.drain_events)
self.assertIsNone(self.T.client)
with patch('os.close') as close:
self.T.client = self.client
close.side_effect = OSError()
self.T._collect(conn)
close.assert_called_with(conn.fileno())
def test_subscribe(self):
self.channel.subclient = Mock()
self.channel.active_fanout_queues.add('a')
self.channel.active_fanout_queues.add('b')
self.channel._fanout_queues.update(a=('a', ''), b=('b', ''))
self.channel._subscribe()
self.channel.subclient.psubscribe.assert_called()
s_args, _ = self.channel.subclient.psubscribe.call_args
self.assertItemsEqual(s_args[0], ['/{db}.a', '/{db}.b'])
self.channel.subclient.connection._sock = None
self.channel._subscribe()
self.channel.subclient.connection.connect.assert_called_with()
def test_register_when_registered_reregisters(self):
p = self.Poller()
p.poller = Mock()
channel, client, type = Mock(), Mock(), Mock()
sock = client.connection._sock = Mock()
sock.fileno.return_value = 10
p._chan_to_sock = {(channel, client, type): 6}
p._register(channel, client, type)
p.poller.unregister.assert_called_with(6)
self.assertTupleEqual(p._fd_to_chan[10], (channel, type))
self.assertEqual(p._chan_to_sock[(channel, client, type)], sock)
p.poller.register.assert_called_with(sock, p.eventflags)
# when client not connected yet
client.connection._sock = None
def after_connected():
client.connection._sock = Mock()
client.connection.connect.side_effect = after_connected
p._register(channel, client, type)
client.connection.connect.assert_called_with()
def test_add_writers(self):
P = self.hub.poller = Mock()
write_A = Mock()
write_B = Mock()
self.hub.add_writer(20, write_A)
self.hub.add_writer(File(21), write_B)
P.register.assert_has_calls([
call(20, self.hub.WRITE),
call(21, self.hub.WRITE),
], any_order=True)
self.assertEqual(self.hub.writers[20], (write_A, ()))
self.assertEqual(self.hub.writers[21], (write_B, ()))
self.hub.remove(20)
self.assertNotIn(20, self.hub.writers)
self.hub.remove(File(21))
self.assertNotIn(21, self.hub.writers)
P.unregister.assert_has_calls([
call(20), call(21),
])
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_qos_restore_visible(self):
client = self.channel._create_client = Mock(name='client')
client = client()
def pipe(*args, **kwargs):
return Pipeline(client)
client.pipeline = pipe
client.zrevrangebyscore.return_value = [
(1, 10),
(2, 20),
(3, 30),
]
qos = redis.QoS(self.channel)
restore = qos.restore_by_tag = Mock(name='restore_by_tag')
qos._vrestore_count = 1
qos.restore_visible()
self.assertFalse(client.zrevrangebyscore.called)
self.assertEqual(qos._vrestore_count, 2)
qos._vrestore_count = 0
qos.restore_visible()
restore.assert_has_calls([
call(1, client), call(2, client), call(3, client),
])
self.assertEqual(qos._vrestore_count, 1)
qos._vrestore_count = 0
restore.reset_mock()
client.zrevrangebyscore.return_value = []
qos.restore_visible()
self.assertFalse(restore.called)
self.assertEqual(qos._vrestore_count, 1)
qos._vrestore_count = 0
client.setnx.side_effect = redis.MutexHeld()
qos.restore_visible()
def test_get_http_connection(self):
x = AsyncConnection(client=Mock(name='client'))
self.assertIsInstance(
x.get_http_connection('aws.vandelay.com', 80, False),
AsyncHTTPConnection,
)
self.assertIsInstance(
x.get_http_connection('aws.vandelay.com', 443, True),
AsyncHTTPSConnection,
)
conn = x.get_http_connection('aws.vandelay.com', 80, False)
self.assertIs(conn.http_client, x._httpclient)
self.assertEqual(conn.host, 'aws.vandelay.com')
self.assertEqual(conn.port, 80)
def test_shuffles(self):
prev_repeat, utils.repeat = utils.repeat, Mock()
try:
utils.repeat.return_value = list(range(10))
values = set(['A', 'B', 'C'])
cycle = utils.shufflecycle(values)
seen = set()
for i in range(10):
next(cycle)
utils.repeat.assert_called_with(None)
self.assertTrue(seen.issubset(values))
with self.assertRaises(StopIteration):
next(cycle)
next(cycle)
finally:
utils.repeat = prev_repeat
def test_read(self):
self.x.read(visibility_timeout=909, callback=self.callback)
self.assertTrue(self.x.connection.receive_message.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 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 setup(self):
class Channel(pyamqp.Channel):
wait_returns = []
def _x_open(self, *args, **kwargs):
pass
def wait(self, *args, **kwargs):
return self.wait_returns
def _send_method(self, *args, **kwargs):
pass
self.conn = Mock()
self.conn._get_free_channel_id.side_effect = nextfun(count(0))
self.conn.channels = {}
self.channel = Channel(self.conn, 0)
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_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_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_mutex(self, lock_id='xxx'):
client = Mock(name='client')
with patch('kombu.transport.redis.uuid') as uuid:
# Won
uuid.return_value = lock_id
client.setnx.return_value = True
client.pipeline = ContextMock()
pipe = client.pipeline.return_value
pipe.get.return_value = lock_id
held = False
with redis.Mutex(client, 'foo1', 100):
held = True
self.assertTrue(held)
client.setnx.assert_called_with('foo1', lock_id)
pipe.get.return_value = 'yyy'
held = False
with redis.Mutex(client, 'foo1', 100):
held = True
self.assertTrue(held)
# Did not win
client.expire.reset_mock()
pipe.get.return_value = lock_id
client.setnx.return_value = False
with self.assertRaises(redis.MutexHeld):
held = False
with redis.Mutex(client, 'foo1', '100'):
held = True
self.assertFalse(held)
client.ttl.return_value = 0
with self.assertRaises(redis.MutexHeld):
held = False
with redis.Mutex(client, 'foo1', '100'):
held = True
self.assertFalse(held)
self.assertTrue(client.expire.called)
# Wins but raises WatchError (and that is ignored)
client.setnx.return_value = True
pipe.watch.side_effect = redis.redis.WatchError()
held = False
with redis.Mutex(client, 'foo1', 100):
held = True
self.assertTrue(held)
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_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 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_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 setUp(self):
if pyamqp is None:
raise SkipTest('py-amqp not installed')
class Channel(pyamqp.Channel):
wait_returns = []
def _x_open(self, *args, **kwargs):
pass
def wait(self, *args, **kwargs):
return self.wait_returns
def _send_method(self, *args, **kwargs):
pass
self.conn = Mock()
self.conn._get_free_channel_id.side_effect = nextfun(count(0))
self.conn.channels = {}
self.channel = Channel(self.conn, 0)
def test_put_priority(self):
client = self.channel.client = Mock(name='client')
msg1 = {'properties': {'priority': 3}}
self.channel._put('george', msg1)
client.lpush.assert_called_with(
self.channel._q_for_pri('george', 3), dumps(msg1),
)
msg2 = {'properties': {'priority': 313}}
self.channel._put('george', msg2)
client.lpush.assert_called_with(
self.channel._q_for_pri('george', 9), dumps(msg2),
)
msg3 = {'properties': {}}
self.channel._put('george', msg3)
client.lpush.assert_called_with(
self.channel._q_for_pri('george', 0), dumps(msg3),
)
def test_put_priority(self):
client = self.channel._create_client = Mock(name='client')
msg1 = {'properties': {'delivery_info': {'priority': 3}}}
self.channel._put('george', msg1)
client().lpush.assert_called_with(
self.channel._q_for_pri('george', 3), JSONEqual(dumps(msg1)),
)
msg2 = {'properties': {'delivery_info': {'priority': 313}}}
self.channel._put('george', msg2)
client().lpush.assert_called_with(
self.channel._q_for_pri('george', 9), JSONEqual(dumps(msg2)),
)
msg3 = {'properties': {'delivery_info': {}}}
self.channel._put('george', msg3)
client().lpush.assert_called_with(
self.channel._q_for_pri('george', 0), JSONEqual(dumps(msg3)),
)
def test_grow_shrink(self):
x = LaxBoundedSemaphore(1)
self.assertEqual(x.initial_value, 1)
cb1 = Mock()
x.acquire(cb1, 1)
cb1.assert_called_with(1)
self.assertEqual(x.value, 0)
cb2 = Mock()
x.acquire(cb2, 2)
cb2.assert_not_called()
self.assertEqual(x.value, 0)
cb3 = Mock()
x.acquire(cb3, 3)
cb3.assert_not_called()
x.grow(2)
cb2.assert_called_with(2)
cb3.assert_called_with(3)
self.assertEqual(x.value, 2)
self.assertEqual(x.initial_value, 3)
self.assertFalse(x._waiting)
x.grow(3)
for i in range(x.initial_value):
self.assertTrue(x.acquire(Mock()))
self.assertFalse(x.acquire(Mock()))
x.clear()
x.shrink(3)
for i in range(x.initial_value):
self.assertTrue(x.acquire(Mock()))
self.assertFalse(x.acquire(Mock()))
self.assertEqual(x.value, 0)
for i in range(100):
x.release()
self.assertEqual(x.value, x.initial_value)
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_imp_reraises_ValueError(self):
imp = Mock()
imp.side_effect = ValueError()
with self.assertRaises(ValueError):
utils.symbol_by_name('kombu.Connection', imp=imp)
def test_close_when_unregister_raises_KeyError(self):
p = self.Poller()
p.poller = Mock()
p._chan_to_sock.update({1: 1})
p.poller.unregister.side_effect = KeyError(1)
p.close()
def test_avail_client_when_not_in_poll(self):
self.channel._in_poll = False
c = self.channel.client = Mock()
with self.channel.conn_or_acquire() as client:
self.assertIs(client, c)
def test_close_client_close_raises(self):
c = self.channel.client = Mock()
c.connection.disconnect.side_effect = self.channel.ResponseError()
self.channel.close()
c.connection.disconnect.assert_called_with()
def test_brpop_read_gives_None(self):
c = self.channel.client = Mock()
c.parse_response.return_value = None
with self.assertRaises(redis.Empty):
self.channel._brpop_read()
