def test11(self):
conn = stomp.Connection(get_default_host())
tl = TestListener('123')
conn.set_listener('', tl)
conn.start()
conn.connect(get_default_user(), get_default_password(), wait=True)
conn.subscribe(destination='/queue/test', ack='auto', id=1)
conn.send(body='this is a test', destination='/queue/test', receipt='123')
tl.wait_for_message()
self.assertTrue(tl.connections == 1, 'should have received 1 connection acknowledgement')
self.assertTrue(tl.messages >= 1, 'should have received at least 1 message')
self.assertTrue(tl.errors == 0, 'should not have received any errors')
conn.unsubscribe(destination='/queue/test', id=1)
wl = WaitingListener('DISCONNECT1')
conn.set_listener('waiting', wl)
# stomp1.1 disconnect with receipt
conn.disconnect(receipt='DISCONNECT1')
# wait for the receipt
wl.wait_on_receipt()
def testheartbeat(self):
conn = stomp.Connection(get_default_host(), heartbeats=(2000, 3000))
listener = TestListener('123')
conn.set_listener('', listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
self.assertTrue(conn.heartbeats[0] > 0)
conn.subscribe(destination='/queue/test', ack='auto', id=1)
conn.send(body='this is a test',
destination='/queue/test',
receipt='123')
listener.wait_for_message()
conn.disconnect(receipt=None)
self.assertTrue(
listener.connections >= 1,
'should have received 1 connection acknowledgement, was %s' %
listener.connections)
self.assertTrue(
listener.messages >= 1,
'should have received 1 message, was %s' % listener.messages)
self.assertTrue(
listener.errors == 0,
'should not have received any errors, was %s' % listener.errors)
self.assertTrue(
listener.heartbeat_timeouts == 0,
'should not have received a heartbeat timeout, was %s' %
listener.heartbeat_timeouts)
def send_test_message(self, conn):
listener = TestListener("123", print_to_log=True)
conn.set_listener("testlistener", listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
queuename = "/queue/test1-%s" % self.timestamp
conn.subscribe(destination=queuename, id=1, ack="auto")
conn.send(body="this is a test", destination=queuename, receipt="123")
listener.wait_for_message()
def testbasic(self):
conn = stomp.Connection11(get_default_host())
listener = TestListener('123')
conn.set_listener('', listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
conn.subscribe(destination='/queue/test', id=1, ack='auto')
conn.send(body='this is a test', destination='/queue/test', receipt='123')
listener.wait_on_receipt()
listener.wait_for_message()
conn.disconnect(receipt=None)
self.assertTrue(listener.connections == 1, 'should have received 1 connection acknowledgement')
self.assertTrue(listener.messages == 1, 'should have received 1 message')
self.assertTrue(listener.errors == 0, 'should not have received any errors')
class TestContext(unittest.TestCase):
def setUp(self):
self.timestamp = time.strftime('%Y%m%d%H%M%S')
def test_with_context(self):
with stomp.Connection(get_default_host()) as conn:
self.listener = TestListener('123')
conn.set_listener('', self.listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
queuename = '/queue/test1-%s' % self.timestamp
conn.subscribe(destination=queuename, id=1, ack='auto')
conn.send(body='this is a test', destination=queuename, receipt='123')
self.listener.wait_for_message()
self.assertTrue(self.listener.connections == 1, 'should have received 1 connection acknowledgement')
self.assertTrue(self.listener.disconnects >= 1, 'should have received 1 disconnect')
def testheartbeat(self):
conn = stomp.Connection(get_default_host(), heartbeats=(2000, 3000))
listener = TestListener('123')
conn.set_listener('', listener)
conn.start()
conn.connect(get_default_user(), get_default_password(), wait=True)
self.assertTrue(conn.heartbeats[0] > 0)
conn.subscribe(destination='/queue/test', ack='auto', id=1)
conn.send(body='this is a test', destination='/queue/test', receipt='123')
listener.wait_for_message()
conn.disconnect(receipt=None)
self.assertTrue(listener.connections >= 1, 'should have received 1 connection acknowledgement, was %s' % listener.connections)
self.assertTrue(listener.messages >= 1, 'should have received 1 message, was %s' % listener.messages)
self.assertTrue(listener.errors == 0, 'should not have received any errors, was %s' % listener.errors)
self.assertTrue(listener.heartbeat_timeouts == 0, 'should not have received a heartbeat timeout, was %s' % listener.heartbeat_timeouts)
class TestContext(unittest.TestCase):
def setUp(self):
self.timestamp = time.strftime('%Y%m%d%H%M%S')
def send_test_message(self, conn):
self.listener = TestListener('123', print_to_log=True)
conn.set_listener('testlistener', self.listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
queuename = '/queue/test1-%s' % self.timestamp
conn.subscribe(destination=queuename, id=1, ack='auto')
conn.send(body='this is a test', destination=queuename, receipt='123')
self.listener.wait_for_message()
def post_test_message(self, conn):
conn.remove_listener('testlistener')
pass
def check_asserts(self):
self.assertTrue(self.listener.connections == 1,
'should have received 1 connection acknowledgement')
self.assertTrue(self.listener.disconnects >= 1,
'should have received 1 disconnect')
def test_with_context_stomp11(self):
with stomp.Connection11(get_default_host()) as conn:
self.send_test_message(conn)
self.check_asserts()
self.post_test_message(conn)
def test_with_context_stomp10(self):
with stomp.Connection10(get_default_host()) as conn:
self.send_test_message(conn)
self.check_asserts()
self.post_test_message(conn)
def test_with_context_stomp12(self):
with stomp.Connection12(get_default_host()) as conn:
self.send_test_message(conn)
self.check_asserts()
self.post_test_message(conn)
def testconnect(self):
conn = stomp.Connection11(get_sni_ssl_host())
conn.set_ssl(get_sni_ssl_host())
listener = TestListener(self.receipt_id, print_to_log=True)
conn.set_listener('', listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
conn.subscribe(destination='/queue/test', id=1, ack='auto')
print('.....sending message with receipt %s' % self.receipt_id)
conn.send(body='this is a test',
destination='/queue/test',
receipt=self.receipt_id)
listener.wait_for_message()
conn.disconnect(receipt=None)
self.assertTrue(listener.connections == 1,
'should have received 1 connection acknowledgement')
self.assertTrue(listener.messages >= 1,
'should have received 1 message')
self.assertTrue(listener.errors == 0,
'should not have received any errors')
def testconnect(self):
if not is_inside_travis():
logging.info("Running ipv6 test")
receipt_id = str(uuid.uuid4())
conn = stomp.Connection11(get_sni_ssl_host())
conn.set_ssl(get_sni_ssl_host())
listener = TestListener(receipt_id, print_to_log=True)
conn.set_listener('', listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
conn.subscribe(destination="/queue/test", id=1, ack="auto")
logging.info("sending message with receipt %s" % receipt_id)
conn.send(body="this is a test",
destination="/queue/test",
receipt=receipt_id)
listener.wait_for_message()
conn.disconnect(receipt=None)
assert listener.connections == 1, "should have received 1 connection acknowledgement"
assert listener.messages >= 1, "should have received 1 message"
assert listener.errors == 0, "should not have received any errors"
def test_ssl_connection(self):
listener = TestListener("123", print_to_log=True)
try:
import ssl
queuename = "/queue/test4-%s" % listener.timestamp
conn = stomp.Connection(get_default_ssl_host())
conn.set_ssl(get_default_ssl_host())
conn.set_listener("testlistener", listener)
conn.connect(get_default_user(), get_default_password(), wait=True)
conn.subscribe(destination=queuename, id=1, ack="auto")
conn.send(body="this is a test", destination=queuename, receipt="123")
listener.wait_on_receipt()
listener.wait_for_message()
conn.disconnect(receipt=None)
assert conn.get_ssl() is not None
assert listener.connections == 1, "should have received 1 connection acknowledgement"
assert listener.messages == 1, "should have received 1 message"
assert listener.errors == 0, "should not have received any errors"
except ImportError:
pass
def test_parsing(self):
def pump(n):
# pump; test server gives us one frame per received something
for _ in range(n):
conn.transport.send(b'\n')
time.sleep(0.01)
# Trailing optional EOLs in a frame
self.server.add_frame('''CONNECTED
version:1.1
session:1
server:test
heart-beat:1000,1000
\x00''' + '\n\n\n')
expected_heartbeat_count = 0
conn = stomp.Connection([('127.0.0.1', 60000)])
listener = TestListener()
conn.set_listener('', listener)
conn.connect()
time.sleep(2)
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
# No trailing EOLs, separate heartbeat
message_body = 'Hello\n...world!'
message_frame = '''MESSAGE
content-type:text/plain
%s\x00''' % message_body
self.server.add_frame(message_frame)
self.server.add_frame('\n')
expected_heartbeat_count += 1
pump(2)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# Trailing EOL, separate heartbeat, another message
self.server.add_frame(message_frame + '\n')
self.server.add_frame('\n')
self.server.add_frame(message_frame + '\n')
expected_heartbeat_count += 1
pump(3)
listener.wait_for_heartbeat()
listener.wait_for_message()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# Torture tests: return content one byte at a time
self.server.add_frame('\n')
for c in message_frame:
self.server.add_frame(c)
self.server.add_frame('\n')
expected_heartbeat_count += 2
pump(len(message_frame) + 2)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# ...and a similar one with content-length and null bytes in body
message_body = '%s\x00\x00%s' % (message_body, message_body)
message_frame = '''MESSAGE
content-type:text/plain
content-length:%s
%s\x00''' % (len(message_body), message_body)
self.server.add_frame('\n')
self.server.add_frame('\n')
for c in message_frame:
self.server.add_frame(c)
self.server.add_frame('\n')
expected_heartbeat_count += 3
pump(len(message_frame) + 3)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual(
{
"content-type": "text/plain",
"content-length": str(len(message_body)),
}, headers)
self.assertEqual(message_body, body)
def test_parsing(self):
def pump(n):
# pump; test server gives us one frame per received something
for _ in range(n):
conn.transport.send(b'\n')
time.sleep(0.01)
# Trailing optional EOLs in a frame
self.server.add_frame('''CONNECTED
version:1.1
session:1
server:test
heart-beat:1000,1000
\x00''' + '\n\n\n')
expected_heartbeat_count = 0
conn = stomp.Connection([('127.0.0.1', 60000)])
listener = TestListener()
conn.set_listener('', listener)
conn.start()
conn.connect()
time.sleep(2)
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
# No trailing EOLs, separate heartbeat
message_body = 'Hello\n...world!'
message_frame = '''MESSAGE
content-type:text/plain
%s\x00''' % message_body
self.server.add_frame(message_frame)
self.server.add_frame('\n')
expected_heartbeat_count += 1
pump(2)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# Trailing EOL, separate heartbeat, another message
self.server.add_frame(message_frame + '\n')
self.server.add_frame('\n')
self.server.add_frame(message_frame + '\n')
expected_heartbeat_count += 1
pump(3)
listener.wait_for_heartbeat()
listener.wait_for_message()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# Torture tests: return content one byte at a time
self.server.add_frame('\n')
for c in message_frame:
self.server.add_frame(c)
self.server.add_frame('\n')
expected_heartbeat_count += 2
pump(len(message_frame) + 2)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({"content-type": "text/plain"}, headers)
self.assertEqual(message_body, body)
# ...and a similar one with content-length and null bytes in body
message_body = '%s\x00\x00%s' % (message_body, message_body)
message_frame = '''MESSAGE
content-type:text/plain
content-length:%s
%s\x00''' % (len(message_body), message_body)
self.server.add_frame('\n')
self.server.add_frame('\n')
for c in message_frame:
self.server.add_frame(c)
self.server.add_frame('\n')
expected_heartbeat_count += 3
pump(len(message_frame) + 3)
listener.wait_for_heartbeat()
headers, body = listener.get_latest_message()
self.assertEqual(expected_heartbeat_count, listener.heartbeat_count)
self.assertEqual({
"content-type": "text/plain",
"content-length": str(len(message_body)),
}, headers)
self.assertEqual(message_body, body)