def test_channel_raise_with_close_reply_code_500(self):
connection = FakeConnection()
channel = Channel(0, connection, 360)
# Set up Fake Channel.
channel._inbound = [1, 2, 3]
channel.set_state(channel.OPEN)
channel._consumer_tags = [1, 2, 3]
close_frame = specification.Channel.Close(
reply_code=500,
reply_text='travis-ci'
)
channel._close_channel(close_frame)
self.assertEqual(channel._inbound, [])
self.assertEqual(channel._consumer_tags, [])
self.assertEqual(channel._state, channel.CLOSED)
self.assertIsInstance(
connection.get_last_frame(),
specification.Channel.CloseOk
)
self.assertRaisesRegexp(
AMQPChannelError,
'Channel 0 was closed by remote server: travis-ci',
channel.check_for_errors
)
def test_io_receive_does_not_raise_on_block(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = socket.error(EWOULDBLOCK)
io._receive()
self.assertIsNone(connection.check_for_errors())
def test_io_set_ssl_context_no_hostname_provided(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {
'context': ssl.create_default_context(),
}
io = IO(connection.parameters)
self.assertRaises(ValueError, io._ssl_wrap_socket, socket.socket())
def test_channel0_credentials(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
credentials = channel._plain_credentials()
self.assertEqual(credentials, '\0guest\0password')
def test_channel0_tune_frame(self):
connection = FakeConnection()
connection.parameters['virtual_host'] = '/'
channel = Channel0(connection)
channel.on_frame(Connection.Tune())
self.assertIsInstance(connection.get_last_frame(), Connection.TuneOk)
self.assertIsInstance(connection.get_last_frame(), Connection.Open)
def test_io_set_ssl_context(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {
'context': ssl.create_default_context(),
'server_hostname': 'localhost',
}
io = IO(connection.parameters)
self.assertTrue(io._ssl_wrap_socket(socket.socket()))
def test_channel_flow_frame(self):
connection = FakeConnection()
connection.set_state(connection.OPEN)
channel = Channel(0, connection, rpc_timeout=360)
channel.set_state(channel.OPEN)
channel.on_frame(specification.Channel.Flow())
self.assertIsInstance(connection.frames_out[0][1],
specification.Channel.FlowOk)
def test_io_get_socket_address(self):
connection = FakeConnection()
connection.parameters['hostname'] = '127.0.0.1'
connection.parameters['port'] = 5672
io = IO(connection.parameters)
addresses = io._get_socket_addresses()
sock_address_tuple = addresses[0]
self.assertEqual(sock_address_tuple[4],
('127.0.0.1', 5672))
def test_io_sets_default_ssl_version(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {}
sock = Mock(name='socket', spec=socket.socket)
sock.fileno.return_value = 1
io = IO(connection.parameters)
self.assertRaises(Exception, io._ssl_wrap_socket, sock)
self.assertEqual(connection.parameters['ssl_options']['ssl_version'],
compatibility.DEFAULT_SSL_VERSION)
def test_io_normal_connection_without_ssl_library(self, _):
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
self.assertRaisesRegexp(
AMQPConnectionError,
'Could not connect to localhost:1234 error: Connection refused',
io.open
)
def test_io_raises_gaierror(self, _):
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
self.assertRaisesRegexp(
AMQPConnectionError,
'could not connect',
io._get_socket_addresses
)
def test_channel0_close_connection(self):
connection = FakeConnection()
connection.set_state(connection.OPEN)
channel = Channel0(connection)
self.assertTrue(connection.is_open)
channel._close_connection(
Connection.Close(reply_text=b'',
reply_code=200)
)
self.assertEqual(connection.exceptions, [])
self.assertTrue(connection.is_closed)
def test_io_normal_connection_without_ssl_library(self):
compatibility.SSL_SUPPORTED = False
try:
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
self.assertRaisesRegexp(AMQPConnectionError,
'Could not connect to localhost:1234',
io.open, [])
finally:
compatibility.SSL_SUPPORTED = True
def test_io_use_defined_ssl_version(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {
'ssl_version': 'travis-ci'
}
sock = Mock(name='socket', spec=socket.socket)
sock.fileno.return_value = 1
io = IO(connection.parameters)
self.assertRaises(Exception, io._ssl_wrap_socket, sock)
self.assertEqual(connection.parameters['ssl_options']['ssl_version'],
'travis-ci')
def test_channel0_start_invalid_auth_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
channel.on_frame(Connection.Start(mechanisms='invalid'))
self.assertRaisesRegexp(
AMQPConnectionError,
'Unsupported Security Mechanism\(s\): invalid',
connection.check_for_errors
)
def test_channel0_send_start_ok_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
channel._send_start_ok_frame(Connection.Start(mechanisms=b'PLAIN'))
self.assertNotEqual(connection.frames_out, [])
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.StartOk)
self.assertNotEqual(frame_out.locale, '')
self.assertIsNotNone(frame_out.locale)
def test_channel0_start_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
properties = {
'version': 0
}
channel.on_frame(Connection.Start(server_properties=properties))
self.assertEqual(channel.server_properties, properties)
self.assertIsInstance(connection.get_last_frame(), Connection.StartOk)
def test_io_ssl_connection_without_ssl_library(self):
compatibility.SSL_SUPPORTED = False
try:
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
parameters['ssl'] = True
io = IO(parameters)
self.assertRaisesRegexp(AMQPConnectionError,
'Python not compiled with '
'support for TLSv1 or higher',
io.open, [])
finally:
compatibility.SSL_SUPPORTED = True
def test_io_simple_ssl_receive(self):
connection = FakeConnection()
connection.parameters['ssl'] = True
io = IO(connection.parameters)
self.assertTrue(io.use_ssl)
if hasattr(ssl, 'SSLObject'):
io.socket = Mock(name='socket', spec=ssl.SSLObject)
elif hasattr(ssl, 'SSLSocket'):
io.socket = Mock(name='socket', spec=ssl.SSLSocket)
io.socket.read.return_value = '12345'
self.assertEqual(io._receive(), '12345')
def test_io_create_ssl_socket(self):
connection = FakeConnection()
connection.parameters['ssl'] = True
io = IO(connection.parameters)
self.assertTrue(io.use_ssl)
addresses = io._get_socket_addresses()
sock_address_tuple = addresses[0]
sock = io._create_socket(socket_family=sock_address_tuple[0])
if hasattr(socket, 'socket'):
self.assertIsInstance(sock, socket.socket)
if hasattr(ssl, 'SSLSocket'):
self.assertIsInstance(sock, ssl.SSLSocket)
self.assertTrue(connection.parameters['ssl_options']['ssl_version'])
def test_io_has_ipv6(self):
restore_func = socket.getaddrinfo
def mock_getaddrinfo(hostname, port, family, socktype):
return [hostname, port, family, socktype]
try:
amqpstorm.io.socket.getaddrinfo = mock_getaddrinfo
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
result = io._get_socket_addresses()
self.assertEqual(result[2], socket.AF_UNSPEC)
self.assertEqual(result[3], socket.SOCK_STREAM)
finally:
amqpstorm.io.socket.getaddrinfo = restore_func
def test_wait_for_request(self):
rpc = Rpc(FakeConnection(), timeout=1)
uuid = rpc.register_request(['travis-ci'])
def delivery_payload():
time.sleep(0.1)
rpc.on_frame(FakePayload(name='travis-ci'))
thread = threading.Thread(target=delivery_payload)
thread.start()
rpc._wait_for_request(
uuid, connection_adapter=rpc._default_connection_adapter)
def test_io_simple_send_zero_bytes_sent(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = Mock(name='socket', spec=socket.socket)
io.socket.send.return_value = 0
io.write_to_socket(self.message)
self.assertRaisesRegexp(
AMQPConnectionError,
'connection/socket error',
connection.check_for_errors
)
def test_channel_with_statement_when_failing(self):
connection = FakeConnection()
try:
with Channel(0, connection, 360) as channel:
channel.exceptions.append(AMQPChannelError('error'))
channel.check_for_errors()
except AMQPChannelError as why:
self.assertIsInstance(why, AMQPChannelError)
self.assertEqual(
self.get_last_log(),
'Closing channel due to an unhandled exception: '
'error')
def test_channel_close_frame(self):
connection = FakeConnection(state=FakeConnection.OPEN)
channel = Channel(0, connection, rpc_timeout=1)
channel.set_state(channel.OPEN)
channel.on_frame(
specification.Channel.Close(reply_code=500,
reply_text='travis-ci'))
self.assertRaisesRegexp(
AMQPChannelError,
'Channel 0 was closed by remote server: travis-ci',
channel.check_for_errors)
def test_basic_publish_confirms_raises_on_timeout(self):
connection = FakeConnection()
channel = Channel(9, connection, 0.01)
channel._confirming_deliveries = True
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(
exception.AMQPChannelError,
'rpc requests .* \(.*\) took too long',
basic.publish, body=self.message,
routing_key='travis-ci'
)
def test_channel0_send_start_ok_external(self):
connection = FakeConnection()
channel = Channel0(connection)
channel._send_start_ok(Connection.Start(mechanisms=b'EXTERNAL'))
self.assertTrue(connection.frames_out)
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.StartOk)
self.assertNotEqual(frame_out.locale, '')
self.assertIsNotNone(frame_out.locale)
def test_io_has_ipv6_is_false(self):
restore_func = socket.getaddrinfo
restore_has_ipv6 = amqpstorm.io.socket.has_ipv6
def mock_getaddrinfo(hostname, port, family, socktype):
return [hostname, port, family, socktype]
try:
amqpstorm.io.socket.getaddrinfo = mock_getaddrinfo
amqpstorm.io.socket.has_ipv6 = False
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
result = io._get_socket_addresses()
self.assertEqual(result[2], socket.AF_INET)
self.assertEqual(result[3], socket.SOCK_STREAM)
finally:
amqpstorm.io.socket.getaddrinfo = restore_func
amqpstorm.io.socket.has_ipv6 = restore_has_ipv6
def test_basic_publish_confirms_nack(self):
message = str(uuid.uuid4())
def on_publish_return_nack(*_):
channel.rpc.on_frame(spec_basic.Nack())
connection = FakeConnection(on_write=on_publish_return_nack)
channel = Channel(9, connection, 1)
channel.confirming_deliveries = True
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertFalse(basic.publish(body=message, routing_key='unittest'))
def test_basic_get_message_empty_queue(self):
get_frame = specification.Basic.Get(queue='travis-ci', no_ack=False)
def on_get_frame(*_):
channel.rpc.on_frame(specification.Basic.GetEmpty())
connection = FakeConnection(on_write=on_get_frame)
channel = Channel(9, connection, 1)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
result = basic._get_message(get_frame, auto_decode=False)
self.assertEqual(result, None)
def test_basic_get_empty(self):
def on_get_frame(*_):
channel.rpc.on_frame(specification.Basic.GetEmpty())
connection = FakeConnection(on_write=on_get_frame)
channel = Channel(9, connection, 1)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
result = basic.get(queue='travis-ci')
self.assertFalse(channel.rpc._request)
self.assertFalse(channel.rpc._response)
self.assertIsNone(result)
def test_basic_publish_confirms_raises_on_timeout(self):
message = str(uuid.uuid4())
connection = FakeConnection()
channel = Channel(9, connection, 0.01)
channel.confirming_deliveries = True
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPChannelError,
"rpc requests",
basic.publish,
body=message,
routing_key='unittest')
def test_channel0_send_tune_ok(self):
connection = FakeConnection()
channel = Channel0(connection)
channel._send_tune_ok(Connection.Tune())
self.assertTrue(connection.frames_out)
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.TuneOk)
self.assertEqual(frame_out.channel_max, MAX_CHANNELS)
self.assertEqual(frame_out.frame_max, MAX_FRAME_SIZE)
def test_queue_declare(self):
def on_declare(*_):
channel.rpc.on_frame(pamqp_queue.DeclareOk())
connection = FakeConnection(on_write=on_declare)
channel = Channel(0, connection, 0.1)
channel.set_state(Channel.OPEN)
queue = Queue(channel)
self.assertEqual(queue.declare(), {
'queue': '',
'message_count': 0,
'consumer_count': 0
})
def test_channel_build_inbound_messages(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
message = b'Hello World!'
message_len = len(message)
deliver = specification.Basic.Deliver()
header = ContentHeader(body_size=message_len)
body = ContentBody(value=message)
channel._inbound = [deliver, header, body]
for message in channel.build_inbound_messages(break_on_empty=True):
self.assertIsInstance(message, Message)
def test_basic_publish_confirms_raises_on_invalid_frame(self):
def on_publish_return_invalid_frame(*_):
channel.rpc.on_frame(specification.Basic.Cancel())
connection = FakeConnection(on_write=on_publish_return_invalid_frame)
channel = Channel(9, connection, 0.01)
channel._confirming_deliveries = True
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPChannelError,
'rpc requests .* \(.*\) took too long',
basic.publish,
body=self.message,
routing_key='travis-ci')
def test_channel_raise_with_close_reply_code_500(self):
connection = FakeConnection()
channel = Channel(0, connection, 360)
# Set up Fake Channel.
channel._inbound = [1, 2, 3]
channel.set_state(channel.OPEN)
channel._consumer_tags = [1, 2, 3]
close_frame = specification.Channel.Close(reply_code=500,
reply_text='travis-ci')
channel._close_channel(close_frame)
self.assertEqual(channel._inbound, [])
self.assertEqual(channel._consumer_tags, [])
self.assertEqual(channel._state, channel.CLOSED)
self.assertIsInstance(connection.get_last_frame(),
specification.Channel.CloseOk)
self.assertRaisesRegexp(
AMQPChannelError,
'Channel 0 was closed by remote server: travis-ci',
channel.check_for_errors)
def test_queue_delete_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
queue = Queue(channel)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'queue should be a string', queue.delete, None)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'if_unused should be a boolean', queue.delete,
'', None)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'if_empty should be a boolean', queue.delete,
'', True, None)
def test_channel0_client_properties(self):
channel = Channel0(FakeConnection())
result = channel._client_properties()
information = 'See https://github.com/eandersson/amqpstorm'
python_version = 'Python %s' % platform.python_version()
self.assertIsInstance(result, dict)
self.assertTrue(result['capabilities']['authentication_failure_close'])
self.assertTrue(result['capabilities']['consumer_cancel_notify'])
self.assertTrue(result['capabilities']['publisher_confirms'])
self.assertTrue(result['capabilities']['connection.blocked'])
self.assertTrue(result['capabilities']['basic.nack'])
self.assertEqual(result['information'], information)
self.assertEqual(result['platform'], python_version)
def test_basic_get_fails(self):
def on_get_frame(*_):
pass
connection = FakeConnection(on_write=on_get_frame)
channel = Channel(9, connection, 0.1)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(AMQPChannelError,
'rpc requests .* \(.*\) took too long',
basic.get, 'travis-ci')
self.assertFalse(channel.rpc._request)
self.assertFalse(channel.rpc._response)
def test_basic_reject_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'delivery_tag should be an integer',
basic.reject, 'travis-ci')
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'delivery_tag should be an integer',
basic.reject, None)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'requeue should be a boolean', basic.reject, 1,
None)
def test_with_for_request_with_custom_adapter(self):
class Adapter(object):
def check_for_errors(self):
pass
rpc = Rpc(FakeConnection(), timeout=1)
uuid = rpc.register_request(['travis-ci'])
def delivery_payload():
time.sleep(0.1)
rpc.on_frame(FakePayload(name='travis-ci'))
thread = threading.Thread(target=delivery_payload)
thread.start()
rpc._wait_for_request(uuid, Adapter())
def test_channel_build_inbound_messages(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(channel.OPEN)
message = self.message.encode('utf-8')
message_len = len(message)
deliver = specification.Basic.Deliver()
header = ContentHeader(body_size=message_len)
body = ContentBody(value=message)
channel._inbound = [deliver, header, body]
for msg in channel.build_inbound_messages(break_on_empty=True):
self.assertIsInstance(msg.body, str)
self.assertEqual(msg.body.encode('utf-8'), message)
def test_channel_close_channel(self):
channel = Channel(0, FakeConnection(), 360)
# Set up Fake Channel.
channel._inbound = [1, 2, 3]
channel.set_state(channel.OPEN)
channel._consumer_tags = [1, 2, 3]
close_frame = specification.Channel.Close(reply_code=200,
reply_text='travis-ci')
# Close Channel.
channel._close_channel(close_frame)
self.assertEqual(channel._inbound, [])
self.assertEqual(channel._consumer_tags, [])
self.assertEqual(channel._state, channel.CLOSED)
def test_basic_qos_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'prefetch_count should be an integer',
basic.qos, 'unittest')
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'prefetch_size should be an integer',
basic.qos, 1, 'unittest')
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'global_ should be a boolean', basic.qos, 1, 1,
'unittest')
def test_basic_nack_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'delivery_tag should be an integer or None',
basic.nack, 'unittest')
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'multiple should be a boolean', basic.nack, 1,
None)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'requeue should be a boolean', basic.nack, 1,
True, None)
def test_channel_build_message_empty_and_then_break(self):
"""Start building a message with an empty inbound queue,
and send an empty ContentBody that should be ignored.
:return:
"""
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
channel._inbound = []
def add_inbound():
channel._inbound.append(ContentBody())
threading.Timer(function=add_inbound, interval=0.1).start()
self.assertFalse(channel._build_message_body(128))
def test_channel_build_message_empty_and_raise(self):
"""Start building a message with an empty inbound queue,
and raise when the channel is closed.
:return:
"""
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
channel._inbound = []
def close_channel():
channel.set_state(Channel.CLOSED)
threading.Timer(function=close_channel, interval=0.1).start()
self.assertRaises(AMQPChannelError, channel._build_message_body, 128)
def test_basic_publish_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'body should be a string',
basic.publish, None, ''
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'routing_key should be a string',
basic.publish, '', None
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'exchange should be a string',
basic.publish, '', '', None
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'properties should be a dict or None',
basic.publish, '', '', '', []
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'properties should be a dict or None',
basic.publish, '', '', '', 1
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'mandatory should be a boolean',
basic.publish, '', '', '', {}, None
)
self.assertRaisesRegexp(
exception.AMQPInvalidArgument,
'immediate should be a boolean',
basic.publish, '', '', '', {}, True, None
)
def test_basic_get_invalid_parameter(self):
channel = Channel(0, FakeConnection(), 360)
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'queue should be a string', basic.get, None)
self.assertRaisesRegexp(exception.AMQPInvalidArgument,
'no_ack should be a boolean', basic.get, '',
'unittest')
channel.consumer_tags.append('unittest')
self.assertRaisesRegexp(
exception.AMQPChannelError, "Cannot call 'get' when channel "
"is set to consume", basic.get, '', True, 'unittest')
def test_basic_publish_confirms_raises_on_invalid_frame(self):
message = str(uuid.uuid4())
def on_publish_return_invalid_frame(*_):
channel.rpc.on_frame(spec_basic.Cancel())
connection = FakeConnection(on_write=on_publish_return_invalid_frame)
channel = Channel(9, connection, 0.01)
channel.confirming_deliveries = True
channel.set_state(Channel.OPEN)
basic = Basic(channel)
self.assertRaisesRegexp(exception.AMQPChannelError,
"rpc requests",
basic.publish,
body=message,
routing_key='unittest')
def test_io_use_ssl_true(self):
connection = FakeConnection()
connection.parameters['ssl'] = True
io = IO(connection.parameters)
self.assertTrue(io.use_ssl)