def test_ack_client_individual(self):
destination = "/queue/ack-test-individual"
# subscribe and send message
self.listener.reset(2) ## expecting 2 messages
self.subscribe_dest(self.conn, destination, None,
ack='client-individual',
headers={'prefetch-count': '10'})
self.conn.send(destination, "test1")
self.conn.send(destination, "test2")
self.assertTrue(self.listener.wait(4), "Both initial messages not received")
self.assertEquals(2, len(self.listener.messages))
# disconnect without acks
self.conn.disconnect()
# now reconnect
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
listener2.reset(2) ## expect 2 messages
conn2.set_listener('', listener2)
self.subscribe_dest(conn2, destination, None,
ack='client-individual',
headers={'prefetch-count': '10'})
self.assertTrue(listener2.wait(2.5), "Did not receive 2 messages")
self.assertEquals(2, len(listener2.messages), "Not exactly 2 messages received")
# now ack only the 'test2' message - expecting individual behaviour
nummsgs = len(listener2.messages)
mid = None
for ind in range(nummsgs):
if listener2.messages[ind]['message']=="test2":
mid = listener2.messages[ind]['headers'][self.ack_id_source_header]
self.assertEquals(1, ind, 'Expecting test2 to be second message')
break
self.assertTrue(mid, "Did not find test2 message id.")
self.ack_message(conn2, mid, None)
finally:
conn2.disconnect()
# now reconnect again, shouldn't see the message
conn3 = self.create_connection()
try:
listener3 = base.WaitableListener()
listener3.reset(2) ## expecting a single message, but wait for two
conn3.set_listener('', listener3)
self.subscribe_dest(conn3, destination, None)
self.assertFalse(listener3.wait(2.5),
"Expected to see only one message. ACK not working?")
self.assertEquals(1, len(listener3.messages), "Expecting exactly one message")
self.assertEquals("test1", listener3.messages[0]['message'], "Unexpected message remains")
finally:
conn3.disconnect()
def test_ack_client(self):
destination = "/queue/ack-test"
# subscribe and send message
self.listener.reset(2) ## expecting 2 messages
self.subscribe_dest(self.conn,
destination,
None,
ack='client',
headers={'prefetch-count': '10'})
self.conn.send(destination, "test1")
self.conn.send(destination, "test2")
self.assertTrue(self.listener. await (4),
"initial message not received")
self.assertEquals(2, len(self.listener.messages))
# disconnect with no ack
self.conn.disconnect()
# now reconnect
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
listener2.reset(2)
conn2.set_listener('', listener2)
self.subscribe_dest(conn2,
destination,
None,
ack='client',
headers={'prefetch-count': '10'})
self.assertTrue(listener2. await (), "message not received again")
self.assertEquals(2, len(listener2.messages))
# now ack only the last message - expecting cumulative behaviour
mid = listener2.messages[1]['headers'][self.ack_id_source_header]
self.ack_message(conn2, mid, None)
finally:
conn2.disconnect()
# now reconnect again, shouldn't see the message
conn3 = self.create_connection()
try:
listener3 = base.WaitableListener()
conn3.set_listener('', listener3)
self.subscribe_dest(conn3, destination, None)
self.assertFalse(listener3. await (3),
"unexpected message. ACK not working?")
finally:
conn3.disconnect()
def test_implicit_connect(self):
''' Implicit connect with receipt on first command '''
self.conn.disconnect()
test_util.enable_implicit_connect()
listener = base.WaitableListener()
new_conn = stomp.Connection(
host_and_ports=[('localhost', int(os.environ["STOMP_PORT"]))])
new_conn.set_listener('', listener)
new_conn.transport.start()
self.subscribe_dest(new_conn,
"/topic/implicit",
'sub_implicit',
receipt='implicit')
try:
self.assertTrue(listener.wait(5))
self.assertEqual(1, len(listener.receipts),
'Missing receipt. Likely not connected')
self.assertEqual('implicit',
listener.receipts[0]['headers']['receipt-id'])
finally:
new_conn.disconnect()
test_util.disable_implicit_connect()
def test_redelivered(self):
destination = "/queue/redelivered-test"
# subscribe and send message
self.subscribe_dest(self.conn, destination, None, ack='client')
self.conn.send(destination, "test1")
message_receive_timeout = 30
self.assertTrue(self.listener.wait(message_receive_timeout), "Test message not received within {0} seconds".format(message_receive_timeout))
self.assertEquals(1, len(self.listener.messages))
self.assertEquals('false', self.listener.messages[0]['headers']['redelivered'])
# disconnect with no ack
self.conn.disconnect()
# now reconnect
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
listener2.reset(1)
conn2.set_listener('', listener2)
self.subscribe_dest(conn2, destination, None, ack='client')
self.assertTrue(listener2.wait(), "message not received again")
self.assertEquals(1, len(listener2.messages))
self.assertEquals('true', listener2.messages[0]['headers']['redelivered'])
finally:
conn2.disconnect()
def test_separate_ids(self):
destination = '/topic/durable-separate'
conn2 = self.create_connection()
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
try:
# ensure durable subscription exists for each ID
self.__subscribe(destination)
self.__assert_receipt()
self.__subscribe(destination, conn2, "other.id")
self.__assert_receipt(listener2)
self.unsubscribe_dest(self.conn, destination, TestDurableSubscription.ID)
self.unsubscribe_dest(conn2, destination, "other.id")
self.listener.reset(101)
listener2.reset(101) ## 100 messages and 1 receipt
# send 100 messages
for x in xrange(0, 100):
self.conn.send(destination, "msg" + str(x))
self.__subscribe(destination)
self.__subscribe(destination, conn2, "other.id")
for l in [self.listener, listener2]:
self.assertTrue(l.await(20))
self.assertEquals(100, len(l.messages))
finally:
conn2.disconnect()
def test_send_and_disconnect(self):
''' Test close socket after send does not lose messages '''
destination = "/queue/reliability"
pub_conn = self.create_connection()
try:
msg = "0" * (128)
count = 10000
listener = base.WaitableListener()
listener.reset(count)
self.conn.set_listener('', listener)
self.subscribe_dest(self.conn, destination, None)
for x in range(0, count):
pub_conn.send(destination, msg + str(x))
time.sleep(2.0)
pub_conn.disconnect()
if listener.wait(30):
self.assertEquals(count, len(listener.messages))
else:
listener.print_state("Final state of listener:")
self.fail("Did not receive %s messages in time" % count)
finally:
if pub_conn.is_connected():
pub_conn.disconnect()
def test_ack_client_tx(self):
destination = "/queue/ack-test-tx"
# subscribe and send message
self.listener.reset()
self.subscribe_dest(self.conn, destination, None, ack='client')
self.conn.send(destination, "test")
self.assertTrue(self.listener. await (3),
"initial message not received")
self.assertEquals(1, len(self.listener.messages))
# disconnect with no ack
self.conn.disconnect()
# now reconnect
conn2 = self.create_connection()
try:
tx = "abc"
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
conn2.begin(transaction=tx)
self.subscribe_dest(conn2, destination, None, ack='client')
self.assertTrue(listener2. await (), "message not received again")
self.assertEquals(1, len(listener2.messages))
# now ack
mid = listener2.messages[0]['headers'][self.ack_id_source_header]
self.ack_message(conn2, mid, None, transaction=tx)
#now commit
conn2.commit(transaction=tx)
finally:
conn2.disconnect()
# now reconnect again, shouldn't see the message
conn3 = self.create_connection()
try:
listener3 = base.WaitableListener()
conn3.set_listener('', listener3)
self.subscribe_dest(conn3, destination, None)
self.assertFalse(listener3. await (3),
"unexpected message. TX ACK not working?")
finally:
conn3.disconnect()
def test_ack_client_tx(self):
d = "/queue/ack-test-tx"
# subscribe and send message
self.listener.reset()
self.conn.subscribe(destination=d, ack='client')
self.conn.send("test", destination=d)
self.assertTrue(self.listener. await (3),
"initial message not received")
self.assertEquals(1, len(self.listener.messages))
# disconnect with no ack
self.conn.disconnect()
# now reconnect
conn2 = self.create_connection()
try:
tx = "abc"
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
conn2.begin(transaction=tx)
conn2.subscribe(destination=d, ack='client')
self.assertTrue(listener2. await (), "message not received again")
self.assertEquals(1, len(listener2.messages))
# now ack
mid = listener2.messages[0]['headers']['message-id']
conn2.ack({'message-id': mid, 'transaction': tx})
#now commit
conn2.commit(transaction=tx)
finally:
conn2.stop()
# now reconnect again, shouldn't see the message
conn3 = self.create_connection()
try:
listener3 = base.WaitableListener()
conn3.set_listener('', listener3)
conn3.subscribe(destination=d)
self.assertFalse(listener3. await (3),
"unexpected message. TX ACK not working?")
finally:
conn3.stop()
def bad_connect(self, new_conn, expected):
self.conn.disconnect()
listener = base.WaitableListener()
new_conn.set_listener('', listener)
try:
new_conn.start()
new_conn.connect()
self.assertTrue(listener. await ())
self.assertEquals(expected, listener.errors[0]['message'])
finally:
if new_conn.is_connected():
new_conn.disconnect()
def bad_connect(self, expected, user='******', passcode='guest', **kwargs):
self.conn.disconnect()
new_conn = self.create_connection_obj(**kwargs)
listener = base.WaitableListener()
new_conn.set_listener('', listener)
try:
new_conn.connect(user, passcode)
self.assertTrue(listener.wait())
self.assertEqual(expected, listener.errors[0]['message'])
finally:
if new_conn.is_connected():
new_conn.disconnect()
def test_default_user(self):
''' Default user connection '''
self.conn.disconnect()
test_util.enable_default_user()
listener = base.WaitableListener()
new_conn = stomp.Connection(
host_and_ports=[('localhost', int(os.environ["STOMP_PORT"]))])
new_conn.set_listener('', listener)
new_conn.connect()
try:
self.assertFalse(listener.wait(3)) # no error back
self.assertTrue(new_conn.is_connected())
finally:
new_conn.disconnect()
test_util.disable_default_user()
def test_default_user(self):
''' Default user connection '''
self.conn.disconnect()
test_util.enable_default_user()
listener = base.WaitableListener()
new_conn = stomp.Connection()
new_conn.set_listener('', listener)
new_conn.start()
new_conn.connect()
try:
self.assertFalse(listener. await (3)) # no error back
self.assertTrue(new_conn.is_connected())
finally:
new_conn.disconnect()
test_util.disable_default_user()
def test_implicit_connect(self):
''' Implicit connect with receipt on first command '''
self.conn.disconnect()
listener = base.WaitableListener()
new_conn = stomp.Connection(user="", passcode="")
new_conn.set_listener('', listener)
new_conn.start() # not going to issue connect
new_conn.subscribe(destination="/topic/implicit", receipt='implicit')
try:
self.assertTrue(listener.await(5))
self.assertEquals(1, len(listener.receipts),
'Missing receipt. Likely not connected')
self.assertEquals('implicit', listener.receipts[0]['headers']['receipt-id'])
finally:
new_conn.disconnect()
def test_send_receive_in_other_conn(self):
''' Test send in one connection, receive in another '''
d = '/queue/test2'
# send
self.conn.send("hello", destination=d)
# now receive
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
conn2.subscribe(destination=d)
self.assertTrue(listener2. await (10), "no receive")
finally:
conn2.stop()
def test_send_receive_in_other_conn(self):
''' Test send in one connection, receive in another '''
destination = '/queue/test2'
# send
self.conn.send(destination, "hello")
# now receive
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
self.subscribe_dest(conn2, destination, None, ack="auto")
self.assertTrue(listener2.await(10), "no receive")
finally:
conn2.disconnect()
def test_send_receive_in_other_conn_with_disconnect(self):
''' Test send, disconnect, receive '''
destination = '/queue/test3'
# send
self.conn.send(destination, "hello thar", receipt="foo")
self.listener.await(3)
self.conn.disconnect()
# now receive
conn2 = self.create_connection()
try:
listener2 = base.WaitableListener()
conn2.set_listener('', listener2)
self.subscribe_dest(conn2, destination, None, ack="auto")
self.assertTrue(listener2.await(10), "no receive")
finally:
conn2.disconnect()
def __test_conn(self, conn):
try:
listener = base.WaitableListener()
conn.set_listener('', listener)
d = "/topic/ssl.test"
conn.subscribe(destination=d, ack="auto", id="ctag", receipt="sub")
self.assertTrue(listener.wait(1))
self.assertEquals("sub",
listener.receipts[0]['headers']['receipt-id'])
listener.reset(1)
conn.send(body="Hello SSL!", destination=d)
self.assertTrue(listener.wait())
self.assertEquals("Hello SSL!", listener.messages[0]['message'])
finally:
conn.disconnect()
def test_send_and_disconnect(self):
''' Test close socket after send does not lose messages '''
d = "/queue/reliability"
pub_conn = self.create_connection()
try:
msg = "0" * (128)
count = 10000
listener = base.WaitableListener()
listener.reset(count)
self.conn.set_listener('', listener)
self.conn.subscribe(destination=d)
for x in range(0, count):
pub_conn.send(msg + str(x), destination=d)
time.sleep(2.0)
pub_conn.close_socket()
if listener. await (30):
self.assertEquals(count, len(listener.messages))
else:
def test_ssl_send_receive(self):
conn = self.__ssl_connect()
try:
listener = base.WaitableListener()
conn.set_listener('', listener)
d = "/topic/ssl.test"
conn.subscribe(destination=d, receipt="sub")
self.assertTrue(listener. await (1))
self.assertEquals("sub",
listener.receipts[0]['headers']['receipt-id'])
listener.reset(1)
conn.send("Hello SSL!", destination=d)
self.assertTrue(listener. await ())
self.assertEquals("Hello SSL!", listener.messages[0]['message'])
finally:
conn.disconnect()