iotedgedev 3.3.4__zip

s/tests/test_iotedgedev_solution_build.py

@@ -0,0 +1,246 @@
+import json
+import os
+import platform
+import shutil
+import time
+from unittest import mock
+
+import pytest
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+
+from .utility import (get_all_docker_images, get_docker_os_type,
+                      get_file_content, get_platform_type, runner_invoke,
+                      update_file_content)
+
+pytestmark = pytest.mark.e2e
+
+output = Output()
+envvars = EnvVars(output)
+
+tests_dir = os.path.join(os.getcwd(), "tests")
+tests_assets_dir = os.path.join(tests_dir, "assets")
+
+env_file_name = envvars.get_dotenv_file()
+env_file_path = envvars.get_dotenv_path(env_file_name)
+
+launch_json_file = os.path.join(tests_dir, "assets", "launch.json")
+launch_json_file_without_nodejs = os.path.join(tests_assets_dir, "launch_without_nodejs.json")
+test_solution_shared_lib_dir = os.path.join(tests_assets_dir, "test_solution_shared_lib")
+
+
+@pytest.fixture
+def prepare_solution_with_env():
+    os.chdir(tests_dir)
+    test_solution = "test_solution"
+    test_solution_dir = os.path.join(tests_dir, test_solution)
+    template = "csharp"
+    module_name = "filtermodule"
+    result = runner_invoke(['new', test_solution, '-m', module_name, '-t', template])
+
+    if 'AZURE IOT EDGE SOLUTION CREATED' not in result.output:
+        raise Exception(result.stdout)
+
+    shutil.copyfile(env_file_path, os.path.join(test_solution_dir, env_file_name))
+
+    os.chdir(test_solution_dir)
+
+    yield prepare_solution_with_env
+    os.chdir(tests_dir)
+    time.sleep(5)
+    shutil.rmtree(test_solution_dir, ignore_errors=True)
+
+    return
+
+
+def test_solution_build_and_push_with_layered_deployment():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+    new_config_deployment_path = os.path.join(test_solution_shared_lib_dir, 'config', "layered_deployment.flattened_props.json")
+
+    # Act
+    result = runner_invoke(['build', '--push', '-f', "layered_deployment.flattened_props.template.json", '-P', get_platform_type()])
+
+    # Assert
+    assert os.path.exists(new_config_deployment_path)
+    assert 'sample_module:0.0.1-RC' in result.output
+    assert 'BUILD COMPLETE' in result.output
+    assert 'PUSH COMPLETE' in result.output
+    assert 'ERROR' not in result.output
+
+
+def test_solution_build_and_push_with_layered_deployment_no_modules():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+    new_config_deployment_path = os.path.join(test_solution_shared_lib_dir, 'config', 'layered_deployment.no_modules.json')
+
+    # Act
+    result = runner_invoke(['build', '--push', '-f', "layered_deployment.no_modules.template.json", '-P', get_platform_type()])
+
+    # Assert
+
+    with open(new_config_deployment_path, "r") as f:
+        content = json.load(f)
+
+    set_property = content["content"]["modulesContent"]["exampleModule"]["properties.desired"]["foo"]
+
+    assert 'ERROR' not in result.output
+    assert 'bar-1.2' == set_property
+
+
+def test_solution_build_and_push_with_platform():
+    os.chdir(test_solution_shared_lib_dir)
+
+    result = runner_invoke(['build', '-P', get_platform_type()])
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'PUSH COMPLETE' not in result.output
+    assert 'sample_module:0.0.1-RC' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+    result = runner_invoke(['push', '--no-build', '-P', get_platform_type()])
+
+    assert 'PUSH COMPLETE' in result.output
+    assert 'BUILD COMPLETE' not in result.output
+    assert 'sample_module:0.0.1-RC' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+
+def test_solution_build_and_push_with_different_cwd():
+    cwd = os.path.join(test_solution_shared_lib_dir, 'config')
+    if not os.path.exists(cwd):
+        os.makedirs(cwd)
+    os.chdir(cwd)
+
+    result = runner_invoke(['build', '-f', '../deployment.template.json', '-P', get_platform_type()])
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'sample_module:0.0.1-RC' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+    result = runner_invoke(['push', '-f', '../deployment.template.json', '--no-build', '-P', get_platform_type()])
+
+    assert 'PUSH COMPLETE' in result.output
+    assert 'sample_module:0.0.1-RC' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+
+@pytest.mark.skipif(platform.system().lower() != 'windows', reason='The path is not valid in non windows platform')
+def test_solution_build_and_push_with_escapedpath():
+    os.chdir(test_solution_shared_lib_dir)
+
+    result = runner_invoke(['build', '-f', 'deployment.escapedpath.template.json', '-P', get_platform_type()])
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+    result = runner_invoke(['push', '--no-build', '-P', get_platform_type()])
+
+    assert 'PUSH COMPLETE' in result.output
+    assert 'sample_module_2:0.0.1-RC' in result.output
+    assert 'ERROR' not in result.output
+
+
+@mock.patch.dict(os.environ, {"VERSION": "0.0.2"})
+def test_solution_build_with_version_and_build_options():
+    os.chdir(test_solution_shared_lib_dir)
+    module_json_file_path = os.path.join(test_solution_shared_lib_dir, "modules", "sample_module", "module.json")
+    module_2_json_file_path = os.path.join(test_solution_shared_lib_dir, "sample_module_2", "module.json")
+    try:
+        update_file_content(module_json_file_path, '"version": "0.0.1-RC"', '"version": "${VERSION}"')
+        update_file_content(module_json_file_path, '"buildOptions": (.*),', '"buildOptions": [ "--add-host=github.com:192.30.255.112", "--build-arg a=b" ],')
+        update_file_content(module_2_json_file_path, '"version": "0.0.1-RC"', '"version": "${VERSION}"')
+        update_file_content(module_2_json_file_path, '"buildOptions": (.*),', '"buildOptions": [ "--add-host=github.com:192.30.255.112", "--build-arg a=b" ],')
+
+        result = runner_invoke(['build', '-P', get_platform_type()])
+
+        assert 'BUILD COMPLETE' in result.output
+        assert 'sample_module:0.0.2' in result.output
+        assert 'sample_module_2:0.0.2' in result.output
+        assert 'ERROR' not in result.output
+        assert '0.0.2' in get_all_docker_images()
+
+    finally:
+        update_file_content(module_json_file_path, '"version": "(.*)"', '"version": "0.0.1-RC"')
+        update_file_content(module_json_file_path, '"buildOptions": (.*),', '"buildOptions": [],')
+        update_file_content(module_2_json_file_path, '"version": "(.*)"', '"version": "0.0.1-RC"')
+        update_file_content(module_2_json_file_path, '"buildOptions": (.*),', '"buildOptions": [],')
+
+
+def test_solution_build_without_schema_template():
+    try:
+        os.chdir(test_solution_shared_lib_dir)
+
+        os.rename('deployment.template.json', 'deployment.template.backup.json')
+        template_without_schema_version = os.path.join(tests_dir, "assets", "deployment.template_without_schema_template.json")
+        shutil.copyfile(template_without_schema_version, 'deployment.template.json')
+
+        update_file_content('deployment.template.json', '"image": "(.*)MODULES.sample_module}",', '"image": "${MODULES.sample_module.' + get_platform_type() + '}",')
+
+        result = runner_invoke(['build'])
+
+        assert 'BUILD COMPLETE' in result.output
+        assert 'ERROR' not in result.output
+
+        config_file_path = os.path.join(test_solution_shared_lib_dir, "config", "deployment.json")
+        assert os.path.exists(config_file_path)
+
+        content = get_file_content(config_file_path)
+        assert "sample_module:0.0.1-RC-" + get_platform_type() in content
+    finally:
+        os.remove('deployment.template.json')
+        os.rename('deployment.template.backup.json', 'deployment.template.json')
+
+
+def test_solution_build_with_default_platform(prepare_solution_with_env):
+    result = runner_invoke(['build'])
+
+    module_name = "filtermodule"
+    test_solution_config_dir = os.path.join('config', 'deployment.' + get_platform_type() + '.json')
+    env_container_registry_server = os.getenv("CONTAINER_REGISTRY_SERVER")
+    with open(test_solution_config_dir) as f:
+        content = json.load(f)
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'ERROR' not in result.output
+    assert env_container_registry_server + "/" + module_name + ":0.0.1-" + get_platform_type() in content[
+        "modulesContent"]["$edgeAgent"]["properties.desired"]["modules"][module_name]["settings"]["image"]
+    assert module_name in get_all_docker_images()
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='Debugger does not support C# in windows container')
+def test_solution_build_with_debug_template():
+    os.chdir(test_solution_shared_lib_dir)
+
+    result = runner_invoke(['build', '-f', os.environ["DEPLOYMENT_CONFIG_DEBUG_TEMPLATE_FILE"], '-P', get_platform_type()])
+
+    module_name = "sample_module"
+    module_2_name = "sample_module_2"
+    test_solution_shared_debug_config = os.path.join('config', 'deployment.debug.' + get_platform_type() + '.json')
+    env_container_registry_server = os.getenv("CONTAINER_REGISTRY_SERVER")
+    with open(test_solution_shared_debug_config) as f:
+        content = json.load(f)
+
+    assert 'BUILD COMPLETE' in result.output
+    assert 'ERROR' not in result.output
+    assert env_container_registry_server + "/" + module_name + ":0.0.1-RC-" + get_platform_type() + ".debug" in content[
+        "modulesContent"]["$edgeAgent"]["properties.desired"]["modules"][module_name]["settings"]["image"]
+    assert env_container_registry_server + "/" + module_2_name + ":0.0.1-RC-" + get_platform_type() + ".debug" in content[
+        "modulesContent"]["$edgeAgent"]["properties.desired"]["modules"][module_2_name]["settings"]["image"]
+    all_docker_images = get_all_docker_images()
+    assert module_name in all_docker_images
+    assert module_2_name in all_docker_images
+
+
+@pytest.mark.skipif(get_docker_os_type() == 'windows', reason='The output of docker build logs is not captured by logs on windows, need to capture this before enabling this test')
+def test_verify_docker_build_status_in_output():
+    os.chdir(test_solution_shared_lib_dir)
+
+    result = runner_invoke(['build', '-f' 'deployment.debug.template.json', '-P', get_platform_type()])
+
+    assert all(x in result.output for x in ["--->", "Step 1/", "Successfully tagged"])

