def test_queue_delete(self): """ Test that messages in a queue being deleted are delivered to the alternate-exchange if specified """ session = self.session #set up a 'dead letter queue': dlq = self.setup_dlq() #create a queue using the dlq as its alternate exchange: session.queue_declare(queue="delete-me", alternate_exchange="dlq") #send it some messages: dp = self.session.delivery_properties(routing_key="delete-me") session.message_transfer(message=Message(dp, "One")) session.message_transfer(message=Message(dp, "Two")) session.message_transfer(message=Message(dp, "Three")) #delete it: session.queue_delete(queue="delete-me") #delete the dlq exchange: session.exchange_delete(exchange="dlq") #check the messages were delivered to the dlq: self.assertEqual("One", dlq.get(timeout=1).body) self.assertEqual("Two", dlq.get(timeout=1).body) self.assertEqual("Three", dlq.get(timeout=1).body) self.assertEmpty(dlq)
def test_ack_and_no_ack(self): """ First, this test tries to receive a message with a no-ack consumer. Second, this test tries to explicitly receive and acknowledge a message with an acknowledging consumer. """ session = self.session session.queue_declare(queue = "myqueue", exclusive=True, auto_delete=True) # No ack consumer ctag = "tag1" session.message_subscribe(queue = "myqueue", destination = ctag) session.message_flow(destination=ctag, unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination=ctag, unit=session.credit_unit.byte, value=0xFFFFFFFFL) body = "test no-ack" session.message_transfer(message=Message(session.delivery_properties(routing_key="myqueue"), body)) msg = session.incoming(ctag).get(timeout = 5) self.assert_(msg.body == body) # Acknowledging consumer session.queue_declare(queue = "otherqueue", exclusive=True, auto_delete=True) ctag = "tag2" session.message_subscribe(queue = "otherqueue", destination = ctag, accept_mode = 1) session.message_flow(destination=ctag, unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination=ctag, unit=session.credit_unit.byte, value=0xFFFFFFFFL) body = "test ack" session.message_transfer(message=Message(session.delivery_properties(routing_key="otherqueue"), body)) msg = session.incoming(ctag).get(timeout = 5) session.message_accept(RangedSet(msg.id)) self.assert_(msg.body == body)
def test_unroutable(self): """ Test that unroutable messages are delivered to the alternate-exchange if specified """ session = self.session #create an exchange with an alternate defined session.exchange_declare(exchange="secondary", type="fanout") session.exchange_declare(exchange="primary", type="direct", alternate_exchange="secondary") #declare, bind (to the alternate exchange) and consume from a queue for 'returned' messages session.queue_declare(queue="returns", exclusive=True, auto_delete=True) session.exchange_bind(queue="returns", exchange="secondary") session.message_subscribe(destination="a", queue="returns") session.message_flow(destination="a", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="a", unit=session.credit_unit.byte, value=0xFFFFFFFFL) returned = session.incoming("a") #declare, bind (to the primary exchange) and consume from a queue for 'processed' messages session.queue_declare(queue="processed", exclusive=True, auto_delete=True) session.exchange_bind(queue="processed", exchange="primary", binding_key="my-key") session.message_subscribe(destination="b", queue="processed") session.message_flow(destination="b", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="b", unit=session.credit_unit.byte, value=0xFFFFFFFFL) processed = session.incoming("b") #publish to the primary exchange #...one message that makes it to the 'processed' queue: dp = self.session.delivery_properties(routing_key="my-key") session.message_transfer(destination="primary", message=Message(dp, "Good")) #...and one that does not: dp = self.session.delivery_properties(routing_key="unused-key") session.message_transfer(destination="primary", message=Message(dp, "Bad")) #delete the exchanges session.exchange_delete(exchange="primary") session.exchange_delete(exchange="secondary") #verify behaviour self.assertEqual("Good", processed.get(timeout=1).body) self.assertEqual("Bad", returned.get(timeout=1).body) self.assertEmpty(processed) self.assertEmpty(returned)
def test_purge(self): """ Test that the purge method removes messages from the queue """ session = self.session #setup, declare a queue and add some messages to it: session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True) session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "one")) session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "two")) session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "three")) #check that the queue now reports 3 messages: session.queue_declare(queue="test-queue") reply = session.queue_query(queue="test-queue") self.assertEqual(3, reply.message_count) #now do the purge, then test that three messages are purged and the count drops to 0 session.queue_purge(queue="test-queue"); reply = session.queue_query(queue="test-queue") self.assertEqual(0, reply.message_count) #send a further message and consume it, ensuring that the other messages are really gone session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "four")) session.message_subscribe(queue="test-queue", destination="tag") session.message_flow(destination="tag", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="tag", unit=session.credit_unit.byte, value=0xFFFFFFFFL) queue = session.incoming("tag") msg = queue.get(timeout=1) self.assertEqual("four", msg.body)
def testDurableBindings(self): try: self.ssn.exchange_unbind(queue="DB_Q1", exchange="DB_E1", binding_key="K1") except: self.start_session() try: self.ssn.exchange_delete(exchange="DB_E1") except: self.start_session() try: self.ssn.queue_delete(queue="DB_Q1") except: self.start_session() self.ssn.queue_declare(queue="DB_Q1", durable=True) self.ssn.exchange_declare(exchange="DB_E1", type="direct", durable=True) self.ssn.exchange_bind(exchange="DB_E1", queue="DB_Q1", binding_key="K1") # Queue up 2 messages, one with non-zero body, one with zero-length. # 2 = delivery_mode.persistent dp = self.ssn.delivery_properties(routing_key="DB_Q1", delivery_mode=2) self.ssn.message_transfer(message=Message(dp, "normal message")) self.ssn.message_transfer(message=Message(dp, "")) # Cycle the broker and make sure the binding recovers self.cycle_broker() response = self.ssn.exchange_bound(exchange="DB_E1", queue="DB_Q1", binding_key="K1") self.assert_(not response.exchange_not_found) self.assert_(not response.queue_not_found) self.assert_(not response.queue_not_matched) self.assert_(not response.key_not_matched) # Are the messages still there? self.ssn.message_subscribe(destination="msgs", queue="DB_Q1", accept_mode=1, acquire_mode=0) self.ssn.message_flow(unit=1, value=0xFFFFFFFFL, destination="msgs") self.ssn.message_flow(unit=0, value=10, destination="msgs") message_arrivals = self.ssn.incoming("msgs") try: message_arrivals.get(timeout=1) message_arrivals.get(timeout=1) except Empty: assert False, 'Durable message(s) not recovered' self.ssn.exchange_unbind(queue="DB_Q1", exchange="DB_E1", binding_key="K1") self.ssn.exchange_delete(exchange="DB_E1") self.ssn.queue_delete(queue="DB_Q1")
def test_queue_autodelete(self): """ Test that messages in a queue being auto-deleted are delivered to the alternate-exchange if specified, including messages that are acquired but not accepted """ session = self.session #set up a 'dead letter queue': session.exchange_declare(exchange="dlq", type="fanout") session.queue_declare(queue="deleted", exclusive=True, auto_delete=True) session.exchange_bind(exchange="dlq", queue="deleted") session.message_subscribe(destination="dlq", queue="deleted") session.message_flow(destination="dlq", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="dlq", unit=session.credit_unit.byte, value=0xFFFFFFFFL) dlq = session.incoming("dlq") #on a separate session, create an auto-deleted queue using the #dlq as its alternate exchange (handling of auto-delete is #different for exclusive and non-exclusive queues, so test #both modes): for mode in [True, False]: session2 = self.conn.session("another-session") session2.queue_declare(queue="my-queue", alternate_exchange="dlq", exclusive=mode, auto_delete=True) #send it some messages: dp = session2.delivery_properties(routing_key="my-queue") session2.message_transfer(message=Message(dp, "One")) session2.message_transfer(message=Message(dp, "Two")) session2.message_transfer(message=Message(dp, "Three")) session2.message_subscribe(destination="incoming", queue="my-queue") session2.message_flow(destination="incoming", unit=session.credit_unit.message, value=1) session2.message_flow(destination="incoming", unit=session.credit_unit.byte, value=0xFFFFFFFFL) self.assertEqual("One", session2.incoming("incoming").get(timeout=1).body) session2.close() #check the messages were delivered to the dlq: self.assertEqual("One", dlq.get(timeout=1).body) self.assertEqual("Two", dlq.get(timeout=1).body) self.assertEqual("Three", dlq.get(timeout=1).body) self.assertEmpty(dlq)
def message_transfer(self, cmd): if cmd.destination == "echo": m = Message(cmd.payload) m.headers = cmd.headers self.session.message_transfer(cmd.destination, cmd.accept_mode, cmd.acquire_mode, m) elif cmd.destination == "abort": self.session.channel.connection.sock.close() elif cmd.destination == "heartbeat": self.session.channel.connection_heartbeat() else: self.queue.put(cmd)
def unbind_test(self, exchange, routing_key="", args=None, headers=None): #bind two queues and consume from them session = self.session session.queue_declare(queue="queue-1", exclusive=True, auto_delete=True) session.queue_declare(queue="queue-2", exclusive=True, auto_delete=True) session.message_subscribe(queue="queue-1", destination="queue-1") session.message_flow(destination="queue-1", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="queue-1", unit=session.credit_unit.byte, value=0xFFFFFFFFL) session.message_subscribe(queue="queue-2", destination="queue-2") session.message_flow(destination="queue-2", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="queue-2", unit=session.credit_unit.byte, value=0xFFFFFFFFL) queue1 = session.incoming("queue-1") queue2 = session.incoming("queue-2") session.exchange_bind(exchange=exchange, queue="queue-1", binding_key=routing_key, arguments=args) session.exchange_bind(exchange=exchange, queue="queue-2", binding_key=routing_key, arguments=args) dp = session.delivery_properties(routing_key=routing_key) if (headers): mp = session.message_properties(application_headers=headers) msg1 = Message(dp, mp, "one") msg2 = Message(dp, mp, "two") else: msg1 = Message(dp, "one") msg2 = Message(dp, "two") #send a message that will match both bindings session.message_transfer(destination=exchange, message=msg1) #unbind first queue session.exchange_unbind(exchange=exchange, queue="queue-1", binding_key=routing_key) #send another message session.message_transfer(destination=exchange, message=msg2) #check one queue has both messages and the other has only one self.assertEquals("one", queue1.get(timeout=1).body) try: msg = queue1.get(timeout=1) self.fail("Got extra message: %s" % msg.body) except Empty: pass self.assertEquals("one", queue2.get(timeout=1).body) self.assertEquals("two", queue2.get(timeout=1).body) try: msg = queue2.get(timeout=1) self.fail("Got extra message: " + msg) except Empty: pass
def test_reroute_priority_queue(self): self.startQmf() session = self.session #setup test queue supporting multiple priority levels session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True, arguments={'x-qpid-priorities':10}) #send some messages of varying priority to that queue: for i in range(0, 5): deliveryProps = session.delivery_properties(routing_key="test-queue", priority=i+5) session.message_transfer(message=Message(deliveryProps, "Message %d" % (i+1))) #declare and bind a queue to amq.fanout through which rerouted #messages can be verified: session.queue_declare(queue="rerouted", exclusive=True, auto_delete=True, arguments={'x-qpid-priorities':10}) session.exchange_bind(queue="rerouted", exchange="amq.fanout") #reroute messages from test queue to amq.fanout (and hence to #rerouted queue): pq = self.qmf.getObjects(_class="queue", name="test-queue")[0] result = pq.reroute(0, False, "amq.fanout", {}) self.assertEqual(result.status, 0) #verify messages are all rerouted: self.subscribe(destination="incoming", queue="rerouted") incoming = session.incoming("incoming") for i in range(0, 5): msg = incoming.get(timeout=1) self.assertEqual("Message %d" % (5-i), msg.body)
def test_reroute_alternate_exchange(self): """ Test that when rerouting, the alternate-exchange is considered if relevant """ self.startQmf() session = self.session # 1. Create 2 exchanges A and B (fanout) where B is the # alternate exchange for A session.exchange_declare(exchange="B", type="fanout") session.exchange_declare(exchange="A", type="fanout", alternate_exchange="B") # 2. Bind queue X to B session.queue_declare(queue="X", exclusive=True, auto_delete=True) session.exchange_bind(queue="X", exchange="B") # 3. Send 1 message to queue Y session.queue_declare(queue="Y", exclusive=True, auto_delete=True) props = session.delivery_properties(routing_key="Y") session.message_transfer(message=Message(props, "reroute me!")) # 4. Call reroute on queue Y and specify that messages should # be sent to exchange A y = self.qmf.getObjects(_class="queue", name="Y")[0] result = y.reroute(1, False, "A", {}) self.assertEqual(result.status, 0) # 5. verify that the message is rerouted through B (as A has # no matching bindings) to X self.subscribe(destination="x", queue="X") self.assertEqual("reroute me!", session.incoming("x").get(timeout=1).body) # Cleanup for e in ["A", "B"]: session.exchange_delete(exchange=e)
def test_queue_deletion(self): session = self.session session.queue_declare(queue = "durable-subscriber-queue", exclusive=True, durable=True) session.exchange_bind(exchange="amq.topic", queue="durable-subscriber-queue", binding_key="xyz") dp = session.delivery_properties(routing_key="xyz", delivery_mode=2) session.message_transfer(destination="amq.topic", message=Message(dp, "my-message")) session.queue_delete(queue = "durable-subscriber-queue")
def test_connection_stats(self): """ Test message in/out stats for connection """ agent = self.setup_access() conn = self.connect() session = conn.session("stats-session") #using qmf find named session and the corresponding connection: conn_qmf = None sessions = agent.getAllSessions() for s in sessions: if s.name == "stats-session": conn_qmf = agent.getConnection(s.connectionRef) assert(conn_qmf) #send a message to a queue session.queue_declare(queue="stats-q", exclusive=True, auto_delete=True) session.message_transfer(message=Message(session.delivery_properties(routing_key="stats-q"), "abc")) #check the 'msgs sent from' stat for this connection conn_qmf.update() self.assertEqual(conn_qmf.msgsFromClient, 1) #receive message from queue session.message_subscribe(destination="d", queue="stats-q") incoming = session.incoming("d") incoming.start() self.assertEqual("abc", incoming.get(timeout=1).body) #check the 'msgs sent to' stat for this connection conn_qmf.update() self.assertEqual(conn_qmf.msgsToClient, 1)
def test_queue_delete_loop(self): """ Test that if a queue is bound to its own alternate exchange, then on deletion there is no infinite looping """ session = self.session dlq = self.setup_dlq() #create a queue using the dlq as its alternate exchange: session.queue_declare(queue="delete-me", alternate_exchange="dlq") #bind that queue to the dlq as well: session.exchange_bind(exchange="dlq", queue="delete-me") #send it some messages: dp = self.session.delivery_properties(routing_key="delete-me") for m in ["One", "Two", "Three"]: session.message_transfer(message=Message(dp, m)) #delete it: session.queue_delete(queue="delete-me") #cleanup: session.exchange_delete(exchange="dlq") #check the messages were delivered to the dlq: for m in ["One", "Two", "Three"]: self.assertEqual(m, dlq.get(timeout=1).body) self.assertEmpty(dlq)
def testSync(self): c = self.connect() c.start(10) s = c.session("test") s.auto_sync = False s.message_transfer("echo", message=Message("test")) s.sync(10)
def test_delete_simple(self): """ Test core queue deletion behaviour """ session = self.session #straight-forward case: session.queue_declare(queue="delete-me") session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "a")) session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "b")) session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "c")) session.queue_delete(queue="delete-me") #check that it has gone by declaring passively try: session.queue_declare(queue="delete-me", passive=True) self.fail("Queue has not been deleted") except SessionException, e: self.assertEquals(404, e.args[0].error_code)
def send_message(self, topic, message, **headers): headers['routing_key'] = headers.get('routing_key', topic) props = self.session.delivery_properties(**headers) msg = Message(props, message) self.session.message_transfer(destination=headers.get( 'exchange', 'amq.topic'), message=msg) super(QpidAMQPHubExtension, self).send_message(topic, message, **headers)
def send(self, routing_key, msg_text): propDelivery = self.__session.delivery_properties( routing_key = routing_key.__str__(), exchange = self.__exchange ) contentType = 'application/x-protobuf' propMessage = self.__session.message_properties( content_type = contentType) self.__session.message_transfer(destination = self.__exchange, message = Message(propDelivery, propMessage, msg_text))
def sendmessage(self, filepath, header): ''' This function sends a message to the external.dropbox queue providing the path to the file to be ingested and a header to determine the plugin to be used to decode the file. @param filepath: string full path to file to be ingested @param header: string header used to determine plugin decoder to use ''' props = self.session.delivery_properties(routing_key='external.dropbox') head = self.session.message_properties(application_headers={'header':header}, user_id=QPID_USERNAME) # For issue QPID-5569. Fixed in Qpid 0.27 self.session.message_transfer(destination='amq.direct', message=Message(props, head, filepath))
def assertPublishGet(self, queue, exchange="", routing_key="", properties=None): """ Publish to exchange and assert queue.get() returns the same message. """ body = self.uniqueString() dp=self.session.delivery_properties(routing_key=routing_key) mp=self.session.message_properties(application_headers=properties) self.session.message_transfer(destination=exchange, message=Message(dp, mp, body)) msg = queue.get(timeout=1) self.assertEqual(body, msg.body) if (properties): self.assertEqual(properties, self.getApplicationHeaders(msg))
def test(self): c = self.connect() c.start(10) ssn1 = c.session("test1", timeout=10) ssn2 = c.session("test2", timeout=10) assert ssn1 == c.sessions["test1"] assert ssn2 == c.sessions["test2"] assert ssn1.channel != None assert ssn2.channel != None assert ssn1 in c.attached.values() assert ssn2 in c.attached.values() ssn1.close(5) assert ssn1.channel == None assert ssn1 not in c.attached.values() assert ssn2 in c.sessions.values() ssn2.close(5) assert ssn2.channel == None assert ssn2 not in c.attached.values() assert ssn2 not in c.sessions.values() ssn = c.session("session", timeout=10) assert ssn.channel != None assert ssn in c.sessions.values() destinations = ("one", "two", "three") for d in destinations: ssn.message_transfer(d) for d in destinations: cmd = self.queue.get(10) assert cmd.destination == d assert cmd.headers == None assert cmd.payload == None msg = Message("this is a test") ssn.message_transfer("four", message=msg) cmd = self.queue.get(10) assert cmd.destination == "four" assert cmd.headers == None assert cmd.payload == msg.body qq = ssn.queue_query("asdf") assert qq.queue == "asdf" c.close(5)
def send_message(connection, notif): session = connection.session(str(uuid4())) props = session.delivery_properties(routing_key=TOPIC_NAME) head = session.message_properties( application_headers={ 'sender': notif.sender, 'response': notif.response }, user_id=QPID_USERNAME) # For issue QPID-5569. Fixed in Qpid 0.27 session.message_transfer(destination=DESTINATION, message=Message(props, head, notif.messageId)) session.close(timeout=10) connection.close()
def test_delete_queue_after_publish(self): session = self.session session.auto_sync = False #create queue session.queue_declare(queue = "q", auto_delete=True, durable=True) #send message for i in range(1, 10): dp = session.delivery_properties(routing_key="q", delivery_mode=2) session.message_transfer(message=Message(dp, "my-message")) session.auto_sync = True #explicitly delete queue session.queue_delete(queue = "q")
def test_reject_no_match(self): """ Test that on rejecting a message, if the queues own alternate exchange cannot find a match for the message, the alternate-exchange of that exchange will be tried. Note: though the spec rules out going to the alternate-exchanges alternate exchange when sending to an exchange, it does not cover this case. """ session = self.session dlq = self.setup_dlq() #setu up an 'intermediary' exchange session.exchange_declare(exchange="my-exchange", type="direct", alternate_exchange="dlq") #create a queue using the intermediary as its alternate exchange: session.queue_declare(queue="delivery-queue", alternate_exchange="my-exchange", auto_delete=True) #send it some messages: dp = self.session.delivery_properties(routing_key="delivery-queue") for m in ["One", "Two", "Three"]: session.message_transfer(message=Message(dp, m)) #get and reject those messages: session.message_subscribe(destination="a", queue="delivery-queue") session.message_flow(destination="a", unit=session.credit_unit.message, value=0xFFFFFFFFL) session.message_flow(destination="a", unit=session.credit_unit.byte, value=0xFFFFFFFFL) incoming = session.incoming("a") for m in ["One", "Two", "Three"]: msg = incoming.get(timeout=1) self.assertEqual(m, msg.body) session.message_reject(RangedSet(msg.id)) session.message_cancel(destination="a") #check the messages were delivered to the dlq: for m in ["One", "Two", "Three"]: self.assertEqual(m, dlq.get(timeout=1).body) self.assertEmpty(dlq) #cleanup: session.exchange_delete(exchange="my-exchange") session.exchange_delete(exchange="dlq")
def test_delete_ifempty(self): """ Test that if_empty field of queue_delete is honoured """ session = self.session #create a queue and add a message to it (use default binding): session.queue_declare(queue="delete-me-2") session.queue_declare(queue="delete-me-2", passive=True) session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me-2"), "message")) #try to delete, but only if empty: try: session.queue_delete(queue="delete-me-2", if_empty=True) self.fail("Expected delete if_empty to fail for non-empty queue") except SessionException, e: self.assertEquals(406, e.args[0].error_code)
def test_simple_delivery_immediate(self): """ Test simple message delivery where consume is issued before publish """ session = self.session session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True) session.exchange_bind(queue="test-queue", exchange="amq.fanout") consumer_tag = "tag1" session.message_subscribe(queue="test-queue", destination=consumer_tag) session.message_flow(unit = session.credit_unit.message, value = 0xFFFFFFFFL, destination = consumer_tag) session.message_flow(unit = session.credit_unit.byte, value = 0xFFFFFFFFL, destination = consumer_tag) queue = session.incoming(consumer_tag) body = "Immediate Delivery" session.message_transfer("amq.fanout", None, None, Message(body)) msg = queue.get(timeout=5) self.assert_(msg.body == body)
def swap(self, session, src, dest): #consume from src: session.message_subscribe(destination="temp-swap", queue=src) session.message_flow(destination="temp-swap", unit=session.credit_unit.message, value=1) session.message_flow(destination="temp-swap", unit=session.credit_unit.byte, value=0xFFFFFFFFL) msg = session.incoming("temp-swap").get(timeout=1) session.message_cancel(destination="temp-swap") session.message_accept(RangedSet(msg.id)) #todo: also complete at this point? #re-publish to dest: dp = session.delivery_properties(routing_key=dest) mp = session.message_properties( correlation_id=self.getMessageProperty(msg, 'correlation_id')) session.message_transfer(message=Message(dp, mp, msg.body))
def txswap(self, tx, id): session = self.session #declare two queues: session.queue_declare(queue="queue-a", auto_delete=True) session.queue_declare(queue="queue-b", auto_delete=True) #put message with specified id on one queue: dp = session.delivery_properties(routing_key="queue-a") mp = session.message_properties(correlation_id=id) session.message_transfer(message=Message(dp, mp, "DtxMessage")) #start the transaction: session.dtx_select() self.assertEqual(self.XA_OK, self.session.dtx_start(xid=tx).status) #'swap' the message from one queue to the other, under that transaction: self.swap(self.session, "queue-a", "queue-b") #mark the end of the transactional work: self.assertEqual(self.XA_OK, self.session.dtx_end(xid=tx).status)
def test_purge_queue(self): """ Test ability to purge messages from the head of a queue. Need to test moveing all, 1 (top message) and N messages. """ self.startQmf() session = self.session "Set up purge queue" session.queue_declare(queue="purge-queue", exclusive=True, auto_delete=True) session.exchange_bind(queue="purge-queue", exchange="amq.direct", binding_key="routing_key") twenty = range(1, 21) props = session.delivery_properties(routing_key="routing_key") for count in twenty: body = "Purge Message %d" % count msg = Message(props, body) session.message_transfer(destination="amq.direct", message=msg) pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0] "Purge top message from purge-queue" result = pq.purge(1, {}) self.assertEqual(result.status, 0) pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0] self.assertEqual(pq.msgDepth, 19) "Purge top 9 messages from purge-queue" result = pq.purge(9, {}) self.assertEqual(result.status, 0) pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0] self.assertEqual(pq.msgDepth, 10) "Purge all messages from purge-queue" result = pq.purge(0, {}) self.assertEqual(result.status, 0) pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0] self.assertEqual(pq.msgDepth, 0)
def testCloseGet(self): c = self.connect() c.start(10) ssn = c.session("test", timeout=10) echos = ssn.incoming("echo") for i in range(10): ssn.message_transfer("echo", message=Message("test%d" % i)) ssn.auto_sync = False ssn.message_transfer("abort") for i in range(10): m = echos.get(timeout=10) assert m.body == "test%d" % i try: m = echos.get(timeout=10) assert False except Closed, e: pass
def test_ack_message_from_deleted_queue(self): session = self.session session.auto_sync = False #create queue session.queue_declare(queue = "q", auto_delete=True, durable=True) #send message dp = session.delivery_properties(routing_key="q", delivery_mode=2) session.message_transfer(message=Message(dp, "my-message")) #create consumer session.message_subscribe(queue = "q", destination = "a", accept_mode = 1, acquire_mode=0) session.message_flow(unit = session.credit_unit.byte, value = 0xFFFFFFFFL, destination = "a") session.message_flow(unit = session.credit_unit.message, value = 10, destination = "a") queue = session.incoming("a") #consume the message, cancel subscription (triggering auto-delete), then ack it msg = queue.get(timeout = 5) session.message_cancel(destination = "a") session.message_accept(RangedSet(msg.id))