def test_api_connection_close(self):
reason = 'travis-ci'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD, timeout=1)
self.assertEqual(len(api.connection.list()), 0,
'found an open connection, test will fail')
connection = Connection(HOST, USERNAME, PASSWORD, timeout=1)
connections = retry_function_wrapper(api.connection.list)
self.assertIsNotNone(connections)
self.assertEqual(len(connections), 1)
for conn in api.connection.list():
self.assertEqual(api.connection.close(conn['name'],
reason=reason), None)
time.sleep(1)
self.assertRaisesRegexp(
AMQPConnectionError,
'Connection was closed by remote server: '
'CONNECTION_FORCED - %s' % reason,
connection.check_for_errors
)
self.assertEqual(len(api.connection.list()), 0)
connection.close()
class PublishLargeMessagesAndGetTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
self.channel.queue.declare('test.basic.large_messages')
self.channel.queue.purge('test.basic.large_messages')
def test_publish_5_large_messages(self):
body = str(uuid.uuid4()) * 8192
messages_to_publish = 5
# Publish 5 Messages.
for _ in range(messages_to_publish):
self.channel.basic.publish(body=body,
routing_key='test.basic.large_messages')
inbound_messages = []
for _ in range(messages_to_publish):
message = self.channel.basic.get('test.basic.large_messages',
no_ack=True, to_dict=False)
self.assertEqual(message.body, body)
inbound_messages.append(message)
self.assertEqual(len(inbound_messages), messages_to_publish)
def tearDown(self):
self.channel.queue.delete('test.basic.large_messages')
self.channel.close()
self.connection.close()
class Publish50kTest(unittest.TestCase):
connection = None
channel = None
messages_to_send = 50000
queue_name = 'test.basic.50k'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
def test_functional_publish_50k_messages(self):
body = str(uuid.uuid4())
# Publish 50k Messages.
for _ in range(self.messages_to_send):
self.channel.basic.publish(body=body, routing_key=self.queue_name)
result = {}
# Let's give RabbitMQ a few seconds to catch up.
for _ in range(5):
time.sleep(0.5)
result = self.channel.queue.declare(queue=self.queue_name,
passive=True)
if self.messages_to_send == result['message_count']:
break
self.assertEqual(result['message_count'], self.messages_to_send)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class GetAndRedeliverTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.get.redeliver')
self.channel.queue.purge('test.get.redeliver')
self.channel.confirm_deliveries()
self.message = str(uuid.uuid4())
self.channel.basic.publish(body=self.message,
routing_key='test.get.redeliver')
message = self.channel.basic.get('test.get.redeliver', no_ack=False,
to_dict=False)
message.reject()
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
def test_get_and_redeliver(self):
message = self.channel.basic.get('test.get.redeliver', no_ack=False,
to_dict=False)
self.assertEqual(message.body, self.message)
def tearDown(self):
self.channel.queue.delete('test.get.redeliver')
self.channel.close()
self.connection.close()
class GeneratorConsumeMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.generator')
self.channel.queue.purge('test.basic.generator')
self.channel.confirm_deliveries()
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.generator')
self.channel.basic.consume(queue='test.basic.generator',
no_ack=True)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
def test_generator_consume(self):
# Store and inbound messages.
inbound_messages = []
for message in \
self.channel.build_inbound_messages(break_on_empty=True):
self.assertIsInstance(message, Message)
inbound_messages.append(message)
# Make sure all five messages were downloaded.
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete('test.basic.generator')
self.channel.close()
self.connection.close()
class PublishAndGetMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.get')
self.channel.queue.purge('test.basic.get')
def test_publish_and_get_five_messages(self):
# Publish 5 Messages.
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.get')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# Get 5 messages.
for _ in range(5):
payload = self.channel.basic.get('test.basic.get', to_dict=False)
self.assertIsInstance(payload, Message)
def tearDown(self):
self.channel.queue.delete('test.basic.get')
self.channel.close()
self.connection.close()
class PublishAndGetMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.get')
self.channel.queue.purge('test.basic.get')
def test_publish_and_get_five_messages(self):
# Publish 5 Messages.
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.get')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# Get 5 messages.
for _ in range(5):
payload = self.channel.basic.get('test.basic.get', to_dict=False)
self.assertIsInstance(payload, Message)
def tearDown(self):
self.channel.queue.delete('test.basic.get')
self.channel.close()
self.connection.close()
class PublishLargeMessagesAndGetTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
self.channel.queue.declare('test.basic.large_messages')
self.channel.queue.purge('test.basic.large_messages')
def test_publish_5_large_messages(self):
body = str(uuid.uuid4()) * 8192
messages_to_publish = 5
# Publish 5 Messages.
for _ in range(messages_to_publish):
self.channel.basic.publish(body=body,
routing_key='test.basic.large_messages')
inbound_messages = []
for _ in range(messages_to_publish):
message = self.channel.basic.get('test.basic.large_messages',
no_ack=True,
to_dict=False)
self.assertEqual(message.body, body)
inbound_messages.append(message)
self.assertEqual(len(inbound_messages), messages_to_publish)
def tearDown(self):
self.channel.queue.delete('test.basic.large_messages')
self.channel.close()
self.connection.close()
class Publish50kTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.50k')
self.channel.queue.purge('test.basic.50k')
def test_publish_50k_messages(self):
body = str(uuid.uuid4())
# Publish 50k Messages.
start_time = time.time()
for _ in range(50000):
self.channel.basic.publish(body=body, routing_key='test.basic.50k')
end_time = time.time() - start_time
# Sleep for 2.5s to make sure RabbitMQ has time to catch up.
time.sleep(2.5)
result = self.channel.queue.declare(queue='test.basic.50k',
passive=True)
LOGGER.info('Published 50k messages in %d', round(end_time, 3))
self.assertEqual(result['message_count'], 50000)
def tearDown(self):
self.channel.queue.delete('test.basic.50k')
self.channel.close()
self.connection.close()
def test_connection_close_when_already_closed(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
connection.set_state(connection.CLOSED)
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def state_set(state):
self.assertEqual(state, connection.CLOSED)
connection.set_state = state_set
self.assertTrue(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertFalse(connection._channels)
self.assertTrue(connection.is_closed)
def test_connection_close(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def on_write(frame_out):
self.assertIsInstance(frame_out, specification.Connection.Close)
connection._channel0._close_connection_ok()
connection._channel0._write_frame = on_write
self.assertFalse(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertTrue(connection.is_closed)
class PublishAndGetEmptyMessagesTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.basic.get_empty'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
def test_functional_publish_and_get_five_empty_messages(self):
# Publish 5 Messages.
for _ in range(5):
self.channel.basic.publish(body=b'',
routing_key=self.queue_name)
# Sleep for 0.1s to make sure RabbitMQ has time to catch up.
time.sleep(0.1)
# Get 5 messages.
inbound_messages = []
for _ in range(5):
payload = self.channel.basic.get(self.queue_name, to_dict=False)
self.assertIsInstance(payload, Message)
self.assertEqual(payload.body, b'')
inbound_messages.append(payload)
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class PublisherConfirmsTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.basic.confirm'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
self.channel.confirm_deliveries()
def test_functional_publish_and_confirm(self):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key=self.queue_name)
# Sleep for 0.1s to make sure RabbitMQ has time to catch up.
time.sleep(0.1)
payload = self.channel.queue.declare(self.queue_name,
passive=True)
self.assertEqual(payload['message_count'], 1)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
def test_connection_close_handles_raise_on_write(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def raise_on_write(_):
raise AMQPConnectionError('travis-ci')
connection._channel0._write_frame = raise_on_write
self.assertFalse(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertFalse(connection._channels)
self.assertTrue(connection.is_closed)
class PublishFailAndFix(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
def test_publish_and_confirm(self):
try:
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.publish.fail.and.fix',
mandatory=True)
except AMQPChannelError as why:
self.assertTrue(self.channel.is_open)
self.assertEqual(why.error_code, 312)
if why.error_code == 312:
self.channel.queue.declare('test.publish.fail.and.fix')
result = \
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.publish.fail.and.fix',
mandatory=True)
self.assertTrue(result)
payload = self.channel.queue.declare('test.publish.fail.and.fix',
passive=True)
self.assertEqual(payload['message_count'], 1)
def tearDown(self):
self.channel.queue.delete('test.publish.fail.and.fix')
self.channel.close()
self.connection.close()
def test_api_connection_close(self):
reason = 'travis-ci'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD, timeout=1)
self.assertEqual(len(api.connection.list()), 0,
'found an open connection, test will fail')
connection = Connection(HOST, USERNAME, PASSWORD, timeout=1)
connections = retry_function_wrapper(api.connection.list)
self.assertIsNotNone(connections)
self.assertEqual(len(connections), 1)
for conn in api.connection.list():
self.assertEqual(api.connection.close(conn['name'], reason=reason),
None)
time.sleep(1)
self.assertRaisesRegexp(
AMQPConnectionError, 'Connection was closed by remote server: '
'CONNECTION_FORCED - %s' % reason, connection.check_for_errors)
self.assertEqual(len(api.connection.list()), 0)
connection.close()
class PublishAndGetLargeMessageTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
self.channel.queue.declare('test.basic.get_large')
self.channel.queue.purge('test.basic.get_large')
def test_publish_and_get_large_message(self):
try:
body = str(uuid.uuid4()) * 65536
# Publish a single large message
self.channel.basic.publish(body=body,
routing_key='test.basic.get_large')
payload = self.channel.basic.get('test.basic.get_large',
to_dict=False)
self.assertEqual(body, payload.body)
finally:
self.channel.queue.purge('test.basic.get_large')
def tearDown(self):
self.channel.queue.delete('test.basic.get_large')
self.channel.close()
self.connection.close()
class ExchangeFunctionalTests(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_functional_exchange_declare(self):
self.channel.exchange.declare('test_functional_exchange_declare',
passive=False,
durable=True,
auto_delete=True)
self.channel.exchange.declare('test_functional_exchange_declare',
passive=True)
def test_functional_exchange_delete(self):
self.channel.exchange.declare('test_functional_exchange_delete')
self.channel.exchange.delete('test_functional_exchange_delete',
if_unused=True)
self.assertRaises(amqpstorm.AMQPChannelError,
self.channel.exchange.declare,
'test_functional_exchange_delete',
passive=True)
def tearDown(self):
self.channel.close()
self.connection.close()
class PublishAndGetLargeMessageTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
self.channel.queue.declare('test.basic.get_large')
self.channel.queue.purge('test.basic.get_large')
def test_publish_and_get_large_message(self):
try:
body = str(uuid.uuid4()) * 65536
# Publish a single large message
self.channel.basic.publish(body=body,
routing_key='test.basic.get_large')
payload = self.channel.basic.get('test.basic.get_large',
to_dict=False)
self.assertEqual(body, payload.body)
finally:
self.channel.queue.purge('test.basic.get_large')
def tearDown(self):
self.channel.queue.delete('test.basic.get_large')
self.channel.close()
self.connection.close()
class GeneratorConsumeMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.generator')
self.channel.queue.purge('test.basic.generator')
self.channel.confirm_deliveries()
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.generator')
self.channel.basic.consume(queue='test.basic.generator', no_ack=True)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
def test_generator_consume(self):
# Store and inbound messages.
inbound_messages = []
for message in \
self.channel.build_inbound_messages(break_on_empty=True):
self.assertIsInstance(message, Message)
inbound_messages.append(message)
# Make sure all five messages were downloaded.
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete('test.basic.generator')
self.channel.close()
self.connection.close()
class PublishFailAndFix(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
def test_publish_and_confirm(self):
try:
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.publish.fail.and.fix',
mandatory=True)
except AMQPChannelError as why:
self.assertTrue(self.channel.is_open)
self.assertEqual(why.error_code, 312)
if why.error_code == 312:
self.channel.queue.declare('test.publish.fail.and.fix')
result = \
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.publish.fail.and.fix',
mandatory=True)
self.assertTrue(result)
payload = self.channel.queue.declare('test.publish.fail.and.fix',
passive=True)
self.assertEqual(payload['message_count'], 1)
def tearDown(self):
self.channel.queue.delete('test.publish.fail.and.fix')
self.channel.close()
self.connection.close()
class GetAndRedeliverTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.get.redeliver')
self.channel.queue.purge('test.get.redeliver')
self.channel.confirm_deliveries()
self.message = str(uuid.uuid4())
self.channel.basic.publish(body=self.message,
routing_key='test.get.redeliver')
message = self.channel.basic.get('test.get.redeliver',
no_ack=False,
to_dict=False)
message.reject()
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
def test_get_and_redeliver(self):
message = self.channel.basic.get('test.get.redeliver',
no_ack=False,
to_dict=False)
self.assertEqual(message.body, self.message)
def tearDown(self):
self.channel.queue.delete('test.get.redeliver')
self.channel.close()
self.connection.close()
def consumer():
connection = Connection(HOST, USERNAME, PASSWORD)
channel = connection.channel()
# Declare a queue.
channel.queue.declare(QUEUE_NAME)
# Publish something we can get.
channel.basic.publish(body='Hello World!', routing_key=QUEUE_NAME,
properties={'content_type': 'text/plain'})
# Retrieve a single message.
result = channel.basic.get(queue=QUEUE_NAME, no_ack=False)
if result:
# If we got a message, handle it.
print('Message:', result['body'])
# Mark the message as handle.
channel.basic.ack(delivery_tag=result['method']['delivery_tag'])
else:
# The queue was empty.
print("Queue '{0}' Empty.".format(QUEUE_NAME))
channel.close()
connection.close()
class OpenMultipleChannelTest(unittest.TestCase):
connection = None
channel = None
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True)
def test_functional_open_multiple_channels(self):
self.connection.open()
self.assertIsNotNone(self.connection._io.socket)
self.assertIsNotNone(self.connection._io.poller)
self.assertTrue(self.connection.is_open)
for index in range(255):
channel = self.connection.channel()
# Verify that the Channel has been opened properly.
self.assertTrue(channel.is_open)
self.assertEqual(int(channel), index + 1)
self.connection.close()
time.sleep(0.1)
self.assertTrue(self.connection.is_closed)
self.assertIsNone(self.connection._io.socket)
self.assertIsNone(self.connection._io.poller)
self.assertEqual(threading.activeCount(),
1,
msg='Current Active threads: %s' % threading._active)
def tearDown(self):
self.connection.close()
class Publish50kTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.50k')
self.channel.queue.purge('test.basic.50k')
def test_publish_50k_messages(self):
body = str(uuid.uuid4())
# Publish 50k Messages.
start_time = time.time()
for _ in range(50000):
self.channel.basic.publish(body=body,
routing_key='test.basic.50k')
end_time = time.time() - start_time
# Sleep for 2.5s to make sure RabbitMQ has time to catch up.
time.sleep(2.5)
result = self.channel.queue.declare(queue='test.basic.50k',
passive=True)
LOGGER.info('Published 50k messages in %d', round(end_time, 3))
self.assertEqual(result['message_count'], 50000)
def tearDown(self):
self.channel.queue.delete('test.basic.50k')
self.channel.close()
self.connection.close()
class PublishEmptyMessagesAndConsumeTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.basic.empty_messages'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
def test_functional_publish_5_empty_messages(self):
body = b''
messages_to_publish = 5
self.channel.basic.consume(queue=self.queue_name,
no_ack=True)
# Publish 5 Messages.
for _ in range(messages_to_publish):
self.channel.basic.publish(body=body,
routing_key=self.queue_name)
inbound_messages = []
for message in self.channel.build_inbound_messages(break_on_empty=True):
self.assertEqual(message.body, body)
inbound_messages.append(message)
self.assertEqual(len(inbound_messages), messages_to_publish)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.properties')
self.channel.queue.purge('test.basic.properties')
self.channel.confirm_deliveries()
def test_publish_with_properties_and_get(self):
app_id = 'travis-ci'.encode('utf-8')
properties = {
'headers': {
'key': 1234567890,
'alpha': 'omega'
}
}
message = Message.create(self.channel,
body=str(uuid.uuid4()),
properties=properties)
# Assign Property app_id
message.app_id = app_id
# Check that it was set correctly.
self.assertEqual(message.properties['app_id'], app_id)
# Get Property Correlation Id
correlation_id = message.correlation_id
# Publish Message
message.publish(routing_key='test.basic.properties')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# New way
payload = self.channel.basic.get('test.basic.properties',
to_dict=False)
self.assertEqual(payload.properties['headers']['key'], 1234567890)
self.assertEqual(payload.properties['headers']['alpha'], 'omega')
self.assertEqual(payload.app_id, app_id.decode('utf-8'))
self.assertEqual(payload.correlation_id, correlation_id)
self.assertIsInstance(payload.properties['app_id'], str)
self.assertIsInstance(payload.properties['correlation_id'], str)
# Old way
result = payload.to_dict()
self.assertEqual(result['properties']['headers'][b'key'], 1234567890)
self.assertEqual(result['properties']['headers'][b'alpha'], b'omega')
self.assertIsInstance(result['properties']['app_id'], bytes)
self.assertIsInstance(result['properties']['correlation_id'], bytes)
self.assertEqual(result['properties']['app_id'], app_id)
self.assertEqual(result['properties']['correlation_id'],
correlation_id.encode('utf-8'))
def tearDown(self):
self.channel.queue.delete('test.basic.properties')
self.channel.close()
self.connection.close()
class PublishMessageAndResend(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.basic.resend'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
self.channel.confirm_deliveries()
message = Message.create(self.channel,
body=str(uuid.uuid4()))
message.app_id = 'travis-ci'
message.publish(self.queue_name)
def test_functional_publish_with_properties_and_get(self):
message = self.channel.basic.get(self.queue_name,
to_dict=False, no_ack=True)
# Check original app_id
self.assertEqual(message.app_id, 'travis-ci')
# Assign Property app_id
app_id = 'travis-ci-2'.encode('utf-8')
message.app_id = app_id
# Check that it was set correctly.
self.assertEqual(message.properties['app_id'], app_id)
# Get Property Correlation Id
correlation_id = message.correlation_id
# Publish Message
message.publish(routing_key=self.queue_name)
# Sleep for 0.1s to make sure RabbitMQ has time to catch up.
time.sleep(0.1)
# New way
payload = self.channel.basic.get(self.queue_name,
to_dict=False, no_ack=True)
self.assertEqual(payload.app_id, app_id.decode('utf-8'))
self.assertEqual(payload.correlation_id, correlation_id)
self.assertIsInstance(payload.properties['app_id'], str)
self.assertIsInstance(payload.properties['correlation_id'], str)
# Old way
result = payload.to_dict()
self.assertIsInstance(result['properties']['app_id'], bytes)
self.assertIsInstance(result['properties']['correlation_id'], bytes)
self.assertEqual(result['properties']['app_id'], app_id)
self.assertEqual(result['properties']['correlation_id'],
correlation_id.encode('utf-8'))
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
def consumer():
connection = Connection('127.0.0.1', 'guest', 'guest',
ssl=True, port=5671)
channel = connection.channel()
channel.queue.declare('simple_queue')
channel.basic.publish(body='Hello World!', routing_key='simple_queue')
channel.close()
connection.close()
class PublishMessageAndResend(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.resend')
self.channel.queue.purge('test.basic.resend')
self.channel.confirm_deliveries()
message = Message.create(self.channel,
body=str(uuid.uuid4()))
message.app_id = 'travis-ci'
message.publish('test.basic.resend')
def test_publish_with_properties_and_get(self):
message = self.channel.basic.get('test.basic.resend',
to_dict=False, no_ack=True)
# Check original app_id
self.assertEqual(message.app_id, 'travis-ci')
# Assign Property app_id
app_id = 'travis-ci-2'.encode('utf-8')
message.app_id = app_id
# Check that it was set correctly.
self.assertEqual(message.properties['app_id'], app_id)
# Get Property Correlation Id
correlation_id = message.correlation_id
# Publish Message
message.publish(routing_key='test.basic.resend')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# New way
payload = self.channel.basic.get('test.basic.resend',
to_dict=False, no_ack=True)
self.assertEqual(payload.app_id, app_id.decode('utf-8'))
self.assertEqual(payload.correlation_id, correlation_id)
self.assertIsInstance(payload.properties['app_id'], str)
self.assertIsInstance(payload.properties['correlation_id'], str)
# Old way
result = payload.to_dict()
self.assertIsInstance(result['properties']['app_id'], bytes)
self.assertIsInstance(result['properties']['correlation_id'], bytes)
self.assertEqual(result['properties']['app_id'], app_id)
self.assertEqual(result['properties']['correlation_id'],
correlation_id.encode('utf-8'))
def tearDown(self):
self.channel.queue.delete('test.basic.resend')
self.channel.close()
self.connection.close()
class QueueFunctionalTests(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_functional_queue_declare(self):
self.channel.queue.declare('test_functional_queue_declare',
passive=False,
durable=True,
auto_delete=True)
self.channel.queue.declare('test_functional_queue_declare',
passive=True)
def test_functional_queue_delete(self):
self.channel.queue.declare('test_functional_queue_delete')
self.channel.queue.delete('test_functional_queue_delete',
if_unused=True)
self.assertRaises(amqpstorm.AMQPChannelError,
self.channel.queue.declare,
'test_functional_queue_delete',
passive=True)
def test_functional_queue_purge(self):
payload = 'hello world'
queue = 'test_functional_functional_queue_purge'
messages_to_send = 10
self.channel.queue.declare(queue, auto_delete=True)
for _ in range(messages_to_send):
self.channel.basic.publish(payload, queue)
result = self.channel.queue.purge(queue)
self.assertEqual(result['message_count'], messages_to_send)
def test_functional_queue_bind(self):
queue = 'test_functional_queue_bind'
self.channel.queue.declare(queue,
passive=False,
durable=True,
auto_delete=True)
self.assertEqual(
self.channel.queue.bind(queue=queue, exchange='amq.direct'), {})
def test_functional_queue_unbind(self):
queue = 'test_functional_queue_unbind'
self.channel.queue.declare(queue,
passive=False,
durable=True,
auto_delete=True)
self.channel.queue.bind(queue=queue, exchange='amq.direct')
self.assertEqual(
self.channel.queue.unbind(queue=queue, exchange='amq.direct'), {})
def tearDown(self):
self.channel.close()
self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.properties')
self.channel.queue.purge('test.basic.properties')
self.channel.confirm_deliveries()
def test_publish_with_properties_and_get(self):
app_id = 'travis-ci'.encode('utf-8')
properties = {'headers': {'key': 1234567890, 'alpha': 'omega'}}
message = Message.create(self.channel,
body=str(uuid.uuid4()),
properties=properties)
# Assign Property app_id
message.app_id = app_id
# Check that it was set correctly.
self.assertEqual(message.properties['app_id'], app_id)
# Get Property Correlation Id
correlation_id = message.correlation_id
# Publish Message
message.publish(routing_key='test.basic.properties')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# New way
payload = self.channel.basic.get('test.basic.properties',
to_dict=False)
self.assertEqual(payload.properties['headers']['key'], 1234567890)
self.assertEqual(payload.properties['headers']['alpha'], 'omega')
self.assertEqual(payload.app_id, app_id.decode('utf-8'))
self.assertEqual(payload.correlation_id, correlation_id)
self.assertIsInstance(payload.properties['app_id'], str)
self.assertIsInstance(payload.properties['correlation_id'], str)
# Old way
result = payload.to_dict()
self.assertEqual(result['properties']['headers'][b'key'], 1234567890)
self.assertEqual(result['properties']['headers'][b'alpha'], b'omega')
self.assertIsInstance(result['properties']['app_id'], bytes)
self.assertIsInstance(result['properties']['correlation_id'], bytes)
self.assertEqual(result['properties']['app_id'], app_id)
self.assertEqual(result['properties']['correlation_id'],
correlation_id.encode('utf-8'))
def tearDown(self):
self.channel.queue.delete('test.basic.properties')
self.channel.close()
self.connection.close()
def consumer():
connection = Connection(HOST, USERNAME, PASSWORD, ssl=True, port=5671,
ssl_options={
'ssl_version': ssl.PROTOCOL_TLSv1,
'cert_reqs': ssl.CERT_NONE
})
channel = connection.channel()
channel.queue.declare('simple_queue')
channel.basic.publish(body='Hello World!', routing_key='simple_queue')
channel.close()
connection.close()
class QueueFunctionalTests(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_functional_queue_declare(self):
self.channel.queue.declare('test_functional_queue_declare',
passive=False,
durable=True, auto_delete=True)
self.channel.queue.declare('test_functional_queue_declare',
passive=True)
def test_functional_queue_delete(self):
self.channel.queue.declare('test_functional_queue_delete')
self.channel.queue.delete('test_functional_queue_delete',
if_unused=True)
self.assertRaises(amqpstorm.AMQPChannelError,
self.channel.queue.declare,
'test_functional_queue_delete', passive=True)
def test_functional_queue_purge(self):
payload = 'hello world'
queue = 'test_functional_functional_queue_purge'
messages_to_send = 10
self.channel.queue.declare(queue, auto_delete=True)
for _ in range(messages_to_send):
self.channel.basic.publish(payload, queue)
result = self.channel.queue.purge(queue)
self.assertEqual(result['message_count'], messages_to_send)
def test_functional_queue_bind(self):
queue = 'test_functional_queue_bind'
self.channel.queue.declare(queue,
passive=False,
durable=True, auto_delete=True)
self.assertEqual(self.channel.queue.bind(queue=queue,
exchange='amq.direct'), {})
def test_functional_queue_unbind(self):
queue = 'test_functional_queue_unbind'
self.channel.queue.declare(queue,
passive=False,
durable=True, auto_delete=True)
self.channel.queue.bind(queue=queue, exchange='amq.direct')
self.assertEqual(self.channel.queue.unbind(queue=queue,
exchange='amq.direct'), {})
def tearDown(self):
self.channel.close()
self.connection.close()
class Consumer(object):
def __init__(self, max_retries=None):
self.max_retries = max_retries
self.connection = None
def create_connection(self):
"""Create a connection.
:return:
"""
attempts = 0
while True:
attempts += 1
try:
self.connection = Connection('127.0.0.1', 'guest', 'guest')
break
except amqpstorm.AMQPError as why:
LOGGER.exception(why)
if self.max_retries and attempts > self.max_retries:
break
time.sleep(min(attempts * 2, 30))
except KeyboardInterrupt:
break
def start(self):
"""Start the Consumers.
:return:
"""
if not self.connection:
self.create_connection()
while True:
try:
channel = self.connection.channel()
channel.queue.declare('simple_queue')
channel.basic.consume(self, 'simple_queue', no_ack=False)
channel.start_consuming()
if not channel.consumer_tags:
channel.close()
except amqpstorm.AMQPError as why:
LOGGER.exception(why)
self.create_connection()
except KeyboardInterrupt:
self.connection.close()
break
def __call__(self, message):
print("Message:", message.body)
message.ack()
class Consumer(object):
def __init__(self, max_retries=None):
self.max_retries = max_retries
self.connection = None
def create_connection(self):
"""Create a connection.
:return:
"""
attempts = 0
while True:
attempts += 1
try:
self.connection = Connection('127.0.0.1', 'guest', 'guest')
break
except amqpstorm.AMQPError as why:
LOGGER.exception(why)
if self.max_retries and attempts > self.max_retries:
break
time.sleep(min(attempts * 2, 30))
except KeyboardInterrupt:
break
def start(self):
"""Start the Consumers.
:return:
"""
if not self.connection:
self.create_connection()
while True:
try:
channel = self.connection.channel()
channel.queue.declare('simple_queue')
channel.basic.consume(self, 'simple_queue', no_ack=False)
channel.start_consuming()
if not channel.consumer_tags:
channel.close()
except amqpstorm.AMQPError as why:
LOGGER.exception(why)
self.create_connection()
except KeyboardInterrupt:
self.connection.close()
break
def __call__(self, message):
print("Message:", message.body)
message.ack()
class ExchangeCreateTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_exchange_create(self):
# Create the Exchange.
self.channel.exchange.declare('test.exchange.create')
# Confirm that the Exchange was declared.
self.channel.exchange.declare('test.exchange.create', passive=True)
def tearDown(self):
self.channel.exchange.delete('test.exchange.create')
self.channel.close()
self.connection.close()
class ExchangeCreateTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_exchange_create(self):
# Create the Exchange.
self.channel.exchange.declare('test.exchange.create')
# Confirm that the Exchange was declared.
self.channel.exchange.declare('test.exchange.create', passive=True)
def tearDown(self):
self.channel.exchange.delete('test.exchange.create')
self.channel.close()
self.connection.close()
class ExchangeFunctionalTests(unittest.TestCase):
def setUp(self):
self.logging_handler = MockLoggingHandler()
logging.root.addHandler(self.logging_handler)
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_functional_exchange_declare(self):
self.channel.exchange.declare('test_functional_exchange_declare',
passive=False,
durable=True,
auto_delete=True)
self.channel.exchange.declare('test_functional_exchange_declare',
passive=True)
def test_functional_exchange_delete(self):
self.channel.exchange.declare('test_functional_exchange_delete')
self.channel.exchange.delete('test_functional_exchange_delete',
if_unused=True)
self.assertRaises(amqpstorm.AMQPChannelError,
self.channel.exchange.declare,
'test_functional_exchange_delete',
passive=True)
def test_functional_exchange_bind(self):
self.channel.exchange.declare('exchange1')
self.channel.exchange.declare('exchange2')
self.assertEqual(
self.channel.exchange.bind('exchange1', 'exchange2',
'routing_key'), {})
def test_functional_exchange_unbind(self):
self.channel.exchange.declare('exchange1')
self.channel.exchange.declare('exchange2')
self.channel.exchange.bind('exchange1', 'exchange2', 'routing_key')
self.assertEqual(
self.channel.exchange.unbind('exchange1', 'exchange2',
'routing_key'), {})
def tearDown(self):
self.channel.close()
self.connection.close()
self.assertFalse(self.logging_handler.messages['warning'])
self.assertFalse(self.logging_handler.messages['error'])
self.assertFalse(self.logging_handler.messages['critical'])
class PublisherConfirmFailsTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
def test_publish_confirm_to_invalid_queue(self):
self.assertRaises(AMQPMessageError,
self.channel.basic.publish,
body=str(uuid.uuid4()),
exchange='amq.direct',
mandatory=True,
routing_key='test.basic.confirm.fails')
def tearDown(self):
self.channel.close()
self.connection.close()
class PublisherConfirmFailsTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.confirm_deliveries()
def test_publish_confirm_to_invalid_queue(self):
self.assertRaises(AMQPMessageError,
self.channel.basic.publish,
body=str(uuid.uuid4()),
exchange='amq.direct',
mandatory=True,
routing_key='test.basic.confirm.fails')
def tearDown(self):
self.channel.close()
self.connection.close()
class ExchangeDeleteTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.exchange.declare('test.exchange.delete')
def test_exchange_delete(self):
# Delete the Exchange.
self.channel.exchange.delete('test.exchange.delete')
# Confirm that the Exchange was deleted.
self.assertRaises(AMQPChannelError, self.channel.exchange.declare,
'test.exchange.delete', passive=True)
def tearDown(self):
self.channel.close()
self.connection.close()
class StartStopConsumeTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.basic.consume'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
self.channel.confirm_deliveries()
def test_functional_start_stop_consumer(self):
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key=self.queue_name)
# Store and inbound messages.
inbound_messages = []
def on_message(message):
self.assertIsInstance(message.body, (bytes, str))
self.assertIsInstance(message.channel, Channel)
self.assertIsInstance(message.properties, dict)
self.assertIsInstance(message.method, dict)
inbound_messages.append(message)
if len(inbound_messages) >= 5:
message.channel.stop_consuming()
self.channel.basic.consume(callback=on_message,
queue=self.queue_name,
no_ack=True)
# Sleep for 0.1s to make sure RabbitMQ has time to catch up.
time.sleep(0.1)
self.channel.start_consuming(to_tuple=False)
# Make sure all five messages were downloaded.
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class ConsumeAndRedeliverTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.consume.redeliver'
message = str(uuid.uuid4())
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare(self.queue_name)
self.channel.queue.purge(self.queue_name)
self.channel.confirm_deliveries()
self.channel.basic.publish(body=self.message,
routing_key=self.queue_name)
def on_message(message):
message.reject()
self.channel.basic.consume(callback=on_message,
queue=self.queue_name,
no_ack=False)
self.channel.process_data_events(to_tuple=False)
# Sleep for 0.1s to make sure RabbitMQ has time to catch up.
time.sleep(0.1)
def test_functional_consume_and_redeliver(self):
# Store and inbound messages.
inbound_messages = []
def on_message(message):
inbound_messages.append(message)
self.assertEqual(message.body, self.message)
message.ack()
self.channel.basic.consume(callback=on_message,
queue=self.queue_name,
no_ack=False)
self.channel.process_data_events(to_tuple=False)
self.assertEqual(len(inbound_messages), 1)
def tearDown(self):
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class PublishAndFail(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.publish.and.fail')
self.channel.confirm_deliveries()
def test_publish_and_confirm(self):
message = Message.create(self.channel, 'hello world')
self.assertRaises(AMQPChannelError, message.publish, 'hello_world',
exchange='fake_exchange', mandatory=True)
self.assertFalse(self.channel.is_open)
def tearDown(self):
self.channel = self.connection.channel()
self.channel.queue.delete('test.publish.and.fail')
self.channel.close()
self.connection.close()
class OpenCloseChannelLoopTest(unittest.TestCase):
connection = None
channel = None
queue_name = 'test.open.close'
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True)
def test_functional_open_close_channel_loop(self):
for _ in range(100):
self.connection.open()
self.channel = self.connection.channel()
# Verify that the Connection/Channel has been opened properly.
self.assertIsNotNone(self.connection._io.socket)
self.assertIsNotNone(self.connection._io.poller)
self.assertTrue(self.channel.is_open)
self.assertTrue(self.connection.is_open)
self.channel.queue.declare(self.queue_name)
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key=self.queue_name)
self.channel.close()
self.connection.close()
# Verify that the Connection/Channel has been closed properly.
self.assertTrue(self.channel.is_closed)
self.assertTrue(self.connection.is_closed)
self.assertIsNone(self.connection._io.socket)
self.assertIsNone(self.connection._io.poller)
time.sleep(0.1)
self.assertEqual(threading.activeCount(),
1,
msg='Current Active threads: %s' % threading._active)
def tearDown(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.delete(self.queue_name)
self.channel.close()
self.connection.close()
class ExchangeDeleteTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.exchange.declare('test.exchange.delete')
def test_exchange_delete(self):
# Delete the Exchange.
self.channel.exchange.delete('test.exchange.delete')
# Confirm that the Exchange was deleted.
self.assertRaises(AMQPChannelError,
self.channel.exchange.declare,
'test.exchange.delete',
passive=True)
def tearDown(self):
self.channel.close()
self.connection.close()
class ConsumeAndRedeliverTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.consume.redeliver')
self.channel.queue.purge('test.consume.redeliver')
self.message = str(uuid.uuid4())
self.channel.confirm_deliveries()
self.channel.basic.publish(body=self.message,
routing_key='test.consume.redeliver')
def on_message(message):
message.reject()
self.channel.basic.consume(callback=on_message,
queue='test.consume.redeliver',
no_ack=False)
self.channel.process_data_events(to_tuple=False)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
def test_consume_and_redeliver(self):
# Store and inbound messages.
inbound_messages = []
def on_message(message):
inbound_messages.append(message)
self.assertEqual(message.body, self.message)
message.ack()
self.channel.basic.consume(callback=on_message,
queue='test.consume.redeliver',
no_ack=False)
self.channel.process_data_events(to_tuple=False)
self.assertEqual(len(inbound_messages), 1)
def tearDown(self):
self.channel.queue.delete('test.consume.redeliver')
self.channel.close()
self.connection.close()
class Publisher(object):
def __init__(self, host, username, password):
self.channel = None
self.connection = None
self.host = host
self.username = username
self.password = password
self.connect()
def connect(self):
self.connection = Connection(self.host, self.username, self.password)
self.channel = self.connection.channel()
def close_connection(self):
self.channel.close()
self.connection.close()
def send_message(self, queue, message):
if self.connection.is_closed:
self.reconnect()
try:
self.channel.basic.publish(body=message,
routing_key=queue)
except AMQPError as why:
# When handling AMQPError's here, be careful as you may
# need to re-send the payload.
print(why)
self.reconnect()
def reconnect(self):
""" Re-connect.
:return:
"""
try:
if self.connection.is_closed:
self.connection.open()
if self.channel.is_closed:
self.channel.open()
except AMQPError:
raise
class PublishAndFail(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.publish.and.fail')
self.channel.confirm_deliveries()
def test_publish_and_confirm(self):
message = Message.create(self.channel, 'hello world')
self.assertRaises(AMQPChannelError,
message.publish,
'hello_world',
exchange='fake_exchange',
mandatory=True)
self.assertFalse(self.channel.is_open)
def tearDown(self):
self.channel = self.connection.channel()
self.channel.queue.delete('test.publish.and.fail')
self.channel.close()
self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.properties')
self.channel.queue.purge('test.basic.properties')
self.channel.confirm_deliveries()
def test_publish_with_properties_and_get(self):
message = str(uuid.uuid4())
properties = {
'headers': {
'key': 1234567890,
'alpha': 'omega'
}
}
self.channel.basic.publish(body=message,
routing_key='test.basic.properties',
properties=properties)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
# New way
payload = self.channel.basic.get('test.basic.properties',
to_dict=False)
self.assertEqual(payload.properties['headers']['key'], 1234567890)
self.assertEqual(payload.properties['headers']['alpha'], 'omega')
# Old way
result = payload.to_dict()
self.assertEqual(result['properties']['headers'][b'key'], 1234567890)
self.assertEqual(result['properties']['headers'][b'alpha'], b'omega')
def tearDown(self):
self.channel.queue.delete('test.basic.properties')
self.channel.close()
self.connection.close()
class OpenCloseOpenCloseTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True)
def test_open_close_loop(self):
for _ in range(100):
self.connection.open()
self.channel = self.connection.channel()
# Verify that the Connection/Channel has been opened properly.
self.assertIsNotNone(self.connection._io.socket)
self.assertIsNotNone(self.connection._io.poller)
self.assertTrue(self.channel.is_open)
self.assertTrue(self.connection.is_open)
self.channel.queue.declare('test.open.close')
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.open.close')
self.channel.close()
self.connection.close()
# Verify that the Connection/Channel has been closed properly.
self.assertTrue(self.channel.is_closed)
self.assertTrue(self.connection.is_closed)
self.assertIsNone(self.connection._io.socket)
self.assertIsNone(self.connection._io.poller)
time.sleep(0.1)
self.assertEqual(threading.activeCount(), 1,
msg='Current Active threads: %s'
% threading._active)
def tearDown(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.delete('test.open.close')
self.channel.close()
self.connection.close()
class PublishAndConsumeMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.consume')
self.channel.queue.purge('test.basic.consume')
self.channel.confirm_deliveries()
def test_publish_and_consume_five_messages(self):
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.consume')
# Store and inbound messages.
inbound_messages = []
def on_message(message):
self.assertIsInstance(message.body, (bytes, str))
self.assertIsInstance(message.channel, Channel)
self.assertIsInstance(message.properties, dict)
self.assertIsInstance(message.method, dict)
inbound_messages.append(message)
self.channel.basic.consume(callback=on_message,
queue='test.basic.consume',
no_ack=True)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
self.channel.process_data_events(to_tuple=False)
# Make sure all five messages were downloaded.
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete('test.basic.consume')
self.channel.close()
self.connection.close()
class PublishAndConsumeMessagesTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.consume')
self.channel.queue.purge('test.basic.consume')
self.channel.confirm_deliveries()
def test_publish_and_consume_five_messages(self):
for _ in range(5):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.consume')
# Store and inbound messages.
inbound_messages = []
def on_message(message):
self.assertIsInstance(message.body, (bytes, str))
self.assertIsInstance(message.channel, Channel)
self.assertIsInstance(message.properties, dict)
self.assertIsInstance(message.method, dict)
inbound_messages.append(message)
self.channel.basic.consume(callback=on_message,
queue='test.basic.consume',
no_ack=True)
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
self.channel.process_data_events(to_tuple=False)
# Make sure all five messages were downloaded.
self.assertEqual(len(inbound_messages), 5)
def tearDown(self):
self.channel.queue.delete('test.basic.consume')
self.channel.close()
self.connection.close()
class PublisherConfirmsTest(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
self.channel.queue.declare('test.basic.confirm')
self.channel.queue.purge('test.basic.confirm')
self.channel.confirm_deliveries()
def test_publish_and_confirm(self):
self.channel.basic.publish(body=str(uuid.uuid4()),
routing_key='test.basic.confirm')
# Sleep for 0.5s to make sure RabbitMQ has time to catch up.
time.sleep(0.5)
payload = self.channel.queue.declare('test.basic.confirm',
passive=True)
self.assertEqual(payload['message_count'], 1)
def tearDown(self):
self.channel.queue.delete('test.basic.confirm')
self.channel.close()
self.connection.close()
class ExchangeFunctionalTests(unittest.TestCase):
def setUp(self):
self.connection = Connection(HOST, USERNAME, PASSWORD)
self.channel = self.connection.channel()
def test_functional_exchange_declare(self):
self.channel.exchange.declare('test_functional_exchange_declare',
passive=False,
durable=True, auto_delete=True)
self.channel.exchange.declare('test_functional_exchange_declare',
passive=True)
def test_functional_exchange_delete(self):
self.channel.exchange.declare('test_functional_exchange_delete')
self.channel.exchange.delete('test_functional_exchange_delete',
if_unused=True)
self.assertRaises(amqpstorm.AMQPChannelError,
self.channel.exchange.declare,
'test_functional_exchange_delete', passive=True)
def tearDown(self):
self.channel.close()
self.connection.close()
def test_connection_close_state(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(Connection.OPEN)
connection.close()
self.assertTrue(connection.is_closed)