s/tests/test_iotedgedev_solution_tag.py

@@ -0,0 +1,99 @@
+import os
+import pytest
+from .utility import (
+    runner_invoke,
+)
+from iotedgedev.azurecli import AzureCli
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+from iotedgedev.connectionstring import DeviceConnectionString
+from unittest import mock
+
+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")
+
+
+# Test that cmd line tags (--tags) overrides DEVICE_TAGS from .env
+@ mock.patch.dict(os.environ, {"DEVICE_TAGS": "invalid_target"})
+def test_add_tags():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['solution', 'tag', '--tags', '{"environment":"dev","building":"9"}'])
+
+    # Assert
+    assert 'TAG UPDATE COMPLETE' in result.output
+    assert '{"environment":"dev","building":"9"}' in result.output
+    assert 'ERROR' not in result.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+
+    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", "{}"])
+
+
+@pytest.mark.parametrize(
+    "tags",
+    [
+        "tags.environment='dev'",
+        "dev"
+    ]
+)
+def test_add_invalid_tag(tags):
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['solution', 'tag', '--tags', tags])
+
+    # Assert
+    assert f"ERROR: Failed to add tag: '{tags}' to device" in result.output
+
+
+def test_error_missing_tag():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    with pytest.raises(Exception) as context:
+        runner_invoke(['solution', 'tag', '--tags'])
+
+    # Assert
+    assert "Error: Option '--tags' requires an argument." in str(context)
+
+
+@ mock.patch.dict(os.environ, {"DEVICE_TAGS": '{"environment":"dev","building":"9"}'})
+def test_default_tag_from_env():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    result = runner_invoke(['solution', 'tag'])
+
+    # Assert
+    assert 'TAG UPDATE COMPLETE' in result.output
+    assert '{"environment":"dev","building":"9"}' in result.output
+    assert 'ERROR' not in result.output
+
+    # Cleanup
+    azure_cli = AzureCli(output, envvars)
+
+    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_missing_default_tag_from_env():
+    # Arrange
+    os.chdir(test_solution_shared_lib_dir)
+
+    # Act
+    with pytest.raises(Exception) as context:
+        runner_invoke(['solution', 'tag'])
+
+    # Assert
+    assert "ERROR: Environment Variable DEVICE_TAGS not set. Either add to .env file or to your system's Environment Variables" in str(context)

