Beispiel #1
0
def test_provider_is_ci():
    """
    Validate |is_ci| reports as expected.

    .. |is_ci| replace:: :func:`Provider.is_ci() <ci_exec.provider.Provider.is_ci>`
    """
    assert not Provider.is_ci()

    # Test individual generic providers report success.
    for generic in _generic_providers:
        generic_map = {generic: "true"}
        with set_env(**generic_map):
            assert Provider.is_ci()

    # Test both being set report success.
    full_generic_map = {generic: "true" for generic in _generic_providers}
    with set_env(**full_generic_map):
        assert Provider.is_ci()

    # Test that setting specific provider(s) also reports success.  This should also be
    # tested in each specific provider test below.
    full_provider_map = {}
    for provider in ["APPVEYOR", "CIRCLECI", "TRAVIS"]:
        provider_map = {provider: "true"}
        with set_env(**provider_map):
            assert Provider.is_ci()

        full_provider_map[provider] = "true"

    with set_env(**full_provider_map):
        assert Provider.is_ci()
Beispiel #2
0
def test_provider_is_jenkins():
    """
    Validate |is_jenkins| reports as expected.

    .. |is_jenkins| replace::

        :func:`Provider.is_jenkins() <ci_exec.provider.Provider.is_jenkins>`
    """
    assert not Provider.is_ci()
    assert not Provider.is_jenkins()
    with set_env(JENKINS_URL="dontcare"):
        assert not Provider.is_ci()
        assert not Provider.is_jenkins()
        with set_env(BUILD_NUMBER="dontcare"):
            assert Provider.is_ci()
            assert Provider.is_jenkins()
            assert provider_sum() == 1
Beispiel #3
0
def test_provider_is_azure_pipelines():
    """
    Validate |is_azure_pipelines| reports as expected.

    .. |is_azure_pipelines| replace::

        :func:`Provider.is_azure_pipelines() <ci_exec.provider.Provider.is_azure_pipelines>`
    """  # noqa: E501
    assert not Provider.is_ci()
    assert not Provider.is_azure_pipelines()
    with set_env(AZURE_HTTP_USER_AGENT="dontcare"):
        assert not Provider.is_ci()
        assert not Provider.is_azure_pipelines()
        with set_env(AGENT_NAME="dontcare"):
            assert not Provider.is_ci()
            assert not Provider.is_azure_pipelines()
            with set_env(BUILD_REASON="dontcare"):
                assert Provider.is_ci()
                assert Provider.is_azure_pipelines()
                assert provider_sum() == 1
Beispiel #4
0
def test_provider_is_appveyor():
    """
    Validate |is_appveyor| reports as expected.

    .. |is_appveyor| replace::

        :func:`Provider.is_appveyor() <ci_exec.provider.Provider.is_appveyor>`
    """
    assert not Provider.is_ci()
    assert not Provider.is_appveyor()
    with set_env(APPVEYOR="true"):
        assert Provider.is_ci()
        assert Provider.is_appveyor()
        assert provider_sum() == 1
Beispiel #5
0
def test_provider_is_travis():
    """
    Validate |is_travis| reports as expected.

    .. |is_travis| replace::

        :func:`Provider.is_travis() <ci_exec.provider.Provider.is_travis>`
    """
    assert not Provider.is_ci()
    assert not Provider.is_travis()
    with set_env(TRAVIS="true"):
        assert Provider.is_ci()
        assert Provider.is_travis()
        assert provider_sum() == 1
Beispiel #6
0
def test_provider_is_github_actions():
    """
    Validate |is_github_actions| reports as expected.

    .. |is_github_actions| replace::

        :func:`Provider.is_github_actions <ci_exec.provider.Provider.is_github_actions>`
    """
    assert not Provider.is_ci()
    assert not Provider.is_github_actions()
    with set_env(GITHUB_ACTIONS="true"):
        assert Provider.is_ci()
        assert Provider.is_github_actions()
        assert provider_sum() == 1
