def test_valid_utf8_topic_recv(self, fake_broker):
mqttc = client.Client("client-id")
# It should be non-ascii multi-bytes character
topic = unicodedata.lookup('SNOWMAN')
def on_message(client, userdata, msg):
assert msg.topic == topic
client.disconnect()
mqttc.on_message = on_message
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(
topic.encode('utf-8'), qos=0
)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
def test_valid_utf8_topic_recv(self, fake_broker):
mqttc = client.Client("client-id")
# It should be non-ascii multi-bytes character
topic = unicodedata.lookup('SNOWMAN')
def on_message(client, userdata, msg):
assert msg.topic == topic
client.disconnect()
mqttc.on_message = on_message
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(topic.encode('utf-8'),
qos=0)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
def test_valid_utf8_topic_publish(self, fake_broker):
mqttc = client.Client("client-id")
# It should be non-ascii multi-bytes character
topic = unicodedata.lookup('SNOWMAN')
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
mqttc.publish(topic, None, 0)
# Small sleep needed to avoid connection reset.
time.sleep(0.3)
publish_packet = paho_test.gen_publish(topic.encode('utf-8'),
qos=0)
packet_in = fake_broker.receive_packet(len(publish_packet))
assert packet_in # Check connection was not closed
assert packet_in == publish_packet
mqttc.disconnect()
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
def test_invalid_utf8_topic(self, fake_broker):
mqttc = client.Client("client-id")
def on_message(client, userdata, msg):
with pytest.raises(UnicodeDecodeError):
msg.topic
client.disconnect()
mqttc.on_message = on_message
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(b"\xff", qos=0)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
def test_invalid_utf8_topic(self, fake_broker):
mqttc = client.Client("client-id")
def on_message(client, userdata, msg):
with pytest.raises(UnicodeDecodeError):
msg.topic
client.disconnect()
mqttc.on_message = on_message
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(b"\xff", qos=0)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
os.path.abspath(
os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0], "..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
mid = 16
connect_packet = paho_test.gen_connect("retain-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("retain/qos0/test",
qos=0,
payload="retained message",
retain=True)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
env['PYTHONPATH'] = '../../src:' + pp
cmd_subfolder = os.path.realpath(
os.path.abspath(
os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0], "..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos0-test-np",
keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("pub/qos0/no-payload/test", qos=0)
disconnect_packet = paho_test.gen_disconnect()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
os.path.abspath(
os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0], "..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos0-test",
keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("pub/qos0/test",
qos=0,
payload="message")
disconnect_packet = paho_test.gen_disconnect()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
import time
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos2-test",
keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 13423
publish_packet = paho_test.gen_publish("pub/qos2/receive",
qos=2,
mid=mid,
payload="message".encode('utf-8'))
pubrec_packet = paho_test.gen_pubrec(mid)
pubrel_packet = paho_test.gen_pubrel(mid)
pubcomp_packet = paho_test.gen_pubcomp(mid)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
# and client id publish-qos0-test
# The test will send a CONNACK message to the client with rc=0. Upon receiving
# the CONNACK and verifying that rc=0, the client should send a PUBLISH message
# to topic "pub/qos0/test" with payload "message" and QoS=0. If rc!=0, the
# client should exit with an error.
# After sending the PUBLISH message, the client should send a DISCONNECT message.
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("pub/qos0/test", qos=0, payload="message".encode('utf-8'))
disconnect_packet = paho_test.gen_disconnect()
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
if paho_test.expect_packet(conn, "publish", publish_packet):
# From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos1-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 1
publish_packet = paho_test.gen_publish("pub/qos1/test", qos=1, mid=mid, payload="message")
publish_packet_dup = paho_test.gen_publish("pub/qos1/test", qos=1, mid=mid, payload="message", dup=True)
puback_packet = paho_test.gen_puback(mid)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
#!/usr/bin/env python
# Test whether a client sends a correct retained PUBLISH to a topic with QoS 0.
import context
import paho_test
rc = 1
keepalive = 60
mid = 16
connect_packet = paho_test.gen_connect("retain-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish(
u"retain/qos0/test", qos=0, payload="retained message".encode('utf-8'), retain=True)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
if paho_test.expect_packet(conn, "publish", publish_packet):
rc = 0
conn.close()
import socket
import sys
# From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("pub/qos0/test", qos=0, payload="message")
disconnect_packet = paho_test.gen_disconnect()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
# After sending the PUBLISH message, the client should send a
# DISCONNECT message.
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-helper-qos0-test",
keepalive=keepalive,
proto_ver=5,
properties=None)
connack_packet = paho_test.gen_connack(rc=0, proto_ver=5)
publish_packet = paho_test.gen_publish(u"pub/qos0/test",
qos=0,
payload="message",
proto_ver=5)
disconnect_packet = paho_test.gen_disconnect()
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
paho_test.expect_packet(conn, "connect", connect_packet)
conn.send(connack_packet)
import sys
# From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
mid = 16
connect_packet = paho_test.gen_connect("retain-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("retain/qos0/test", qos=0, payload="retained message", retain=True)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
env['PYTHONPATH'] = '../../src:'+pp
client = subprocess.Popen(client_args, env=env)
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("asyncio-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
subscribe_packet = paho_test.gen_subscribe(mid=1, topic=u"sub-test", qos=1)
suback_packet = paho_test.gen_suback(mid=1, qos=1)
unsubscribe_packet = paho_test.gen_unsubscribe(mid=2, topic=u"unsub-test")
unsuback_packet = paho_test.gen_unsuback(mid=2)
publish_packet = paho_test.gen_publish(u"b2c", qos=0, payload="msg")
publish_packet_in = paho_test.gen_publish(u"asyncio",
qos=1,
mid=3,
payload="message")
puback_packet_in = paho_test.gen_puback(mid=3)
disconnect_packet = paho_test.gen_disconnect()
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
# Test the reconnect_on_failure = False mode
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("01-reconnect-on-failure",
keepalive=keepalive)
connack_packet_ok = paho_test.gen_connack(rc=0)
connack_packet_failure = paho_test.gen_connack(
rc=1) # CONNACK_REFUSED_PROTOCOL_VERSION
publish_packet = paho_test.gen_publish(u"reconnect/test",
qos=0,
payload="message")
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
paho_test.expect_packet(conn, "connect", connect_packet)
conn.send(connack_packet_ok)
# Connection is a success, so we expect a publish
paho_test.expect_packet(conn, "publish", publish_packet)
def test_message_callback(self, fake_broker):
mqttc = client.Client("client-id")
userdata = {
'on_message': 0,
'callback1': 0,
'callback2': 0,
}
mqttc.user_data_set(userdata)
def on_message(client, userdata, msg):
assert msg.topic == 'topic/value'
userdata['on_message'] += 1
def callback1(client, userdata, msg):
assert msg.topic == 'topic/callback/1'
userdata['callback1'] += 1
def callback2(client, userdata, msg):
assert msg.topic in ('topic/callback/3', 'topic/callback/1')
userdata['callback2'] += 1
mqttc.on_message = on_message
mqttc.message_callback_add('topic/callback/1', callback1)
mqttc.message_callback_add('topic/callback/+', callback2)
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(b"topic/value", qos=1, mid=1)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
publish_packet = paho_test.gen_publish(b"topic/callback/1", qos=1, mid=2)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
publish_packet = paho_test.gen_publish(b"topic/callback/3", qos=1, mid=3)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
puback_packet = paho_test.gen_puback(mid=1)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
puback_packet = paho_test.gen_puback(mid=2)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
puback_packet = paho_test.gen_puback(mid=3)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
mqttc.disconnect()
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
assert userdata['on_message'] == 1
assert userdata['callback1'] == 1
assert userdata['callback2'] == 2
# From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos1-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 123
publish_packet = paho_test.gen_publish("pub/qos1/receive", qos=1, mid=mid, payload="message")
puback_packet = paho_test.gen_puback(mid)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
env['PYTHONPATH'] = '../../src:'+pp
# The client should then exit with return code==0.
import time
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos1-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 123
publish_packet = paho_test.gen_publish(
u"pub/qos1/receive", qos=1, mid=mid, payload="message".encode('utf-8'))
puback_packet = paho_test.gen_puback(mid)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
conn.send(publish_packet)
if paho_test.expect_packet(conn, "puback", puback_packet):
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect(
"publish-qos2-test",
keepalive=keepalive,
clean_session=False,
)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 1
publish_packet = paho_test.gen_publish(u"pub/qos2/test",
qos=2,
mid=mid,
payload="message")
publish_dup_packet = paho_test.gen_publish(u"pub/qos2/test",
qos=2,
mid=mid,
payload="message",
dup=True)
pubrec_packet = paho_test.gen_pubrec(mid)
pubrel_packet = paho_test.gen_pubrel(mid)
pubcomp_packet = paho_test.gen_pubcomp(mid)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
#!/usr/bin/env python
# Test whether a client sends a correct PUBLISH to a topic with QoS 1, then responds correctly to a disconnect.
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos1-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
disconnect_packet = paho_test.gen_disconnect()
mid = 1
publish_packet = paho_test.gen_publish(
u"pub/qos1/test", qos=1, mid=mid, payload="message".encode('utf-8'))
publish_packet_dup = paho_test.gen_publish(
u"pub/qos1/test", qos=1, mid=mid, payload="message".encode('utf-8'), dup=True)
puback_packet = paho_test.gen_puback(mid)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(15)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
def test_message_callback(self, fake_broker):
mqttc = client.Client("client-id")
userdata = {
'on_message': 0,
'callback1': 0,
'callback2': 0,
}
mqttc.user_data_set(userdata)
def on_message(client, userdata, msg):
assert msg.topic == 'topic/value'
userdata['on_message'] += 1
def callback1(client, userdata, msg):
assert msg.topic == 'topic/callback/1'
userdata['callback1'] += 1
def callback2(client, userdata, msg):
assert msg.topic in ('topic/callback/3', 'topic/callback/1')
userdata['callback2'] += 1
mqttc.on_message = on_message
mqttc.message_callback_add('topic/callback/1', callback1)
mqttc.message_callback_add('topic/callback/+', callback2)
mqttc.connect_async("localhost", 1888)
mqttc.loop_start()
try:
fake_broker.start()
connect_packet = paho_test.gen_connect("client-id")
packet_in = fake_broker.receive_packet(len(connect_packet))
assert packet_in # Check connection was not closed
assert packet_in == connect_packet
connack_packet = paho_test.gen_connack(rc=0)
count = fake_broker.send_packet(connack_packet)
assert count # Check connection was not closed
assert count == len(connack_packet)
publish_packet = paho_test.gen_publish(b"topic/value",
qos=1,
mid=1)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
publish_packet = paho_test.gen_publish(b"topic/callback/1",
qos=1,
mid=2)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
publish_packet = paho_test.gen_publish(b"topic/callback/3",
qos=1,
mid=3)
count = fake_broker.send_packet(publish_packet)
assert count # Check connection was not closed
assert count == len(publish_packet)
puback_packet = paho_test.gen_puback(mid=1)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
puback_packet = paho_test.gen_puback(mid=2)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
puback_packet = paho_test.gen_puback(mid=3)
packet_in = fake_broker.receive_packet(len(puback_packet))
assert packet_in # Check connection was not closed
assert packet_in == puback_packet
mqttc.disconnect()
disconnect_packet = paho_test.gen_disconnect()
packet_in = fake_broker.receive_packet(len(disconnect_packet))
assert packet_in # Check connection was not closed
assert packet_in == disconnect_packet
finally:
mqttc.loop_stop()
packet_in = fake_broker.receive_packet(1)
assert not packet_in # Check connection is closed
assert userdata['on_message'] == 1
assert userdata['callback1'] == 1
assert userdata['callback2'] == 2
#!/usr/bin/env python
# Test whether a client sends a correct retained PUBLISH to a topic with QoS 0.
import context
import paho_test
rc = 1
keepalive = 60
mid = 16
connect_packet = paho_test.gen_connect("retain-qos0-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish(
u"retain/qos0/test",
qos=0,
payload="retained message".encode('utf-8'),
retain=True)
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
if paho_test.expect_packet(conn, "publish", publish_packet):
# client should exit with an error.
# After sending the PUBLISH message, the client should send a
# DISCONNECT message.
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect(
"publish-helper-qos0-test", keepalive=keepalive,
)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish(
u"pub/qos0/test", qos=0, payload="message".encode('utf-8'),
)
disconnect_packet = paho_test.gen_disconnect()
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
conn.settimeout(10)
if paho_test.expect_packet(conn, "connect", connect_packet):
conn.send(connack_packet)
import sys
import time
# From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder
cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"..")))
if cmd_subfolder not in sys.path:
sys.path.insert(0, cmd_subfolder)
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("publish-qos0-test-np", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
publish_packet = paho_test.gen_publish("pub/qos0/no-payload/test", qos=0)
disconnect_packet = paho_test.gen_disconnect()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(10)
sock.bind(('', 1888))
sock.listen(5)
client_args = sys.argv[1:]
env = dict(os.environ)
try:
pp = env['PYTHONPATH']
except KeyError:
pp = ''
import context
import paho_test
rc = 1
keepalive = 60
connect_packet = paho_test.gen_connect("decorators-test", keepalive=keepalive)
connack_packet = paho_test.gen_connack(rc=0)
subscribe_packet = paho_test.gen_subscribe(mid=1, topic=u"sub-test", qos=1)
suback_packet = paho_test.gen_suback(mid=1, qos=1)
unsubscribe_packet = paho_test.gen_unsubscribe(mid=2, topic=u"unsub-test")
unsuback_packet = paho_test.gen_unsuback(mid=2)
publish_packet = paho_test.gen_publish(u"b2c", qos=0, payload="msg")
publish_packet_in = paho_test.gen_publish(u"decorators",
qos=1,
mid=3,
payload="message")
puback_packet_in = paho_test.gen_puback(mid=3)
disconnect_packet = paho_test.gen_disconnect()
sock = paho_test.create_server_socket()
client = context.start_client()
try:
(conn, address) = sock.accept()
