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))