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()
