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_unexpected_channel_close(self):
client = yield self.create_connection()
channel = yield client.channel()
with self.assertRaises(ChannelClosed):
yield channel.declare_queue("amq.restricted_queue_name",
auto_delete=True)
yield wait((client.close(), client.closing))
def test_declaration_result(self):
client = yield self.create_connection()
channel = yield client.channel()
queue = yield channel.declare_queue(auto_delete=True)
self.assertEqual(queue.declaration_result.message_count, 0)
self.assertEqual(queue.declaration_result.consumer_count, 0)
yield wait((client.close(), client.closing))
def test_queue_empty_fail_false(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)
result = yield queue.get(fail=False)
self.assertIsNone(result)
yield queue.delete()
yield wait((client.close(), client.closing))
def test_declaration_result_with_consumers(self):
client = yield self.create_connection()
channel1 = yield client.channel()
queue_name = self.get_random_name("queue", "declaration-result")
queue1 = yield channel1.declare_queue(queue_name, auto_delete=True)
yield queue1.consume(print)
channel2 = yield client.channel()
queue2 = yield channel2.declare_queue(queue_name, passive=True)
self.assertEqual(queue2.declaration_result.consumer_count, 1)
yield wait((client.close(), client.closing))
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_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_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_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_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))
