def test_get(self): conn = Connection('localhost', io_loop=self.io_loop) ch = None test_msg = Message('test') def on_msg(msg): global ch assert msg.body == 'test' msg.ack() ch.get('test_queue', on_missing_msg) def on_missing_msg(msg): assert msg is None conn.close(self.stop) def on_connect(): global ch ch = conn.channel() ch.exchange_declare('test_exchange', durable=False) ch.queue_delete('test_queue') ch.queue_declare('test_queue', durable=False) ch.queue_bind('test_queue', 'test_exchange', 'test') ch.publish(test_msg, exchange='test_exchange', routing_key='test') ch.get('test_queue', on_msg) conn.connect(on_connect) self.wait()
def test_consume(self): global count conn = Connection('localhost', io_loop=self.io_loop) test_msg = Message('test') count = 0 def clean_up(): assert not ch.consumers conn.close(self.stop) def consume_callback(msg): global ch, count, consumer count += 1 assert msg.body == 'test', msg.body if count == 50: consumer.cancel(clean_up) def on_connect(): global ch, consumer ch = conn.channel() ch.exchange_declare('test_exchange', durable=False) ch.queue_delete('test_queue') ch.queue_declare('test_queue', durable=False) ch.queue_bind('test_queue', 'test_exchange', 'test') for _ in xrange(50): ch.publish(test_msg, exchange='test_exchange', routing_key='test') consumer = Consumer(consume_callback) ch.consume('test_queue', consumer, no_ack=True) conn.connect(on_connect) self.wait()
def test_handshake(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.assertEquals(conn.status, status.OPENED) conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_heartbeat(self): conn = Connection('localhost', heartbeat=1, io_loop=self.io_loop) def clean_up(): conn.status == status.OPENED conn.close(self.stop) conn.connect(lambda: None) self.io_loop.add_timeout(time.time() + 4, clean_up) self.wait()
def _start_new_connect(self): self.conn = Connection(self.Queue_Server, username=self.Queue_User, password=self.Queue_PassWord, vhost=self.Queue_Path, port=self.Queue_Port, io_loop=tornado.ioloop.IOLoop.instance()) self.conn.on_disconnect = self.on_queue_disconnect self.conn.on_error = self.on_queue_error self.conn.connect(self.on_connect)
def test_open(self): conn = Connection('localhost', io_loop=self.io_loop) def clean_up(**kargs): conn.close(self.stop) def on_connect(): ch = conn.channel(callback=clean_up) conn.connect(on_connect) self.wait()
def test_publish(self): conn = Connection('localhost', io_loop=self.io_loop) test_msg = Message('test') def on_connect(): ch = conn.channel() ch.exchange_declare('test_exchange', durable=False) ch.publish(test_msg, exchange='test_exchange', routing_key='test') conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_channel_flow(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel() self.ch.flow(active=False, callback=cleanup) def cleanup(): conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_reliable_publishing(self): test_msg = Message('test') conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): ch = conn.channel() ch.exchange_declare('test_imm', durable=False) ch.on_error = lambda: None ch.select() ch.publish(test_msg, exchange='test_imm') ch.commit(lambda: conn.close(self.stop)) conn.connect(on_connect) self.wait()
def test_close(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel(callback=on_channel) def on_channel(): self.ch.close(when_channel_close) def when_channel_close(): try: self.ch.get('foo', callback=lambda msg: None) except AmqpStatusError, e: clean_up() else:
def test_conn_error(self): conn = Connection('localhost', io_loop=self.io_loop) def send_wrong_method(): tune = Tune(frame_max=0, channel_max=0, heartbeat=0) conn.send_method(tune, callback=done) def done(conn_error): assert conn_error.method == Tune, repr(conn_error.method) assert conn_error.reply_code == 'CHANNEL_ERROR' assert conn.status == status.CLOSED self.stop() conn.on_error = done conn.connect(send_wrong_method) self.wait()
def test_channel_error(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel() self.ch.on_error = on_error self.ch.queue_bind('foo', 'bar') def on_error(ch_error): assert ch_error.method == queue.Bind, ch_error.method assert ch_error.reply_code == 'NOT_FOUND' assert self.ch.status == status.CLOSED conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_queue(self): conn = Connection('localhost', io_loop=self.io_loop) def on_creation(qinfo): assert qinfo.queue == 'test_queue' assert qinfo.message_count == 0 assert qinfo.consumer_count == 0 def on_connect(): ch = conn.channel() ch.queue_delete('test_queue') ch.queue_declare('test_queue', durable=False, callback=on_creation) conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_heartbeat_server_disconnected(self): conn = Connection('localhost', io_loop=self.io_loop) def clean_up(): conn.status == status.CLOSED self.stop() conn.on_disconnect = clean_up def launch_heartbeat(): conn.heartbeat = 1 HeartbeatMonitor(conn).start() conn.connect(launch_heartbeat) self.io_loop.add_timeout(time.time() + 3, clean_up) self.wait()
def test_basic_return(self): test_msg = Message('test') conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): ch = conn.channel() ch.on_return = on_return ch.exchange_declare('test_mand', durable=False) ch.publish(test_msg, exchange='test_mand', mandatory=True) def on_return(msg): rx = msg.rx_data assert rx.reply_code == 312, rx.reply_code # NO_ROUTE assert rx.exchange == 'test_mand', rx.exchange_declare conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_nack(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel() self.ch.exchange_declare('test_exchange', durable=False) self.ch.queue_delete('test_queue') self.ch.queue_declare('test_queue', durable=True) self.ch.qos(prefetch_count=49) self.ch.queue_bind('test_queue', 'test_exchange', 'test') for i in xrange(50): msg = Message('test %d' % i) self.ch.publish(msg, exchange='test_exchange', routing_key='test') consumer = Consumer(consume_callback) self.ch.consume('test_queue', consumer, no_ack=False) def consume_callback(msg): if msg.body == 'test 20': msg.ack() if msg.body == 'test 49': msg.nack(multiple=True) self.ch.close() on_channel_closed() msgs = [] def on_channel_closed(): self.ch2 = conn.channel() for i in xrange(49): self.ch2.get('test_queue', lambda msg: msgs.append(msg)) self.ch2.get('test_queue', check_and_clean_up) def check_and_clean_up(msg): msgs.append(msg) good_msgs = [m for m in msgs if m is not None] assert len(good_msgs) == 49, len(good_msgs) conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_queue_unbind(self): conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel() self.ch.queue_delete('test_unbind_queue') self.ch.queue_declare('test_unbind_queue', auto_delete=True) self.ch.exchange_declare('test_unbind_exchange', durable=False) self.ch.queue_bind(queue='test_unbind_queue', exchange='test_unbind_exchange', callback=on_binded) def on_binded(): self.ch.queue_unbind(queue='test_unbind_queue', exchange='test_unbind_exchange', callback=on_unbinded) def on_unbinded(): conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_purge_queue(self): test_msg = Message('test') conn = Connection('localhost', io_loop=self.io_loop) def on_connect(): self.ch = conn.channel() self.ch.queue_delete('test_queue') self.ch.queue_declare('test_purge_queue', auto_delete=True) self.ch.exchange_declare('test_purge_exchange', durable=False) self.ch.queue_bind(queue='test_purge_queue', exchange='test_purge_exchange') self.ch.queue_purge('test_purge_queue') for _ in xrange(3): self.ch.publish(test_msg, exchange='test_purge_exchange') self.ch.queue_purge('test_purge_queue', purged) def purged(msg_count): assert msg_count == 3, msg_count conn.close(self.stop) conn.connect(on_connect) self.wait()
def test_channel_id_rollover(self): global count conn = Connection('localhost', io_loop=self.io_loop) count = 0 def next_channel(): global count count += 1 self.ch = conn.channel() if (count < 70000): self.ch.close(callback=next_channel) else: self.ch.close(callback=cleanup) def on_connect(): next_channel() def cleanup(): conn.close(self.stop) conn.connect(on_connect) self.wait(timeout=300)
def test_publish_huge(self): conn = Connection('localhost', io_loop=self.io_loop) msg = "test message" * 151343 test_msg = Message(msg) def on_connect(): ch = conn.channel() def callback(msg): conn.close(self.stop) def on_creation(q): ch.publish(test_msg, exchange='test_exchange', routing_key='test') ch.consume(q.queue, callback) ch.exchange_declare('test_exchange', durable=False) ch.queue_delete('test_queue') ch.queue_declare('test_queue', durable=False, callback=on_creation) ch.queue_bind('test_queue', 'test_exchange', 'test') conn.connect(on_connect) self.wait(timeout=1)
def test_heartbeat_client_disconnected(self): conn = Connection('localhost', heartbeat=1, io_loop=self.io_loop) conn.process_heartbeat = lambda hb: None conn.on_disconnect = self.stop conn.connect(lambda: None) self.wait()