async def send_test_message(i): print("sending message #" + str(i)) msg = Message("test wind speed " + str(i)) msg.message_id = uuid.uuid4() msg.correlation_id = "correlation-1234" msg.custom_properties["tornado-warning"] = "yes" await device_client.send_event(msg) print("done sending message #" + str(i))
async def test_send_to_output_calls_transport(self, client, transport): message = Message("this is a message") output_name = "some_output" await client.send_to_output(message, output_name) assert transport.send_output_event.call_count == 1 assert transport.send_output_event.call_args[0][0] == message assert message.output_name == output_name
def test_send_event_sends_overlapped_events(self, device_transport): fake_msg_1 = create_fake_message() fake_msg_2 = Message(fake_event_2) mock_mqtt_provider = device_transport._mqtt_provider # connect device_transport.connect() mock_mqtt_provider.on_mqtt_connected() # send an event callback_1 = MagicMock() device_transport.send_event(fake_msg_1, callback_1) mock_mqtt_provider.publish.assert_called_once_with( encoded_fake_topic, fake_msg_1.data) # while we're waiting for that send to complete, send another event callback_2 = MagicMock() device_transport.send_event(fake_msg_2, callback_2) # verify that we've called publish twice and verify that neither send_event # has completed (because we didn't do anything here to complete it). assert mock_mqtt_provider.publish.call_count == 2 callback_1.assert_not_called() callback_2.assert_not_called()
def test_receive_c2d_message_returns_message_from_c2d_inbox(self, mocker, client): message = Message("this is a message") inbox_mock = mocker.MagicMock(autospec=SyncClientInbox) inbox_mock.get.return_value = message manager_get_inbox_mock = mocker.patch.object( client._inbox_manager, "get_c2d_message_inbox", return_value=inbox_mock ) received_message = client.receive_c2d_message() assert manager_get_inbox_mock.call_count == 1 assert inbox_mock.get.call_count == 1 assert received_message is message
def test_send_message_with_no_properties(self, device_transport): fake_msg = Message("Petrificus Totalus") mock_mqtt_provider = device_transport._mqtt_provider device_transport.connect() mock_mqtt_provider.on_mqtt_connected() device_transport.send_event(fake_msg) mock_mqtt_provider.connect.assert_called_once_with( device_transport._auth_provider.get_current_sas_token()) mock_mqtt_provider.publish.assert_called_once_with( fake_topic, fake_msg.data)
def test_send_message_with_output_name(self, module_transport): fake_msg = Message("Petrificus Totalus") fake_msg.custom_properties[ custom_property_name] = custom_property_value fake_msg.output_name = "fake_output_name" fake_output_topic = ("devices/" + fake_device_id + "/modules/" + fake_module_id + "/messages/events/" + before_sys_key + "on" + after_sys_key + "fake_output_name" + topic_separator + custom_property_name + after_sys_key + custom_property_value) mock_mqtt_provider = module_transport._mqtt_provider module_transport.connect() mock_mqtt_provider.on_mqtt_connected() module_transport.send_event(fake_msg) mock_mqtt_provider.connect.assert_called_once_with( module_transport._auth_provider.get_current_sas_token()) mock_mqtt_provider.publish.assert_called_once_with( fake_output_topic, fake_msg.data)
async def test_receive_input_message_returns_message_from_input_inbox( self, mocker, client): message = Message("this is a message") inbox_mock = mocker.MagicMock(autospec=AsyncClientInbox) inbox_mock.get.return_value = await create_completed_future(message) manager_get_inbox_mock = mocker.patch.object(client._inbox_manager, "get_input_message_inbox", return_value=inbox_mock) input_name = "some_input" received_message = await client.receive_input_message(input_name) assert manager_get_inbox_mock.call_count == 1 assert manager_get_inbox_mock.call_args == mocker.call(input_name) assert inbox_mock.get.call_count == 1 assert received_message is message
def message(self): return Message("some message")
async def test_send_event_calls_transport(self, client, transport): message = Message("this is a message") await client.send_event(message) assert transport.send_event.call_count == 1 assert transport.send_event.call_args[0][0] == message
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here. conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING") # The "Authentication Provider" is the object in charge of creating authentication "tokens" for the device client. auth_provider = auth.from_connection_string(conn_str) # For now, the SDK only supports MQTT as a protocol. the client object is used to interact with your Azure IoT hub. # It needs an Authentication Provider to secure the communication with the hub, using either tokens or x509 certificates device_client = DeviceClient.from_authentication_provider( auth_provider, "mqtt") # Connect the client. device_client.connect() # send 5 messages with a 1 second pause between each message for i in range(0, 5): print("sending message #" + str(i)) msg = Message("test wind speed " + str(i)) msg.message_id = uuid.uuid4() msg.correlation_id = "correlation-1234" msg.custom_properties["tornado-warning"] = "yes" device_client.send_event(msg) time.sleep(1) # send only string messages for i in range(5, 10): print("sending message #" + str(i)) device_client.send_event("test payload message " + str(i)) time.sleep(1) # finally, disconnect device_client.disconnect()
def create_fake_output_message(): msg = Message(fake_event) msg.message_id = fake_message_id msg.output_name = "fake_output_name" return msg
def create_fake_message(): msg = Message(fake_event) msg.message_id = fake_message_id msg.custom_properties[custom_property_name] = custom_property_value return msg