def test_module_send_event_iothub_fi(): try: log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("connecting eventhub client") eventhub_client = connections.connect_eventhub_client() sent_message = test_utilities.random_string_in_json() disconnect_edgehub() # DISCONNECT EDGEHUB log_message("sending event " + " async: " + str(sent_message)) thread = module_client.send_event_async(sent_message) connect_edgehub() # RECONNECT EDGEHUB log_message("getting result with timeout: " + str(local_timeout)) thread.wait(local_timeout) # Result is None if successful log_message("wait for event to arrive at eventhub") received_message = eventhub_client.wait_for_next_event( runtime_config.test_module.device_id, test_utilities.default_eventhub_timeout, expected=sent_message, ) if not received_message: log_message("Message not received") assert False log_message("disconnecting module client") module_client.disconnect() log_message("disconnecting eventhub client") eventhub_client.disconnect() finally: restart_edgehub(hard=False)
def test_module_test_to_friend_and_back_fi(): try: test_client = connections.connect_test_module_client() test_client.enable_input_messages() friend_client = connections.connect_friend_module_client() friend_client.enable_input_messages() test_input_thread = test_client.wait_for_input_event_async( friend_to_test_input) friend_input_thread = friend_client.wait_for_input_event_async( test_to_friend_input) disconnect_edgehub() sent_message = test_utilities.max_random_string() test_client.send_output_event(test_to_friend_output, sent_message) connect_edgehub() midpoint_message = friend_input_thread.get(receive_timeout) assert midpoint_message == sent_message second_sent_message = test_utilities.max_random_string() friend_client.send_output_event(friend_to_test_output, second_sent_message) received_message = test_input_thread.get(receive_timeout) assert received_message == second_sent_message friend_client.disconnect() test_client.disconnect() finally: restart_edgehub(hard=True)
async def test_module_can_set_reported_properties_and_service_can_retrieve_them_fi( logger ): try: reported_properties_sent = {"foo": random.randint(1, 9999)} logger("connecting module client") module_client = connections.connect_test_module_client() logger("enabling twin") await module_client.enable_twin() logger("disabling edgehub") sleep(2) disconnect_edgehub() connect_edgehub() await module_client.patch_twin(reported_properties_sent) sleep(2) logger("patched twin") logger("disconnecting module client") module_client.disconnect_sync() logger("module client disconnected") logger("connecting registry client") registry_client = connections.connect_registry_client() logger("disabling edgehub") sleep(2) disconnect_edgehub() connect_edgehub() sleep(2) logger("reconnected edgehub") logger("getting twin") twin_received = await registry_client.get_module_twin( module_client.device_id, module_client.module_id ) logger("disconnecting registry client") registry_client.disconnect_sync() logger("registry client disconnected") reported_properties_received = twin_received["properties"]["reported"] if "$version" in reported_properties_received: del reported_properties_received["$version"] if "$metadata" in reported_properties_received: del reported_properties_received["$metadata"] logger("expected:" + str(reported_properties_sent)) logger("received:" + str(reported_properties_received)) assert reported_properties_sent == reported_properties_received finally: restart_edgehub() sleep(5)
def test_module_method_call_invoked_from_service(): """ invoke a module call from the service and responds to it from the test module. """ restart_edgehub(hard=True) time.sleep(5) service_client = connections.connect_service_client() module_client = connections.connect_test_module_client() do_module_method_call( service_client, module_client, get_current_config().test_module.device_id, get_current_config().test_module.module_id, registration_sleep=time_for_method_to_fully_register_service_call, ) module_client.disconnect() service_client.disconnect()
def do_device_method_call(source_module, destination_module, destination_device_id): """ Helper function which invokes a method call on one module and responds to it from another module """ try: log_message("enabling methods on the destination") destination_module.enable_methods() # start listening for method calls on the destination side log_message("starting to listen from destination module") receiver_thread = destination_module.roundtrip_method_async( method_name, status_code, method_invoke_parameters, method_response_body) time.sleep(time_for_method_to_fully_register) disconnect_edgehub() # invoking the call from caller side time.sleep(5) connect_edgehub() log_message("invoking method call") request_thread = source_module.call_device_method_async( destination_device_id, method_invoke_parameters) response = request_thread.get() print("method call complete. Response is:") print(str(response)) # wait for that response to arrive back at the source and verify that it's all good. log_message("response = " + str(response) + "\n") assert response["status"] == status_code # edge bug: the response that edge returns is stringified. The same response that comes back from an iothub service call is not stringified if isinstance(response["payload"], str): response["payload"] = json.loads(response["payload"]) assert response["payload"] == method_response_body receiver_thread.wait() finally: connect_edgehub() restart_edgehub(hard=False)
async def do_device_method_call(source_module, destination_module, destination_device_id): """ Helper function which invokes a method call on one module and responds to it from another module """ try: adapter_config.logger("enabling methods on the destination") await destination_module.enable_methods() # start listening for method calls on the destination side adapter_config.logger("starting to listen from destination module") receiver_future = asyncio.ensure_future( destination_module.wait_for_method_and_return_response( method_name, status_code, method_invoke_parameters, method_response_body)) await asyncio.sleep(time_for_method_to_fully_register) disconnect_edgehub() # invoking the call from caller side await asyncio.sleep(5) connect_edgehub() adapter_config.logger("invoking method call") response = await source_module.call_device_method( destination_device_id, method_invoke_parameters) adapter_config.logger("method call complete. Response is:") adapter_config.logger(str(response)) # wait for that response to arrive back at the source and verify that it's all good. adapter_config.logger("response = " + str(response) + "\n") assert response["status"] == status_code # edge bug: the response that edge returns is stringified. The same response that comes back from an iothub service call is not stringified if isinstance(response["payload"], str): response["payload"] = json.loads(response["payload"]) assert response["payload"] == method_response_body await receiver_future finally: connect_edgehub() restart_edgehub(hard=False)
def test_module_send_multiple_event_iothub_fi(): try: log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("connecting eventhub client") eventhub_client = connections.connect_eventhub_client() log_message("enabling telemetry on eventhub client") eventhub_client.enable_telemetry() log_message("start waiting for events on eventhub") input_thread = eventhub_client.wait_for_event_async( environment.edge_device_id) sent_message = test_utilities.random_string_in_json() log_message("disconnecting edgehub") disconnect_edgehub() # DISCONNECT EDGEHUB print("PYTEST FAKE: begin sending events async...") # Send String of Messages Asynchronously to create a queue for i in range(5): print("PYTEST FAKE: sending event " + str(i) + " async: " + str(sent_message)) thread = module_client.send_event_async(sent_message) connect_edgehub() # RECONNECT EDGEHUB log_message("getting result with timeout: " + str(local_timeout)) thread.wait(local_timeout) # Result is None if successful log_message("wait for event to arrive at eventhub") received_message = input_thread.get( test_utilities.default_eventhub_timeout) log_message("expected event: " + str(sent_message)) log_message("received event: " + str(received_message)) test_utilities.assert_json_equality(received_message, sent_message) log_message("disconnecting module client") module_client.disconnect() log_message("disconnecting eventhub client") eventhub_client.disconnect() finally: restart_edgehub(hard=False)
def test_module_output_routed_upstream_fi(): try: module_client = connections.connect_test_module_client() eventhub_client = connections.connect_eventhub_client() disconnect_edgehub() connect_edgehub() sent_message = test_utilities.random_string_in_json() module_client.send_output_event(output_name, sent_message) received_message = eventhub_client.wait_for_next_event( get_current_config().test_module.device_id, test_utilities.default_eventhub_timeout, expected=sent_message, ) if not received_message: log_message("Message not received") assert False module_client.disconnect() eventhub_client.disconnect() finally: restart_edgehub(hard=False)