def test_module_can_set_reported_properties_and_service_can_retrieve_them(): reported_properties_sent = {"foo": random.randint(1, 9999)} log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() log_message("patching twin") module_client.patch_twin(reported_properties_sent) log_message("disconnecting module client") module_client.disconnect() log_message("module client disconnected") log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("getting twin") twin_received = registry_client.get_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id) log_message("disconnecting registry client") registry_client.disconnect() log_message("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"] log_message("expected:" + str(reported_properties_sent)) log_message("received:" + str(reported_properties_received)) assert reported_properties_sent == reported_properties_received
def test_registry_client_connect_disconnect_fi(): log_message("registry_client = connections.connect_registry_client()") registry_client = connections.connect_registry_client() disconnect_edgehub() connect_edgehub() log_message("registry_client.disconnect()") registry_client.disconnect()
async def test_service_can_set_desired_properties_and_module_can_retrieve_them_fi( logger): twin_sent = {"properties": {"desired": {"foo": random.randint(1, 9999)}}} logger("connecting registry client") registry_client = connections.connect_registry_client() logger("disconnecting edgehub") sleep(2) disconnect_edgehub() # DISCONNECTING EGEHUB connect_edgehub() # CONNECTING EDGEHUB await registry_client.patch_module_twin(settings.test_module.device_id, settings.test_module.module_id, twin_sent) logger("patching twin") logger("disconnecting registry client") registry_client.disconnect_sync() logger("connecting module client") module_client = connections.connect_test_module_client() logger("enabling twin") await module_client.enable_twin() logger("disconnecting edgehub") sleep(2) disconnect_edgehub() # DISCONNECTING EGEHUB sleep(5) connect_edgehub() # CONNECTING EDGEHUB twin_received = await module_client.get_twin() logger("getting module twin") logger("disconnecting module client") module_client.disconnect_sync() logger("module client disconnected") logger("twin sent: " + str(twin_sent)) logger("twin received:" + str(twin_received)) assert (twin_sent["properties"]["desired"]["foo"] == twin_received["properties"]["desired"]["foo"])
def test_service_can_set_desired_properties_and_module_can_retrieve_them(): twin_sent = {"properties": {"desired": {"foo": random.randint(1, 9999)}}} log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("patching twin") registry_client.patch_module_twin( environment.edge_device_id, environment.module_id, twin_sent ) log_message("disconnecting registry client") registry_client.disconnect() log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() log_message("getting module twin") twin_received = module_client.get_twin() log_message("disconnecting module client") module_client.disconnect() log_message("module client disconnected") log_message("twin sent: " + str(twin_sent)) log_message("twin received:" + str(twin_received)) assert ( twin_sent["properties"]["desired"]["foo"] == twin_received["properties"]["desired"]["foo"] )
def test_service_can_set_multiple_desired_property_patches_and_module_can_retrieve_them_as_events( ): log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() base = random.randint(1, 9999) * 100 for i in range(1, 4): log_message("sending patch #" + str(i) + " through registry client") twin_sent = {"properties": {"desired": {"foo": base + i}}} registry_client.patch_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " sent") log_message("start waiting for patch #" + str(i)) patch_thread = module_client.wait_for_desired_property_patch_async() log_message("Tringgering patch #" + str(i) + " through registry client") twin_sent = {"properties": {"desired": {"foo": base + i}}} registry_client.patch_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " triggered") log_message("getting patch " + str(i) + " on module client") patch_received = patch_thread.get() log_message("patch received:" + json.dumps(patch_received)) log_message("desired properties sent: " + str(twin_sent["properties"]["desired"]["foo"])) # Most of the time, the C wrapper returns a patch with "foo" at the root. Sometimes it # returns a patch with "properties/desired" at the root. I know that this has to do with timing and # the difference between the code that handles the initial GET and the code that handles # the PATCH that arrives later. I suspect it has something to do with the handling for # DEVICE_TWIN_UPDATE_COMPLETE and maybe we occasionally get a full twin when we're waiting # for a patch, but that's just an educated guess. # # I don't know if this is happening in the SDK or in the glue. # this happens relatively rarely. Maybe 1/20, maybe 1/100 times foo_val = get_patch_received(patch_received) if foo_val == -1: log_message("patch received of invalid format!") assert 0 log_message("desired properties recieved: " + str(foo_val)) assert twin_sent["properties"]["desired"]["foo"] == foo_val registry_client.disconnect() module_client.disconnect()
def registry(logger): registry = connections.connect_registry_client() yield registry logger(separator.format("registry")) try: registry.disconnect_sync() except Exception as e: logger("exception disconnecting registry: {}".format(e))
def test_service_can_set_multiple_desired_property_patches_and_module_can_retrieve_them_as_events_fi( ): log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() base = random.randint(1, 9999) * 100 for i in range(1, 4): log_message("sending patch #" + str(i) + " through registry client") # Send patch twin_sent = {"properties": {"desired": {"foo": base + i}}} registry_client.patch_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " sent") log_message("start waiting for patch #" + str(i)) patch_thread = (module_client.wait_for_desired_property_patch_async() ) # Set Twin Callback log_message("Fault Injection: disconnecting edgehub") disconnect_edgehub() # DISCONNECTING EGEHUB log_message("Fault Injection: reconnecting edgehub") connect_edgehub() # CONNECTING EDGEHUB sleep(2) log_message("Tringgering patch #" + str(i) + " through registry client") # Trigger Twin Callback registry_client.patch_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " triggered") log_message("waiting for patch " + str(i) + " to arrive at module client") patch_received = patch_thread.get() # Get twin from patch received log_message("patch received:" + json.dumps(patch_received)) log_message("desired properties sent: " + str(twin_sent["properties"]["desired"]["foo"])) foo_val = get_patch_received(patch_received) if foo_val == -1: log_message("patch received of invalid format!") assert 0 log_message("desired properties recieved: " + str(foo_val)) assert twin_sent["properties"]["desired"]["foo"] == foo_val registry_client.disconnect() module_client.disconnect()
def test_service_can_set_desired_properties_and_module_can_retrieve_them_fi(): try: twin_sent = { "properties": { "desired": { "foo": random.randint(1, 9999) } } } log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("disconnecting edgehub") sleep(2) disconnect_edgehub() # DISCONNECTING EGEHUB connect_edgehub() # CONNECTING EDGEHUB registry_client.patch_module_twin( runtime_config.test_module.device_id, runtime_config.test_module.module_id, twin_sent, ) log_message("patching twin") log_message("disconnecting registry client") registry_client.disconnect() log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() log_message("disconnecting edgehub") sleep(2) disconnect_edgehub() # DISCONNECTING EGEHUB sleep(5) connect_edgehub() # CONNECTING EDGEHUB twin_received = module_client.get_twin() log_message("getting module twin") log_message("disconnecting module client") module_client.disconnect() log_message("module client disconnected") log_message("twin sent: " + str(twin_sent)) log_message("twin received:" + str(twin_received)) assert (twin_sent["properties"]["desired"]["foo"] == twin_received["properties"]["desired"]["foo"]) finally: cMod = client.containers.get("cMod") friendMod = client.containers.get("friendMod") edgeHub = client.containers.get("edgeHub") edgeHub.restart() friendMod.restart() cMod.restart()
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 registry(logger): registry = connections.connect_registry_client() yield registry logger(separator.format("registry")) registry.disconnect_sync()
def test_registry_client_connect_disconnect(): registry_client = connections.connect_registry_client() registry_client.disconnect()
def test_service_can_set_multiple_desired_property_patches_and_module_can_retrieve_them_as_events( ): log_message("connecting registry client") registry_client = connections.connect_registry_client() log_message("connecting module client") module_client = connections.connect_test_module_client() log_message("enabling twin") module_client.enable_twin() base = random.randint(1, 9999) * 100 for i in range(1, 4): log_message("sending patch #" + str(i) + " through registry client") twin_sent = {"properties": {"desired": {"foo": base + i}}} registry_client.patch_module_twin( get_current_config().test_module.device_id, get_current_config().test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " sent") log_message("start waiting for patch #" + str(i)) patch_thread = module_client.wait_for_desired_property_patch_async() log_message("Tringgering patch #" + str(i) + " through registry client") twin_sent = {"properties": {"desired": {"foo": base + i}}} registry_client.patch_module_twin( get_current_config().test_module.device_id, get_current_config().test_module.module_id, twin_sent, ) log_message("patch " + str(i) + " triggered") done = False mistakes_left = 1 while not done: log_message("getting patch " + str(i) + " on module client") patch_received = patch_thread.get() log_message("patch received:" + json.dumps(patch_received)) log_message("desired properties sent: " + str(twin_sent["properties"]["desired"]["foo"])) foo_val = get_patch_received(patch_received) if foo_val == -1: log_message("patch received of invalid format!") assert 0 log_message("desired properties recieved: " + str(foo_val)) if twin_sent["properties"]["desired"]["foo"] == foo_val: log_message("success") done = True else: if mistakes_left: # We sometimes get the old value before we get the new value, and that's # perfectly valid (especially with QOS 1 on MQTT). If we got the wrong # value, we just try again. mistakes_left = mistakes_left - 1 log_message( "trying again. We still have {} mistakes left".format( mistakes_left)) log_message("start waiting for patch #{} again".format(i)) patch_thread = module_client.wait_for_desired_property_patch_async( ) else: log_message("too many mistakes. Failing") assert False registry_client.disconnect() module_client.disconnect()