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=u"mqtt")) 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( 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, (ConnACK(session_present=False, return_code=0).serialise() + SubACK(packet_identifier=1, return_codes=[0]).serialise())) client_protocol.data = b"" session.publish(u"com.test.wamp", u"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=u"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="foo", packet_identifier=1, payload=b"bar").serialise() data = ( Connect(client_id="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_lastwill(self): """ FIXME: reactivate this test. The MQTT client can set a last will message which will be published when it disconnects. """ reactor, router, server_factory, session_factory = build_mqtt_server() session, pump = connect_application_session( server_factory, ObservingSession, component_config=ComponentConfig(realm="mqtt", controller=MockContainer())) client_transport, client_protocol, mqtt_pump = connect_mqtt_server( server_factory) client_transport.write( Connect(client_id="testclient", username="******", password="******", will_topic="test", will_message=b'{"args":["foobar"]}', flags=ConnectFlags(clean_session=False, username=True, password=True, will=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(Disconnect().serialise()) mqtt_pump.flush() pump.flush() self.assertEqual(client_transport.disconnected, True) # 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": ["foobar"]}])
def test_unknown_connect_code_must_lose_connection(self): """ A non-zero, and non-1-to-5 connect code from the handler must result in a lost connection, and no CONNACK. Compliance statements MQTT-3.2.2-4, MQTT-3.2.2-5 """ h = BasicHandler(6) 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) self.assertTrue(t.disconnecting) self.assertEqual(t.value(), b'')
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="mqtt", controller=MockContainer())) client_transport, client_protocol, mqtt_pump = connect_mqtt_server( server_factory) client_transport.write( Connect(client_id="testclient", username="******", 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="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": { 'bar': 'baz' } }])
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_transport_paused_while_processing(self): """ The transport is paused whilst the MQTT protocol is parsing/handling existing items. """ d = Deferred() h = BasicHandler() h.process_connect = lambda x: d r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=False)).serialise()) self.assertEqual(t.producerState, 'producing') for x in iterbytes(data): p.dataReceived(x) self.assertEqual(t.producerState, 'paused') d.callback((0, False)) self.assertEqual(t.producerState, 'producing')
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_non_zero_connect_code_must_have_no_present_session(self): """ A non-zero connect code in a CONNACK must be paired with no session present. Compliance statement MQTT-3.2.2-4 """ h = BasicHandler(self.connect_code) 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) events = cp.data_received(t.value()) self.assertEqual(len(events), 1) self.assertEqual(attr.asdict(events[0]), { 'return_code': self.connect_code, 'session_present': False, })
def test_unsubscription_gets_unsuback_with_same_id(self): """ When an unsubscription is processed, the UnsubACK has the same ID. Unsubscriptions are always processed. Compliance statements MQTT-3.10.4-4, MQTT-3.10.4-5, MQTT-3.12.4-1 """ got_packets = [] class SubHandler(BasicHandler): def process_unsubscribe(self, event): got_packets.append(event) return succeed(None) h = SubHandler() r, t, p, cp = make_test_items(h) unsub = Unsubscribe(packet_identifier=1234, topics=["foo"]).serialise() data = ( Connect(client_id="test123", flags=ConnectFlags(clean_session=True)).serialise() + unsub ) for x in iterbytes(data): p.dataReceived(x) events = cp.data_received(t.value()) self.assertEqual(len(events), 2) self.assertFalse(t.disconnecting) # UnsubACK that has the same ID self.assertIsInstance(events[1], UnsubACK) self.assertEqual(events[1].packet_identifier, 1234) # The unsubscribe handler should have been called self.assertEqual(len(got_packets), 1) self.assertEqual(got_packets[0].serialise(), unsub)
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="test123", flags=ConnectFlags(clean_session=False)) pub = Publish(duplicate=False, qos_level=3, retain=False, topic_name="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_got_sent_packet(self): """ `process_connect` on the handler will get the correct Connect packet. """ got_packets = [] class SubHandler(BasicHandler): def process_connect(self_, event): got_packets.append(event) return succeed((0, False)) h = SubHandler() 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) self.assertEqual(len(got_packets), 1) self.assertEqual(got_packets[0].client_id, u"test123") self.assertEqual(got_packets[0].serialise(), data)
def test_exception_in_subscribe_drops_connection(self): """ Transient failures (like an exception from handler.process_subscribe) will cause the connection it happened on to be dropped. Compliance statement MQTT-4.8.0-2 """ class SubHandler(BasicHandler): @inlineCallbacks def process_subscribe(self, event): raise Exception("boom!") h = SubHandler() r, t, p, cp = make_test_items(h) data = (Connect(client_id=u"test123", flags=ConnectFlags(clean_session=True)).serialise() + Subscribe(packet_identifier=1234, topic_requests=[SubscriptionTopicRequest(u"a", 0) ]).serialise()) with LogCapturer("trace") as logs: for x in iterbytes(data): p.dataReceived(x) sent_logs = logs.get_category("MQ501") 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)