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 test_110(self):
sub = MqttClient("unisub:{seq}", connect=4)
pub = MqttClient("unipub:{seq}", connect=4)
evt = sub.subscribe(u"ᛋᚳᛖᚪᛚ/+/ᚦᛖᚪᚻ", qos=0)
if not isinstance(evt, EventSuback) or \
evt.mid != sub.get_last_mid():
debug(evt)
return False
topic = u"ᛋᚳᛖᚪᛚ/䑓/ᚦᛖᚪᚻ"
content = u"На берегу пустынных волн"
evt = pub.publish(topic, payload=content, qos=0)
evt = sub.recv()
if not isinstance(evt, EventPublish) or\
evt.msg.topic != topic:
debug(evt)
return false
content2 = evt.msg.payload.decode('utf8')
if content2 != content:
debugt("payload differs: {0} != {1}".format(content, content2))
return False
sub.disconnect()
pub.disconnect()
return True
def test_232(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
sub = MqttClient("conformity-sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=2)
pub.publish("foo/bar", "grrr", qos=2) # receive PUBREC as response
pub.pubrel(pub.get_last_mid(),
read_response=False) # triggers message delivery
evt = sub.recv()
if not isinstance(evt, EventPublish) or evt.msg.payload != "grrr":
debug(evt)
return False
ack = sub.unsubscribe("foo/bar")
if not isinstance(ack, EventUnsuback):
debug(ack)
return False
rel = sub.pubrec(evt.msg.mid)
if not isinstance(rel, EventPubrel):
debug(rel)
return False
sub.pubcomp(evt.msg.mid)
comp = pub.recv()
if not isinstance(comp, EventPubcomp):
debug(comp)
return False
pub.disconnect()
sub.disconnect()
return True
def test_012(self):
monitor = MqttClient("monitor:{seq}", connect=4)
# NOTE: '/' prefix skips $ messages
# TODO: remove it when '$' filter will be impl.
monitor.subscribe("/#", qos=2)
client = MqttClient("rabbit:{seq}") # no keepalive
will = {
'topic': '/node/disconnect',
'message': client.clientid(),
'retain': True
}
client.connect(version=4, will=will)
client.socket_close()
evt = monitor.recv()
if not isinstance(evt, EventPublish) or evt.msg.topic != will['topic'] or \
evt.msg.payload != will['message'] or \
evt.msg.qos != 0:
debug(evt)
return False
if not evt.msg.retain:
debug("evt remain flag set")
return False
monitor.disconnect()
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_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_020(self):
retain = MqttClient("retain:{seq}", connect=4)
sub = MqttClient("subscriber:{seq}", connect=4)
topic = "/woot/wo/ot"
msg = "expression of simplistic ecstasy"
retain.publish(topic, msg, retain=True)
# exact match topic
sub.subscribe("/woot/wo/ot", qos=0, read_response=False)
while True:
evt = sub.recv()
if isinstance(evt, EventSuback):
acked = True
continue
# receiving retained message
if isinstance(evt, EventPublish) and\
evt.msg.topic == topic and\
evt.msg.payload == msg and\
evt.msg.retain:
pubevt = evt
continue
break
if not acked:
debug("not acked")
return False
if pubevt is None:
debug("message not received")
return False
return True
def test_003(self):
monitor = MqttClient("monitor:{seq}", connect=4)
# NOTE: '/' prefix skips $ messages
# TODO: remove it when '$' filter will be impl.
monitor.subscribe("/#", qos=0)
client = MqttClient("rabbit:{seq}", keepalive=2)
will = {'topic': '/node/disconnect', 'message': client.clientid()}
client.connect(version=4, will=will)
time.sleep(1)
client.send_pingreq()
evt = monitor.recv()
if monitor.recv() != None:
debug(evt)
return False
time.sleep(4)
evt = monitor.recv()
if not isinstance(evt, EventPublish) or evt.msg.topic != will['topic'] or \
evt.msg.payload != will['message']:
debug(evt)
return False
monitor.disconnect()
return True
def test_012(self):
pub = MqttClient("conformity:{seq}", connect=4)
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("/retain/+", qos=0)
pub.publish("/retain/delivered", 'waze', retain=True)
msg = sub.recv()
if not isinstance(msg, EventPublish) or \
msg.msg.topic != '/retain/delivered' or \
msg.msg.payload != 'waze' or\
msg.msg.retain:
debug(msg)
return False
# same with empty payload
pub.publish("/retain/empty", '', retain=True)
msg = sub.recv()
if not isinstance(msg, EventPublish) or \
msg.msg.topic != '/retain/empty' or \
msg.msg.payload != None or\
msg.msg.retain:
debug(msg)
return False
pub.disconnect()
sub.disconnect()
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_231(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
sub = MqttClient("conformity-sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=1)
pub.publish("foo/bar", "grrr", qos=1)
evt = sub.recv()
if not isinstance(evt, EventPublish) or evt.msg.payload != "grrr":
debug(evt)
return False
ack = sub.unsubscribe("foo/bar")
if not isinstance(ack, EventUnsuback):
debug(ack)
return False
sub.puback(evt.msg.mid)
ack2 = pub.recv()
if not isinstance(ack2, EventPuback):
debug(ack2)
return False
pub.disconnect()
sub.disconnect()
return True
def test_203(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
sub = MqttClient("conformity-sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=2)
pub.publish("foo/bar", "wootwoot", qos=2, read_response=False)
# PUB PUBREC
evt = pub.recv()
pub.pubrel(pub.get_last_mid(), read_response=False)
# subscr: receiving PUBLISH
evt = sub.recv()
sub.pubrec(evt.msg.mid, read_response=False)
# subscr: receiving PUBREL
evt = sub.recv()
# sending PUBCOMP with wrong pktid
sub.forge(
NC.CMD_PUBCOMP,
0,
[('uint16', (evt.mid + 10) % 65535) # wrong pktid
],
send=True)
evt = pub.recv()
# publisher: PUBCOMP never received
if evt is not None:
debug(evt)
return False
pub.disconnect()
sub.disconnect()
return True
def test_112(self):
## PINGREG
c = MqttClient("conformity:{seq}", raw_connect=True)
evt = c.connect(version=4)
# flags shoud be 0
c.forge(NC.CMD_PINGREQ, 4, [], send=True)
if c.conn_is_alive():
debug("connection still alive")
return False
## SUBSCRIBE
c = MqttClient("conformity2:{seq}", raw_connect=True)
evt = c.connect(version=4)
# flags shoud be 2
c.forge(
NC.CMD_SUBSCRIBE,
3,
[
('uint16', 42), # identifier
('string', '/foo/bar'), # topic filter
('byte', 0) # qos
],
send=True)
if c.conn_is_alive():
debug("connection still alive")
return False
return True
def test_200(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
sub = MqttClient("conformity-sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=1)
pub.publish("foo/bar", "wootwoot", qos=1)
# reading PUBLISH
evt = sub.recv()
# sending PUBACK with wrong pktid
sub.forge(
NC.CMD_PUBACK,
0,
[('uint16', (evt.msg.mid + 10) % 65535) # wrong pktid
],
send=True)
evt = pub.recv()
# PUBACK from server is never received
if evt is not None:
debug(evt)
return False
pub.disconnect()
sub.disconnect()
return True
def test_012(self):
pub = MqttClient("publisher:{seq}", connect=4)
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
if c.connack().session_present != 0:
debug("session present")
return False
c.subscribe("/cs/qos-0", qos=0)
c.disconnect()
# reconnect w/ same clientid
time.sleep(.5)
c2 = MqttClient(client_id=c.client_id, connect=4, clean_session=0)
if c2.connack().session_present != 1:
debug("session not present")
return False
pub.publish("/cs/qos-0", "", qos=1)
evt = c2.recv()
if not isinstance(evt, EventPublish) or\
evt.msg.topic != '/cs/qos-0' or\
evt.msg.qos != 0:
debug(evt)
return False
return True
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_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_013(self):
pub = MqttClient("conformity:{seq}", connect=4)
sub = MqttClient("sub:{seq}", connect=4)
sub.subscribe("/test/022/013/+", qos=2)
pub.publish("/test/022/013/t1", 'hurry', retain=True, qos=1)
msg = sub.recv()
if not isinstance(msg, EventPublish) or \
msg.msg.topic != '/test/022/013/t1' or \
msg.msg.payload != 'hurry' or\
msg.msg.qos != 1 or\
msg.msg.retain:
debug(msg)
return False
# same with empty payload
pub.publish("/test/022/013/t2", 'up', retain=True, qos=2)
pub.pubrel(pub.get_last_mid())
msg = sub.recv()
if not isinstance(msg, EventPublish) or \
msg.msg.topic != '/test/022/013/t2' or \
msg.msg.payload != "up" or\
msg.msg.qos != 2 or\
msg.msg.retain:
debug(msg)
return False
return True
def test_023(self):
retain = MqttClient("retain:{seq}", connect=4)
sub = MqttClient("subscr:{seq}", connect=4)
# matching topics
rs = {
# match
"dead/bea/t k/id/s": {
'topic': "dead/bea/t k/id/s",
'payload': "children that just aren't worth supporting",
'retain': True
},
# match
"dead/abe/t k/id/s": {
'topic': "dead/abe/t k/id/s",
'payload': "just children that aren't supporting worth",
'retain': True
},
}
for args in rs.values():
retain.publish(**args)
# no match
nors = {
'topic': "dead/be/a/t k/ids",
'payload': "children that just aren't worth supporting",
'retain': True
}
retain.publish(**nors)
#NOTE: we must receive BOTH rs message, but NOT nors one
#NOTE: PUBLISH messages MAY arrived BEFORE PUBACK
sub.subscribe("dead/+/t k/#", qos=0, read_response=False)
count = 0
while True:
evt = sub.recv()
if evt is None:
break
if isinstance(evt, EventSuback):
continue
if not isinstance(evt, EventPublish) or\
not evt.msg.retain or\
evt.msg.topic not in rs:
debug(evt)
return False
count += 1
if count != len(rs):
debug("not received enough messages")
return False
retain.disconnect()
sub.disconnect()
return True
def test_213(self):
c = MqttClient("conformity:{seq}", connect=4)
c.publish("foo/+/bar", "", qos=0)
if c.conn_is_alive():
debug("connection still alive")
return False
c = MqttClient("conformity:{seq}", connect=4)
c.publish("foo/#/bar", "", qos=0)
if c.conn_is_alive():
debug("connection still alive")
return False
return True
def test_021(self):
c = MqttClient("metrics:{seq}", connect=4)
d = MqttClient("duck:{seq}", connect=3)
c.subscribe('$SYS/#', qos=0)
pubs_start = sys_value(c, "$SYS/broker/publish/messages/received", int)
d.publish("foo/bar", "")
pubs_end = sys_value(c, "$SYS/broker/publish/messages/received", int)
if pubs_end != pubs_start + 1:
debug("{0}, {1}".format(pubs_start, pubs_end))
return False
c.disconnect()
return True
def test_021(self):
retain = MqttClient("retain:{seq}", connect=4)
sub = MqttClient("subscriber:{seq}", connect=4)
topic = "/woot/wo/ot"
msg = "expression of simplistic ecstasy"
retain.publish(topic, msg, retain=True)
# wildcard match topic
sub.subscribe("/woot/+/ot", qos=0, read_response=False)
acked = False
pubevt = None
while True:
evt = sub.recv()
if isinstance(evt, EventSuback):
acked = True
continue
# receiving retained message
if isinstance(evt, EventPublish) and\
evt.msg.topic == topic and\
evt.msg.payload == msg and\
evt.msg.retain:
pubevt = evt
continue
break
if not acked:
debug("not acked")
return False
if pubevt is None:
debug("message not received")
return False
# MUST NOT match
topic = "/scri/b/b/le"
msg = "hundrerd dollar bill"
retain.publish(topic, msg, retain=True)
sub.subscribe("/scri/*/le", qos=0)
evt = sub.recv()
if evt is not None:
debug(evt)
return False
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_105(self):
c = MqttClient("conformity:{seq}")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(('127.0.0.1', 1883))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(0)
except Exception as e:
debug(e)
return False
c._c.sock = sock
ret = c.forge(
NC.CMD_CONNECT,
0,
[
('string', 'MQTT'),
('byte', NC.PROTOCOL_VERSION_4),
('byte', 1 << 6), # set password flag
('uint16', 60), # keepalive
('string', 'ff') # client id
],
send=True)
if ret != NC.ERR_CONN_LOST:
debug("invalid error code: {0}".format(ret))
return False
return True
def test_108(self):
c = MqttClient("conformity:{seq}")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(('127.0.0.1', 1883))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(0)
except Exception as e:
debug(e)
return False
c._c.sock = sock
c.forge(
NC.CMD_CONNECT,
0,
[
('string', 'MQTT'),
('byte', NC.PROTOCOL_VERSION_4),
('byte', 0), # flags
('uint16', 10), # keepalive
('string', '') # client id
],
send=True)
evt = c._c.pop_event()
if not isinstance(evt, EventConnack) or evt.ret_code != 2:
debug(evt)
return False
return True
def test_014(self):
c = MqttClient("cs:{seq}", connect=4, clean_session=0)
if c.connack().session_present != 0:
debug("session present")
return False
c.disconnect()
# reconnect w/ same clientid, cleansession = 0
time.sleep(.5)
c2 = MqttClient(client_id=c.client_id, connect=4, clean_session=0)
if c2.connack().session_present != 1:
debug("session not present")
return False
c2.disconnect()
return True
def test_109(self):
c = MqttClient("conformity:{seq}")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(('127.0.0.1', 1883))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(0)
except Exception as e:
debug(e)
return False
c._c.sock = sock
pkt = MqttPkt()
pkt.command = NC.CMD_CONNECT
pkt.remaining_length = 12 + 26 # client_id = "ff"
pkt.alloc()
pkt.write_string("MQTT")
pkt.write_byte(NC.PROTOCOL_VERSION_4)
pkt.write_byte(0) # flags
pkt.write_uint16(10) # keepalive
pkt.write_string("ABCDEFGHIJKLMNOPQRSTUVWXYZ") # client id - 26 chars
c._c.packet_queue(pkt)
c._c.packet_write()
c._c.loop()
if c.conn_is_alive():
debug("connection still alive")
return False
return True
def test_100(self):
c = MqttClient("conformity:{seq}")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(('127.0.0.1', 1883))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(0)
except Exception as e:
debug(e)
return False
c._c.sock = sock
e = c.subscribe("foo/bar", qos=0)
if e is not None:
debug(e)
return False
# socket MUST be disconnected
try:
e = c.publish("foo", "bar")
sock.getpeername()
except socket.error as e:
return True
debug("connection still alive")
return False
def test_103(self):
c = MqttClient("conformity:{seq}")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(('127.0.0.1', 1883))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(0)
except Exception as e:
debug(e)
return False
c._c.sock = sock
c.forge(
NC.CMD_CONNECT,
0,
[
('string', 'MQTT'),
('byte', NC.PROTOCOL_VERSION_3),
('byte', 0), # flags
('uint16', 60), # keepalive
('string', 'ff') # client id
],
send=True) # should return CONN_REFUSED
evt = c._c.pop_event()
if not isinstance(evt, EventConnack) or evt.ret_code != 1:
debug(evt)
return False
ret = c._c.loop()
if ret != NC.ERR_CONN_LOST:
debug("invalid error code: {0}".format(ret))
return False
return True
def test_011(self):
c = MqttClient("reg:{seq}", connect=4)
e = c.publish("/foo/bar", "plop")
# QOS = 0 : no response indented
c.disconnect()
return (e is None)