Beispiel #7
0
def test_provider_is_circle_ci():
    """
    Validate |is_circle_ci| reports as expected.

    .. |is_circle_ci| replace::

        :func:`Provider.is_circle_ci() <ci_exec.provider.Provider.is_circle_ci>`
    """
    assert not Provider.is_ci()
    assert not Provider.is_circle_ci()
    with set_env(CIRCLECI="true"):
        assert Provider.is_ci()
        assert Provider.is_circle_ci()
        assert provider_sum() == 1
Beispiel #8
0
def test_env_or_platform_default():
    """
    Validate |env_or_platform_default| returns expected values for each platform.

    .. |env_or_platform_default| replace::

        :func:`~ci_exec.parsers.utils.env_or_platform_default`
    """
    kwargs = dict(env="CC", windows="cl.exe", darwin="clang", other="gcc")
    cc = env_or_platform_default(**kwargs)
    system = platform.system()
    if system == "Windows":
        assert cc == "cl.exe"
    elif system == "Darwin":
        assert cc == "clang"
    else:
        assert cc == "gcc"

    with set_env(CC="supercompiler"):
        cc = env_or_platform_default(**kwargs)
        assert cc == "supercompiler"
Beispiel #9
0
def test_unset_env():
    """Validate |unset_env| unsets environment variables."""
    with pytest.raises(ValueError) as exc_info:

        @unset_env()
        def no_arguments_bad():  # pragma: no cover
            pass  # pragma: no cover

    assert str(exc_info.value) == "unset_env: at least one argument required."

    with pytest.raises(ValueError) as exc_info:

        @unset_env(12)
        def integer_arg_bad():  # pragma: no cover
            pass  # pragma: no cover

    assert str(exc_info.value) == "unset_env: all arguments must be strings."

    with pytest.raises(ValueError) as exc_info:

        @unset_env("KEY", 12, "ANOTHER_KEY")
        def integer_arg_still_bad():  # pragma: no cover
            pass  # pragma: no cover

    assert str(exc_info.value) == "unset_env: all arguments must be strings."

    # The actual environment setting test.
    def unset_env_decorator_test():
        @unset_env("CC", "CXX", "FC")
        def unset_all():
            assert "CC" not in os.environ
            assert "CXX" not in os.environ
            assert "FC" not in os.environ

        @set_env(CC="clang", CXX="clang++", FC="flang")
        def set_llvm():
            @set_env(CC="gcc", CXX="g++", FC="gfortran")
            def set_gnu():
                @set_env(CC="icc", CXX="icpc", FC="ifort")
                def set_intel():
                    # Test setting before and after.
                    assert os.environ["CC"] == "icc"
                    assert os.environ["CXX"] == "icpc"
                    assert os.environ["FC"] == "ifort"
                    unset_all()
                    assert os.environ["CC"] == "icc"
                    assert os.environ["CXX"] == "icpc"
                    assert os.environ["FC"] == "ifort"

                # Test setting before and after.
                assert os.environ["CC"] == "gcc"
                assert os.environ["CXX"] == "g++"
                assert os.environ["FC"] == "gfortran"
                set_intel()
                unset_all()
                assert os.environ["CC"] == "gcc"
                assert os.environ["CXX"] == "g++"
                assert os.environ["FC"] == "gfortran"

            # Test setting before and after.
            assert os.environ["CC"] == "clang"
            assert os.environ["CXX"] == "clang++"
            assert os.environ["FC"] == "flang"
            set_gnu()
            unset_all()
            assert os.environ["CC"] == "clang"
            assert os.environ["CXX"] == "clang++"
            assert os.environ["FC"] == "flang"

        # Test setting before and after.
        assert "CC" not in os.environ
        assert "CXX" not in os.environ
        assert "FC" not in os.environ
        set_llvm()
        assert "CC" not in os.environ
        assert "CXX" not in os.environ
        assert "FC" not in os.environ

    unset_env_decorator_test()

    # Same test only with `with`.
    assert "CC" not in os.environ
    assert "CXX" not in os.environ
    assert "FC" not in os.environ
    with set_env(CC="clang", CXX="clang++", FC="flang"):
        assert os.environ["CC"] == "clang"
        assert os.environ["CXX"] == "clang++"
        assert os.environ["FC"] == "flang"
        with unset_env("CC", "CXX", "FC"):
            assert "CC" not in os.environ
            assert "CXX" not in os.environ
            assert "FC" not in os.environ
        with set_env(CC="gcc", CXX="g++", FC="gfortran"):
            assert os.environ["CC"] == "gcc"
            assert os.environ["CXX"] == "g++"
            assert os.environ["FC"] == "gfortran"
            with unset_env("CC", "CXX", "FC"):
                assert "CC" not in os.environ
                assert "CXX" not in os.environ
                assert "FC" not in os.environ
            with set_env(CC="icc", CXX="icpc", FC="ifort"):
                assert os.environ["CC"] == "icc"
                assert os.environ["CXX"] == "icpc"
                assert os.environ["FC"] == "ifort"
                with unset_env("CC", "CXX", "FC"):
                    assert "CC" not in os.environ
                    assert "CXX" not in os.environ
                    assert "FC" not in os.environ
                assert os.environ["CC"] == "icc"
                assert os.environ["CXX"] == "icpc"
                assert os.environ["FC"] == "ifort"
            assert os.environ["CC"] == "gcc"
            assert os.environ["CXX"] == "g++"
            assert os.environ["FC"] == "gfortran"
        assert os.environ["CC"] == "clang"
        assert os.environ["CXX"] == "clang++"
        assert os.environ["FC"] == "flang"
    assert "CC" not in os.environ
    assert "CXX" not in os.environ
    assert "FC" not in os.environ

    # Make sure that function arguments are passed through / return propagated.
    @set_env(CC="icc", CXX="icpc", FC="ifort")
    def func_returns_wrapper(*args, **kwargs):
        @unset_env("CC", "CXX", "FC")
        def func_returns(x: int, y: int, z: int = 3, w: int = 4) -> bool:
            assert "CC" not in os.environ
            assert "CXX" not in os.environ
            assert "FC" not in os.environ
            return (x + y + z) > w

        # Test setting before and after.
        assert os.environ["CC"] == "icc"
        assert os.environ["CXX"] == "icpc"
        assert os.environ["FC"] == "ifort"
        ret = func_returns(*args, **kwargs)
        assert os.environ["CC"] == "icc"
        assert os.environ["CXX"] == "icpc"
        assert os.environ["FC"] == "ifort"
        return ret

    assert func_returns_wrapper(1, 2, 3, 4) == True  # noqa: E712
    assert func_returns_wrapper(1, 2, z=3) == True  # noqa: E712
    assert func_returns_wrapper(1, 2) == True  # noqa: E712
    assert func_returns_wrapper(1, 2, w=11) == False  # noqa: E712
    args = [1, 2]
    kwargs = {"z": -3, "w": 111}
    assert func_returns_wrapper(*args, **kwargs) == False  # noqa: E712
