iotedgedev 3.3.4__zip

s/tests/test_envvars.py

@@ -0,0 +1,169 @@
+import os
+from unittest import mock
+
+import pytest
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+
+pytestmark = pytest.mark.unit
+
+
+def test_get_envvar__valid():
+    envvars = EnvVars(Output())
+    deployment_template = envvars.get_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE")
+    assert deployment_template is not None
+
+
+def test_get_envvar__invalid():
+    envvars = EnvVars(Output())
+    testerval = envvars.get_envvar("TESTER")
+    assert not testerval
+
+
+def test_load_valid():
+    envvars = EnvVars(Output())
+    envvars.load()
+    assert envvars.DEPLOYMENT_CONFIG_TEMPLATE_FILE == "deployment.template.json"
+
+
+def test_verify_envvar_has_val__valid():
+    envvars = EnvVars(Output())
+    envvars.load()
+    result = envvars.verify_envvar_has_val("DEPLOYMENT_CONFIG_TEMPLATE_FILE", envvars.DEPLOYMENT_CONFIG_TEMPLATE_FILE)
+    assert not result
+
+
+def test_get_envvar_key_if_val__valid():
+    envvars = EnvVars(Output())
+    assert envvars.get_envvar_key_if_val("DEPLOYMENT_CONFIG_TEMPLATE_FILE")
+
+
+def test_get_envvar_key_if_val__invalid():
+    envvars = EnvVars(Output())
+    assert not envvars.get_envvar_key_if_val("TESTER")
+
+
+def test_set_envvar():
+    envvars = EnvVars(Output())
+    registry_server = envvars.get_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE")
+    envvars.set_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE", "deployment.template_new.json")
+    new_registry_server = envvars.get_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE")
+    assert new_registry_server == "deployment.template_new.json"
+    envvars.set_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE", registry_server)
+
+
+def test_envvar_clean():
+    EnvVars(Output())
+    envvar_clean_name = u"IOTEDGEDEV_ENVVAR_CLEAN_TEST"
+    os.environ[envvar_clean_name] = u"test unicode string"
+
+
+@pytest.mark.parametrize(
+    "command, command_list",
+    [
+        ("solution new test_solution", ["init", "e2e", "solution new", "new", "simulator stop"]),
+        ("solution new", ["init", "e2e", "solution new", "new", "simulator stop"]),
+        ("", ["init", "e2e", "", "new", "simulator stop"]),
+    ]
+)
+def test_in_command_list_true(command, command_list):
+    envvars = EnvVars(Output())
+    assert envvars.in_command_list(command, command_list)
+
+
+@pytest.mark.parametrize(
+    "command, command_list",
+    [
+        ("solution add filtermodule", ["init", "e2e", "solution new", "new", "simulator stop"]),
+        ("solution addotherstuff filtermodule", ["init", "e2e", "solution add", "new", "simulator stop"]),
+        ("", ["init", "e2e", "solution new", "new", "simulator stop"]),
+        ("solution new test_solution", ["init", "e2e", "", "new", "simulator stop"])
+    ]
+)
+def test_in_command_list_false(command, command_list):
+    envvars = EnvVars(Output())
+    assert not envvars.in_command_list(command, command_list)
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "iothub setup --update-dotenv",
+        ""
+    ]
+)
+def test_is_terse_command_true(command):
+    envvars = EnvVars(Output())
+    assert envvars.is_terse_command(command)
+
+
+def test_is_terse_command_false():
+    envvars = EnvVars(Output())
+    assert not envvars.is_terse_command("solution add")
+
+
+def test_default_container_registry_server_key_exists():
+    envvars = EnvVars(Output())
+    envvars.load()
+    assert "CONTAINER_REGISTRY_SERVER" in os.environ
+
+
+@pytest.mark.parametrize(
+    "envvar",
+    [
+        "CONTAINER_REGISTRY_SERVER",
+        "CONTAINER_REGISTRY_USERNAME",
+        "CONTAINER_REGISTRY_PASSWORD"
+
+    ]
+)
+def test_default_envvar_value_exists(envvar):
+    envvars = EnvVars(Output())
+    server = envvars.get_envvar(envvar)
+    assert server is not None
+
+
+def test_container_registry_server_key_missing_sys_exit():
+    envvars = EnvVars(Output())
+    with pytest.raises(ValueError):
+        envvars.get_envvar("CONTAINER_REGISTRY_SERVER_UNITTEST", required=True)
+
+
+@pytest.mark.parametrize(
+    "envvar",
+    [
+        "CONTAINER_REGISTRY_SERVER",
+        "CONTAINER_REGISTRY_USERNAME",
+        "CONTAINER_REGISTRY_PASSWORD"
+
+    ]
+)
+def test_unique_envvar_tokens(envvar):
+    unique = set()
+    envvar_lenght = len(envvar)
+    is_unique = True
+    envvars = EnvVars(Output())
+    envvars.load()
+    for key in os.environ:
+        if key.startswith(envvar):
+            token = key[envvar_lenght:]
+            if token not in unique:
+                unique.add(token)
+            else:
+                is_unique = False
+    assert is_unique
+
+
+@mock.patch.dict(os.environ, {
+    "CONTAINER_REGISTRY_SERVER_UNITTEST": "unittest.azurecr.io",
+    "CONTAINER_REGISTRY_USERNAME_UNITTEST": "username",
+    "CONTAINER_REGISTRY_PASSWORD_UNITTEST": "password"
+})
+def test_additional_container_registry_map_is_set_from_environ():
+    envvars = EnvVars(Output())
+    envvars.load()
+    assert len(envvars.CONTAINER_REGISTRY_MAP) == 2
+    assert 'UNITTEST' in envvars.CONTAINER_REGISTRY_MAP.keys()
+    assert envvars.CONTAINER_REGISTRY_MAP['UNITTEST'].server == 'unittest.azurecr.io'
+    assert envvars.CONTAINER_REGISTRY_MAP['UNITTEST'].username == 'username'
+    assert envvars.CONTAINER_REGISTRY_MAP['UNITTEST'].password == 'password'

