def test_connect__socket_error(self):
self.conn = Connection()
self.conn.collect = Mock(name='collect')
with patch('socket.socket', side_effect=socket.error):
with pytest.raises(socket.error):
self.conn.connect()
self.conn.collect.assert_called_with()
def test_connecion_ignore_methods_during_close(self, on_blocked_mock):
# Test checking that py-amqp will discard any received methods
# except Close and Close-OK after sending Connecion.Close method
# to server.
frame_writer_cls_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
frame_writer_mock.reset_mock()
# Inject CloseOk response from broker
transport_mock().read_frame.side_effect = [
build_frame_type_1(
spec.Connection.Blocked, channel=0
),
build_frame_type_1(
spec.Connection.CloseOk
)
]
t = conn.transport
conn.close()
on_blocked_mock.assert_not_called()
frame_writer_mock.assert_called_once_with(
1, 0, spec.Connection.Close, dumps('BsBB', (0, '', 0, 0)), None
)
t.close.assert_called_once_with()
def test_missing_credentials(self):
with pytest.raises(ValueError):
self.conn = Connection(userid=None,
password=None,
login_method='AMQPLAIN')
with pytest.raises(ValueError):
self.conn = Connection(password=None, login_method='PLAIN')
def test_login_method_external(self):
self.conn = Connection(userid=None,
password=None,
login_method='EXTERNAL')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], EXTERNAL)
def test_channel_open_close(self):
# Test checking opening and closing channel
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
channel_id = 1
transport_mock().read_frame.side_effect = [
# Inject Open Handshake
build_frame_type_1(spec.Channel.OpenOk,
channel=channel_id,
args=(1, False),
arg_format='Lb'),
# Inject close method
build_frame_type_1(spec.Channel.CloseOk, channel=channel_id)
]
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
on_open_mock = Mock()
ch = conn.channel(channel_id=channel_id, callback=on_open_mock)
on_open_mock.assert_called_once_with(ch)
assert ch.is_open is True
ch.close()
frame_writer_mock.assert_has_calls([
call(1, 1, spec.Channel.Open, dumps('s', ('', )), None),
call(1, 1, spec.Channel.Close, dumps('BsBB', (0, '', 0, 0)),
None)
])
assert ch.is_open is False
def test_received_channel_Close_during_connection_close(self):
# This test verifies that library handles correctly closing channel
# during closing of connection:
# 1. User requests closing connection - client sends Connection.Close
# 2. Broker requests closing Channel - client receives Channel.Close
# 3. Broker sends Connection.CloseOk
# see GitHub issue #218
conn = Connection()
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
channel_id = 1
create_channel(channel_id, conn, transport_mock)
# Replies sent by broker
transport_mock().read_frame.side_effect = [
# Inject close methods
build_frame_type_1(
spec.Channel.Close,
channel=channel_id,
args=(1, False),
arg_format='Lb'
),
build_frame_type_1(
spec.Connection.CloseOk
)
]
conn.close()
def _ensure(self):
if self.conn:
if self.conn.is_alive():
return
else:
self.close()
self.conn = Connection(**self.conn_params)
def test_basic_deliver(self):
# Test checking delivering single message
callback_mock = Mock()
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
consumer_tag = 'amq.ctag-PCmzXGkhCw_v0Zq7jXyvkg'
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
# Inject ConsumeOk response from Broker
transport_mock().read_frame.side_effect = [
# Inject Consume-ok response
build_frame_type_1(spec.Basic.ConsumeOk,
channel=1,
args=(consumer_tag, ),
arg_format='s'),
# Inject basic-deliver response
build_frame_type_1(
spec.Basic.Deliver,
channel=1,
arg_format='sLbss',
args=(
# consumer-tag, delivery-tag, redelivered,
consumer_tag,
1,
False,
# exchange-name, routing-key
'foo_exchange',
'routing-key')),
build_frame_type_2(channel=1,
body_len=12,
properties=b'0\x00\x00\x00\x00\x00\x01'),
build_frame_type_3(channel=1, body=b'Hello World!'),
]
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ch.basic_consume('my_queue', callback=callback_mock)
conn.drain_events()
callback_mock.assert_called_once_with(ANY)
msg = callback_mock.call_args[0][0]
assert isinstance(msg, Message)
assert msg.body_size == 12
assert msg.body == b'Hello World!'
assert msg.frame_method == spec.Basic.Deliver
assert msg.delivery_tag == 1
assert msg.ready is True
assert msg.delivery_info == {
'consumer_tag': 'amq.ctag-PCmzXGkhCw_v0Zq7jXyvkg',
'delivery_tag': 1,
'redelivered': False,
'exchange': 'foo_exchange',
'routing_key': 'routing-key'
}
assert msg.properties == {
'application_headers': {},
'delivery_mode': 1
}
def test_login_method_gssapi(self):
try:
self.conn = Connection(userid=None, password=None,
login_method='GSSAPI')
except NotImplementedError:
pass
else:
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], GSSAPI)
class AMQPClient(object):
"""docstring for AMQPClient"""
def __init__(self, host='localhost', userid='guest',
password='******', virtual_host='/', heartbeat=0):
super(AMQPClient, self).__init__()
self.conn_params = {
'host': host,
'userid': userid,
'password': password,
'virtual_host': virtual_host,
'heartbeat': heartbeat,
}
self.conn = None
self.channel = None
def _ensure(self):
if self.conn:
if self.conn.is_alive():
return
else:
self.close()
self.conn = Connection(**self.conn_params)
def close(self):
if not self.conn:
return
try:
self.conn.close()
except:
pass
self.conn = None
def _queue(self, queue=None, exchange=None, exchange_type='direct', routing_key=None):
self._ensure()
channel = self.conn.channel()
channel.queue_declare(queue=queue, durable=True,
exclusive=False, auto_delete=False)
channel.exchange_declare(
exchange=exchange, type=exchange_type, durable=True, auto_delete=False)
channel.queue_bind(queue=queue, exchange=exchange,
routing_key=routing_key)
return channel
def queue(self, queue=None, exchange=None, exchange_type='direct', routing_key=None):
channel = self._queue(queue, exchange, exchange_type, routing_key)
return AMQPQueue(self, channel, queue, exchange, exchange_type, routing_key)
def wait(self, timeout=None):
self._ensure()
self.conn.drain_events(timeout=timeout)
def test__enter__socket_error(self):
# test when entering
self.conn = Connection()
self.conn.close = Mock(name='close')
reached = False
with patch('socket.socket', side_effect=socket.error):
with pytest.raises(socket.error):
with self.conn:
reached = True
assert not reached and not self.conn.close.called
assert self.conn._transport is None and not self.conn.connected
def test_rabbitmq_conection(self):
print('RABBITMQ_PORT_5672_TCP_ADDR')
print(os.environ.get('RABBITMQ_PORT_5672_TCP_ADDR'))
print('RABBITMQ_PORT_5672_TCP_PORT')
print(os.environ.get('RABBITMQ_PORT_5672_TCP_PORT'))
# BROKER_URL = 'amqp://*****:*****@localhost:5672//'
conn = Connection(host='{}:{}'.format(
os.environ.get('RABBITMQ_PORT_5672_TCP_ADDR'),
os.environ.get('RABBITMQ_PORT_5672_TCP_PORT')))
self.assertIsNotNone(conn.connection)
conn.close()
self.assertIsNone(conn.connection)
def setup_conn(self):
self.frame_handler = Mock(name='frame_handler')
self.frame_writer = Mock(name='frame_writer_cls')
self.conn = Connection(
frame_handler=self.frame_handler,
frame_writer=self.frame_writer,
)
self.conn.Channel = Mock(name='Channel')
self.conn.Transport = Mock(name='Transport')
self.conn.transport = self.conn.Transport.return_value
self.conn.send_method = Mock(name='send_method')
self.conn.frame_writer = Mock(name='frame_writer')
def test_connection_methods(self, method, callback):
# Test verifying that proper Connection callback is called when
# given method arrived from Broker.
with patch.object(Connection, callback) as callback_mock:
conn = Connection()
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
# Inject desired method
transport_mock().read_frame.return_value = ret_factory(
method, channel=0, args=(1, False), arg_format='Lb')
conn.drain_events(0)
callback_mock.assert_called_once()
def test_connect__socket_error(self):
# check Transport.Connect error
# socket.error derives from IOError
# ssl.SSLError derives from socket.error
self.conn = Connection()
self.conn.Transport = Mock(name='Transport')
transport = self.conn.Transport.return_value
transport.connect.side_effect = IOError
assert self.conn._transport is None and not self.conn.connected
with pytest.raises(IOError):
self.conn.connect()
transport.connect.assert_called
assert self.conn._transport is None and not self.conn.connected
def test_channel_ignore_methods_during_close(self):
# Test checking that py-amqp will discard any received methods
# except Close and Close-OK after sending Channel.Close method
# to server.
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
consumer_tag = 'amq.ctag-PCmzXGkhCw_v0Zq7jXyvkg'
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
channel_id = 1
transport_mock().read_frame.side_effect = [
# Inject Open Handshake
build_frame_type_1(spec.Channel.OpenOk,
channel=channel_id,
args=(1, False),
arg_format='Lb'),
# Inject basic-deliver response
build_frame_type_1(
spec.Basic.Deliver,
channel=1,
arg_format='sLbss',
args=(
# consumer-tag, delivery-tag, redelivered,
consumer_tag,
1,
False,
# exchange-name, routing-key
'foo_exchange',
'routing-key')),
build_frame_type_2(channel=1,
body_len=12,
properties=b'0\x00\x00\x00\x00\x00\x01'),
build_frame_type_3(channel=1, body=b'Hello World!'),
# Inject close method
build_frame_type_1(spec.Channel.CloseOk, channel=channel_id),
]
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
with patch('amqp.Channel._on_basic_deliver') as on_deliver_mock:
ch = conn.channel(channel_id=channel_id)
ch.close()
on_deliver_mock.assert_not_called()
frame_writer_mock.assert_has_calls([
call(1, 1, spec.Channel.Open, dumps('s', ('', )), None),
call(1, 1, spec.Channel.Close, dumps('BsBB', (0, '', 0, 0)),
None)
])
assert ch.is_open is False
class AMQPClient(object):
"""docstring for AMQPClient"""
def __init__(self, host="localhost", userid="guest", password="******", virtual_host="/", heartbeat=0):
super(AMQPClient, self).__init__()
self.conn_params = {
"host": host,
"userid": userid,
"password": password,
"virtual_host": virtual_host,
"heartbeat": heartbeat,
}
self.conn = None
self.channel = None
def _ensure(self):
if self.conn:
if self.conn.is_alive():
return
else:
self.close()
self.conn = Connection(**self.conn_params)
def close(self):
if not self.conn:
return
try:
self.conn.close()
except:
pass
self.conn = None
def _queue(self, queue=None, exchange=None, exchange_type="direct", routing_key=None):
self._ensure()
channel = self.conn.channel()
channel.queue_declare(queue=queue, durable=True, exclusive=False, auto_delete=False)
channel.exchange_declare(exchange=exchange, type=exchange_type, durable=True, auto_delete=False)
channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
return channel
def queue(self, queue=None, exchange=None, exchange_type="direct", routing_key=None):
channel = self._queue(queue, exchange, exchange_type, routing_key)
return AMQPQueue(self, channel, queue, exchange, exchange_type, routing_key)
def wait(self, timeout=None):
self._ensure()
self.conn.drain_events(timeout=timeout)
def test_exchange_declare(self):
# Test verifying declaring exchange
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Exchange.DeclareOk, channel=1)
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ret = ch.exchange_declare('foo', 'fanout')
assert ret is None
frame_writer_mock.assert_called_once_with(
1,
1,
spec.Exchange.Declare,
dumps(
'BssbbbbbF',
(
0,
# exchange, type, passive, durable,
'foo',
'fanout',
False,
False,
# auto_delete, internal, nowait, arguments
True,
False,
False,
None)),
None)
def test_queue_purge(self):
# Test verifying purging queue
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Queue.PurgeOk,
channel=1,
arg_format='l',
args=(4,)
)
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
msg_count = ch.queue_purge('foo')
assert msg_count == 4
frame_writer_mock.assert_called_once_with(
1, 1, spec.Queue.Purge,
dumps(
'Bsb',
# queue, nowait
(0, 'foo', False)
),
None
)
def test_queue_declare(self):
# Test verifying declaring queue
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Queue.DeclareOk,
channel=1,
arg_format='sll',
args=('foo', 1, 2)
)
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ret = ch.queue_declare('foo')
assert ret == queue_declare_ok_t(
queue='foo', message_count=1, consumer_count=2
)
frame_writer_mock.assert_called_once_with(
1, 1, spec.Queue.Declare,
dumps(
'BsbbbbbF',
(
0,
# queue, passive, durable, exclusive,
'foo', False, False, False,
# auto_delete, nowait, arguments
True, False, None
)
),
None
)
def test_with(self):
with Connection(**settings.connect_args) as conn:
self.assertEqual(conn.transport is None, False)
with conn.channel(1) as ch:
self.assertEqual(1 in conn.channels, True)
#
# Do something with the channel
#
ch.exchange_declare('unittest.fanout',
'fanout',
auto_delete=True)
msg = Message('unittest message',
content_type='text/plain',
application_headers={
'foo': 7,
'bar': 'baz'
})
ch.basic_publish(msg, 'unittest.fanout')
#
# check that the channel was closed
#
self.assertEqual(1 in conn.channels, False)
self.assertEqual(ch.is_open, False)
#
# Check that the connection was closed
#
self.assertEqual(conn.transport, None)
def test_queue_get_empty(self):
# Test verifying getting message from empty queue
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Basic.GetEmpty,
channel=1,
arg_format='s',
args=('s')
)
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ret = ch.basic_get('foo')
assert ret is None
frame_writer_mock.assert_called_once_with(
1, 1, spec.Basic.Get,
dumps(
'Bsb',
# queue, nowait
(0, 'foo', False)
),
None
)
def test_consume_no_consumer_tag(self):
# Test verifing starting consuming without specified consumer_tag
callback_mock = Mock()
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
consumer_tag = 'amq.ctag-PCmzXGkhCw_v0Zq7jXyvkg'
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
# Inject ConsumeOk response from Broker
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Basic.ConsumeOk,
channel=1,
args=(consumer_tag, ),
arg_format='s')
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ret = ch.basic_consume('my_queue', callback=callback_mock)
frame_writer_mock.assert_called_once_with(
1, 1, spec.Basic.Consume,
dumps('BssbbbbF',
(0, 'my_queue', '', False, False, False, False, None)),
None)
assert ch.callbacks[consumer_tag] == callback_mock
assert ret == 'amq.ctag-PCmzXGkhCw_v0Zq7jXyvkg'
def test_consume_with_consumer_tag(self):
# Test verifing starting consuming with specified consumer_tag
callback_mock = Mock()
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
# Inject ConcumeOk response from Broker
transport_mock().read_frame.return_value = ret_factory(
spec.Basic.ConsumeOk,
channel=1,
args=('my_tag', ),
arg_format='s')
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ch.basic_consume('my_queue',
callback=callback_mock,
consumer_tag='my_tag')
frame_writer_mock.assert_called_once_with(
1, 1, spec.Basic.Consume,
dumps('BssbbbbF', (0, 'my_queue', 'my_tag', False, False,
False, False, None)), None)
assert ch.callbacks['my_tag'] == callback_mock
def test_exchange_delete(self):
# Test verifying declaring exchange
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.return_value = build_frame_type_1(
spec.Exchange.DeleteOk, channel=1)
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
ret = ch.exchange_delete('foo')
assert ret == ()
frame_writer_mock.assert_called_once_with(
1,
1,
spec.Exchange.Delete,
dumps(
'Bsbb',
(
0,
# exchange, if-unused, no-wait
'foo',
False,
False)),
None)
def test_connect(self):
# Test checking connection handshake
frame_writer_cls_mock = Mock()
on_open_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
conn = Connection(frame_writer=frame_writer_cls_mock,
on_open=on_open_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
on_open_mock.assert_called_once_with(conn)
security_mechanism = sasl.AMQPLAIN('guest',
'guest').start(conn).decode(
'utf-8', 'surrogatepass')
# Expected responses from client
frame_writer_mock.assert_has_calls([
call(
1,
0,
spec.Connection.StartOk,
# Due Table type, we cannot compare bytestream directly
DataComparator('FsSs', (CLIENT_CAPABILITIES, 'AMQPLAIN',
security_mechanism, 'en_US')),
None),
call(
1, 0, spec.Connection.TuneOk,
dumps('BlB',
(conn.channel_max, conn.frame_max, conn.heartbeat)),
None),
call(1, 0, spec.Connection.Open,
dumps('ssb', (conn.virtual_host, '', False)), None)
])
def _ensure(self):
if self.conn:
if self.conn.is_alive():
return
else:
self.close()
self.conn = Connection(**self.conn_params)
def test_connection_close(self):
# Test checking closing connection
frame_writer_cls_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
frame_writer_mock.reset_mock()
# Inject CloseOk response from broker
transport_mock().read_frame.return_value = ret_factory(
spec.Connection.CloseOk, args=(1, False), arg_format='Lb')
t = conn.transport
conn.close()
frame_writer_mock.assert_called_once_with(
1, 0, spec.Connection.Close, dumps('BsBB', (0, '', 0, 0)),
None)
t.close.assert_called_once_with()
def test_connection_closed_by_broker(self):
# Test that library response correctly CloseOk when
# close method is received and _on_close_ok() method is called.
frame_writer_cls_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
with patch.object(Connection, '_on_close_ok') as callback_mock:
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
frame_writer_mock.reset_mock()
# Inject Close response from broker
transport_mock().read_frame.return_value = ret_factory(
spec.Connection.Close, args=(1, False), arg_format='Lb')
with pytest.raises(ConnectionError):
conn.drain_events(0)
frame_writer_mock.assert_called_once_with(
1, 0, spec.Connection.CloseOk, '', None)
callback_mock.assert_called_once_with()
def test_connect_no_capabilities(self):
# Test checking connection handshake with broker
# not supporting capabilities
frame_writer_cls_mock = Mock()
on_open_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
conn = Connection(
frame_writer=frame_writer_cls_mock, on_open=on_open_mock
)
with patch.object(conn, 'Transport') as transport_mock:
server_properties = dict(SERVER_PROPERTIES)
del server_properties['capabilities']
client_properties = dict(CLIENT_PROPERTIES)
del client_properties['capabilities']
handshake(
conn, transport_mock, server_properties=server_properties
)
on_open_mock.assert_called_once_with(conn)
security_mechanism = sasl.AMQPLAIN(
'guest', 'guest'
).start(conn).decode('utf-8', 'surrogatepass')
# Expected responses from client
frame_writer_mock.assert_has_calls(
[
call(
1, 0, spec.Connection.StartOk,
# Due Table type, we cannot compare bytestream directly
DataComparator(
'FsSs',
(
client_properties, 'AMQPLAIN',
security_mechanism,
'en_US'
)
),
None
),
call(
1, 0, spec.Connection.TuneOk,
dumps(
'BlB',
(conn.channel_max, conn.frame_max, conn.heartbeat)
),
None
),
call(
1, 0, spec.Connection.Open,
dumps('ssb', (conn.virtual_host, '', False)),
None
)
]
)
assert conn.client_properties == client_properties
def test_login_method_response(self):
# An old way of doing things.:
login_method, login_response = b'foo', b'bar'
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.conn = Connection(login_method=login_method,
login_response=login_response)
self.conn.send_method = Mock(name='send_method')
self.conn._on_start(3, 4, {'foo': 'bar'}, login_method,
'en_US en_GB')
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, login_method,
login_response, self.conn.locale,
),
)
def test_login_method_gssapi(self):
try:
self.conn = Connection(userid=None, password=None,
login_method='GSSAPI')
except NotImplementedError:
pass
else:
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], GSSAPI)
def test__enter__socket_error(self):
# test when entering
self.conn = Connection()
self.conn.close = Mock(name='close')
reached = False
with patch('socket.socket', side_effect=socket.error):
with pytest.raises(socket.error):
with self.conn:
reached = True
assert not reached and not self.conn.close.called
assert self.conn._transport is None and not self.conn.connected
def test_queue_get(self):
# Test verifying getting message from queue
frame_writer_cls_mock = Mock()
conn = Connection(frame_writer=frame_writer_cls_mock)
with patch.object(conn, 'Transport') as transport_mock:
handshake(conn, transport_mock)
ch = create_channel(1, conn, transport_mock)
transport_mock().read_frame.side_effect = [
build_frame_type_1(
spec.Basic.GetOk,
channel=1,
arg_format='Lbssl',
args=(
# delivery_tag, redelivered, exchange_name
1, False, 'foo_exchange',
# routing_key, message_count
'routing_key', 1
)
),
build_frame_type_2(
channel=1,
body_len=12,
properties=b'0\x00\x00\x00\x00\x00\x01'
),
build_frame_type_3(
channel=1,
body=b'Hello World!'
)
]
frame_writer_mock = frame_writer_cls_mock()
frame_writer_mock.reset_mock()
msg = ch.basic_get('foo')
assert msg.body_size == 12
assert msg.body == b'Hello World!'
assert msg.frame_method == spec.Basic.GetOk
assert msg.delivery_tag == 1
assert msg.ready is True
assert msg.delivery_info == {
'delivery_tag': 1, 'redelivered': False,
'exchange': 'foo_exchange',
'routing_key': 'routing_key', 'message_count': 1
}
assert msg.properties == {
'application_headers': {}, 'delivery_mode': 1
}
frame_writer_mock.assert_called_once_with(
1, 1, spec.Basic.Get,
dumps(
'Bsb',
# queue, nowait
(0, 'foo', False)
),
None
)
def setup(self):
self.frame_handler = Mock(name='frame_handler')
self.frame_writer = Mock(name='frame_writer')
self.conn = Connection(
frame_handler=self.frame_handler,
frame_writer=self.frame_writer,
)
self.conn.Channel = Mock(name='Channel')
self.conn.Transport = Mock(name='Transport')
self.conn.transport = self.conn.Transport.return_value
self.conn.send_method = Mock(name='send_method')
self.conn._frame_writer = Mock(name='_frame_writer')
def test_connect_missing_capabilities(self):
# Test checking connection handshake with broker
# supporting subset of capabilities
frame_writer_cls_mock = Mock()
on_open_mock = Mock()
frame_writer_mock = frame_writer_cls_mock()
conn = Connection(frame_writer=frame_writer_cls_mock,
on_open=on_open_mock)
with patch.object(conn, 'Transport') as transport_mock:
server_properties = dict(SERVER_PROPERTIES)
server_properties['capabilities'] = {
# This capability is not supported by client
'basic.nack': True,
'consumer_cancel_notify': True,
'connection.blocked': False,
# server does not support 'authentication_failure_close'
# which is supported by client
}
client_properties = dict(CLIENT_PROPERTIES)
client_properties['capabilities'] = {
'consumer_cancel_notify': True,
}
handshake(conn,
transport_mock,
server_properties=server_properties)
on_open_mock.assert_called_once_with(conn)
security_mechanism = sasl.AMQPLAIN('guest',
'guest').start(conn).decode(
'utf-8', 'surrogatepass')
# Expected responses from client
frame_writer_mock.assert_has_calls([
call(
1,
0,
spec.Connection.StartOk,
# Due Table type, we cannot compare bytestream directly
DataComparator('FsSs', (client_properties, 'AMQPLAIN',
security_mechanism, 'en_US')),
None),
call(
1, 0, spec.Connection.TuneOk,
dumps('BlB',
(conn.channel_max, conn.frame_max, conn.heartbeat)),
None),
call(1, 0, spec.Connection.Open,
dumps('ssb', (conn.virtual_host, '', False)), None)
])
assert conn.client_properties == client_properties
def test_connect__socket_error(self):
# check Transport.Connect error
# socket.error derives from IOError
# ssl.SSLError derives from socket.error
self.conn = Connection()
self.conn.Transport = Mock(name='Transport')
transport = self.conn.Transport.return_value
transport.connect.side_effect = IOError
assert self.conn._transport is None and not self.conn.connected
with pytest.raises(IOError):
self.conn.connect()
transport.connect.assert_called
assert self.conn._transport is None and not self.conn.connected
def setup_conn(self):
self.frame_handler = Mock(name='frame_handler')
self.frame_writer = Mock(name='frame_writer_cls')
self.conn = Connection(
frame_handler=self.frame_handler,
frame_writer=self.frame_writer,
authentication=AMQPLAIN('foo', 'bar'),
)
self.conn.Channel = Mock(name='Channel')
self.conn.Transport = Mock(name='Transport')
self.conn.transport = self.conn.Transport.return_value
self.conn.send_method = Mock(name='send_method')
self.conn.frame_writer = Mock(name='frame_writer')
def test_login_method_response(self):
# An old way of doing things.:
login_method, login_response = b'foo', b'bar'
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.conn = Connection(login_method=login_method,
login_response=login_response)
self.conn.send_method = Mock(name='send_method')
self.conn._on_start(3, 4, {'foo': 'bar'}, login_method,
'en_US en_GB')
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, login_method,
login_response, self.conn.locale,
),
)
def open(self):
"""
Open a connection to the broker.
"""
if self.is_open():
# already open
return
connector = Connector.find(self.url)
host = ':'.join((connector.host, utf8(connector.port)))
virtual_host = connector.virtual_host or VIRTUAL_HOST
domain = self.ssl_domain(connector)
userid = connector.userid or USERID
password = connector.password or PASSWORD
log.info('open: %s', connector)
self._impl = RealConnection(
host=host,
virtual_host=virtual_host,
ssl=domain,
userid=userid,
password=password,
confirm_publish=True)
log.info('opened: %s', self.url)
def test_sasl_authentication(self):
authentication = SASL()
self.conn = Connection(authentication=authentication)
assert self.conn.authentication == (authentication,)
def test_collect_no_transport(self):
self.conn = Connection()
self.conn.connect = Mock(name='connect')
assert not self.conn.connected
self.conn.collect()
assert not self.conn.connect.called
def test_invalid_method(self):
with pytest.raises(ValueError):
self.conn = Connection(login_method='any')
def test_plain(self):
self.conn = Connection(userid='foo', password='******')
auth = self.conn.authentication[3]
assert isinstance(auth, PLAIN)
assert auth.username == 'foo'
assert auth.password == 'bar'
def test_gssapi(self):
self.conn = Connection()
assert isinstance(self.conn.authentication[0], GSSAPI)
def test_login_method_external(self):
self.conn = Connection(userid=None, password=None,
login_method='EXTERNAL')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], EXTERNAL)
# a-priori. We keep an account of which partitions are in flight, and make sure
# to return the next free partition when one is requested.
#
from amqp import Connection, Message
partitions = 4096
# sequence number space S = sequence number space in postgres = domain of int8
S_total = 2**64-1
S_start = -2**63
S_end = 2**63 - 1
partsize = S_total / partitions
print("Seeding rabbitmq sequence_space with %ld partitions of %ld size"% (partitions, partsize))
conn = Connection(host='localhost', userid='admin', password='******', virtual_host='/messaging')
channel = conn.channel()
for p in range(0, partitions):
channel.basic_publish(
Message(
"%ld:%ld" % ((S_start + (p * partsize)), (S_start + ((p + 1) * partsize) - 1)),
content_type='text/plain',
content_encoding='utf-8',
delivery_mode=2),
exchange='sequencer',
routing_key='pond')
print "%ld:%ld" % ((S_start + (p * partsize)), (S_start + ((p + 1) * partsize) - 1))
def test_login_response(self):
self.conn = Connection(login_response='foo')
self.assertEqual(self.conn.login_response, 'foo')
def test_amqplain(self):
self.conn = Connection(userid='foo', password='******')
assert isinstance(self.conn.authentication[1], AMQPLAIN)
assert self.conn.authentication[1].username == 'foo'
assert self.conn.authentication[1].password == 'bar'
class test_Connection(Case):
def setup(self):
self.frame_handler = Mock(name='frame_handler')
self.frame_writer = Mock(name='frame_writer')
self.conn = Connection(
frame_handler=self.frame_handler,
frame_writer=self.frame_writer,
)
self.conn.Channel = Mock(name='Channel')
self.conn.Transport = Mock(name='Transport')
self.conn.transport = self.conn.Transport.return_value
self.conn.send_method = Mock(name='send_method')
self.conn._frame_writer = Mock(name='_frame_writer')
def test_login_response(self):
self.conn = Connection(login_response='foo')
self.assertEqual(self.conn.login_response, 'foo')
def test_enter_exit(self):
self.conn.connect = Mock(name='connect')
self.conn.close = Mock(name='close')
with self.conn:
self.conn.connect.assert_called_with()
self.conn.close.assert_called_with()
def test_then(self):
self.conn.on_open = Mock(name='on_open')
on_success = Mock(name='on_success')
on_error = Mock(name='on_error')
self.conn.then(on_success, on_error)
self.conn.on_open.then.assert_called_with(on_success, on_error)
def test_connect(self):
self.conn.transport.connected = False
self.conn.drain_events = Mock(name='drain_events')
def on_drain(*args, **kwargs):
self.conn._handshake_complete = True
self.conn.drain_events.side_effect = on_drain
self.conn.connect()
self.conn.Transport.assert_called_with(
self.conn.host, self.conn.connect_timeout, self.conn.ssl,
self.conn.read_timeout, self.conn.write_timeout,
socket_settings=self.conn.socket_settings,
)
def test_connect__already_connected(self):
callback = Mock(name='callback')
self.conn.transport.connected = True
self.assertIs(self.conn.connect(callback), callback.return_value)
callback.assert_called_with()
def test_on_start(self):
self.conn._on_start(3, 4, {'foo': 'bar'}, 'x y z', 'en_US en_GB')
self.assertEqual(self.conn.version_major, 3)
self.assertEqual(self.conn.version_minor, 4)
self.assertEqual(self.conn.server_properties, {'foo': 'bar'})
self.assertEqual(self.conn.mechanisms, ['x', 'y', 'z'])
self.assertEqual(self.conn.locales, ['en_US', 'en_GB'])
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, self.conn.login_method,
self.conn.login_response, self.conn.locale,
),
)
def test_on_start__consumer_cancel_notify(self):
self.conn._on_start(
3, 4, {'capabilities': {'consumer_cancel_notify': 1}},
'', '',
)
cap = self.conn.client_properties['capabilities']
self.assertTrue(cap['consumer_cancel_notify'])
def test_on_start__connection_blocked(self):
self.conn._on_start(
3, 4, {'capabilities': {'connection.blocked': 1}},
'', '',
)
cap = self.conn.client_properties['capabilities']
self.assertTrue(cap['connection.blocked'])
def test_on_secure(self):
self.conn._on_secure('vfz')
def test_on_tune(self):
self.conn.client_heartbeat = 16
self.conn._on_tune(345, 16, 10)
self.assertEqual(self.conn.channel_max, 345)
self.assertEqual(self.conn.frame_max, 16)
self.assertEqual(self.conn.server_heartbeat, 10)
self.assertEqual(self.conn.heartbeat, 10)
self.conn.send_method.assert_called_with(
spec.Connection.TuneOk, 'BlB', (
self.conn.channel_max, self.conn.frame_max,
self.conn.heartbeat,
),
callback=self.conn._on_tune_sent,
)
def test_on_tune__client_heartbeat_disabled(self):
self.conn.client_heartbeat = 0
self.conn._on_tune(345, 16, 10)
self.assertEqual(self.conn.heartbeat, 0)
def test_on_tune_sent(self):
self.conn._on_tune_sent()
self.conn.send_method.assert_called_with(
spec.Connection.Open, 'ssb', (self.conn.virtual_host, '', False),
)
def test_on_open_ok(self):
self.conn.on_open = Mock(name='on_open')
self.conn._on_open_ok()
self.assertTrue(self.conn._handshake_complete)
self.conn.on_open.assert_called_with(self.conn)
def test_connected(self):
self.conn.transport.connected = False
self.assertFalse(self.conn.connected)
self.conn.transport.connected = True
self.assertTrue(self.conn.connected)
self.conn.transport = None
self.assertFalse(self.conn.connected)
def test_collect(self):
channels = self.conn.channels = {
0: self.conn, 1: Mock(name='c1'), 2: Mock(name='c2'),
}
transport = self.conn.transport
self.conn.collect()
transport.close.assert_called_with()
for i, channel in items(channels):
if i:
channel.collect.assert_called_with()
def test_collect__channel_raises_socket_error(self):
self.conn.channels = self.conn.channels = {1: Mock(name='c1')}
self.conn.channels[1].collect.side_effect = socket.error()
self.conn.collect()
def test_get_free_channel_id__raises_IndexError(self):
self.conn._avail_channel_ids = []
with self.assertRaises(ResourceError):
self.conn._get_free_channel_id()
def test_claim_channel_id(self):
self.conn._claim_channel_id(30)
with self.assertRaises(ConnectionError):
self.conn._claim_channel_id(30)
def test_channel(self):
callback = Mock(name='callback')
c = self.conn.channel(3, callback)
self.conn.Channel.assert_called_with(self.conn, 3, on_open=callback)
c2 = self.conn.channel(3, callback)
self.assertIs(c2, c)
def test_is_alive(self):
with self.assertRaises(NotImplementedError):
self.conn.is_alive()
def test_drain_events(self):
self.conn.blocking_read = Mock(name='blocking_read')
self.conn.drain_events(30)
self.conn.blocking_read.assert_called_with(30)
def test_blocking_read__no_timeout(self):
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.transport.having_timeout = ContextMock()
ret = self.conn.blocking_read(None)
self.conn.transport.read_frame.assert_called_with()
self.conn.on_inbound_frame.assert_called_with(
self.conn.transport.read_frame(),
)
self.assertIs(ret, self.conn.on_inbound_frame())
def test_blocking_read__timeout(self):
self.conn.transport = TCPTransport('localhost:5672')
sock = self.conn.transport.sock = Mock(name='sock')
sock.gettimeout.return_value = 1
self.conn.transport.read_frame = Mock(name='read_frame')
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.blocking_read(3)
sock.gettimeout.assert_called_with()
sock.settimeout.assert_has_calls([call(3), call(1)])
self.conn.transport.read_frame.assert_called_with()
self.conn.on_inbound_frame.assert_called_with(
self.conn.transport.read_frame(),
)
sock.gettimeout.return_value = 3
self.conn.blocking_read(3)
def test_blocking_read__SSLError(self):
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.transport = TCPTransport('localhost:5672')
sock = self.conn.transport.sock = Mock(name='sock')
sock.gettimeout.return_value = 1
self.conn.transport.read_frame = Mock(name='read_frame')
self.conn.transport.read_frame.side_effect = SSLError(
'operation timed out')
with self.assertRaises(socket.timeout):
self.conn.blocking_read(3)
self.conn.transport.read_frame.side_effect = SSLError(
'The operation did not complete foo bar')
with self.assertRaises(socket.timeout):
self.conn.blocking_read(3)
self.conn.transport.read_frame.side_effect = SSLError(
'oh noes')
with self.assertRaises(SSLError):
self.conn.blocking_read(3)
def test_on_inbound_method(self):
self.conn.channels[1] = self.conn.channel(1)
self.conn.on_inbound_method(1, (50, 60), 'payload', 'content')
self.conn.channels[1].dispatch_method.assert_called_with(
(50, 60), 'payload', 'content',
)
def test_close(self):
self.conn.close(reply_text='foo', method_sig=spec.Channel.Open)
self.conn.send_method.assert_called_with(
spec.Connection.Close, 'BssBB',
(0, 'foo', spec.Channel.Open[0], spec.Channel.Open[1]),
wait=spec.Connection.CloseOk,
)
def test_close__already_closed(self):
self.conn.transport = None
self.conn.close()
def test_on_close(self):
self.conn._x_close_ok = Mock(name='_x_close_ok')
with self.assertRaises(NotFound):
self.conn._on_close(404, 'bah not found', 50, 60)
def test_x_close_ok(self):
self.conn._x_close_ok()
self.conn.send_method.assert_called_with(
spec.Connection.CloseOk, callback=self.conn._on_close_ok,
)
def test_on_close_ok(self):
self.conn.collect = Mock(name='collect')
self.conn._on_close_ok()
self.conn.collect.assert_called_with()
def test_on_blocked(self):
self.conn._on_blocked()
self.conn.on_blocked = Mock(name='on_blocked')
self.conn._on_blocked()
self.conn.on_blocked.assert_called_with(
'connection blocked, see broker logs')
def test_on_unblocked(self):
self.conn._on_unblocked()
self.conn.on_unblocked = Mock(name='on_unblocked')
self.conn._on_unblocked()
self.conn.on_unblocked.assert_called_with()
def test_send_heartbeat(self):
self.conn.send_heartbeat()
self.conn._frame_writer.send.assert_called_with(
(8, 0, None, None, None),
)
self.conn._frame_writer.send.side_effect = StopIteration()
with self.assertRaises(RecoverableConnectionError):
self.conn.send_heartbeat()
def test_heartbeat_tick__no_heartbeat(self):
self.conn.heartbeat = 0
self.conn.heartbeat_tick()
def test_heartbeat_tick(self):
self.conn.heartbeat = 3
self.conn.heartbeat_tick()
self.conn.bytes_sent = 3124
self.conn.bytes_recv = 123
self.conn.heartbeat_tick()
self.conn.last_heartbeat_received -= 1000
self.conn.last_heartbeat_sent -= 1000
with self.assertRaises(ConnectionError):
self.conn.heartbeat_tick()
def test_server_capabilities(self):
self.conn.server_properties['capabilities'] = {'foo': 1}
self.assertEqual(self.conn.server_capabilities, {'foo': 1})
class TestChannel(unittest.TestCase):
def setUp(self):
self.conn = Connection(**settings.connect_args)
self.ch = self.conn.channel()
def tearDown(self):
self.ch.close()
self.conn.close()
def test_defaults(self):
"""Test how a queue defaults to being bound to an AMQP default
exchange, and how publishing defaults to the default exchange, and
basic_get defaults to getting from the most recently declared queue,
and queue_delete defaults to deleting the most recently declared
queue."""
msg = Message(
'funtest message',
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'},
)
qname, _, _ = self.ch.queue_declare()
self.ch.basic_publish(msg, routing_key=qname)
msg2 = self.ch.basic_get(no_ack=True)
self.assertEqual(msg, msg2)
n = self.ch.queue_purge()
self.assertEqual(n, 0)
n = self.ch.queue_delete()
self.assertEqual(n, 0)
def test_encoding(self):
my_routing_key = 'funtest.test_queue'
qname, _, _ = self.ch.queue_declare()
self.ch.queue_bind(qname, 'amq.direct', routing_key=my_routing_key)
#
# No encoding, body passed through unchanged
#
msg = Message('hello world')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
if sys.version_info[0] < 3:
self.assertFalse(hasattr(msg2, 'content_encoding'))
self.assertTrue(isinstance(msg2.body, str))
self.assertEqual(msg2.body, 'hello world')
#
# Default UTF-8 encoding of unicode body, returned as unicode
#
msg = Message(u'hello world')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'UTF-8')
self.assertTrue(isinstance(msg2.body, unicode))
self.assertEqual(msg2.body, u'hello world')
#
# Explicit latin_1 encoding, still comes back as unicode
#
msg = Message(u'hello world', content_encoding='latin_1')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'latin_1')
self.assertTrue(isinstance(msg2.body, unicode))
self.assertEqual(msg2.body, u'hello world')
#
# Plain string with specified encoding comes back as unicode
#
msg = Message('hello w\xf6rld', content_encoding='latin_1')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'latin_1')
self.assertTrue(isinstance(msg2.body, unicode))
self.assertEqual(msg2.body, u'hello w\u00f6rld')
#
# Plain string (bytes in Python 3.x) with bogus encoding
#
# don't really care about latin_1, just want bytes
test_bytes = u'hello w\xd6rld'.encode('latin_1')
msg = Message(test_bytes, content_encoding='I made this up')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'I made this up')
self.assertTrue(isinstance(msg2.body, bytes))
self.assertEqual(msg2.body, test_bytes)
#
# Turn off auto_decode for remaining tests
#
self.ch.auto_decode = False
#
# Unicode body comes back as utf-8 encoded str
#
msg = Message(u'hello w\u00f6rld')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'UTF-8')
self.assertTrue(isinstance(msg2.body, bytes))
self.assertEqual(msg2.body, u'hello w\xc3\xb6rld'.encode('latin_1'))
#
# Plain string with specified encoding stays plain string
#
msg = Message('hello w\xf6rld', content_encoding='latin_1')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'latin_1')
self.assertTrue(isinstance(msg2.body, bytes))
self.assertEqual(msg2.body, u'hello w\xf6rld'.encode('latin_1'))
#
# Explicit latin_1 encoding, comes back as str
#
msg = Message(u'hello w\u00f6rld', content_encoding='latin_1')
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg2.content_encoding, 'latin_1')
self.assertTrue(isinstance(msg2.body, bytes))
self.assertEqual(msg2.body, u'hello w\xf6rld'.encode('latin_1'))
def test_exception(self):
"""
Check that Channel exceptions are actually raised as Python
exceptions.
"""
with self.assertRaises(ChannelError):
self.ch.queue_delete('bogus_queue_that_does_not_exist')
def test_invalid_header(self):
"""
Test sending a message with an unserializable object in the header
http://code.google.com/p/py-amqplib/issues/detail?id=17
"""
qname, _, _ = self.ch.queue_declare()
msg = Message(application_headers={'test': None})
self.assertRaises(
FrameSyntaxError, self.ch.basic_publish, msg, routing_key=qname,
)
def test_large(self):
"""
Test sending some extra large messages.
"""
qname, _, _ = self.ch.queue_declare()
for multiplier in [100, 1000, 10000]:
msg = Message(
'funtest message' * multiplier,
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'},
)
self.ch.basic_publish(msg, routing_key=qname)
msg2 = self.ch.basic_get(no_ack=True)
self.assertEqual(msg, msg2)
def test_publish(self):
self.ch.exchange_declare('funtest.fanout', 'fanout', auto_delete=True)
msg = Message(
'funtest message',
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'},
)
self.ch.basic_publish(msg, 'funtest.fanout')
def test_queue(self):
my_routing_key = 'funtest.test_queue'
msg = Message(
'funtest message',
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'},
)
qname, _, _ = self.ch.queue_declare()
self.ch.queue_bind(qname, 'amq.direct', routing_key=my_routing_key)
self.ch.basic_publish(msg, 'amq.direct', routing_key=my_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg, msg2)
def test_unbind(self):
my_routing_key = 'funtest.test_queue'
qname, _, _ = self.ch.queue_declare()
self.ch.queue_bind(qname, 'amq.direct', routing_key=my_routing_key)
self.ch.queue_unbind(qname, 'amq.direct', routing_key=my_routing_key)
def test_basic_return(self):
self.ch.exchange_declare('funtest.fanout', 'fanout', auto_delete=True)
msg = Message(
'funtest message',
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'})
self.ch.basic_publish(msg, 'unittest.fanout')
self.ch.basic_publish(msg, 'unittest.fanout', mandatory=True)
self.ch.basic_publish(msg, 'unittest.fanout', mandatory=True)
self.ch.basic_publish(msg, 'unittest.fanout', mandatory=True)
self.ch.close()
#
# 3 of the 4 messages we sent should have been returned
#
self.assertEqual(self.ch.returned_messages.qsize(), 3)
def test_exchange_bind(self):
"""Test exchange binding.
Network configuration is as follows (-> is forwards to :
source_exchange -> dest_exchange -> queue
The test checks that once the message is publish to the
destination exchange(unittest.topic_dest) it is delivered to the queue.
"""
test_routing_key = 'unit_test__key'
dest_exchange = 'unittest.topic_dest_bind'
source_exchange = 'unittest.topic_source_bind'
self.ch.exchange_declare(dest_exchange, 'topic', auto_delete=True)
self.ch.exchange_declare(source_exchange, 'topic', auto_delete=True)
qname, _, _ = self.ch.queue_declare()
self.ch.exchange_bind(destination = dest_exchange,
source = source_exchange,
routing_key = test_routing_key)
self.ch.queue_bind(qname, dest_exchange,
routing_key=test_routing_key)
msg = Message('unittest message',
content_type='text/plain',
application_headers={'foo': 7, 'bar': 'baz'})
self.ch.basic_publish(msg, source_exchange,
routing_key = test_routing_key)
msg2 = self.ch.basic_get(qname, no_ack=True)
self.assertEqual(msg, msg2)
def test_exchange_unbind(self):
dest_exchange = 'unittest.topic_dest_unbind'
source_exchange = 'unittest.topic_source_unbind'
test_routing_key = 'unit_test__key'
self.ch.exchange_declare(dest_exchange,
'topic', auto_delete=True)
self.ch.exchange_declare(source_exchange,
'topic', auto_delete=True)
self.ch.exchange_bind(destination=dest_exchange,
source=source_exchange,
routing_key=test_routing_key)
self.ch.exchange_unbind(destination=dest_exchange,
source=source_exchange,
routing_key=test_routing_key)
def test_collect_again(self):
self.conn = Connection()
self.conn.collect()
self.conn.collect()
def test_sasl_authentication_iterable(self):
authentication = SASL()
self.conn = Connection(authentication=(authentication,))
assert self.conn.authentication == (authentication,)
class TestConnection(unittest.TestCase):
def setUp(self):
self.conn = Connection(**settings.connect_args)
def tearDown(self):
if self.conn:
self.conn.close()
def test_channel(self):
ch = self.conn.channel(1)
self.assertEqual(ch.channel_id, 1)
ch2 = self.conn.channel()
self.assertNotEqual(ch2.channel_id, 1)
ch.close()
ch2.close()
def test_close(self):
"""
Make sure we've broken various references when closing
channels and connections, to help with GC.
"""
#
# Create a channel and make sure it's linked as we'd expect
#
ch = self.conn.channel()
self.assertEqual(1 in self.conn.channels, True)
self.assertEqual(ch.connection, self.conn)
self.assertEqual(ch.is_open, True)
#
# Close the channel and make sure the references are broken
# that we expect.
#
ch.close()
self.assertEqual(ch.connection, None)
self.assertEqual(1 in self.conn.channels, False)
self.assertEqual(ch.callbacks, {})
self.assertEqual(ch.is_open, False)
#
# Close the connection and make sure the references we expect
# are gone.
#
self.conn.close()
self.assertEqual(self.conn.connection, None)
self.assertEqual(self.conn.channels, None)
def test_gc_closed(self):
"""
Make sure we've broken various references when closing
channels and connections, to help with GC.
gc.garbage: http://docs.python.org/library/gc.html#gc.garbage
"A list of objects which the collector found to be
unreachable but could not be freed (uncollectable objects)."
"""
unreachable_before = len(gc.garbage)
#
# Create a channel and make sure it's linked as we'd expect
#
ch = self.conn.channel()
self.assertEqual(1 in self.conn.channels, True)
#
# Close the connection and make sure the references we expect
# are gone.
#
self.conn.close()
gc.collect()
gc.collect()
gc.collect()
self.assertEqual(unreachable_before, len(gc.garbage))
def test_gc_forget(self):
"""
Make sure the connection gets gc'ed when there is no more
references to it.
"""
unreachable_before = len(gc.garbage)
ch = self.conn.channel()
self.assertEqual(1 in self.conn.channels, True)
# remove all the references
self.conn = None
ch = None
gc.collect()
gc.collect()
gc.collect()
self.assertEqual(unreachable_before, len(gc.garbage))
def test_external(self):
self.conn = Connection()
assert isinstance(self.conn.authentication[1], EXTERNAL)
def test_missing_credentials(self):
with pytest.raises(ValueError):
self.conn = Connection(userid=None, password=None,
login_method='AMQPLAIN')
with pytest.raises(ValueError):
self.conn = Connection(password=None, login_method='PLAIN')
class test_Connection:
@pytest.fixture(autouse=True)
def setup_conn(self):
self.frame_handler = Mock(name='frame_handler')
self.frame_writer = Mock(name='frame_writer_cls')
self.conn = Connection(
frame_handler=self.frame_handler,
frame_writer=self.frame_writer,
authentication=AMQPLAIN('foo', 'bar'),
)
self.conn.Channel = Mock(name='Channel')
self.conn.Transport = Mock(name='Transport')
self.conn.transport = self.conn.Transport.return_value
self.conn.send_method = Mock(name='send_method')
self.conn.frame_writer = Mock(name='frame_writer')
def test_sasl_authentication(self):
authentication = SASL()
self.conn = Connection(authentication=authentication)
assert self.conn.authentication == (authentication,)
def test_sasl_authentication_iterable(self):
authentication = SASL()
self.conn = Connection(authentication=(authentication,))
assert self.conn.authentication == (authentication,)
def test_gssapi(self):
self.conn = Connection()
assert isinstance(self.conn.authentication[0], GSSAPI)
def test_external(self):
self.conn = Connection()
assert isinstance(self.conn.authentication[1], EXTERNAL)
def test_amqplain(self):
self.conn = Connection(userid='foo', password='******')
auth = self.conn.authentication[2]
assert isinstance(auth, AMQPLAIN)
assert auth.username == 'foo'
assert auth.password == 'bar'
def test_plain(self):
self.conn = Connection(userid='foo', password='******')
auth = self.conn.authentication[3]
assert isinstance(auth, PLAIN)
assert auth.username == 'foo'
assert auth.password == 'bar'
def test_login_method_gssapi(self):
try:
self.conn = Connection(userid=None, password=None,
login_method='GSSAPI')
except NotImplementedError:
pass
else:
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], GSSAPI)
def test_login_method_external(self):
self.conn = Connection(userid=None, password=None,
login_method='EXTERNAL')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], EXTERNAL)
def test_login_method_amqplain(self):
self.conn = Connection(login_method='AMQPLAIN')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], AMQPLAIN)
def test_login_method_plain(self):
self.conn = Connection(login_method='PLAIN')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], PLAIN)
def test_enter_exit(self):
self.conn.connect = Mock(name='connect')
self.conn.close = Mock(name='close')
with self.conn:
self.conn.connect.assert_called_with()
self.conn.close.assert_called_with()
def test__enter__socket_error(self):
# test when entering
self.conn = Connection()
self.conn.close = Mock(name='close')
reached = False
with patch('socket.socket', side_effect=socket.error):
with pytest.raises(socket.error):
with self.conn:
reached = True
assert not reached and not self.conn.close.called
assert self.conn._transport is None and not self.conn.connected
def test__exit__socket_error(self):
# test when exiting
connection = self.conn
transport = connection._transport
transport.connected = True
connection.send_method = Mock(name='send_method',
side_effect=socket.error)
reached = False
with pytest.raises(socket.error):
with connection:
reached = True
assert reached
assert connection.send_method.called and transport.close.called
assert self.conn._transport is None and not self.conn.connected
def test_then(self):
self.conn.on_open = Mock(name='on_open')
on_success = Mock(name='on_success')
on_error = Mock(name='on_error')
self.conn.then(on_success, on_error)
self.conn.on_open.then.assert_called_with(on_success, on_error)
def test_connect(self):
self.conn.transport.connected = False
self.conn.drain_events = Mock(name='drain_events')
def on_drain(*args, **kwargs):
self.conn._handshake_complete = True
self.conn.drain_events.side_effect = on_drain
self.conn.connect()
self.conn.Transport.assert_called_with(
self.conn.host, self.conn.connect_timeout, self.conn.ssl,
self.conn.read_timeout, self.conn.write_timeout,
socket_settings=self.conn.socket_settings,
)
def test_connect__already_connected(self):
callback = Mock(name='callback')
self.conn.transport.connected = True
assert self.conn.connect(callback) == callback.return_value
callback.assert_called_with()
def test_connect__socket_error(self):
# check Transport.Connect error
# socket.error derives from IOError
# ssl.SSLError derives from socket.error
self.conn = Connection()
self.conn.Transport = Mock(name='Transport')
transport = self.conn.Transport.return_value
transport.connect.side_effect = IOError
assert self.conn._transport is None and not self.conn.connected
with pytest.raises(IOError):
self.conn.connect()
transport.connect.assert_called
assert self.conn._transport is None and not self.conn.connected
def test_on_start(self):
self.conn._on_start(3, 4, {'foo': 'bar'}, b'x y z AMQPLAIN PLAIN',
'en_US en_GB')
assert self.conn.version_major == 3
assert self.conn.version_minor == 4
assert self.conn.server_properties == {'foo': 'bar'}
assert self.conn.mechanisms == [b'x', b'y', b'z',
b'AMQPLAIN', b'PLAIN']
assert self.conn.locales == ['en_US', 'en_GB']
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, b'AMQPLAIN',
self.conn.authentication[0].start(self.conn), self.conn.locale,
),
)
def test_on_start_string_mechanisms(self):
self.conn._on_start(3, 4, {'foo': 'bar'}, 'x y z AMQPLAIN PLAIN',
'en_US en_GB')
assert self.conn.version_major == 3
assert self.conn.version_minor == 4
assert self.conn.server_properties == {'foo': 'bar'}
assert self.conn.mechanisms == [b'x', b'y', b'z',
b'AMQPLAIN', b'PLAIN']
assert self.conn.locales == ['en_US', 'en_GB']
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, b'AMQPLAIN',
self.conn.authentication[0].start(self.conn), self.conn.locale,
),
)
def test_missing_credentials(self):
with pytest.raises(ValueError):
self.conn = Connection(userid=None, password=None,
login_method='AMQPLAIN')
with pytest.raises(ValueError):
self.conn = Connection(password=None, login_method='PLAIN')
def test_invalid_method(self):
with pytest.raises(ValueError):
self.conn = Connection(login_method='any')
def test_mechanism_mismatch(self):
with pytest.raises(ConnectionError):
self.conn._on_start(3, 4, {'foo': 'bar'}, b'x y z',
'en_US en_GB')
def test_login_method_response(self):
# An old way of doing things.:
login_method, login_response = b'foo', b'bar'
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.conn = Connection(login_method=login_method,
login_response=login_response)
self.conn.send_method = Mock(name='send_method')
self.conn._on_start(3, 4, {'foo': 'bar'}, login_method,
'en_US en_GB')
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
self.conn.send_method.assert_called_with(
spec.Connection.StartOk, 'FsSs', (
self.conn.client_properties, login_method,
login_response, self.conn.locale,
),
)
def test_on_start__consumer_cancel_notify(self):
self.conn._on_start(
3, 4, {'capabilities': {'consumer_cancel_notify': 1}},
b'AMQPLAIN', '',
)
cap = self.conn.client_properties['capabilities']
assert cap['consumer_cancel_notify']
def test_on_start__connection_blocked(self):
self.conn._on_start(
3, 4, {'capabilities': {'connection.blocked': 1}},
b'AMQPLAIN', '',
)
cap = self.conn.client_properties['capabilities']
assert cap['connection.blocked']
def test_on_start__authentication_failure_close(self):
self.conn._on_start(
3, 4, {'capabilities': {'authentication_failure_close': 1}},
b'AMQPLAIN', '',
)
cap = self.conn.client_properties['capabilities']
assert cap['authentication_failure_close']
def test_on_start__authentication_failure_close__disabled(self):
self.conn._on_start(
3, 4, {'capabilities': {}},
b'AMQPLAIN', '',
)
assert 'capabilities' not in self.conn.client_properties
def test_on_secure(self):
self.conn._on_secure('vfz')
def test_on_tune(self):
self.conn.client_heartbeat = 16
self.conn._on_tune(345, 16, 10)
assert self.conn.channel_max == 345
assert self.conn.frame_max == 16
assert self.conn.server_heartbeat == 10
assert self.conn.heartbeat == 10
self.conn.send_method.assert_called_with(
spec.Connection.TuneOk, 'BlB', (
self.conn.channel_max, self.conn.frame_max,
self.conn.heartbeat,
),
callback=self.conn._on_tune_sent,
)
def test_on_tune__client_heartbeat_disabled(self):
self.conn.client_heartbeat = 0
self.conn._on_tune(345, 16, 10)
assert self.conn.heartbeat == 0
def test_on_tune_sent(self):
self.conn._on_tune_sent()
self.conn.send_method.assert_called_with(
spec.Connection.Open, 'ssb', (self.conn.virtual_host, '', False),
)
def test_on_open_ok(self):
self.conn.on_open = Mock(name='on_open')
self.conn._on_open_ok()
assert self.conn._handshake_complete
self.conn.on_open.assert_called_with(self.conn)
def test_connected(self):
self.conn.transport.connected = False
assert not self.conn.connected
self.conn.transport.connected = True
assert self.conn.connected
self.conn.transport = None
assert not self.conn.connected
def test_collect(self):
channels = self.conn.channels = {
0: self.conn, 1: Mock(name='c1'), 2: Mock(name='c2'),
}
transport = self.conn.transport
self.conn.collect()
transport.close.assert_called_with()
for i, channel in items(channels):
if i:
channel.collect.assert_called_with()
assert self.conn._transport is None
def test_collect__channel_raises_socket_error(self):
self.conn.channels = self.conn.channels = {1: Mock(name='c1')}
self.conn.channels[1].collect.side_effect = socket.error()
self.conn.collect()
def test_collect_no_transport(self):
self.conn = Connection()
self.conn.connect = Mock(name='connect')
assert not self.conn.connected
self.conn.collect()
assert not self.conn.connect.called
def test_collect_again(self):
self.conn = Connection()
self.conn.collect()
self.conn.collect()
def test_get_free_channel_id__raises_IndexError(self):
self.conn._avail_channel_ids = []
with pytest.raises(ResourceError):
self.conn._get_free_channel_id()
def test_claim_channel_id(self):
self.conn._claim_channel_id(30)
with pytest.raises(ConnectionError):
self.conn._claim_channel_id(30)
def test_channel(self):
callback = Mock(name='callback')
c = self.conn.channel(3, callback)
self.conn.Channel.assert_called_with(self.conn, 3, on_open=callback)
c2 = self.conn.channel(3, callback)
assert c2 is c
def test_is_alive(self):
with pytest.raises(NotImplementedError):
self.conn.is_alive()
def test_drain_events(self):
self.conn.blocking_read = Mock(name='blocking_read')
self.conn.drain_events(30)
self.conn.blocking_read.assert_called_with(30)
def test_blocking_read__no_timeout(self):
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.transport.having_timeout = ContextMock()
ret = self.conn.blocking_read(None)
self.conn.transport.read_frame.assert_called_with()
self.conn.on_inbound_frame.assert_called_with(
self.conn.transport.read_frame(),
)
assert ret is self.conn.on_inbound_frame()
def test_blocking_read__timeout(self):
self.conn.transport = TCPTransport('localhost:5672')
sock = self.conn.transport.sock = Mock(name='sock')
sock.gettimeout.return_value = 1
self.conn.transport.read_frame = Mock(name='read_frame')
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.blocking_read(3)
sock.gettimeout.assert_called_with()
sock.settimeout.assert_has_calls([call(3), call(1)])
self.conn.transport.read_frame.assert_called_with()
self.conn.on_inbound_frame.assert_called_with(
self.conn.transport.read_frame(),
)
sock.gettimeout.return_value = 3
self.conn.blocking_read(3)
def test_blocking_read__SSLError(self):
self.conn.on_inbound_frame = Mock(name='on_inbound_frame')
self.conn.transport = TCPTransport('localhost:5672')
sock = self.conn.transport.sock = Mock(name='sock')
sock.gettimeout.return_value = 1
self.conn.transport.read_frame = Mock(name='read_frame')
self.conn.transport.read_frame.side_effect = SSLError(
'operation timed out')
with pytest.raises(socket.timeout):
self.conn.blocking_read(3)
self.conn.transport.read_frame.side_effect = SSLError(
'The operation did not complete foo bar')
with pytest.raises(socket.timeout):
self.conn.blocking_read(3)
self.conn.transport.read_frame.side_effect = SSLError(
'oh noes')
with pytest.raises(SSLError):
self.conn.blocking_read(3)
def test_on_inbound_method(self):
self.conn.channels[1] = self.conn.channel(1)
self.conn.on_inbound_method(1, (50, 60), 'payload', 'content')
self.conn.channels[1].dispatch_method.assert_called_with(
(50, 60), 'payload', 'content',
)
def test_close(self):
self.conn.collect = Mock(name='collect')
self.conn.close(reply_text='foo', method_sig=spec.Channel.Open)
self.conn.send_method.assert_called_with(
spec.Connection.Close, 'BsBB',
(0, 'foo', spec.Channel.Open[0], spec.Channel.Open[1]),
wait=spec.Connection.CloseOk,
)
def test_close__already_closed(self):
self.conn.transport = None
self.conn.close()
def test_close__socket_error(self):
self.conn.send_method = Mock(name='send_method',
side_effect=socket.error)
with pytest.raises(socket.error):
self.conn.close()
self.conn.send_method.assert_called()
assert self.conn._transport is None and not self.conn.connected
def test_on_close(self):
self.conn._x_close_ok = Mock(name='_x_close_ok')
with pytest.raises(NotFound):
self.conn._on_close(404, 'bah not found', 50, 60)
def test_x_close_ok(self):
self.conn._x_close_ok()
self.conn.send_method.assert_called_with(
spec.Connection.CloseOk, callback=self.conn._on_close_ok,
)
def test_on_close_ok(self):
self.conn.collect = Mock(name='collect')
self.conn._on_close_ok()
self.conn.collect.assert_called_with()
def test_on_blocked(self):
self.conn._on_blocked()
self.conn.on_blocked = Mock(name='on_blocked')
self.conn._on_blocked()
self.conn.on_blocked.assert_called_with(
'connection blocked, see broker logs')
def test_on_unblocked(self):
self.conn._on_unblocked()
self.conn.on_unblocked = Mock(name='on_unblocked')
self.conn._on_unblocked()
self.conn.on_unblocked.assert_called_with()
def test_send_heartbeat(self):
self.conn.send_heartbeat()
self.conn.frame_writer.assert_called_with(
8, 0, None, None, None,
)
def test_heartbeat_tick__no_heartbeat(self):
self.conn.heartbeat = 0
self.conn.heartbeat_tick()
def test_heartbeat_tick(self):
self.conn.heartbeat = 3
self.conn.heartbeat_tick()
self.conn.bytes_sent = 3124
self.conn.bytes_recv = 123
self.conn.heartbeat_tick()
self.conn.last_heartbeat_received -= 1000
self.conn.last_heartbeat_sent -= 1000
with pytest.raises(ConnectionError):
self.conn.heartbeat_tick()
def test_server_capabilities(self):
self.conn.server_properties['capabilities'] = {'foo': 1}
assert self.conn.server_capabilities == {'foo': 1}
def setUp(self):
self.conn = Connection(**settings.connect_args)
self.ch = self.conn.channel()
def test_login_method_plain(self):
self.conn = Connection(login_method='PLAIN')
auths = self.conn.authentication
assert len(auths) == 1
assert isinstance(auths[0], PLAIN)
def setUp(self):
self.conn = Connection(**settings.connect_args)