Beispiel #10
0
def test_set_env():
    """Validate |set_env| sets environment variables."""
    with pytest.raises(ValueError) as exc_info:

        @set_env()
        def no_arguments_bad():  # pragma: no cover
            pass  # pragma: no cover

    assert str(exc_info.value) == "set_env: at least one argument required."

    with pytest.raises(ValueError) as exc_info:

        @set_env(KEY=12)
        def integer_value_bad():  # pragma: no cover
            pass  # pragma: no cover

    assert str(
        exc_info.value) == "set_env: all keys and values must be strings."

    # The actual environment setting test.
    def set_env_decorator_test():
        @set_env(CC="clang")
        def set_cc():
            @set_env(CXX="clang++")
            def set_cxx():
                @set_env(FC="flang")
                def set_fc():
                    @set_env(CC="gcc", CXX="g++", FC="gfortran")
                    def nested_setting():
                        assert os.environ["CC"] == "gcc"
                        assert os.environ["CXX"] == "g++"
                        assert os.environ["FC"] == "gfortran"

                    # Test setting before and after.
                    assert os.environ["CC"] == "clang"
                    assert os.environ["CXX"] == "clang++"
                    assert os.environ["FC"] == "flang"
                    nested_setting()
                    assert os.environ["CC"] == "clang"
                    assert os.environ["CXX"] == "clang++"
                    assert os.environ["FC"] == "flang"

                # Test setting before and after.
                assert os.environ["CC"] == "clang"
                assert os.environ["CXX"] == "clang++"
                assert "FC" not in os.environ
                set_fc()
                assert os.environ["CC"] == "clang"
                assert os.environ["CXX"] == "clang++"
                assert "FC" not in os.environ

            # Test setting before and after.
            assert os.environ["CC"] == "clang"
            assert "CXX" not in os.environ
            assert "FC" not in os.environ
            set_cxx()
            assert os.environ["CC"] == "clang"
            assert "CXX" not in os.environ
            assert "FC" not in os.environ

        # Test setting before and after.
        # NOTE: since we are in tox and CC / CXX are *NOT* in `passenv`, even if a user
        # has CC / CXX setup these should not be set (!)
        assert "CC" not in os.environ
        assert "CXX" not in os.environ
        assert "FC" not in os.environ
        set_cc()
        assert "CC" not in os.environ
        assert "CXX" not in os.environ
        assert "FC" not in os.environ

    set_env_decorator_test()

    # Same test only with `with`.
    assert "CC" not in os.environ
    assert "CXX" not in os.environ
    assert "FC" not in os.environ
    with set_env(CC="clang"):
        assert os.environ["CC"] == "clang"
        assert "CXX" not in os.environ
        assert "FC" not in os.environ
        with set_env(CXX="clang++"):
            assert os.environ["CC"] == "clang"
            assert os.environ["CXX"] == "clang++"
            assert "FC" not in os.environ
            with set_env(FC="flang"):
                assert os.environ["CC"] == "clang"
                assert os.environ["CXX"] == "clang++"
                assert os.environ["FC"] == "flang"
                with set_env(CC="gcc", CXX="g++", FC="gfortran"):
                    assert os.environ["CC"] == "gcc"
                    assert os.environ["CXX"] == "g++"
                    assert os.environ["FC"] == "gfortran"
                assert os.environ["CC"] == "clang"
                assert os.environ["CXX"] == "clang++"
                assert os.environ["FC"] == "flang"
            assert os.environ["CC"] == "clang"
            assert os.environ["CXX"] == "clang++"
            assert "FC" not in os.environ
        assert os.environ["CC"] == "clang"
        assert "CXX" not in os.environ
        assert "FC" not in os.environ
    assert "CC" not in os.environ
    assert "CXX" not in os.environ
    assert "FC" not in os.environ

    # Make sure that function arguments are passed through / return propagated.
    @set_env(CC="icc", CXX="icpc", FC="ifort")
    def func_returns(x: int, y: int, z: int = 3, w: int = 4) -> bool:
        assert os.environ["CC"] == "icc"
        assert os.environ["CXX"] == "icpc"
        assert os.environ["FC"] == "ifort"
        return (x + y + z) > w

    assert func_returns(1, 2, 3, 4) == True  # noqa: E712
    assert func_returns(1, 2, z=3) == True  # noqa: E712
    assert func_returns(1, 2) == True  # noqa: E712
    assert func_returns(1, 2, w=11) == False  # noqa: E712
    args = [1, 2]
    kwargs = {"z": -3, "w": 111}
    assert func_returns(*args, **kwargs) == False  # noqa: E712