s/tests/test_utility.py

@@ -0,0 +1,132 @@
+import os
+from unittest import mock
+
+import pytest
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+from iotedgedev.utility import Utility
+
+from .utility import (assert_file_equal, assert_json_file_equal,
+                      assert_list_equal)
+
+pytestmark = pytest.mark.unit
+
+tests_dir = os.path.join(os.getcwd(), "tests")
+test_assets_dir = os.path.join(tests_dir, "assets")
+test_file_1 = os.path.join(test_assets_dir, "deployment.template_1.json")
+test_file_2 = os.path.join(test_assets_dir, "deployment.template_2.json")
+test_file_4 = os.path.join(test_assets_dir, "deployment.template_4.json")
+
+
+@pytest.fixture
+def utility():
+    output = Output()
+    envvars = EnvVars(output)
+    envvars.load()
+    return Utility(envvars, output)
+
+
+def test_ensure_dir(request, utility):
+    before_ensure = os.listdir(tests_dir)
+    utility.ensure_dir(test_assets_dir)
+    after_ensure = os.listdir(tests_dir)
+    assert_list_equal(before_ensure, after_ensure)
+
+    new_dir = "new_dir"
+    utility.ensure_dir(new_dir)
+    assert os.path.exists(new_dir)
+
+    def clean():
+        if os.path.exists(new_dir):
+            os.rmdir(new_dir)
+    request.addfinalizer(clean)
+
+
+def test_copy_from_template_dir(utility, tmpdir):
+    src_file = "deployment.template.json"
+    dest_dir = tmpdir.strpath
+    dest_file = tmpdir.join(src_file).strpath
+    utility.copy_from_template_dir(src_file, dest_dir, replacements={"%MODULE%": "filtermodule"})
+    assert_file_equal(dest_file, test_file_4)
+
+
+def test_copy_template(utility, tmpdir):
+    replacements = {
+        "${MODULES.csharpmodule.amd64}": "localhost:5000/csharpmodule:0.0.1-amd64",
+        "${MODULES.csharpfunction.amd64.debug}": "localhost:5000/csharpfunction:0.0.1-amd64.debug"
+    }
+    dest = tmpdir.join("deployment_template_1.dest.json").strpath
+    utility.copy_template(test_file_1, dest, replacements=replacements, expandvars=False)
+    assert_json_file_equal(test_file_2, dest)
+
+
+@mock.patch.dict(os.environ, {"CONTAINER_REGISTRY_SERVER": "localhost:5000"})
+def test_copy_template_expandvars(utility, tmpdir):
+    replacements = {
+        "${MODULES.csharpmodule.amd64}": "${CONTAINER_REGISTRY_SERVER}/csharpmodule:0.0.1-amd64",
+        "${MODULES.csharpfunction.amd64.debug}": "${CONTAINER_REGISTRY_SERVER}/csharpfunction:0.0.1-amd64.debug"
+    }
+    dest = tmpdir.join("deployment_template_2.dest.json").strpath
+    dest2 = tmpdir.join("deployment_template_2.dest2.json").strpath
+    utility.copy_template(test_file_1, dest, replacements=replacements, expandvars=True)
+    utility.copy_template(test_file_2, dest2, expandvars=True)
+    assert_json_file_equal(dest, dest2)
+
+
+def test_in_asterisk_list(utility):
+    assert utility.in_asterisk_list("filtermodule", "pipemodule, filtermodule")
+
+
+def test_in_asterisk_list_empty(utility):
+    assert not utility.in_asterisk_list("filtermodule", "")
+
+
+def test_in_asterisk_list_asterisk(utility):
+    assert utility.in_asterisk_list("filtermodule", "*")
+
+
+def test_del_key(utility):
+    dict_ = {
+        "1": 0,
+        "2": {
+            "3": 0,
+            "4": "foo",
+            "5": {
+                "6": 0
+            }
+        }
+    }
+
+    assert utility.del_key("not a dict", ["1", "2"]) is None
+    assert utility.del_key(dict_, ["2", "5"]) == {"6": 0}
+    assert utility.del_key(dict_, ["1", "non_existent_key"]) is None
+    assert utility.del_key(dict_, ["2", "non_existent_key"]) is None
+
+    expected = {
+        "1": 0,
+        "2": {
+            "3": 0,
+            "4": "foo"
+        }
+    }
+
+    assert dict_ == expected
+
+
+def test_get_sha256_hash():
+    assert Utility.get_sha256_hash("foo") == "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"
+
+
+@mock.patch.dict(os.environ, {"DEPLOYMENT_CONFIG_FILE": "foo.json"})
+def test_get_deployment_manifest_name__set_from_envvar():
+    assert Utility.get_deployment_manifest_name("deployment.debug.template.json", "1.0.0", "amd64") == "foo.json"
+
+
+def test_get_deployment_manifest_name():
+    assert Utility.get_deployment_manifest_name("config/deployment.template.json", "0.0.1", "amd64") == "deployment.json"
+    assert Utility.get_deployment_manifest_name("deployment.template.json", "0.0.1", "amd64") == "deployment.json"
+    assert Utility.get_deployment_manifest_name("deployment.debug.template.json", "0.0.1", "amd64") == "deployment.debug.json"
+    assert Utility.get_deployment_manifest_name("config/deployment.template.json", "1.0.0", "amd64") == "deployment.amd64.json"
+    assert Utility.get_deployment_manifest_name("deployment.template.json", "1.0.0", "amd64") == "deployment.amd64.json"
+    assert Utility.get_deployment_manifest_name("deployment.debug.template.json", "1.0.0", "amd64") == "deployment.debug.amd64.json"
+    assert Utility.get_deployment_manifest_name("", "", "") == "deployment.json"