s/tests/test_iotedgedev_iothub_deploy.py

@@ -0,0 +1,199 @@
+import os
+import uuid
+from unittest import mock
+
+import pytest
+from iotedgedev.azurecli import AzureCli
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+from iotedgedev.connectionstring import DeviceConnectionString
+
+from .utility import get_platform_type, runner_invoke
+
+pytestmark = pytest.mark.e2e
+
+output = Output()
+envvars = EnvVars(output)
+test_solution_shared_lib_dir = os.path.join(os.getcwd(), "tests", "assets", "test_solution_shared_lib")
+
+
+@pytest.mark.parametrize(
+    "config, manifest",
+    [
+        ("layered_deployment.flattened_props.template.json", "layered_deployment.flattened_props.json"),
+        ("layered_deployment.no_modules.template.json", "layered_deployment.no_modules.json"),
+        ("deployment.template.json", f"deployment.{get_platform_type()}.json")
+    ]
+)
+# Test that cmd line target condition (-t) overrides target condition from .env
+@ mock.patch.dict(os.environ, {"IOTHUB_DEPLOYMENT_TARGET_CONDITION": "invalid_target"})
+def test_iothub_deploy(config, manifest):
+    # Arrange
+    deployment_name = f'test-{uuid.uuid4()}'
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['build', '-f', config, '-P', get_platform_type()])
+    result = runner_invoke(['iothub', 'deploy',
+                            '-f', f'config/{manifest}',
+                           '-n', deployment_name,
+                            '-p', '10',
+                            '-t', "tags.environment='dev'"
+                            ])
+
+    # Assert
+    assert 'DEPLOYMENT COMPLETE' in result.output
+    assert 'ERROR' not in result.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+    assert azure_cli.invoke_az_cli_outproc(["iot", "edge", "deployment", "delete", "-d", deployment_name, "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING")])
+
+
+@ mock.patch.dict(os.environ, {"IOTHUB_DEPLOYMENT_TARGET_CONDITION": "tags.environment='dev'"})
+def test_iothub_deploy_with_target_group_set_from_dotenv():
+    # Arrange
+    deployment_name = f'test-layered{uuid.uuid4()}'
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['build', '-f', "layered_deployment.flattened_props.template.json", '-P', get_platform_type()])
+    result = runner_invoke(['iothub', 'deploy',
+                            '-f', 'config/layered_deployment.flattened_props.json',
+                           '-n', deployment_name,
+                            '-p', '10',
+                            ])
+
+    # Assert
+    assert 'DEPLOYMENT COMPLETE' in result.output
+    assert 'ERROR' not in result.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+
+    assert azure_cli.invoke_az_cli_outproc(["iot", "edge", "deployment", "delete", "-d", deployment_name, "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING")])
+
+
+def test_iothub_deploy_error_from_az_cli_bubbled_up():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['build', '-f', "layered_deployment.flattened_props.template.json", '-P', get_platform_type()])
+    result = runner_invoke(['iothub', 'deploy',
+                            '-f', 'config/layered_deployment.flattened_props.json',
+                           '-n', "test-layered-deployment",
+                            '-p', '10',
+                            '-t', "invalid_target_group"
+                            ])
+
+    # Assert
+    assert "ERROR: {'Message': 'ErrorCode:ArgumentInvalid;BadRequest'," in result.output
+
+
+def test_iothub_deploy_error_missing_name():
+    # Act
+    with pytest.raises(Exception) as context:
+        runner_invoke(['iothub', 'deploy', '-n', "test"])
+
+    # Assert
+    assert "Error: Missing option '--priority' / '-p'." in str(context)
+
+
+def test_iothub_deploy_error_missing_priority():
+    # Act
+    with pytest.raises(Exception) as context:
+        runner_invoke(['iothub', 'deploy', '-n', "test"])
+
+    # Assert
+    assert "Error: Missing option '--priority' / '-p'." in str(context)
+
+
+def test_iothub_deploy_error_missing_target_condition():
+    # Act
+    with pytest.raises(Exception) as context:
+        runner_invoke(['iothub', 'deploy', '-n', "test", '-p', '10'])
+
+    # Assert
+    assert "ERROR: Environment Variable IOTHUB_DEPLOYMENT_TARGET_CONDITION not set. Either add to .env file or to your system's Environment Variables" in str(context.value)
+
+
+def test_iothub_deploy_and_add_tags():
+    # Arrange
+    tags = '{"environment":"dev","building":"9"}'
+    deployment_name = f'test-{uuid.uuid4()}'
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['build', '-f', "layered_deployment.flattened_props.template.json", '-P', get_platform_type()])
+    result = runner_invoke(['iothub', 'deploy',
+                            '-f', 'config/layered_deployment.flattened_props.json',
+                           '-n', deployment_name,
+                            '-p', '10',
+                            '-t', "tags.environment='dev'",
+                            '-dt', tags
+                            ])
+
+    # Assert
+    assert 'DEPLOYMENT COMPLETE' in result.output
+    assert 'TAG UPDATE COMPLETE' in result.output
+    assert tags in result.output
+    assert 'ERROR' not in result.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+
+    assert azure_cli.invoke_az_cli_outproc(["iot", "edge", "deployment", "delete", "-d", deployment_name, "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING")])
+    assert azure_cli.invoke_az_cli_outproc(["iot", "hub", "device-twin", "replace", "-d", DeviceConnectionString(envvars.get_envvar("DEVICE_CONNECTION_STRING")).device_id,
+                                            "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING"), "--json", "{}"])
+
+
+def test_iothub_deploy_and_add_tags_retry_after_invalid_tag():
+    # GIVEN: `iothub deploy` run fails
+    # WHEN: Device tag has an invalid format
+    # THEN: Rerunning the command will lead to a failed deploy part,
+    #       as the deployment already exists from the previous run,
+    #       but it will succeed in adding the new and correct device tags.
+    #       Leaving the iothub and device in the initially desired end state again.
+
+    # Arrange
+    tags1 = 'invalid_tag'
+    tags2 = '{"environment":"dev","building":"9"}'
+    deployment_name = f'test-{uuid.uuid4()}'
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['build', '-f', "layered_deployment.flattened_props.template.json", '-P', get_platform_type()])
+    result = runner_invoke(['iothub', 'deploy',
+                            '-f', 'config/layered_deployment.flattened_props.json',
+                           '-n', deployment_name,
+                            '-p', '10',
+                            '-t', "tags.environment='dev'",
+                            '-dt', tags1
+                            ])
+
+    result_retry = runner_invoke(['iothub', 'deploy',
+                                  '-f', 'config/layered_deployment.flattened_props.json',
+                                  '-n', deployment_name,
+                                  '-p', '10',
+                                  '-t', "tags.environment='dev'",
+                                  '-dt', tags2
+                                  ])
+
+    # Assert
+    assert 'DEPLOYMENT COMPLETE' in result.output
+    assert 'TAG UPDATE COMPLETE' not in result.output
+    assert f"ERROR: Failed to add tag: '{tags1}' to device" in result.output
+
+    assert 'DEPLOYMENT COMPLETE' not in result_retry.output
+    assert 'TAG UPDATE COMPLETE' in result_retry.output
+    assert tags2 in result_retry.output
+    assert 'ERROR: Failed to deploy' in result_retry.output
+    assert f'Message\': "ErrorCode:ConfigurationAlreadyExists;Configuration with id \'{deployment_name}\' already exist on IotHub.' in result_retry.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+
+    assert azure_cli.invoke_az_cli_outproc(["iot", "edge", "deployment", "delete", "-d", deployment_name, "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING")])
+    assert azure_cli.invoke_az_cli_outproc(["iot", "hub", "device-twin", "replace", "-d", DeviceConnectionString(envvars.get_envvar("DEVICE_CONNECTION_STRING")).device_id,
+                                            "-l", envvars.get_envvar("IOTHUB_CONNECTION_STRING"), "--json",  "{}"])

