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)