def test_raises_error_on_shutdown_pipeline_op_error(
self, mocker, pipeline_error, client_error, provisioning_pipeline,
registration_result):
# success result is required to trigger shutdown
registration_result._status = "assigned"
error = pipeline_error()
def register_complete_success_callback(payload, callback):
callback(result=registration_result)
def shutdown_failure_callback(callback):
callback(result=None, error=error)
mocker.patch.object(provisioning_pipeline,
"register",
side_effect=register_complete_success_callback)
mocker.patch.object(provisioning_pipeline,
"shutdown",
side_effect=shutdown_failure_callback)
client = ProvisioningDeviceClient(provisioning_pipeline)
with pytest.raises(client_error) as e_info:
client.register()
assert e_info.value.__cause__ is error
assert provisioning_pipeline.register.call_count == 1
def test_waits_for_pipeline_op_completion(self, mocker,
registration_result):
manual_provisioning_pipeline_with_callback = mocker.MagicMock()
event_init_mock = mocker.patch.object(threading, "Event")
event_mock = event_init_mock.return_value
pipeline_function = manual_provisioning_pipeline_with_callback.register
def check_callback_completes_event():
# Assert exactly one Event was instantiated so we know the following asserts
# are related to the code under test ONLY
assert event_init_mock.call_count == 1
# Assert waiting for Event to complete
assert event_mock.wait.call_count == 1
assert event_mock.set.call_count == 0
# Manually trigger callback
cb = pipeline_function.call_args[1]["callback"]
cb(result=registration_result)
# Assert Event is now completed
assert event_mock.set.call_count == 1
event_mock.wait.side_effect = check_callback_completes_event
client = ProvisioningDeviceClient(
manual_provisioning_pipeline_with_callback)
client._provisioning_payload = "payload"
client.register()
def test_client_register_success_calls_polling_machine_register_with_callback(
self, mocker, mock_polling_machine):
# Override callback to pass successful result
def register_complete_success_callback(callback):
callback(result=create_success_result())
mocker.patch.object(mock_polling_machine,
"register",
side_effect=register_complete_success_callback)
mqtt_provisioning_pipeline = mocker.MagicMock()
mock_polling_machine_init = mocker.patch(
"azure.iot.device.provisioning.provisioning_device_client.PollingMachine"
)
mock_polling_machine_init.return_value = mock_polling_machine
client = ProvisioningDeviceClient(mqtt_provisioning_pipeline)
result = client.register()
assert mock_polling_machine.register.call_count == 1
assert callable(mock_polling_machine.register.call_args[1]["callback"])
assert result is not None
assert result.registration_state == fake_registration_state
assert result.status == fake_status
assert result.registration_state == fake_registration_state
assert result.registration_state.device_id == fake_device_id
assert result.registration_state.assigned_hub == fake_assigned_hub
def test_waits_for_pipeline_op_completion_on_failure(
self, mocker, provisioning_pipeline, registration_result):
# fail result
registration_result._status = "not assigned"
# Set up mocks
cb_mock_register = mocker.MagicMock()
cb_mock_register.wait_for_completion.return_value = registration_result
cb_mock_shutdown = mocker.MagicMock()
mocker.patch(
"azure.iot.device.provisioning.provisioning_device_client.EventedCallback"
).side_effect = [cb_mock_register, cb_mock_shutdown]
# Run test
client = ProvisioningDeviceClient(provisioning_pipeline)
client.register()
# Calls made as expected
assert provisioning_pipeline.register.call_count == 1
assert provisioning_pipeline.shutdown.call_count == 0
# Callbacks sent to pipeline as expected
assert provisioning_pipeline.register.call_args == mocker.call(
payload=mocker.ANY, callback=cb_mock_register)
# Callback completions were waited upon as expected
assert cb_mock_register.wait_for_completion.call_count == 1
assert cb_mock_shutdown.wait_for_completion.call_count == 0
def test_get_payload(self, mocker, mock_polling_machine, payload_input):
mqtt_provisioning_pipeline = mocker.MagicMock()
mock_polling_machine_init = mocker.patch(
"azure.iot.device.provisioning.provisioning_device_client.PollingMachine"
)
mock_polling_machine_init.return_value = mock_polling_machine
client = ProvisioningDeviceClient(mqtt_provisioning_pipeline)
client.provisioning_payload = payload_input
assert client.provisioning_payload == payload_input
def test_register_calls_pipeline_register(self, provisioning_pipeline,
mocker, registration_result):
def register_complete_success_callback(payload, callback):
callback(result=registration_result)
mocker.patch.object(provisioning_pipeline,
"register",
side_effect=register_complete_success_callback)
client = ProvisioningDeviceClient(provisioning_pipeline)
client.register()
assert provisioning_pipeline.register.call_count == 1
def test_client_creation(self, mocker, mock_pipeline_init):
spy_client_init = mocker.spy(ProvisioningDeviceClient, "__init__")
ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
symmetric_key=fake_symmetric_key,
)
assert spy_client_init.call_count == 1
assert spy_client_init.call_args == mocker.call(mocker.ANY, mock_pipeline_init.return_value)
def test_client_creation(self, mocker, mock_pipeline_init, x509):
spy_client_init = mocker.spy(ProvisioningDeviceClient, "__init__")
ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
x509=x509,
)
assert spy_client_init.call_count == 1
assert spy_client_init.call_args == mocker.call(mocker.ANY, mock_pipeline_init.return_value)
def test_client_cancel_calls_polling_machine_cancel_with_callback(
self, mocker, mock_polling_machine):
mqtt_provisioning_pipeline = mocker.MagicMock()
mock_polling_machine_init = mocker.patch(
"azure.iot.device.provisioning.provisioning_device_client.PollingMachine"
)
mock_polling_machine_init.return_value = mock_polling_machine
client = ProvisioningDeviceClient(mqtt_provisioning_pipeline)
client.cancel()
assert mock_polling_machine.cancel.call_count == 1
assert callable(mock_polling_machine.cancel.call_args[1]["callback"])
def test_no_shutdown_upon_fail(self, mocker, provisioning_pipeline, registration_result):
# fail result
registration_result._status = "not assigned"
def register_complete_fail_callback(payload, callback):
callback(result=registration_result)
mocker.patch.object(
provisioning_pipeline, "register", side_effect=register_complete_fail_callback
)
client = ProvisioningDeviceClient(provisioning_pipeline)
client.register()
assert provisioning_pipeline.shutdown.call_count == 0
def test_verifies_registration_result_returned(self, mocker,
provisioning_pipeline,
registration_result):
result = registration_result
def register_complete_success_callback(payload, callback):
callback(result=result)
mocker.patch.object(provisioning_pipeline,
"register",
side_effect=register_complete_success_callback)
client = ProvisioningDeviceClient(provisioning_pipeline)
result_returned = client.register()
assert result_returned == result
def test_security_client(self, mocker):
spy_sec_client = mocker.spy(security, "SymmetricKeySecurityClient")
ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
symmetric_key=fake_symmetric_key,
)
assert spy_sec_client.call_count == 1
assert spy_sec_client.call_args == mocker.call(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
symmetric_key=fake_symmetric_key,
)
def test_returns_client(self, mocker):
client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
symmetric_key=fake_symmetric_key,
)
assert isinstance(client, ProvisioningDeviceClient)
def test_security_client(self, mocker, x509):
spy_sec_client = mocker.spy(security, "X509SecurityClient")
ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
x509=x509,
)
assert spy_sec_client.call_count == 1
assert spy_sec_client.call_args == mocker.call(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
x509=x509,
)
def test_raises_error_on_register_pipeline_op_error(
self, mocker, pipeline_error, client_error, provisioning_pipeline):
error = pipeline_error()
def register_complete_failure_callback(payload, callback):
callback(result=None, error=error)
mocker.patch.object(provisioning_pipeline,
"register",
side_effect=register_complete_failure_callback)
client = ProvisioningDeviceClient(provisioning_pipeline)
with pytest.raises(client_error) as e_info:
client.register()
assert e_info.value.__cause__ is error
assert provisioning_pipeline.register.call_count == 1
def test_pipeline(self, mocker, mock_pipeline_init, x509):
# Note that the details of how the pipeline config is set up are covered in the
# SharedClientCreateMethodUserOptionTests
mock_pipeline_config = mocker.patch.object(
pipeline, "ProvisioningPipelineConfig"
).return_value
mock_sec_client = mocker.patch.object(security, "X509SecurityClient").return_value
ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
x509=x509,
)
assert mock_pipeline_init.call_count == 1
assert mock_pipeline_init.call_args == mocker.call(mock_sec_client, mock_pipeline_config)
def test_returns_client(self, mocker, x509):
client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=fake_provisioning_host,
registration_id=fake_registration_id,
id_scope=fake_id_scope,
x509=x509,
)
assert isinstance(client, ProvisioningDeviceClient)
def test_create_from_x509_cert(self, mocker, protocol):
patch_set_x509_client = mocker.patch.object(
pipeline_ops_provisioning, "SetX509SecurityClientOperation")
client = ProvisioningDeviceClient.create_from_x509_certificate(
fake_provisioning_host, fake_registration_id, fake_id_scope,
fake_x509())
assert isinstance(client, ProvisioningDeviceClient)
assert patch_set_x509_client.call_count == 1
assert client._provisioning_pipeline is not None
def test_create_from_symmetric_key(self, mocker, protocol):
patch_set_sym_client = mocker.patch.object(
pipeline_ops_provisioning,
"SetSymmetricKeySecurityClientOperation")
patch_set_sym_client.callback = mocker.MagicMock()
client = ProvisioningDeviceClient.create_from_symmetric_key(
fake_provisioning_host, fake_symmetric_key, fake_registration_id,
fake_id_scope)
assert isinstance(client, ProvisioningDeviceClient)
assert patch_set_sym_client.call_count == 1
assert client._provisioning_pipeline is not None
def test_client_register_failure_calls_polling_machine_register_with_callback(
self, mocker, mock_polling_machine):
# Override callback to pass successful result
def register_complete_failure_callback(callback):
callback(result=None, error=create_error())
mocker.patch.object(mock_polling_machine,
"register",
side_effect=register_complete_failure_callback)
mqtt_provisioning_pipeline = mocker.MagicMock()
mock_polling_machine_init = mocker.patch(
"azure.iot.device.provisioning.provisioning_device_client.PollingMachine"
)
mock_polling_machine_init.return_value = mock_polling_machine
client = ProvisioningDeviceClient(mqtt_provisioning_pipeline)
with pytest.raises(RuntimeError):
client.register()
assert mock_polling_machine.register.call_count == 1
assert callable(mock_polling_machine.register.call_args[1]["callback"])
def test_enables_provisioning_only_if_not_already_enabled(
self, mocker, provisioning_pipeline, registration_result):
# Override callback to pass successful result
def register_complete_success_callback(payload, callback):
callback(result=registration_result)
mocker.patch.object(provisioning_pipeline,
"register",
side_effect=register_complete_success_callback)
provisioning_pipeline.responses_enabled.__getitem__.return_value = False
# assert provisioning_pipeline.responses_enabled is False
client = ProvisioningDeviceClient(provisioning_pipeline)
client.register()
assert provisioning_pipeline.enable_responses.call_count == 1
provisioning_pipeline.enable_responses.reset_mock()
provisioning_pipeline.responses_enabled.__getitem__.return_value = True
client.register()
assert provisioning_pipeline.enable_responses.call_count == 0
def test_sets_provisioning_pipeline(self, provisioning_pipeline):
client = ProvisioningDeviceClient(provisioning_pipeline)
assert client._provisioning_pipeline is provisioning_pipeline
def client(self, provisioning_pipeline):
return ProvisioningDeviceClient(provisioning_pipeline)
def test_get_payload(self, mocker, payload_input):
provisioning_pipeline = mocker.MagicMock()
client = ProvisioningDeviceClient(provisioning_pipeline)
client.provisioning_payload = payload_input
assert client.provisioning_payload == payload_input
def test_payload(self, provisioning_pipeline):
client = ProvisioningDeviceClient(provisioning_pipeline)
assert client._provisioning_payload is None
def test_create_from_symmetric_key(self, mocker, protocol):
client = ProvisioningDeviceClient.create_from_symmetric_key(
fake_provisioning_host, fake_symmetric_key, fake_registration_id,
fake_id_scope)
assert isinstance(client, ProvisioningDeviceClient)
assert client._provisioning_pipeline is not None
def test_create_from_x509_cert(self, mocker, protocol):
client = ProvisioningDeviceClient.create_from_x509_certificate(
fake_provisioning_host, fake_registration_id, fake_id_scope,
fake_x509())
assert isinstance(client, ProvisioningDeviceClient)
assert client._provisioning_pipeline is not None
def test_raises_exception_on_init_of_abstract_transport(mocker):
fake_transport = mocker.MagicMock
with pytest.raises(TypeError):
ProvisioningDeviceClient(fake_transport)