s/tests/test_iotedgedev_simulator.py

@@ -0,0 +1,133 @@
+import os
+import pytest
+import shutil
+import time
+
+from iotedgedev.version import PY35
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+
+from .utility import get_docker_os_type
+from .utility import get_platform_type
+from .utility import runner_invoke
+
+pytestmark = pytest.mark.e2e
+
+output = Output()
+envvars = EnvVars(output)
+
+env_file_name = envvars.get_dotenv_file()
+env_file_path = envvars.get_dotenv_path(env_file_name)
+
+root_dir = os.getcwd()
+tests_dir = os.path.join(root_dir, 'tests')
+
+test_solution = 'test_solution'
+test_solution_dir = os.path.join(tests_dir, test_solution)
+
+
+@pytest.fixture(scope="module", autouse=True)
+def create_solution(request):
+    os.chdir(tests_dir)
+    result = runner_invoke(['solution', 'new', test_solution])
+
+    assert 'AZURE IOT EDGE SOLUTION CREATED' in result.output
+
+    shutil.copyfile(env_file_path, os.path.join(test_solution_dir, env_file_name))
+    os.chdir(test_solution_dir)
+
+    def clean():
+        os.chdir(root_dir)
+        time.sleep(5)
+        shutil.rmtree(test_solution_dir, ignore_errors=True)
+        shutil.rmtree(test_solution_dir+"_shared_lib", ignore_errors=True)
+        runner_invoke(['simulator', 'stop'])
+
+    request.addfinalizer(clean)
+
+    return
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_setup():
+    result = runner_invoke(['simulator', 'setup'])
+
+    assert 'Setup IoT Edge Simulator successfully.' in result.output
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_setup_with_iothub():
+    result = runner_invoke(['simulator', 'setup', '-i', os.getenv("IOTHUB_CONNECTION_STRING")])
+
+    assert 'Setup IoT Edge Simulator successfully.' in result.output
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_start_single():
+    result = runner_invoke(['simulator', 'start', '-i', 'input1'])
+
+    assert 'IoT Edge Simulator has been started in single module mode.' in result.output
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_modulecred():
+    result = runner_invoke(['simulator', 'modulecred'])
+
+    assert 'EdgeHubConnectionString=HostName=' in result.output
+    assert 'EdgeModuleCACertificateFile=' in result.output
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_stop(capfd):
+    runner_invoke(['simulator', 'stop'])
+    out, err = capfd.readouterr()
+
+    assert 'IoT Edge Simulator has been stopped successfully.' in out
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_start_solution(capfd):
+    result = runner_invoke(['simulator', 'start', '-s', '-b', '-f', 'deployment.template.json'])
+    out, err = capfd.readouterr()
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'IoT Edge Simulator has been started in solution mode.' in out
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_start_solution_with_setup(capfd):
+    result = runner_invoke(['simulator', 'start', '--setup', '-s', '-b', '-f', 'deployment.template.json'])
+    out, err = capfd.readouterr()
+
+    assert 'Setup IoT Edge Simulator successfully.' in result.output
+    assert 'BUILD COMPLETE' in result.output
+    assert 'IoT Edge Simulator has been started in solution mode.' in out
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_monitor(capfd):
+    try:
+        result = runner_invoke(['monitor', '--timeout', '30'])
+        out, err = capfd.readouterr()
+        # Assert output from simulator
+        sim_match = 'timeCreated'
+
+        if not PY35:
+            assert 'Monitoring events from device' in out
+            assert sim_match in out
+        else:
+            assert not err
+            assert sim_match in result.output
+    finally:
+        test_stop(capfd)
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Simulator does not support windows container')
+def test_start_solution_with_deployment(capfd):
+    platform_type = get_platform_type()
+    deployment_file_path = os.path.join(test_solution_dir, 'config', 'deployment.' + platform_type + '.json')
+    runner_invoke(['simulator', 'start', '-f', deployment_file_path])
+    out, err = capfd.readouterr()
+
+    assert 'IoT Edge Simulator has been started in solution mode.' in out
+    test_monitor(capfd)