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_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_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_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_030(self):
retain = MqttClient("retain:{seq}", connect=4)
sub = MqttClient("subscr:{seq}", connect=4)
msg = {'topic': "baby/ma/ma", 'payload': "The mother of your child(ren)", 'retain': True,
'qos': 1}
retain.publish(**msg)
sub.subscribe("baby/ma/+", qos=1, read_response=False)
pubevt = None
while True:
evt = sub.recv()
if isinstance(evt, EventSuback): continue
if isinstance(evt, EventPublish) and\
evt.msg.qos == 1 and\
evt.msg.retain and\
evt.msg.topic == msg['topic'] and\
evt.msg.payload == msg['payload']:
pubevt = evt; continue
break
if pubevt is None:
debug("message not received")
return False
sub.puback(mid=pubevt.msg.mid)
retain.disconnect(); sub.disconnect()
return True
def test_022(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/#", 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
retain.disconnect(); sub.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_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_202(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()
# sending PUBREL with wrong pktid
pub.forge(NC.CMD_PUBREL, 2, [
('uint16', (evt.mid+10)%65535) # wrong pktid
], send=True)
# subscriber: PUBLISH never received
evt = sub.recv()
if evt is not None:
debug(evt)
return False
evt = pub.recv()
# publisher: PUBCOMP never received
if evt is not None:
debug(evt)
return False
pub.disconnect(); sub.disconnect()
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_270(self):
pub = MqttClient("luser:{seq}", connect=4)
pub.publish("$foo/bar", "test1")
if pub.conn_is_alive():
debug("connection still alive")
return False
return True
def test_003(self):
c = MqttClient("conformity:{seq}", connect=4)
c.publish("/foo/bar/2", "plop", qos=2, retain=True)
c.disconnect()
# checking message as been store in db
store = env.db.hgetall('retain:/foo/bar/2')
if store.get('data') != 'plop' or store.get('qos') != '2':
debug(store)
return False
return True
def _(qos):
v_start = yield exometer.value('wave.messages.in.'+str(qos))
c = MqttClient("metrics:{seq}", connect=4)
c.publish("foo/bar", "", qos=qos)
c.disconnect()
v_end = yield exometer.value('wave.messages.in.'+str(qos))
if v_end['count'] - v_start['count'] != 1:
debug("{0}, {1}".format(v_end, v_start))
defer.returnValue(False)
defer.returnValue(True)
def test_001(self):
c = MqttClient("conformity:{seq}", connect=4)
c.publish("/foo/bar/0", "plop", qos=0, retain=True)
c.disconnect()
# checking message as been store in db
store = env.db.hgetall('retain:/foo/bar/0')
if not (store.get('data') == 'plop' and store.get('qos') == '0'):
debug(store)
return False
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_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_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_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)
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_020(self):
ws = MqttClient("ws:{seq}", port=1884, websocket=True, connect=4)
tcp = MqttClient("tcp:{seq}", connect=4)
tcp.subscribe("foo/bar", qos=0)
ws.publish("foo/bar", "baz", qos=0)
evt = tcp.recv()
if not isinstance(evt, EventPublish) or\
evt.msg.topic != "foo/bar" or\
evt.msg.payload != "baz":
debug(evt)
return False
ws.disconnect(); tcp.disconnect()
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_010(self):
c = MqttClient("conformity:{seq}", connect=4)
c.publish("/retain/delete", 'waze', qos=0, retain=True)
store = env.db.hgetall("retain:/retain/delete")
if store != {'data': 'waze', 'qos': '0'}:
debug(store)
return False
# deleting message
c.publish("/retain/delete", '', retain=True)
retain = env.db.keys('retain:/retain/delete')
if retain != []:
debug("retain= {0}".format(retain))
return False
c.disconnect()
return True
def test_240(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
pub.publish("foo/bar", "", qos=2, read_response=False); mid1 = pub.get_last_mid()
pub.publish("bar/baz", "", qos=2, read_response=False); mid2 = pub.get_last_mid()
evt = pub.recv()
if not isinstance(evt, EventPubrec) or evt.mid != mid1:
debug(evt)
return False
evt = pub.recv()
if not isinstance(evt, EventPubrec) or evt.mid != mid2:
debug(evt)
return False
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_011(self):
c = MqttClient("v311:{seq}", connect=4)
e = c.publish("/foo/bar", payload="plop")
# QOS = 0 : no response indented
if e is not None:
debug(e)
c.disconnect()
return False
c.disconnect()
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_230(self):
pub = MqttClient("conformity-pub:{seq}", connect=4)
sub = MqttClient("conformity-sub:{seq}", connect=4)
sub.subscribe("foo/bar", qos=0)
pub.publish("foo/bar", "grrr", qos=0)
evt = sub.recv()
if not isinstance(evt, EventPublish) or evt.msg.payload != "grrr":
debug(evt)
return False
sub.unsubscribe("foo/bar")
pub.publish("foo/bar", "grrr bis", qos=0)
evt = sub.recv()
if evt is not None:
debug(evt)
return False
pub.disconnect(); sub.disconnect()
return True
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 _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_003(self):
f = open('../log/wave.access.log', 'r')
f.seek(0, os.SEEK_END)
yield app.set_acl(enabled=False)
# here we start
c = MqttClient("conformity:{seq}", connect=4)
c.publish("foo/bar", "baz", qos=1)
f.readline() # skip CONNECT
if not _match(
f, {
'request_method': 'PUBLISH',
'request_url': 'foo/bar',
'response_bytes_clf': '3',
'status': '200',
'request_header_user_agent': c.client_id
}):
defer.returnValue(False)
# test w/ acls on
yield app.set_acl(enabled=True)
c.publish("foo/bar", "", qos=0)
if not _match(
f, {
'request_method': 'PUBLISH',
'request_url': 'foo/bar',
'response_bytes_clf': '0',
'status': '403',
'request_header_user_agent': c.client_id
}):
defer.returnValue(False)
c.publish("foo/bar", "", qos=1)
if not _match(
f, {
'request_method': 'PUBLISH',
'request_url': 'foo/bar',
'response_bytes_clf': '0',
'status': '403',
'request_header_user_agent': c.client_id
}):
defer.returnValue(False)
c.publish("foo/bar", "", qos=2)
if not _match(
f, {
'request_method': 'PUBLISH',
'request_url': 'foo/bar',
'response_bytes_clf': '0',
'status': '403',
'request_header_user_agent': c.client_id
}):
defer.returnValue(False)
c.publish("foo/bat", "", qos=0)
if not _match(
f, {
'request_method': 'PUBLISH',
'request_url': 'foo/bat',
'response_bytes_clf': '0',
'status': '200',
'request_header_user_agent': c.client_id
}):
defer.returnValue(False)
c.disconnect()
defer.returnValue(True)
