def test_message_copy(self):
msg1 = Message(bytes(shortuuid.uuid(), 'utf-8'))
msg2 = copy(msg1)
msg1.lock()
self.assertFalse(msg2.locked)
def test_purge_queue(self):
queue_name = self.get_random_name("test_connection4")
routing_key = self.get_random_name()
channel = yield self.create_channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=True)
yield queue.bind(exchange, routing_key)
try:
body = bytes(shortuuid.uuid(), 'utf-8')
yield exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'}), routing_key)
yield queue.purge()
with self.assertRaises(gen.TimeoutError):
yield queue.get(timeout=1)
except:
yield queue.unbind(exchange, routing_key)
yield queue.delete()
def test_simple_publish_and_receive_to_bound_exchange(self):
routing_key = self.get_random_name()
src_name = self.get_random_name("source", "exchange")
dest_name = self.get_random_name("destination", "exchange")
channel = yield self.create_channel()
src_exchange = yield self.declare_exchange(src_name,
auto_delete=True,
channel=channel)
dest_exchange = yield self.declare_exchange(dest_name,
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(auto_delete=True, channel=channel)
yield queue.bind(dest_exchange, routing_key)
yield dest_exchange.bind(src_exchange, routing_key)
self.addCleanup(dest_exchange.unbind, src_exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
yield src_exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield queue.unbind(dest_exchange, routing_key)
def test_simple_publish_and_receive_delivery_mode_explicitly_none(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield self.create_channel()
exchange = yield self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
yield exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'},
delivery_mode=None), routing_key)
incoming_message = yield queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield queue.unbind(exchange, routing_key)
def test_simple_publish_without_confirm(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield self.create_channel(publisher_confirms=False)
exchange = yield self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
result = yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
self.assertIsNone(result)
incoming_message = yield queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield queue.unbind(exchange, routing_key)
def test_internal_exchange(self):
client = yield self.create_connection()
routing_key = self.get_random_name()
exchange_name = self.get_random_name("internal", "exchange")
channel = yield client.channel()
exchange = yield self.declare_exchange(exchange_name,
auto_delete=True,
internal=True,
channel=channel)
queue = yield self.declare_queue(auto_delete=True, channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
with self.assertRaises(ValueError):
f = exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'}), routing_key)
yield f
yield queue.unbind(exchange, routing_key)
def test_consuming_not_coroutine(self):
client = yield self.create_connection()
queue_name = self.get_random_name("tc2")
routing_key = self.get_random_name()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=True)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
f = concurrent.Future()
def handle(message):
message.ack()
self.assertEqual(message.body, body)
self.assertEqual(message.routing_key, routing_key)
f.set_result(True)
yield queue.consume(handle)
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
if not f.done():
yield f
yield queue.unbind(exchange, routing_key)
yield exchange.delete()
yield wait((client.close(), client.closing))
def test_big_message(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_big")
routing_key = self.get_random_name()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=True)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8') * 9999999
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield queue.unbind(exchange, routing_key)
yield queue.delete()
yield wait((client.close(), client.closing))
def test_dlx(self):
suffix = self.get_random_name()
routing_key = "%s_routing_key" % suffix
dlx_routing_key = "%s_dlx_routing_key" % suffix
channel = yield self.create_channel()
f = concurrent.Future()
@gen.coroutine
def dlx_handle(message):
message.ack()
self.assertEqual(message.body, body)
self.assertEqual(message.routing_key, dlx_routing_key)
f.set_result(True)
direct_exchange = yield self.declare_exchange(
'direct', channel=channel, auto_delete=True) # type:
# topika.Exchange
dlx_exchange = yield channel.declare_exchange('dlx',
ExchangeType.DIRECT,
auto_delete=True)
direct_queue = yield channel.declare_queue(
"%s_direct_queue" % suffix,
auto_delete=True,
arguments={
'x-message-ttl': 300,
'x-dead-letter-exchange': 'dlx',
'x-dead-letter-routing-key': dlx_routing_key
})
dlx_queue = yield channel.declare_queue("%s_dlx_queue" % suffix,
auto_delete=True)
yield dlx_queue.consume(dlx_handle)
yield dlx_queue.bind(dlx_exchange, dlx_routing_key)
yield direct_queue.bind(direct_exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
try:
yield direct_exchange.publish(
Message(body,
content_type='text/plain',
headers={
'x-message-ttl': 100,
'x-dead-letter-exchange': 'dlx',
}), routing_key)
if not f.done():
yield f
finally:
yield dlx_queue.unbind(dlx_exchange, routing_key)
yield direct_queue.unbind(direct_exchange, routing_key)
yield direct_queue.delete()
yield direct_exchange.delete()
yield dlx_exchange.delete()
def test_basic_return(self):
client = yield self.create_connection()
channel = yield client.channel() # type: topika.Channel
f = concurrent.Future()
channel.add_on_return_callback(f.set_result)
body = bytes(shortuuid.uuid(), 'utf-8')
yield channel.default_exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
self.get_random_name("test_basic_return"))
returned = yield f
self.assertEqual(returned.body, body)
# handler with exception
f = concurrent.Future()
yield channel.close()
channel = yield client.channel() # type: topika.Channel
def bad_handler(message):
try:
raise ValueError
finally:
f.set_result(message)
channel.add_on_return_callback(bad_handler)
body = bytes(shortuuid.uuid(), 'utf-8')
yield channel.default_exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
self.get_random_name("test_basic_return"))
returned = yield f
self.assertEqual(returned.body, body)
yield wait((client.close(), client.closing))
def test_connection_close(self):
""" Try setting an invalid delivery mode on a message """
client = yield self.create_connection()
routing_key = self.get_random_name()
channel = yield client.channel() # type: topika.Channel
exchange = yield channel.declare_exchange('direct', auto_delete=True)
try:
with self.assertRaises(pika.exceptions.ChannelClosedByBroker):
msg = Message(bytes(shortuuid.uuid(), 'utf-8'))
msg.delivery_mode = 8
yield exchange.publish(msg, routing_key)
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct',
auto_delete=True)
finally:
yield exchange.delete()
yield wait((client.close(), client.closing))
def test_message_info(self):
body = bytes(shortuuid.uuid(), 'utf-8')
info = {
'headers': {
"foo": "bar"
},
'content_type': "application/json",
'content_encoding': "text",
'delivery_mode': DeliveryMode.PERSISTENT.value,
'priority': 0,
'correlation_id': b'1',
'reply_to': 'test',
'expiration': 1.5,
'message_id': shortuuid.uuid(),
'timestamp': int(time.time()),
'type': '0',
'user_id': 'guest',
'app_id': 'test',
'body_size': len(body)
}
msg = Message(body=body,
headers={'foo': 'bar'},
content_type='application/json',
content_encoding='text',
delivery_mode=DeliveryMode.PERSISTENT,
priority=0,
correlation_id=1,
reply_to='test',
expiration=1.5,
message_id=info['message_id'],
timestamp=info['timestamp'],
type='0',
user_id='guest',
app_id='test')
self.assertDictEqual(info, msg.info())
def test_temporary_queue(self):
channel = yield self.create_channel()
queue = yield channel.declare_queue(auto_delete=True)
self.assertNotEqual(queue.name, '')
body = os.urandom(32)
yield channel.default_exchange.publish(Message(body=body),
routing_key=queue.name)
message = yield queue.get()
self.assertEqual(message.body, body)
yield channel.queue_delete(queue.name)
def test_context_process_redelivery(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield self.create_channel()
exchange = yield self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
with self.assertRaises(AssertionError):
with incoming_message.process(requeue=True,
reject_on_redelivered=True):
raise AssertionError
incoming_message = yield queue.get(timeout=5)
with mock.patch('topika.message.LOGGER') as message_logger:
with self.assertRaises(Exception):
with incoming_message.process(requeue=True,
reject_on_redelivered=True):
raise Exception
self.assertTrue(message_logger.info.called)
self.assertEqual(message_logger.info.mock_calls[0][1][1].body,
incoming_message.body)
self.assertEqual(incoming_message.body, body)
yield queue.unbind(exchange, routing_key)
def test_on_return_raises(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_on_return_raises")
body = uuid.uuid4().bytes
with self.assertRaises(RuntimeError):
yield client.channel(publisher_confirms=False,
on_return_raises=True)
channel = yield client.channel(publisher_confirms=True,
on_return_raises=True)
for _ in range(100):
with self.assertRaises(topika.exceptions.UnroutableError):
yield channel.default_exchange.publish(
Message(body=body),
routing_key=queue_name,
)
yield client.close()
def test_declaration_result_with_messages(self):
client = yield self.create_connection()
channel1 = yield client.channel()
channel2 = yield client.channel()
queue_name = self.get_random_name("queue", "declaration-result")
queue1 = yield channel1.declare_queue(queue_name, auto_delete=True)
yield channel1.default_exchange.publish(Message(body=b'test'),
routing_key=queue1.name)
queue2 = yield channel2.declare_queue(queue_name, passive=True)
yield queue2.get()
yield queue2.delete()
self.assertEqual(queue2.declaration_result.consumer_count, 0)
self.assertEqual(queue2.declaration_result.message_count, 1)
yield wait((client.close(), client.closing))
def test_expiration(self):
client = yield self.create_connection()
channel = yield client.channel() # type: topika.Channel
dlx_queue = yield channel.declare_queue(
self.get_random_name("test_dlx")) # type: topika.Queue
dlx_exchange = yield channel.declare_exchange(
self.get_random_name("dlx"), ) # type: topika.Exchange
yield dlx_queue.bind(dlx_exchange, routing_key=dlx_queue.name)
queue = yield channel.declare_queue(
self.get_random_name("test_expiration"),
arguments={
"x-message-ttl": 10000,
"x-dead-letter-exchange": dlx_exchange.name,
"x-dead-letter-routing-key": dlx_queue.name,
}) # type: topika.Queue
body = bytes(shortuuid.uuid(), 'utf-8')
yield channel.default_exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'},
expiration=0.5), queue.name)
f = concurrent.Future()
yield dlx_queue.consume(f.set_result, no_ack=True)
message = yield f
self.assertEqual(message.body, body)
self.assertEqual(message.headers['x-death'][0]['original-expiration'],
'500')
yield wait((client.close(), client.closing))
def test_no_ack_redelivery(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=False)
yield queue.bind(exchange, routing_key)
# publish 2 messages
for _ in range(2):
body = bytes(shortuuid.uuid(), 'utf-8')
msg = Message(body)
yield exchange.publish(msg, routing_key)
# ack 1 message out of 2
first_message = yield queue.get(timeout=5)
last_message = yield queue.get(timeout=5)
last_message.ack()
# close channel, not acked message should be redelivered
yield channel.close()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=False)
# receive not acked message
message = yield queue.get(timeout=5)
self.assertEqual(message.body, first_message.body)
message.ack()
yield queue.unbind(exchange, routing_key)
def test_message_nack(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_nack_queue")
body = uuid.uuid4().bytes
channel = yield client.channel()
queue = yield channel.declare_queue(queue_name, auto_delete=True)
yield channel.default_exchange.publish(Message(body=body),
routing_key=queue_name)
message = yield queue.get() # type: topika.IncomingMessage
self.assertEqual(message.body, body)
message.nack(requeue=True)
message = yield queue.get()
self.assertTrue(message.redelivered)
self.assertEqual(message.body, body)
message.ack()
yield queue.delete()
yield wait((client.close(), client.closing))
def test_queue_empty_exception(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_get_on_empty_queue")
channel = yield client.channel()
queue = yield channel.declare_queue(queue_name, auto_delete=True)
with self.assertRaises(topika.exceptions.QueueEmpty):
yield queue.get(timeout=5)
yield channel.default_exchange.publish(
Message(b'test'),
queue_name,
)
message = yield queue.get(timeout=5)
self.assertEqual(message.body, b'test')
# test again for #110
with self.assertRaises(topika.exceptions.QueueEmpty):
yield queue.get(timeout=5)
yield queue.delete()
yield wait((client.close(), client.closing))
def test_ack_multiple(self):
client = yield self.create_connection()
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=False)
yield queue.bind(exchange, routing_key)
# publish 2 messages
for _ in range(2):
body = bytes(shortuuid.uuid(), 'utf-8')
msg = Message(body)
yield exchange.publish(msg, routing_key)
# ack only last mesage with multiple flag, first message should be acked too
yield queue.get(timeout=5)
last_message = yield queue.get(timeout=5)
last_message.ack(multiple=True)
# close channel, no messages should be redelivered
yield channel.close()
channel = yield client.channel()
exchange = yield channel.declare_exchange('direct', auto_delete=True)
queue = yield channel.declare_queue(queue_name, auto_delete=False)
with self.assertRaises(topika.exceptions.QueueEmpty):
yield queue.get()
yield queue.unbind(exchange, routing_key)
yield queue.delete()
yield wait((client.close(), client.closing))
def test_incoming_message_info(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield self.create_channel()
exchange = yield self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
self.maxDiff = None
info = {
'headers': {
"foo": "bar"
},
'content_type': "application/json",
'content_encoding': "text",
'delivery_mode': DeliveryMode.PERSISTENT.value,
'priority': 0,
'correlation_id': b'1',
'reply_to': 'test',
'expiration': 1.5,
'message_id': shortuuid.uuid(),
'timestamp': int(time.time()),
'type': '0',
'user_id': 'guest',
'app_id': 'test',
'body_size': len(body)
}
msg = Message(body=body,
headers={'foo': 'bar'},
content_type='application/json',
content_encoding='text',
delivery_mode=DeliveryMode.PERSISTENT,
priority=0,
correlation_id=1,
reply_to='test',
expiration=1.5,
message_id=info['message_id'],
timestamp=info['timestamp'],
type='0',
user_id='guest',
app_id='test')
yield exchange.publish(msg, routing_key)
incoming_message = yield queue.get(timeout=5)
incoming_message.ack()
info['synchronous'] = incoming_message.synchronous
info['routing_key'] = incoming_message.routing_key
info['redelivered'] = incoming_message.redelivered
info['exchange'] = incoming_message.exchange
info['delivery_tag'] = incoming_message.delivery_tag
info['consumer_tag'] = incoming_message.consumer_tag
info['cluster_id'] = incoming_message.cluster_id
self.assertEqual(incoming_message.body, body)
self.assertDictEqual(incoming_message.info(), info)
yield queue.unbind(exchange, routing_key)
def test_context_process(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield self.create_channel()
exchange = yield self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = yield self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
yield queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
with self.assertRaises(AssertionError):
with incoming_message.process(requeue=True):
raise AssertionError
self.assertEqual(incoming_message.locked, True)
incoming_message = yield queue.get(timeout=5)
with incoming_message.process():
pass
self.assertEqual(incoming_message.body, body)
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
with self.assertRaises(MessageProcessError):
with incoming_message.process():
incoming_message.reject(requeue=True)
self.assertEqual(incoming_message.locked, True)
incoming_message = yield queue.get(timeout=5)
with incoming_message.process(ignore_processed=True):
incoming_message.reject(requeue=False)
self.assertEqual(incoming_message.body, body)
yield exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = yield queue.get(timeout=5)
with self.assertRaises(AssertionError):
with incoming_message.process(requeue=True,
reject_on_redelivered=True):
raise AssertionError
incoming_message = yield queue.get(timeout=5)
with self.assertRaises(AssertionError):
with incoming_message.process(requeue=True,
reject_on_redelivered=True):
raise AssertionError
self.assertEqual(incoming_message.locked, True)
yield queue.unbind(exchange, routing_key)