s/tests/utility.py

@@ -0,0 +1,132 @@
+import json
+import re
+import subprocess
+import sys
+
+import click
+from click.testing import CliRunner
+from iotedgedev.dockercls import Docker
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+from iotedgedev.utility import Utility
+
+output = Output()
+envvars = EnvVars(output)
+
+
+def assert_list_equal(list1, list2):
+    assert len(list1) == len(list2) and sorted(list1) == sorted(list2)
+
+
+def assert_file_equal(file1, file2):
+    with open(file1, "r") as f1:
+        with open(file2, "r") as f2:
+            assert f1.read() == f2.read()
+
+
+def assert_json_file_equal(file1, file2):
+    with open(file1, "r") as f1:
+        with open(file2, "r") as f2:
+            assert json.load(f1) == json.load(f2)
+
+
+def get_docker_client():
+    envvars.load(force=True)
+    utility = Utility(envvars, output)
+    docker_client = Docker(envvars, utility, output)
+    docker_client.init_registry()
+    return docker_client
+
+
+def get_docker_os_type():
+    os_type = get_docker_client().get_os_type().lower()
+    return os_type
+
+
+def get_platform_type():
+    if get_docker_os_type() == 'windows':
+        platform_type = 'windows-amd64'
+    else:
+        platform_type = 'amd64'
+    return platform_type
+
+
+def get_all_docker_containers():
+    output = start_process(['docker', 'ps', '-a'], False)
+    return output
+
+
+def get_all_docker_images():
+    output = start_process(['docker', 'image', 'ls'], False)
+    return output
+
+
+def prune_docker_images():
+    output = start_process(['docker', 'image', 'prune', '-f'], False)
+    return output
+
+
+def prune_docker_containers():
+    output = start_process(['docker', 'container', 'prune', '-f'], False)
+    return output
+
+
+def prune_docker_build_cache():
+    output = start_process(['docker', 'builder', 'prune', '-f'], False)
+    return output
+
+
+def remove_docker_container(container_name):
+    output = start_process(['docker', 'rm', '-f', container_name], False)
+    return output
+
+
+def remove_docker_image(image_name):
+    output = start_process(['docker', 'rmi', '-f', image_name], False)
+    return output
+
+
+def runner_invoke(args, expect_failure=False):
+    runner = CliRunner()
+    with runner.isolation(env={"DEFAULT_PLATFORM": get_platform_type()}):
+        iotedgedev_import = "iotedgedev.cli"
+        cli = __import__(iotedgedev_import, fromlist=['main'])
+        # Remove "iotedgedev.cli" import from cache, to prevent variables being saved across tests
+        del sys.modules[iotedgedev_import]
+        result = runner.invoke(cli.main, args)
+        if (result.exit_code == 0) or (expect_failure is True):
+            return result
+        else:
+            raise Exception(result.stdout)
+
+
+def start_process(command, is_shell):
+    process = subprocess.Popen(command, shell=is_shell,
+                               stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    output, error = process.communicate()
+    if process.returncode == 0:
+        return str(output)
+    else:
+        raise Exception(error)
+
+
+def update_file_content(file_path, actual_value, expected_value):
+    with open(file_path, "r+") as f:
+        stream_data = f.read()
+        ret = re.sub(actual_value, expected_value, stream_data)
+        f.seek(0)
+        f.truncate()
+        f.write(ret)
+
+
+def get_file_content(file_path):
+    with open(file_path, "r+") as f:
+        content = f.read()
+
+    return content
+
+
+def get_cli_command_structure(obj):
+    if isinstance(obj, click.Group):
+        return {name: get_cli_command_structure(value)
+                for name, value in obj.commands.items()}

s/tox.ini

@@ -0,0 +1,29 @@
+[tox]
+envlist = py36, py37, py38, py39
+
+#[travis]
+#python =
+#    3.6: py36
+    
+#[testenv:flake8]
+#basepython=python
+#deps=flake8
+#commands=flake8 iotedgedev
+
+[testenv]
+deps = -rrequirements_dev.txt
+#setenv = PIP_EXTRA_INDEX_URL=https://test.pypi.org/simple/
+commands = pytest -s -v {posargs}
+#setenv =
+#    PYTHONPATH = {toxinidir}
+
+#commands = 
+#    python setup.py test
+
+passenv = *
+
+; If you want to make tox run the tests with the same versions, create a
+; requirements.txt with the pinned versions and uncomment the following lines:
+; deps =
+;    -r{toxinidir}/requirements.txt 
+