async def test_ok(self, event_loop, exchange):
connection = cabbage.AmqpConnection(hosts=[(HOST, 5672)],
loop=event_loop)
rpc = cabbage.AsyncAmqpRpc(connection=connection)
rpc.callback_exchange = exchange
with patch('cabbage.amqp.aioamqp_connect') as mock_connect:
mock_connect.return_value = (MockTransport(), MockProtocol())
await rpc.connect()
mock_connect.assert_called_once()
# check that client is set up correctly:
assert isinstance(rpc.channel, aioamqp.channel.Channel
) # actually it's a mock pretending to be a Channel
rpc.channel.queue_declare.assert_called_with(exclusive=True)
rpc.channel.basic_consume.assert_called_once_with(
callback=rpc._on_response, queue_name=rpc.callback_queue)
if rpc.callback_exchange != '':
rpc.channel.exchange_declare.assert_called_once_with(
exchange_name=rpc.callback_exchange,
type_name='topic',
durable=True)
rpc.channel.queue_bind.assert_called_once_with(
queue_name=rpc.callback_queue,
exchange_name=rpc.callback_exchange,
routing_key=rpc.callback_queue)
else:
rpc.channel.exchange_declare.assert_not_called()
rpc.channel.queue_bind.assert_not_called()
async def test_retry(self, event_loop):
"""Keep reconnecting if an error occurs."""
attempts = 10
async def faulty_connect(_attempts=[attempts], **kwargs):
assert kwargs == dict(host=HOST,
port=PORT,
login=USERNAME,
password=PASSWORD,
virtualhost=VIRTUALHOST,
loop=event_loop,
ssl=False)
_attempts[0] -= 1
if _attempts[0]:
raise OSError('[Errno 113] Connect call failed')
return mock_transport, mock_protocol
connection = cabbage.AmqpConnection(hosts=[(HOST, PORT)],
username=USERNAME,
password=PASSWORD,
virtualhost=VIRTUALHOST,
loop=event_loop)
mock_transport, mock_protocol = MockTransport(), MockProtocol()
with patch('cabbage.amqp.aioamqp_connect',
new=faulty_connect), patch('asyncio.sleep') as mock_sleep:
await connection.connect()
assert mock_sleep.call_count == attempts - 1
assert connection.transport is mock_transport
assert connection.protocol is mock_protocol
async def test_called_twice(self, event_loop):
"""Check that calling the method twice has no effect."""
connection = cabbage.AmqpConnection(loop=event_loop)
mock_transport, mock_protocol = MockTransport(), MockProtocol()
connection.transport = mock_transport
connection.protocol = mock_protocol
with patch('cabbage.amqp.aioamqp_connect') as mock_connect:
await connection.connect()
mock_connect.assert_not_called()
assert connection.transport is mock_transport
assert connection.protocol is mock_protocol
async def test_amqp_connection_with_default_port(event_loop):
DEFAULT_PORT = 5672
mock_transport, mock_protocol = MockTransport(), MockProtocol()
with patch('asyncio.base_events.BaseEventLoop.create_connection'
) as mock_connect:
mock_connect.return_value = (mock_transport, mock_protocol)
await aioamqp_connect(host=HOST,
virtualhost=VIRTUALHOST,
login=USERNAME,
password=PASSWORD,
loop=event_loop,
ssl=False)
mock_connect.assert_called_once_with(mock.ANY, HOST, DEFAULT_PORT)
async def test_amqp_connection_ssl_context(event_loop):
mock_transport, mock_protocol = MockTransport(), MockProtocol()
with patch('asyncio.base_events.BaseEventLoop.create_connection'
) as mock_connect:
with patch('ssl.create_default_context') as mock_default_context:
mock_connect.return_value = (mock_transport, mock_protocol)
await aioamqp_connect(host=HOST,
port=PORT,
virtualhost=VIRTUALHOST,
login=USERNAME,
password=PASSWORD,
verify_ssl=False,
ssl=mock_default_context)
assert mock_default_context.check_hostname is False
assert mock_default_context.verify_mode == ssl.CERT_NONE
async def test_amqp_connection_exception(event_loop):
ssl_context = mock.MagicMock()
mock_transport, mock_protocol = MockTransport(), MockProtocol()
mock_protocol.start_connection = mock.MagicMock(
side_effect=ValueError('TestException'))
with patch('asyncio.base_events.BaseEventLoop.create_connection'
) as mock_connect:
mock_connect.return_value = (mock_transport, mock_protocol)
with pytest.raises(ValueError, message='Expected ValueError'):
await aioamqp_connect(host=HOST,
port=PORT,
virtualhost=VIRTUALHOST,
login=USERNAME,
password=PASSWORD,
loop=event_loop,
ssl=ssl_context)
async def test_amqp_connection_ssl(event_loop):
ssl_context = mock.MagicMock()
mock_transport, mock_protocol = MockTransport(), MockProtocol()
with patch('asyncio.base_events.BaseEventLoop.create_connection'
) as mock_connect:
mock_connect.return_value = (mock_transport, mock_protocol)
await aioamqp_connect(host=HOST,
port=PORT,
virtualhost=VIRTUALHOST,
login=USERNAME,
password=PASSWORD,
loop=event_loop,
ssl=ssl_context)
mock_connect.assert_called_once_with(mock.ANY,
HOST,
PORT,
ssl=ssl_context)
async def test_default_params(self, event_loop):
"""Check that AmqpConnection supplies reasonable defaults."""
connection = cabbage.AmqpConnection(loop=event_loop)
mock_transport, mock_protocol = MockTransport(), MockProtocol()
with patch('cabbage.amqp.aioamqp_connect') as mock_connect:
mock_connect.return_value = (mock_transport, mock_protocol)
await connection.connect()
mock_connect.assert_called_once_with(host='localhost',
port=5672,
login='******',
password='******',
virtualhost='/',
loop=event_loop,
ssl=False)
assert connection.transport is mock_transport
assert connection.protocol is mock_protocol
async def test_connect(self, event_loop):
"""Check typical connection call."""
mock_transport, mock_protocol = MockTransport(), MockProtocol()
connection = cabbage.AmqpConnection(hosts=[(HOST, PORT)],
username=USERNAME,
password=PASSWORD,
virtualhost=VIRTUALHOST,
loop=event_loop)
with patch('cabbage.amqp.aioamqp_connect') as mock_connect:
mock_connect.return_value = (mock_transport, mock_protocol)
await connection.connect()
mock_connect.assert_called_once_with(host=HOST,
port=PORT,
login=USERNAME,
password=PASSWORD,
virtualhost=VIRTUALHOST,
loop=event_loop,
ssl=False)
assert connection.transport is mock_transport
assert connection.protocol is mock_protocol
async def test_ok(self, connection: AmqpConnection):
connection.protocol = MockProtocol()
connection.protocol.state = OPEN
assert connection.is_connected is True