def iothub_client_init():
global client
client = IoTHubClient(CONNECTION_STRING, PROTOCOL)
if client.protocol == IoTHubTransportProvider.HTTP:
client.set_option("timeout", TIMEOUT)
client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME)
# set the time until a message times out
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# some embedded platforms need certificate information
set_certificates(client)
# to enable MQTT logging set to 1
if client.protocol == IoTHubTransportProvider.MQTT:
client.set_option("logtrace", 0)
client.set_message_callback(
receive_message_callback, RECEIVE_CONTEXT)
if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS:
client.set_device_twin_callback(
device_twin_callback, TWIN_CONTEXT)
client.set_device_method_callback(
device_method_callback, METHOD_CONTEXT)
if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS:
client.set_connection_status_callback(
connection_status_callback, CONNECTION_STATUS_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
retryPolicyReturn = client.get_retry_policy()
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
def iothub_client_init(ConString, Proto):
logging.basicConfig(filename='smartlib{0}.log'.format(dt.date.today().isocalendar()[1]), level=logging.DEBUG)
# prepare iothub client
print("ConString {0}".format(ConString))
client = IoTHubClient(ConString, Proto)
if client.protocol == IoTHubTransportProvider.HTTP:
client.set_option("timeout", TIMEOUT)
client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME)
# set the time until a message times out
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# some embedded platforms need certificate information
set_certificates(client)
# to enable MQTT logging set to 1
if client.protocol == IoTHubTransportProvider.MQTT:
client.set_option("logtrace", 0)
client.set_message_callback(
receive_message_callback, RECEIVE_CONTEXT)
if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS:
client.set_device_twin_callback(
device_twin_callback, TWIN_CONTEXT)
client.set_device_method_callback(
device_method_callback, METHOD_CONTEXT)
if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS:
client.set_connection_status_callback(
connection_status_callback, CONNECTION_STATUS_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 0
client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
retryPolicyReturn = client.get_retry_policy()
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
return client
def iothub_client_init():
# prepare iothub client
client = IoTHubClient(CONNECTION_STRING, PROTOCOL)
if client.protocol == IoTHubTransportProvider.HTTP:
client.set_option("timeout", TIMEOUT)
client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME)
# set the time until a message times out
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# some embedded platforms need certificate information
set_certificates(client)
# to enable MQTT logging set to 1
if client.protocol == IoTHubTransportProvider.MQTT:
client.set_option("logtrace", 0)
client.set_message_callback(
receive_message_callback, RECEIVE_CONTEXT)
if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS:
client.set_device_twin_callback(
device_twin_callback, TWIN_CONTEXT)
client.set_device_method_callback(
device_method_callback, METHOD_CONTEXT)
if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS:
client.set_connection_status_callback(
connection_status_callback, CONNECTION_STATUS_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
retryPolicyReturn = client.get_retry_policy()
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
return client
def iothub_client_init(self):
log = logger.getLogger()
# prepare iothub client
log.debug("- creating the client with {0} {1} {2} {3}".format(
self.iothub_uri, self.device_id, self.security_type.name,
self.protocol.name))
client = IoTHubClient(self.iothub_uri, self.device_id,
self.security_type, self.protocol)
# set the time until a message times out
client.set_option("messageTimeout", self.MESSAGE_TIMEOUT)
client.set_option("logtrace", 0)
client.set_message_callback(self.receive_message_callback,
self.RECEIVE_CONTEXT)
client.set_device_twin_callback(self.device_twin_callback,
self.TWIN_CONTEXT)
client.set_device_method_callback(self.device_method_callback,
self.METHOD_CONTEXT)
client.set_connection_status_callback(self.connection_status_callback,
self.CONNECTION_STATUS_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
log.info("SetRetryPolicy to: retryPolicy = {0}".format(retryPolicy))
log.info("SetRetryPolicy to: retryTimeoutLimitInSeconds = {0}".format(
retryInterval))
retryPolicyReturn = client.get_retry_policy()
log.info("GetRetryPolicy returned: retryPolicy = {0}".format(
retryPolicyReturn.retryPolicy))
log.info("GetRetryPolicy returned: retryTimeoutLimitInSeconds = {0}\n".
format(retryPolicyReturn.retryTimeoutLimitInSeconds))
return client
def iothub_client_init(self):
# prepare iothub client
client = IoTHubClient(self.connectionString,
IoTHubTransportProvider.MQTT)
# set the time until a message times out
client.set_option("messageTimeout", self.MESSAGE_TIMEOUT)
client.set_option("logtrace", 0)
client.set_message_callback(self.receive_message_callback,
self.RECEIVE_CONTEXT)
client.set_device_twin_callback(self.device_twin_callback,
self.TWIN_CONTEXT)
client.set_device_method_callback(self.device_method_callback,
self.METHOD_CONTEXT)
client.set_connection_status_callback(self.connection_status_callback,
self.CONNECTION_STATUS_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
logger.log("SetRetryPolicy to: retryPolicy = {0}".format(retryPolicy))
logger.log(
"SetRetryPolicy to: retryTimeoutLimitInSeconds = {0}".format(
retryInterval))
retryPolicyReturn = client.get_retry_policy()
logger.log("GetRetryPolicy returned: retryPolicy = {0}".format(
retryPolicyReturn.retryPolicy))
logger.log(
"GetRetryPolicy returned: retryTimeoutLimitInSeconds = {0}\n".
format(retryPolicyReturn.retryTimeoutLimitInSeconds))
return client
def iothub_client_init():
# prepare iothub client
client = IoTHubClient(CONNECTION_STRING, PROTOCOL)
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
client.set_option("logtrace", 0)
client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
retryPolicyReturn = client.get_retry_policy()
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
return client
def iothub_client_init():
# prepare iothub client
client = IoTHubClient(CONNECTION_STRING, IoTHubTransportProvider.MQTT)
client.set_option("messageTimeout", MESSAGE_TIMEOUT)
if client.protocol == IoTHubTransportProvider.MQTT:
client.set_option("logtrace", 0)
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
retryPolicyReturn = client.get_retry_policy()
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
return client
def run_e2e_device_client(iothub_service_client_messaging, iothub_device_method, iothub_device_twin, device_id, device_connection_string, protocol, authMethod):
global IOTHUB_E2E_X509_CERT
global IOTHUB_E2E_X509_THUMBPRINT
global IOTHUB_E2E_X509_PRIVATE_KEY
global CERTIFICATES
global MESSAGING_CONTEXT
###########################################################################
# IoTHubClient
# prepare
# act
device_client = IoTHubClient(device_connection_string, protocol)
# verify
assert isinstance(device_client, IoTHubClient), 'Error: Invalid type returned!'
assert device_client != None, "Error: device_client is NULL"
###########################################################################
###########################################################################
# set_option
# prepare
# act
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
if authMethod == IoTHubRegistryManagerAuthMethod.X509_THUMBPRINT:
device_client.set_option("x509certificate", IOTHUB_E2E_X509_CERT)
device_client.set_option("x509privatekey", IOTHUB_E2E_X509_PRIVATE_KEY)
if device_client.protocol == IoTHubTransportProvider.HTTP:
device_client.set_option("timeout", HTTP_TIMEOUT)
device_client.set_option("MinimumPollingTime", HTTP_MINIMUM_POLLING_TIME)
device_client.set_option("TrustedCerts", CERTIFICATES)
device_client.set_option("logtrace", True)
# verify
###########################################################################
###########################################################################
# set_message_callback
# prepare
# act
device_client.set_message_callback(receive_message_callback, MESSAGING_CONTEXT)
###########################################################################
###########################################################################
# set_connection_status_callback
# prepare
# act
device_client.set_connection_status_callback(connection_status_callback, CONNECTION_STATUS_CONTEXT)
###########################################################################
# verify
###########################################################################
if protocol == IoTHubTransportProvider.MQTT or protocol == IoTHubTransportProvider.MQTT_WS:
###########################################################################
# set_device_twin_callback
# prepare
# act
device_client.set_device_twin_callback(device_twin_callback, MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# set_device_method_callback
# prepare
# act
device_client.set_device_method_callback(device_method_callback, MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# update device twin
# prepare
global TWIN_CALLBACK_EVENT
global TWIN_CALLBACK_COUNTER
TWIN_CALLBACK_EVENT.clear()
TWIN_CALLBACK_COUNTER = 0
# act
sc_update_twin(iothub_device_twin, device_id)
TWIN_CALLBACK_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert TWIN_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
###########################################################################
# call device method
# prepare
global DEVICE_METHOD_EVENT
global DEVICE_METHOD_CALLBACK_COUNTER
DEVICE_METHOD_EVENT.clear()
DEVICE_METHOD_CALLBACK_COUNTER = 0
method_name = "E2EMethodName"
payload_json = "{\"method_number\":\"42\"}"
# act
sc_invoke_device_method(iothub_device_method, device_id, method_name, payload_json)
DEVICE_METHOD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert DEVICE_METHOD_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
if protocol == IoTHubTransportProvider.AMQP \
or protocol == IoTHubTransportProvider.AMQP_WS \
or protocol == IoTHubTransportProvider.MQTT \
or protocol == IoTHubTransportProvider.MQTT_WS:
###########################################################################
# send_reported_state
# prepare
global REPORTED_STATE_EVENT
global REPORTED_STATE_CALLBACK_COUNTER
reported_state = "{\"newState\":\"standBy\"}"
REPORTED_STATE_EVENT.clear()
REPORTED_STATE_CALLBACK_COUNTER = 0
# act
device_client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, REPORTED_STATE_CONTEXT)
REPORTED_STATE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert REPORTED_STATE_CALLBACK_COUNTER > 0, "Error: send_reported_state_callback has not been called"
###########################################################################
###########################################################################
# set_retry_policy
# get_retry_policy
# prepare
# act
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
device_client.set_retry_policy(retryPolicy, retryInterval)
print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
# verify
retryPolicyReturn = device_client.get_retry_policy()
assert retryPolicyReturn.retryPolicy == IoTHubClientRetryPolicy.RETRY_INTERVAL, "Error: set_retry_policy/get_retry_policy failed"
assert retryPolicyReturn.retryTimeoutLimitInSeconds == 100, "Error: set_retry_policy/get_retry_policy failed"
print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy)
print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
###########################################################################
# send_event_async
# prepare
global MESSAGING_MESSAGE
global MESSAGE_RECEIVE_EVENT
global MESSAGE_RECEIVE_CALLBACK_COUNTER
MESSAGING_MESSAGE = ''.join([random.choice(string.ascii_letters) for n in range(12)])
message = IoTHubMessage(bytearray(MESSAGING_MESSAGE, 'utf8'))
MESSAGE_RECEIVE_EVENT.clear()
MESSAGE_RECEIVE_CALLBACK_COUNTER = 0
# act
sc_send_message(iothub_service_client_messaging, device_id, message)
MESSAGE_RECEIVE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert MESSAGE_RECEIVE_CALLBACK_COUNTER > 0, "Error: message has not been received"
###########################################################################
###########################################################################
# get_send_status
# prepare
status_counter = 0
status = -1;
# act
while status_counter < 1:
status = device_client.get_send_status()
print ( "Send status: {0}".format(status) )
# verify
assert status == 0, "get_send_status reported status is not IDLE"
status_counter += 1
###########################################################################
if protocol != IoTHubTransportProvider.AMQP \
and protocol != IoTHubTransportProvider.AMQP_WS:
###########################################################################
# get_last_message_receive_time
# prepare
last_receive_time = -1
# act
last_receive_time = device_client.get_last_message_receive_time()
# verify
assert last_receive_time > 0, "Error: get_last_message_receive_time failed"
###########################################################################
###########################################################################
# upload_blob_async
# prepare
global BLOB_UPLOAD_CONTEXT
global BLOB_UPLOAD_EVENT
global BLOB_UPLOAD_CALLBACK_COUNTER
destination_file_name = ''.join([random.choice(string.ascii_letters) for n in range(12)])
source = "Blob content for file upload test!"
size = 34
BLOB_UPLOAD_EVENT.clear()
BLOB_UPLOAD_CALLBACK_COUNTER = 0
# act
device_client.upload_blob_async(destination_file_name, source, size, blob_upload_conf_callback, BLOB_UPLOAD_CONTEXT)
BLOB_UPLOAD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert BLOB_UPLOAD_CALLBACK_COUNTER > 0, "Error: blob_upload_conf_callback callback has not been called"
def run_e2e_device_client(iothub_service_client_messaging,
iothub_device_method, iothub_device_twin, device_id,
device_connection_string, protocol, authMethod):
global IOTHUB_E2E_X509_CERT
global IOTHUB_E2E_X509_THUMBPRINT
global IOTHUB_E2E_X509_PRIVATE_KEY
global CERTIFICATES
global MESSAGING_CONTEXT
###########################################################################
# IoTHubClient
# prepare
# act
device_client = IoTHubClient(device_connection_string, protocol)
# verify
assert isinstance(device_client,
IoTHubClient), 'Error: Invalid type returned!'
assert device_client != None, "Error: device_client is NULL"
###########################################################################
###########################################################################
# set_option
# prepare
# act
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
if authMethod == IoTHubRegistryManagerAuthMethod.X509_THUMBPRINT:
device_client.set_option("x509certificate", IOTHUB_E2E_X509_CERT)
device_client.set_option("x509privatekey", IOTHUB_E2E_X509_PRIVATE_KEY)
if device_client.protocol == IoTHubTransportProvider.HTTP:
device_client.set_option("timeout", HTTP_TIMEOUT)
device_client.set_option("MinimumPollingTime",
HTTP_MINIMUM_POLLING_TIME)
device_client.set_option("TrustedCerts", CERTIFICATES)
device_client.set_option("logtrace", True)
# verify
###########################################################################
###########################################################################
# set_message_callback
# prepare
# act
device_client.set_message_callback(receive_message_callback,
MESSAGING_CONTEXT)
###########################################################################
###########################################################################
# set_connection_status_callback
# prepare
# act
device_client.set_connection_status_callback(connection_status_callback,
CONNECTION_STATUS_CONTEXT)
###########################################################################
# verify
###########################################################################
if protocol == IoTHubTransportProvider.MQTT or protocol == IoTHubTransportProvider.MQTT_WS:
###########################################################################
# set_device_twin_callback
# prepare
# act
device_client.set_device_twin_callback(device_twin_callback,
MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# set_device_method_callback
# prepare
# act
device_client.set_device_method_callback(device_method_callback,
MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# update device twin
# prepare
global TWIN_CALLBACK_EVENT
global TWIN_CALLBACK_COUNTER
TWIN_CALLBACK_EVENT.clear()
TWIN_CALLBACK_COUNTER = 0
# act
sc_update_twin(iothub_device_twin, device_id)
TWIN_CALLBACK_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert TWIN_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
###########################################################################
# call device method
# prepare
global DEVICE_METHOD_EVENT
global DEVICE_METHOD_CALLBACK_COUNTER
DEVICE_METHOD_EVENT.clear()
DEVICE_METHOD_CALLBACK_COUNTER = 0
method_name = "E2EMethodName"
payload_json = "{\"method_number\":\"42\"}"
# act
sc_invoke_device_method(iothub_device_method, device_id, method_name,
payload_json)
DEVICE_METHOD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert DEVICE_METHOD_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
if protocol == IoTHubTransportProvider.AMQP \
or protocol == IoTHubTransportProvider.AMQP_WS \
or protocol == IoTHubTransportProvider.MQTT \
or protocol == IoTHubTransportProvider.MQTT_WS:
###########################################################################
# send_reported_state
# prepare
global REPORTED_STATE_EVENT
global REPORTED_STATE_CALLBACK_COUNTER
reported_state = "{\"newState\":\"standBy\"}"
REPORTED_STATE_EVENT.clear()
REPORTED_STATE_CALLBACK_COUNTER = 0
# act
device_client.send_reported_state(reported_state, len(reported_state),
send_reported_state_callback,
REPORTED_STATE_CONTEXT)
REPORTED_STATE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert REPORTED_STATE_CALLBACK_COUNTER > 0, "Error: send_reported_state_callback has not been called"
###########################################################################
###########################################################################
# set_retry_policy
# get_retry_policy
# prepare
# act
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
device_client.set_retry_policy(retryPolicy, retryInterval)
print("SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print("SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
# verify
retryPolicyReturn = device_client.get_retry_policy()
assert retryPolicyReturn.retryPolicy == IoTHubClientRetryPolicy.RETRY_INTERVAL, "Error: set_retry_policy/get_retry_policy failed"
assert retryPolicyReturn.retryTimeoutLimitInSeconds == 100, "Error: set_retry_policy/get_retry_policy failed"
print("GetRetryPolicy returned: retryPolicy = %d" %
retryPolicyReturn.retryPolicy)
print("GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" %
retryPolicyReturn.retryTimeoutLimitInSeconds)
###########################################################################
# send_event_async
# prepare
global MESSAGING_MESSAGE
global MESSAGE_RECEIVE_EVENT
global MESSAGE_RECEIVE_CALLBACK_COUNTER
MESSAGING_MESSAGE = ''.join(
[random.choice(string.ascii_letters) for n in range(12)])
message = IoTHubMessage(bytearray(MESSAGING_MESSAGE, 'utf8'))
MESSAGE_RECEIVE_EVENT.clear()
MESSAGE_RECEIVE_CALLBACK_COUNTER = 0
# act
sc_send_message(iothub_service_client_messaging, device_id, message)
MESSAGE_RECEIVE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert MESSAGE_RECEIVE_CALLBACK_COUNTER > 0, "Error: message has not been received"
###########################################################################
###########################################################################
# get_send_status
# prepare
status_counter = 0
status = -1
# act
while status_counter < 1:
status = device_client.get_send_status()
print("Send status: {0}".format(status))
# verify
assert status == 0, "get_send_status reported status is not IDLE"
status_counter += 1
###########################################################################
if protocol != IoTHubTransportProvider.AMQP \
and protocol != IoTHubTransportProvider.AMQP_WS:
###########################################################################
# get_last_message_receive_time
# prepare
last_receive_time = -1
# act
last_receive_time = device_client.get_last_message_receive_time()
# verify
assert last_receive_time > 0, "Error: get_last_message_receive_time failed"
###########################################################################
###########################################################################
# upload_blob_async
# prepare
global BLOB_UPLOAD_CONTEXT
global BLOB_UPLOAD_EVENT
global BLOB_UPLOAD_CALLBACK_COUNTER
destination_file_name = ''.join(
[random.choice(string.ascii_letters) for n in range(12)])
source = "Blob content for file upload test!"
size = 34
BLOB_UPLOAD_EVENT.clear()
BLOB_UPLOAD_CALLBACK_COUNTER = 0
# act
device_client.upload_blob_async(destination_file_name, source, size,
blob_upload_conf_callback,
BLOB_UPLOAD_CONTEXT)
BLOB_UPLOAD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert BLOB_UPLOAD_CALLBACK_COUNTER > 0, "Error: blob_upload_conf_callback callback has not been called"
