def test_020(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
c.subscribe("/cs/topic1/+", qos=2)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsgs = {
"/cs/topic1/q0": [0, env.gen_msg(42)],
"/cs/topic1/q1": [1, env.gen_msg(42)],
"/cs/topic1/q2": [2, env.gen_msg(42)],
}
for (topic, (qos, msg)) in pubmsgs.iteritems():
ack = pub.publish(topic, msg, qos=qos)
if qos == 2:
pub.pubrel(ack.mid)
pub.disconnect()
msgs = env.db.lrange("queue:" + c.clientid(), 0, -1)
for (topic, qos,
msgid) in [msgs[i:i + 3] for i in range(0, len(msgs), 3)]:
content = env.db.get("msg:" + msgid)
origin = pubmsgs.get(topic, [-1, ""])
#print topic, origin, qos, content
if int(qos) != origin[0] or content != origin[1]:
debug("{0}: {1}, {2}".format(origin, qos, content))
return False
return True
def test_003(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', qos=2)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=1)
e = sub.recv()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 1:
debug('received event (supposely publish): {0}'.format(e))
return False
# send PUBACK
sub.puback(e.msg.mid)
e2 = pub.recv()
if not isinstance(e2, EventPuback) or \
e2.mid != pub.get_last_mid():
debug('received event (supposely puback): {0}'.format(e2))
return False
sub.unsubscribe('a/b')
sub.disconnect(); pub.disconnect()
return True
def test_010(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', 2)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=2, read_response=False)
pub.pubrec(pub.get_last_mid())
# PUBREC
pub.recv()
pub.pubrec(pub.get_last_mid())
pub.puback(pub.get_last_mid())
pub.pubcomp(pub.get_last_mid())
# finally send correct PUBREL message
pub.pubrel(pub.get_last_mid())
# PUBLISH received by subscriber
evt = sub.recv()
sub.pubrel(sub.get_last_mid())
sub.puback(sub.get_last_mid())
sub.pubcomp(sub.get_last_mid())
return True
def test_003(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', qos=1)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=1)
pub.recv()
e = sub.recv()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 1:
debug('failing event: {0}'.format(e))
return False
# send PUBACK
sub.puback(e.msg.mid)
puback_evt = pub.recv()
# PUBACK mid == PUBLISH mid
# validating [MQTT-2.3.1-6]
if not isinstance(puback_evt, EventPuback) or \
puback_evt.mid != pub.get_last_mid():
debug('failing event: {0}'.format(puback_evt))
return False
sub.unsubscribe('a/b')
sub.disconnect(); pub.disconnect()
return True
def test_021(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
c.subscribe("/cs/topic1/+", qos=2)
c.subscribe("/cs/topic1/q2", qos=1)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsg = {
'topic': "/cs/topic1/q2",
'qos': 2,
'payload': env.gen_msg(42)
}
ack = pub.publish(**pubmsg)
pub.pubrel(ack.mid)
pub.disconnect()
msgs = env.db.lrange("queue:" + c.clientid(), 0, -1)
if len(msgs) != 2 * 3:
debug(msgs)
return False
for (topic, qos,
msgid) in [msgs[i:i + 3] for i in range(0, len(msgs), 3)]:
content = env.db.get("msg:" + msgid)
if topic != pubmsg['topic'] or content != pubmsg['payload']:
debug("{0}: {1}, {2}".format(topic, content, pubmsg))
return False
if int(qos) not in (1, 2):
debug("{0}: qos {1}".format(topic, qos))
return False
return True
def test_002(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=1)
pub = MqttClient("pub:{seq}", connect=4)
pub.publish("foo/bar", env.gen_msg(42), qos=1)
evt = sub.recv()
if not isinstance(evt, EventPublish):
debug(evt)
defer.returnValue(False)
# PUBACK not send
sub.destroy(); del sub
if (yield supervisor.count('wave_msgworkers_sup')) != 1:
debug("wrong msgworkers count")
defer.returnValue(False)
# msg worker is destroyed after 5 secs
time.sleep(6)
if (yield supervisor.count('wave_msgworkers_sup')) != 0:
debug("wrong msgworkers count")
defer.returnValue(False)
pub.disconnect()
defer.returnValue(True)
def _pubsub(self, pubtopic, subtopic, match):
msg = gen_msg()
sub = MqttClient("sub:{seq}", connect=4)
suback_evt = sub.subscribe(subtopic, 0)
if not isinstance(suback_evt, EventSuback) or \
suback_evt.mid != sub.get_last_mid() or \
suback_evt.granted_qos[0] != 0:
if match: debug("failed to subscribe: {0}".format(suback_evt))
return False
pub = MqttClient("pub:{seq}", connect=4)
pub.publish(pubtopic, msg)
pub.disconnect()
e = sub.recv()
unsuback_evt = sub.unsubscribe(subtopic)
if not isinstance(unsuback_evt, EventUnsuback) or \
unsuback_evt.mid != sub.get_last_mid():
if match: debug("failed to unsubscribe: {0}".format(unsuback_evt))
return False
sub.disconnect()
#print e, e.msg.topic, e.msg.payload
if not isinstance(e, EventPublish) or \
e.msg.topic != pubtopic or \
e.msg.payload != msg:
if match: debug("invalid received msg: {0}".format(e))
return False
return True
def test_030(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=1)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish("foo/bar", payload=msg, qos=1)
e1 = sub.recv()
msg2 = gen_msg()
pub.publish("foo/bar", payload=msg2, qos=1)
e2 = sub.recv()
if e2.msg.mid != e1.msg.mid + 1:
debug('failing event: {0}'.format(e2))
return False
return True
def test_024(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
if c.connack().session_present != 0:
debug("session present")
return False
c.subscribe("/cs/topic1/+", qos=0)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsg = {
'topic': "/cs/topic1/q2",
'qos': 2,
'payload': env.gen_msg(42)
}
ack = pub.publish(**pubmsg)
pub.pubrel(ack.mid)
# clean_session = 1 => offline subscriptions & published messages dropped
c2 = MqttClient(client_id=c.client_id, connect=4, clean_session=1)
if c2.connack().session_present != 0:
debug("session present")
return False
evt = c2.recv()
if evt is not None:
debug(evt)
return False
pub.publish("/cs/topic1/qz", env.gen_msg(42), qos=0)
pub.disconnect()
evt = c2.recv()
if evt is not None:
debug(evt)
return False
c2.disconnect()
return True
def test_022(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
c.subscribe("/cs/topic1/+", qos=0)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsg = {
'topic': "/cs/topic1/q2",
'qos': 2,
'payload': env.gen_msg(42)
}
ack = pub.publish(**pubmsg)
pub.pubrel(ack.mid)
pub.disconnect()
c2 = MqttClient(client_id=c.client_id,
connect=4,
clean_session=0,
read_connack=False)
#NOTE: response order is not guaranteed
acked = False
pubevt = False
while True:
evt = c2.recv()
#print evt
if isinstance(evt, EventConnack):
if evt.session_present != 1:
debug("{0}: session not present".format(evt))
return False
acked = True
continue
if isinstance(evt, EventPublish) and\
evt.msg.topic == pubmsg['topic'] and\
evt.msg.payload == pubmsg['payload'] and\
evt.msg.qos == 0:
pubevt = evt
continue
if evt != None:
debug(evt)
return False
break
c2.disconnect()
return True
def test_004(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', 2)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=2, read_response=False)
msgid = pub.get_last_mid()
# PUBREC
e = pub.recv()
# validating [MQTT-2.3.1-6]
if not isinstance(e, EventPubrec) or e.mid != msgid:
debug('failing event (PUBREC waited): {0}'.format(e))
return False
pub.pubrel(msgid, read_response=False)
# subscriber ready to receive msg
e = sub.recv()
if not isinstance(e, EventPublish) or e.msg.qos != 2 or e.msg.payload != msg:
debug('failing event (PUBLISH waited): {0}'.format(e))
return False
# subscriber: send PUBREC after having received PUBLISH message
sub.pubrec(e.msg.mid, read_response=False)
e2 = sub.recv()
# validating [MQTT-2.3.1-6]
if not isinstance(e2, EventPubrel) or e2.mid != e.msg.mid:
debug('failing event (PUBREL waited): {0}'.format(e))
return False
sub.pubcomp(e.msg.mid)
#
pubcomp_evt = pub.recv()
# validating [MQTT-2.3.1-6]
if not isinstance(pubcomp_evt, EventPubcomp) or pubcomp_evt.mid != msgid:
debug('failing event (PUBCOMP waited): {0}'.format(e))
return False
sub.unsubscribe('a/b')
sub.disconnect(); pub.disconnect()
return True
def test_006(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', qos=1)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=1)
pub.recv()
e = sub.recv()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 1:
debug('failing event: {0}'.format(e))
return False
# send PUBREL (! ERROR: not a QOS 2 message)
sub.pubrec(e.msg.mid)
puback_evt = pub.recv()
if not puback_evt is None:
debug('failing event: {0}'.format(puback_evt))
return False
# unexpected PUBREL
sub.pubrel(e.msg.mid)
puback_evt = pub.recv()
if not puback_evt is None:
debug('failing event: {0}'.format(puback_evt))
return False
# unexpected PUBCOMP
sub.pubcomp(e.msg.mid)
puback_evt = pub.recv()
if not puback_evt is None:
debug('failing event: {0}'.format(puback_evt))
return False
sub.unsubscribe('a/b')
sub.disconnect()
pub.disconnect()
return True
def test_005(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', qos=1)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=1)
# destoying socket
pub.destroy(); del pub
e = sub.recv()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 1:
debug('failing event: {0}'.format(e))
return False
sub.disconnect()
return True
def test_002(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', 2)
pub = MqttClient("pub:{seq}", connect=4)
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=0)
pub.disconnect()
e = sub.recv()
sub.unsubscribe('a/b')
sub.disconnect()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 0:
debug(e)
return False
return True
def test_001(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=0)
pub = MqttClient("pub:{seq}", connect=4)
pub.publish("foo/bar", env.gen_msg(42), qos=2)
# PUBREL not sent
pub.destroy(); del pub
cnt = yield supervisor.count('wave_msgworkers_sup')
if cnt != 1:
debug("wrong msgworkers count: {0}".format(cnt))
defer.returnValue(False)
# msg worker is destroyed after 5 secs
time.sleep(6)
if (yield supervisor.count('wave_msgworkers_sup')) != 0:
debug("wrong msgworkers count")
defer.returnValue(False)
defer.returnValue(True)
def test_022(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', qos=0)
pub = MqttClient("pub:{seq}", connect=4)
# published with qos 0
msg = gen_msg()
pub.publish('a/b', payload=msg, qos=1)
pub.disconnect()
e = sub.recv()
sub.unsubscribe('a/b')
sub.disconnect()
if not isinstance(e, EventPublish) or \
e.msg.payload != msg or \
e.msg.qos != 0:
debug('failing event: {0}'.format(e))
return False
return True
def test_013(self):
pub = MqttClient("pub:{seq}", connect=4)
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe('a/b', 0)
# NOTE: remaining length value is message length + 5 bytes (topic encoded) + 2 bytes (msgid)
msg = gen_msg(17000)
#print "msg=", msg, len(msg)
puback_evt = pub.publish('a/b', msg, qos=1)
if not isinstance(puback_evt, EventPuback) or \
puback_evt.mid != pub.get_last_mid():
return False
publish_evt = sub.recv()
if not isinstance(publish_evt, EventPublish) or \
publish_evt.msg.payloadlen != len(msg) or \
publish_evt.msg.payload != msg:
return False
return True
def test_003(self):
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=1)
sub2 = MqttClient("sub:{seq}", connect=4)
sub2.subscribe("foo/+", qos=1)
pub = MqttClient("pub:{seq}", connect=4)
pub.publish("foo/bar", env.gen_msg(42), qos=1)
evt1 = sub.recv()
evt2 = sub2.recv()
sub.destroy(); del sub
if (yield supervisor.count('wave_msgworkers_sup')) != 1:
debug("wrong msgworkers count")
defer.returnValue(False)
# sub removed, sub2 still alive
time.sleep(6)
if (yield supervisor.count('wave_msgworkers_sup')) != 1:
debug("wrong msgworkers count")
defer.returnValue(False)
# sub2 still alive
time.sleep(6)
if (yield supervisor.count('wave_msgworkers_sup')) != 1:
debug("wrong msgworkers count")
defer.returnValue(False)
# msg worker is destroyed after 5 secs
sub2.puback(evt2.msg.mid)
if (yield supervisor.count('wave_msgworkers_sup')) != 0:
debug("wrong msgworkers count")
defer.returnValue(False)
pub.disconnect()
defer.returnValue(True)
def test_010(self):
sub = MqttClient("sub:{seq}", connect=4, clean_session=0)
sub.subscribe("foo/+", qos=2)
sub.disconnect()
if (yield supervisor.count('wave_msgworkers_sup')) != 0:
debug("wrong msgworkers count")
defer.returnValue(False)
pub = MqttClient("pub:{seq}", connect=4)
rec = pub.publish("foo/bar", env.gen_msg(42), qos=2)
ack = pub.pubrel(rec.mid)
print ack
if not isinstance(ack, EventPubcomp):
debug(ack)
defer.returnValue(False)
# msg is published to offline storage, msg worker should exit immediately
if (yield supervisor.count('wave_msgworkers_sup')) != 0:
debug("wrong msgworkers count")
defer.returnValue(False)
defer.returnValue(True)
def test_031(self):
sub = MqttClient("sub:{seq}", connect=4)
ack = sub.subscribe_multi([('foo/+', 1), ('foo/#', 1)])
debug("subscribe_multi response: {0}".format(ack))
pub = MqttClient("pub:{seq}", connect=4)
pub.publish("foo/bar", gen_msg(42), qos=1)
evt = sub.recv()
if not isinstance(evt, EventPublish) or\
evt.msg.topic != 'foo/bar' or\
evt.msg.qos != 1:
debug('failing event: {0}'.format(evt))
return False
sub.puback(evt.msg.mid, read_response=False)
evt = pub.recv()
if evt is not None:
debug('failing event: {0}'.format(evt))
return False
# receive 2d publish
evt = sub.recv()
if not isinstance(evt, EventPublish) or\
evt.msg.topic != 'foo/bar' or\
evt.msg.qos != 1:
debug('failing event: {0}'.format(evt))
return False
sub.puback(evt.msg.mid)
evt = pub.recv()
if not isinstance(evt, EventPuback):
debug('failing event: {0}'.format(evt))
return False
return True
def test_030(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
c.subscribe("/cs/topic1/+", qos=0)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsg = {
'topic': "/cs/topic1/waz",
'qos': 0,
'payload': env.gen_msg(42)
}
ack = pub.publish(**pubmsg)
c2 = MqttClient(client_id=c.client_id, connect=4, clean_session=0)
evt = c2.connack()
if not isinstance(evt, EventConnack):
debug(evt)
return False
c2.recv()
c2.disconnect()
pub.disconnect()
return True
def _t_check(self, client, acl, user, password):
ctrl = MqttClient("ctrl:{seq}", connect=4, username='******', password='******')
c = MqttClient("client:{seq}", connect=4, username=user, password=password)
ctrl.subscribe("test/#", qos=0)
## subscribe
# MUST FAIL when acl on
ret = c.subscribe("test/{0}/sub/0".format(client), qos=0)
if not isinstance(ret, EventSuback):
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
if acl and ret.granted_qos != [0x80] or\
not acl and ret.granted_qos != [0]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
## publish
# NOTE: publish never reports failure or success
topic = "test/{0}/pub/0".format(client); msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if acl and e != None:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
elif not acl and (not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg):
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
# MUST ALWAYS SUCCEED
ret = c.subscribe("test/{0}/sub/1".format(client), qos=0)
if not isinstance(ret, EventSuback) or ret.granted_qos != [0]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
if acl:
ret = c.subscribe("test/{0}/sub/1/extra".format(client), qos=0)
if not isinstance(ret, EventSuback) or ret.granted_qos != [0x80]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return false
topic = "test/{0}/pub/1".format(client); msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
if acl:
msg = env.gen_msg(10)
c.publish("test/{0}/pub/1/extra".format(client), msg)
e = ctrl.recv()
if e != None:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
topic = "test/{0}/pub/2/foo/bar".format(client); msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
ctrl.disconnect(); c.disconnect()
return True
def _t_check(self, client, acl, user, password):
ctrl = MqttClient("ctrl:{seq}",
connect=4,
username='******',
password='******')
c = MqttClient("client:{seq}",
connect=4,
username=user,
password=password)
ctrl.subscribe("test/#", qos=0)
## subscribe
# MUST FAIL when acl on
ret = c.subscribe("test/{0}/sub/0".format(client), qos=0)
if not isinstance(ret, EventSuback):
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
if acl and ret.granted_qos != [0x80] or\
not acl and ret.granted_qos != [0]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
## publish
# NOTE: publish never reports failure or success
topic = "test/{0}/pub/0".format(client)
msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if acl and e != None:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
elif not acl and (not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg):
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
# MUST ALWAYS SUCCEED
ret = c.subscribe("test/{0}/sub/1".format(client), qos=0)
if not isinstance(ret, EventSuback) or ret.granted_qos != [0]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return False
if acl:
ret = c.subscribe("test/{0}/sub/1/extra".format(client), qos=0)
if not isinstance(ret, EventSuback) or ret.granted_qos != [0x80]:
debug("{0}, acl {1}: {2}".format(client, acl, ret))
return false
topic = "test/{0}/pub/1".format(client)
msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
if acl:
msg = env.gen_msg(10)
c.publish("test/{0}/pub/1/extra".format(client), msg)
e = ctrl.recv()
if e != None:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
topic = "test/{0}/pub/2/foo/bar".format(client)
msg = env.gen_msg(10)
c.publish(topic, msg)
e = ctrl.recv()
if not isinstance(e, EventPublish) or\
e.msg.topic != topic or\
e.msg.payload != msg:
debug("{0}, acl {1}: {2}".format(client, acl, e))
return False
ctrl.disconnect()
c.disconnect()
return True
def test_023(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
if c.connack().session_present != 0:
debug("session present")
return False
c.subscribe("/cs/topic1/+", qos=2)
c.disconnect()
pub = MqttClient("pub:{seq}", connect=4)
pubmsgs = {
"/cs/topic1/q0": [0, env.gen_msg(42)],
"/cs/topic1/q1": [1, env.gen_msg(42)],
"/cs/topic1/q2": [2, env.gen_msg(42)],
}
pubmsg = {
'topic': "/cs/topic1/q2",
'qos': 2,
'payload': env.gen_msg(42)
}
for (topic, (qos, msg)) in pubmsgs.iteritems():
ack = pub.publish(topic, msg, qos=qos)
if qos == 2:
pub.pubrel(ack.mid)
pub.disconnect()
c2 = MqttClient(client_id=c.client_id,
connect=4,
clean_session=0,
read_connack=False)
#NOTE: response order is not guaranteed
acked = False
pubcnt = 0
while True:
evt = c2.recv()
#print evt
if isinstance(evt, EventConnack):
if evt.session_present != 1:
debug("{0}: session not present".format(evt))
return False
acked = True
continue
if isinstance(evt, EventPublish):
orig = pubmsgs.get(evt.msg.topic, [None, None])
if evt.msg.payload == orig[1] and evt.msg.qos == orig[0]:
pubcnt += 1
continue
if evt != None:
debug(evt)
return False
break
if not acked:
debug("not acked")
return False
if pubcnt != 3:
debug("not all messages received: {0}".format(pubcnt))
return False
c2.disconnect()
return True
# - test subscribe return
import time
import random
from TestSuite import TestSuite, desc, catch
from mqttcli import MqttClient
from nyamuk.event import *
from lib.env import gen_msg, debug
class ConnectFlags(TestSuite):
def __init__(self):
TestSuite.__init__(self, "CONNECT flags")
def pubsub(self, (pub, ctrl, dummy), clbs={}):
msg = gen_msg(10)
## no response expected
pub.publish("/test/qos/0", msg)
## checking we received message for both control-sample & dummy clients
evt = ctrl.recv()
if not isinstance(evt, EventPublish) or evt.msg.payload != msg:
debug(evt, depth=1); return False
evt = dummy.recv()
#print evt, checkfn(evt, msg)
def nop(*args, **kwargs):
return True
ret = clbs.get('checkrecv', nop)(evt, msg)
if not ret: debug(evt, depth=1)
def test_001(self):
pub = MqttClient("publisher:{seq}")
evt = pub.connect()
if not isinstance(evt, EventConnack) or evt.ret_code != 0:
debug(evt); return False
ctrl = MqttClient("control-sample:{seq}")
evt = ctrl.connect()
if not isinstance(evt, EventConnack) or evt.ret_code != 0:
debug(evt); return False
evt = ctrl.subscribe("/test/qos/0", qos=0)
if not isinstance(evt, EventSuback):
debug(evt); return False
###
dummyid = "dummy:{0}".format(random.randint(0,9999))
dummy = MqttClient(dummyid)
evt = dummy.connect(clean_session=1)
if not isinstance(evt, EventConnack) or evt.ret_code != 0:
debug(evt); return False
evt = dummy.subscribe("/test/qos/0", qos=0)
if not isinstance(evt, EventSuback):
debug(evt); return False
#print evt.mid
# 1. sent qos0, 1, 2 messages; check reception
if not self.pubsub((pub, ctrl, dummy), clbs={
'checkrecv': lambda evt, msg: isinstance(evt, EventPublish) and evt.msg.payload == msg
}):
return False
# 2. disconnecting (properly) dummmy; then reconnects
dummy.disconnect(); del(dummy)
# be sure dummy client disconnection in fully complete on broker side before going further
time.sleep(1)
## publish message
msg = gen_msg(10)
pub.publish("/test/qos/0", payload=msg)
## reconnects, without explicitly subscribing topic
dummy = MqttClient(dummyid)
evt = dummy.connect(clean_session=1)
if not isinstance(evt, EventConnack) or evt.ret_code != 0:
debug(evt); return False
## checking message is not received by dummy
evt = ctrl.recv()
if not isinstance(evt, EventPublish) or evt.msg.payload != msg:
debug(evt); return False
evt = dummy.recv()
if evt != None:
debug(evt); return False
## dummy resubscribe, check we receive messages
evt = dummy.subscribe("/test/qos/0", qos=0)
if not isinstance(evt, EventSuback):
debug(evt); return False
## send test message
if not self.pubsub((pub, ctrl, dummy), clbs={
'checkrecv': lambda evt, msg: evt is not None and evt.msg.payload == msg
}):
debug('pubsub failed')
return False
# cleanup
pub.disconnect()
ctrl.disconnect()
dummy.disconnect()
return True
def test_004(self):
pub = MqttClient("pub:{seq}", connect=4)
pub.publish('a/b', payload=gen_msg(), qos=1)
pub.destroy(); del pub # socket destroyed
return True
