def _test_retained(self): """ The MQTT client can set and receive retained messages. """ reactor, router, server_factory, session_factory = build_mqtt_server() client_transport, client_protocol, mqtt_pump = connect_mqtt_server( server_factory) client_transport.write( Connect(client_id=u"testclient", username=u"test123", password=u"password", flags=ConnectFlags(clean_session=False, username=True, password=True)).serialise()) client_transport.write( Publish(duplicate=False, qos_level=1, retain=True, topic_name=u"com/test/wamp", packet_identifier=123, payload=b'{}').serialise()) mqtt_pump.flush() self.assertEqual( client_protocol.data, (ConnACK(session_present=False, return_code=0).serialise() + PubACK(packet_identifier=123).serialise())) client_protocol.data = b"" client_transport.write( Subscribe(packet_identifier=1, topic_requests=[ SubscriptionTopicRequest( topic_filter=u"com/test/wamp", max_qos=0) ]).serialise()) mqtt_pump.flush() self.assertEqual( client_protocol.data, SubACK(packet_identifier=1, return_codes=[0]).serialise()) client_protocol.data = b"" reactor.advance(0.1) mqtt_pump.flush() # This needs to be replaced with the real deal, see https://github.com/crossbario/crossbar/issues/885 self.assertEqual( client_protocol.data, Publish(duplicate=False, qos_level=0, retain=True, topic_name=u"com/test/wamp", payload=json.dumps( {}, sort_keys=True).encode('utf8')).serialise())
def _test_basic_publish(self): reactor, router, server_factory, session_factory = build_mqtt_server() session, pump = connect_application_session( server_factory, ObservingSession, component_config=ComponentConfig(realm=u"mqtt")) client_transport, client_protocol, mqtt_pump = connect_mqtt_server(server_factory) client_transport.write( Connect(client_id=u"testclient", username=u"test123", password=u"password", flags=ConnectFlags(clean_session=False, username=True, password=True)).serialise()) mqtt_pump.flush() # We get a CONNECT self.assertEqual(client_protocol.data, ConnACK(session_present=False, return_code=0).serialise()) client_protocol.data = b"" client_transport.write( Publish(duplicate=False, qos_level=0, retain=False, topic_name=u"test", payload=b'{"kwargs": {"bar": "baz"}}').serialise()) mqtt_pump.flush() pump.flush() # This needs to be replaced with the real deal, see https://github.com/crossbario/crossbar/issues/885 self.assertEqual(len(session.events), 1) self.assertEqual( session.events, [{"args": tuple(), "kwargs": {u'bar': u'baz'}}])
def test_lose_conn_on_reserved_qos3(self): """ If we get, somehow, a QoS "3" Publish (one with both QoS bits set to 3), we will drop the connection. Compliance statement: MQTT-3.3.1-4 """ h = BasicHandler() r, t, p, cp = make_test_items(h) conn = Connect(client_id=u"test123", flags=ConnectFlags(clean_session=False)) pub = Publish(duplicate=False, qos_level=3, retain=False, topic_name=u"foo", packet_identifier=1, payload=b"bar") with LogCapturer("trace") as logs: p._handle_events([conn, pub]) sent_logs = logs.get_category("MQ403") self.assertEqual(len(sent_logs), 1) self.assertEqual(sent_logs[0]["log_level"], LogLevel.error) self.assertTrue(t.disconnecting)
def test_qos_2_queues_message(self): """ The WAMP layer calling send_publish will queue a message up for sending, and send it next time it has a chance. """ h = BasicHandler() r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise()) for x in iterbytes(data): p.dataReceived(x) # Connect has happened events = cp.data_received(t.value()) t.clear() self.assertFalse(t.disconnecting) self.assertIsInstance(events[0], ConnACK) # WAMP layer calls send_publish, with QoS 2 p.send_publish(u"hello", 2, b'some bytes', False) # Nothing should have been sent yet, it is queued self.assertEqual(t.value(), b'') # Advance the clock r.advance(0.1) # We should now get the sent Publish expected_publish = Publish(duplicate=False, qos_level=2, retain=False, packet_identifier=1, topic_name=u"hello", payload=b"some bytes") events = cp.data_received(t.value()) t.clear() self.assertEqual(len(events), 1) self.assertEqual(events[0], expected_publish) # We send the PubREC, which we should get a PubREL back with pubrec = PubREC(packet_identifier=1) for x in iterbytes(pubrec.serialise()): p.dataReceived(x) events = cp.data_received(t.value()) t.clear() self.assertEqual(len(events), 1) self.assertEqual(events[0], PubREL(packet_identifier=1)) # We send the PubCOMP, which has no response pubcomp = PubCOMP(packet_identifier=1) for x in iterbytes(pubcomp.serialise()): p.dataReceived(x) self.assertFalse(t.disconnecting)
def _(proto): p.append(proto) proto.transport.write( Connect(client_id=u"test123", flags=ConnectFlags(clean_session=False)).serialise()) proto.transport.write( Publish(duplicate=False, qos_level=1, retain=False, topic_name=u"test", payload=b"{}", packet_identifier=1).serialise())
def _test_basic_subscribe(self): """ The MQTT client can subscribe to a WAMP topic and get messages. """ reactor, router, server_factory, session_factory = build_mqtt_server() client_transport, client_protocol, mqtt_pump = connect_mqtt_server( server_factory) session, pump = connect_application_session( server_factory, ApplicationSession, component_config=ComponentConfig(realm="mqtt", controller=MockContainer())) client_transport.write( Connect(client_id="testclient", username="******", password="******", flags=ConnectFlags(clean_session=False, username=True, password=True)).serialise()) client_transport.write( Subscribe(packet_identifier=1, topic_requests=[ SubscriptionTopicRequest( topic_filter="com/test/wamp", max_qos=0) ]).serialise()) mqtt_pump.flush() self.assertEqual( client_protocol.data, (ConnACK(session_present=False, return_code=0).serialise() + SubACK(packet_identifier=1, return_codes=[0]).serialise())) client_protocol.data = b"" session.publish("com.test.wamp", "bar") pump.flush() reactor.advance(0.1) mqtt_pump.flush() self.assertEqual( client_protocol.data, Publish(duplicate=False, qos_level=0, retain=False, topic_name="com/test/wamp", payload=b'{"args":["bar"]}').serialise())
def test_qos_1_sends_ack(self): """ When a QoS 1 Publish packet is recieved, we send a PubACK with the same packet identifier as the original Publish. Compliance statement MQTT-3.3.4-1 Spec part 3.4 """ got_packets = [] class PubHandler(BasicHandler): def process_publish_qos_1(self, event): got_packets.append(event) return succeed(None) h = PubHandler() r, t, p, cp = make_test_items(h) pub = Publish(duplicate=False, qos_level=1, retain=False, topic_name=u"foo", packet_identifier=1, payload=b"bar").serialise() data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise() + pub) with LogCapturer("trace") as logs: for x in iterbytes(data): p.dataReceived(x) events = cp.data_received(t.value()) self.assertFalse(t.disconnecting) # ConnACK + PubACK with the same packet ID self.assertEqual(len(events), 2) self.assertEqual(events[1], PubACK(packet_identifier=1)) # The publish handler should have been called self.assertEqual(len(got_packets), 1) self.assertEqual(got_packets[0].serialise(), pub) # We should get a debug message saying we got the publish messages = logs.get_category("MQ202") self.assertEqual(len(messages), 1) self.assertEqual(messages[0]["publish"].serialise(), pub)
def test_qos_0_sends_no_ack(self): """ When a QoS 0 Publish packet is recieved, we don't send back a PubACK. """ got_packets = [] class PubHandler(BasicHandler): def process_publish_qos_0(self, event): got_packets.append(event) return succeed(None) h = PubHandler() r, t, p, cp = make_test_items(h) pub = Publish(duplicate=False, qos_level=0, retain=False, topic_name=u"foo", packet_identifier=None, payload=b"bar").serialise() data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise() + pub) with LogCapturer("trace") as logs: for x in iterbytes(data): p.dataReceived(x) events = cp.data_received(t.value()) self.assertFalse(t.disconnecting) # Just the connack, no puback. self.assertEqual(len(events), 1) # The publish handler should have been called self.assertEqual(len(got_packets), 1) self.assertEqual(got_packets[0].serialise(), pub) # We should get a debug message saying we got the publish messages = logs.get_category("MQ201") self.assertEqual(len(messages), 1) self.assertEqual(messages[0]["publish"].serialise(), pub)
def test_qos_0_queues_message(self): """ The WAMP layer calling send_publish will queue a message up for sending, and send it next time it has a chance. """ h = BasicHandler() r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise()) for x in iterbytes(data): p.dataReceived(x) # Connect has happened events = cp.data_received(t.value()) t.clear() self.assertFalse(t.disconnecting) self.assertIsInstance(events[0], ConnACK) # WAMP layer calls send_publish p.send_publish(u"hello", 0, b'some bytes', False) # Nothing should have been sent yet, it is queued self.assertEqual(t.value(), b'') # Advance the clock r.advance(0.1) # We should now get the sent Publish events = cp.data_received(t.value()) self.assertEqual(len(events), 1) self.assertEqual( events[0], Publish(duplicate=False, qos_level=0, retain=False, packet_identifier=None, topic_name=u"hello", payload=b"some bytes"))
def test_qos_2_failure_drops_connection(self): """ Transient failures (like an exception from handler.process_publish_qos_2) will cause the connection it happened on to be dropped. Compliance statement MQTT-4.8.0-2 """ class PubHandler(BasicHandler): def process_publish_qos_2(self, event): raise Exception("boom!") h = PubHandler() r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise() + Publish(duplicate=False, qos_level=2, retain=False, topic_name=u"foo", packet_identifier=1, payload=b"bar").serialise()) with LogCapturer("trace") as logs: for x in iterbytes(data): p.dataReceived(x) sent_logs = logs.get_category("MQ505") self.assertEqual(len(sent_logs), 1) self.assertEqual(sent_logs[0]["log_level"], LogLevel.critical) self.assertEqual(sent_logs[0]["log_failure"].value.args[0], "boom!") events = cp.data_received(t.value()) self.assertEqual(len(events), 1) self.assertTrue(t.disconnecting) # We got the error, we need to flush it so it doesn't make the test # error self.flushLoggedErrors()
def test_qos_2_resent_on_disconnect_pubcomp(self): """ If we send a QoS2 Publish and we did not get a PubCOMP from the client before it disconnected, we will resend the PubREL packet if it connects with a non-clean session. Compliance statements: MQTT-4.4.0-1, MQTT-3.3.1-1 """ h = BasicHandler() r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=False)).serialise()) for x in iterbytes(data): p.dataReceived(x) # WAMP layer calls send_publish, with QoS 2 p.send_publish(u"hello", 2, b'some bytes', False) # Advance the clock r.advance(0.1) # We should now get the sent Publish expected_publish = Publish(duplicate=False, qos_level=2, retain=False, packet_identifier=1, topic_name=u"hello", payload=b"some bytes") events = cp.data_received(t.value()) t.clear() self.assertEqual(len(events), 2) self.assertEqual(events[1], expected_publish) # We send the PubREC to this Publish pubrec = PubREC(packet_identifier=1) for x in iterbytes(pubrec.serialise()): p.dataReceived(x) # Should get a PubREL back events = cp.data_received(t.value()) t.clear() self.assertEqual(len(events), 1) self.assertEqual(events[0], PubREL(packet_identifier=1)) # Disconnect the client t.connected = False t.loseConnection() p.connectionLost(None) r2, t2, p2, cp2 = make_test_items(h) # We must NOT have a clean session data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=False)).serialise()) for x in iterbytes(data): p2.dataReceived(x) # The flushing is queued, so we'll have to spin the reactor r2.advance(0.1) # Should get a resent PubREL back events = cp2.data_received(t2.value()) t2.clear() self.assertEqual(len(events), 2) self.assertIsInstance(events[0], ConnACK) self.assertEqual(events[1], PubREL(packet_identifier=1)) self.assertFalse(t2.disconnecting) # We send the PubCOMP to this PubREL pubcomp = PubCOMP(packet_identifier=1) for x in iterbytes(pubcomp.serialise()): p2.dataReceived(x) # No more packets sent to us events = cp2.data_received(t2.value()) self.assertEqual(len(events), 0) self.assertFalse(t2.disconnecting)
def test_qos_1_resent_on_disconnect(self): """ If we send a QoS1 Publish and we did not get a PubACK from the client before it disconnected, we will resend the Publish packet if it connects with a non-clean session. Compliance statements: MQTT-4.4.0-1, MQTT-3.3.1-1 """ h = BasicHandler() r, t, p, cp = make_test_items(h) data = ( Connect(client_id="test123", flags=ConnectFlags(clean_session=False)).serialise() ) for x in iterbytes(data): p.dataReceived(x) # WAMP layer calls send_publish, with QoS 1 p.send_publish("hello", 1, b'some bytes', False) # Advance the clock r.advance(0.1) # We should now get the sent Publish expected_publish = Publish(duplicate=False, qos_level=1, retain=False, packet_identifier=1, topic_name="hello", payload=b"some bytes") events = cp.data_received(t.value()) t.clear() self.assertEqual(len(events), 2) self.assertEqual(events[1], expected_publish) # Disconnect the client t.connected = False t.loseConnection() p.connectionLost(None) r2, t2, p2, cp2 = make_test_items(h) # We must NOT have a clean session data = ( Connect(client_id="test123", flags=ConnectFlags(clean_session=False)).serialise() ) for x in iterbytes(data): p2.dataReceived(x) # The flushing is queued, so we'll have to spin the reactor r2.advance(0.1) # We should have two events; the ConnACK, and the Publish. The ConnACK # MUST come first. events = cp2.data_received(t2.value()) t2.clear() self.assertEqual(len(events), 2) self.assertIsInstance(events[0], ConnACK) self.assertIsInstance(events[1], Publish) # The Publish packet must have DUP set to True. resent_publish = Publish(duplicate=True, qos_level=1, retain=False, packet_identifier=1, topic_name="hello", payload=b"some bytes") self.assertEqual(events[1], resent_publish) # We send the PubACK to this Publish puback = PubACK(packet_identifier=1) for x in iterbytes(puback.serialise()): p2.dataReceived(x) events = cp2.data_received(t2.value()) self.assertEqual(len(events), 0) self.assertFalse(t2.disconnecting)