mirror of
https://github.com/fedora-python/tox-current-env.git
synced 2024-12-24 09:06:15 +01:00
594 lines
20 KiB
Python
594 lines
20 KiB
Python
import os
|
|
import re
|
|
import shutil
|
|
import textwrap
|
|
|
|
import pytest
|
|
|
|
from utils import (
|
|
DOT_TOX,
|
|
NATIVE_EXEC_PREFIX_MSG,
|
|
NATIVE_SITE_PACKAGES,
|
|
NATIVE_TOXENV,
|
|
TOX_VERSION,
|
|
envs_from_tox_ini,
|
|
modify_config,
|
|
needs_all_pythons,
|
|
prep_tox_output,
|
|
tox,
|
|
tox_footer,
|
|
)
|
|
|
|
|
|
if TOX_VERSION.major != 4:
|
|
pytest.skip("skipping tests for tox 4", allow_module_level=True)
|
|
|
|
|
|
def test_native_toxenv_current_env():
|
|
result = tox("-e", NATIVE_TOXENV, "--current-env")
|
|
assert result.stdout.splitlines()[0] == NATIVE_EXEC_PREFIX_MSG
|
|
assert not (DOT_TOX / NATIVE_TOXENV / "lib").is_dir()
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_deps(toxenv, print_deps_stdout_arg):
|
|
result = tox("-e", toxenv, print_deps_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
tox
|
|
six
|
|
py
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
@pytest.mark.parametrize("pre_post", ["pre", "post", "both"])
|
|
def test_print_deps_with_commands_pre_post(projdir, toxenv, pre_post, print_deps_stdout_arg):
|
|
with modify_config(projdir / 'tox.ini') as config:
|
|
if pre_post == "both":
|
|
config["testenv"]["commands_pre"] = "echo unexpected"
|
|
config["testenv"]["commands_post"] = "echo unexpected"
|
|
else:
|
|
config["testenv"][f"commands_{pre_post}"] = "echo unexpected"
|
|
result = tox("-e", toxenv, print_deps_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
tox
|
|
six
|
|
py
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(
|
|
expected.splitlines()
|
|
)
|
|
assert result.stderr == ""
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_deps_with_tox_minversion(projdir, toxenv, print_deps_stdout_arg):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["tox"]["minversion"] = "3.13"
|
|
result = tox("-e", toxenv, print_deps_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
tox>=3.13
|
|
six
|
|
py
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_deps_with_tox_requires(projdir, toxenv, print_deps_stdout_arg):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["tox"]["requires"] = "\n pytest > 5\n pluggy"
|
|
result = tox("-e", toxenv, print_deps_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
pytest>5
|
|
pluggy
|
|
tox
|
|
six
|
|
py
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_deps_with_tox_minversion_and_requires(
|
|
projdir, toxenv, print_deps_stdout_arg
|
|
):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["tox"]["minversion"] = "3.13"
|
|
config["tox"]["requires"] = "\n pytest > 5\n pluggy"
|
|
result = tox("-e", toxenv, print_deps_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
pytest>5
|
|
pluggy
|
|
tox>=3.13
|
|
six
|
|
py
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_extras(toxenv, print_extras_stdout_arg):
|
|
result = tox("-e", toxenv, print_extras_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
dev
|
|
full
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(
|
|
expected.splitlines()
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_dependency_groups(toxenv, print_dependency_groups_stdout_arg):
|
|
result = tox("-e", toxenv, print_dependency_groups_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
dg1
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(
|
|
expected.splitlines()
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_dependency_groups_empty(projdir, toxenv, print_dependency_groups_stdout_arg):
|
|
with modify_config(projdir / 'tox.ini') as config:
|
|
del config["testenv"]["dependency_groups"]
|
|
result = tox("-e", toxenv, print_dependency_groups_stdout_arg)
|
|
expected = [l.strip() for l in tox_footer(toxenv).splitlines() if l.strip()]
|
|
got = [l.strip() for l in prep_tox_output(result.stdout).splitlines() if l.strip()]
|
|
assert got == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
@pytest.mark.parametrize("pre_post", ["pre", "post", "both"])
|
|
def test_print_extras_with_commands_pre_post(projdir, toxenv, pre_post, print_extras_stdout_arg):
|
|
with modify_config(projdir / 'tox.ini') as config:
|
|
if pre_post == "both":
|
|
config["testenv"]["commands_pre"] = "echo unexpected"
|
|
config["testenv"]["commands_post"] = "echo unexpected"
|
|
else:
|
|
config["testenv"][f"commands_{pre_post}"] = "echo unexpected"
|
|
result = tox("-e", toxenv, print_extras_stdout_arg)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
dev
|
|
full
|
|
{tox_footer(toxenv)}
|
|
"""
|
|
).lstrip()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(
|
|
expected.splitlines()
|
|
)
|
|
assert result.stderr == ""
|
|
|
|
|
|
def test_allenvs_print_deps(print_deps_stdout_arg):
|
|
result = tox(print_deps_stdout_arg)
|
|
expected = []
|
|
for env in envs_from_tox_ini():
|
|
expected.extend(("tox", "six", "py", f"{env}: OK"))
|
|
expected.pop() # The last "py310: OK" is not there
|
|
expected.append(tox_footer(spaces=0))
|
|
expected = ("\n".join(expected)).splitlines()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(expected)
|
|
|
|
|
|
def test_allenvs_print_extras(print_extras_stdout_arg):
|
|
result = tox(print_extras_stdout_arg)
|
|
expected = []
|
|
for env in envs_from_tox_ini():
|
|
expected.extend(("dev", "full", f"{env}: OK"))
|
|
expected.pop() # The last "py310: OK" is not there
|
|
expected.append(tox_footer(spaces=0))
|
|
expected = ("\n".join(expected)).splitlines()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(expected)
|
|
|
|
|
|
def test_allenvs_print_dependency_groups(print_dependency_groups_stdout_arg):
|
|
result = tox(print_dependency_groups_stdout_arg)
|
|
expected = []
|
|
for env in envs_from_tox_ini():
|
|
expected.extend(("dg1", f"{env}: OK"))
|
|
expected.pop() # The last "py310: OK" is not there
|
|
expected.append(tox_footer(spaces=0))
|
|
expected = ("\n".join(expected)).splitlines()
|
|
assert sorted(prep_tox_output(result.stdout).splitlines()) == sorted(expected)
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_deps_to_file(toxenv, tmp_path):
|
|
depspath = tmp_path / "deps"
|
|
result = tox("-e", toxenv, "--print-deps-to", str(depspath))
|
|
assert sorted(depspath.read_text().splitlines()) == sorted(
|
|
["tox", "six", "py"]
|
|
)
|
|
expected = tox_footer(toxenv, spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_extras_to_file(toxenv, tmp_path):
|
|
extraspath = tmp_path / "extras"
|
|
result = tox("-e", toxenv, "--print-extras-to", str(extraspath))
|
|
assert sorted(extraspath.read_text().splitlines()) == sorted(["dev", "full"])
|
|
expected = tox_footer(toxenv, spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("toxenv", envs_from_tox_ini())
|
|
def test_print_dependency_groups_to_file(toxenv, tmp_path, dependency_groups_support):
|
|
groupspath = tmp_path / "dependency_groups"
|
|
result = tox("-e", toxenv, "--print-dependency-groups-to", str(groupspath))
|
|
assert sorted(groupspath.read_text().splitlines()) == ["dg1"]
|
|
expected = tox_footer(toxenv, spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("option", ("--print-deps-to", "--print-deps-to-file"))
|
|
def test_allenvs_print_deps_to_file(tmp_path, option):
|
|
depspath = tmp_path / "deps"
|
|
result = tox(option, str(depspath))
|
|
assert sorted(depspath.read_text().splitlines()) == sorted(
|
|
["tox", "six", "py"] * len(envs_from_tox_ini())
|
|
)
|
|
expected = ""
|
|
for env in envs_from_tox_ini()[:-1]:
|
|
expected += f"{env}: OK\n"
|
|
expected += tox_footer(spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("option", ("--print-extras-to", "--print-extras-to-file"))
|
|
def test_allenvs_print_extras_to_file(tmp_path, option):
|
|
extraspath = tmp_path / "extras"
|
|
result = tox(option, str(extraspath))
|
|
assert sorted(extraspath.read_text().splitlines()) == sorted(
|
|
["dev", "full"] * len(envs_from_tox_ini())
|
|
)
|
|
expected = ""
|
|
for env in envs_from_tox_ini()[:-1]:
|
|
expected += f"{env}: OK\n"
|
|
expected += tox_footer(spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("option", ("--print-dependency-groups-to", "--print-dependency-groups-to-file"))
|
|
def test_allenvs_print_dependency_groups_to_file(tmp_path, option, dependency_groups_support):
|
|
groupspath = tmp_path / "dependency_groups"
|
|
result = tox(option, str(groupspath))
|
|
assert sorted(groupspath.read_text().splitlines()) == (
|
|
["dg1"] * len(envs_from_tox_ini())
|
|
)
|
|
expected = ""
|
|
for env in envs_from_tox_ini()[:-1]:
|
|
expected += f"{env}: OK\n"
|
|
expected += tox_footer(spaces=0) + "\n"
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
def test_allenvs_print_deps_to_existing_file(tmp_path):
|
|
depspath = tmp_path / "deps"
|
|
depspath.write_text("nada")
|
|
_ = tox("--print-deps-to", str(depspath))
|
|
lines = depspath.read_text().splitlines()
|
|
assert "nada" not in lines
|
|
assert "six" in lines
|
|
assert "py" in lines
|
|
|
|
|
|
def test_allenvs_print_extras_to_existing_file(tmp_path):
|
|
extraspath = tmp_path / "extras"
|
|
extraspath.write_text("nada")
|
|
_ = tox("--print-extras-to", str(extraspath))
|
|
lines = extraspath.read_text().splitlines()
|
|
assert "nada" not in lines
|
|
assert "dev" in lines
|
|
assert "full" in lines
|
|
|
|
|
|
def test_allenvs_print_dependency_groups_to_existing_file(tmp_path, dependency_groups_support):
|
|
groupspath = tmp_path / "dependency_groups"
|
|
groupspath.write_text("nada")
|
|
_ = tox("--print-dependency-groups-to", str(groupspath))
|
|
lines = groupspath.read_text().splitlines()
|
|
assert "nada" not in lines
|
|
assert "dg1" in lines
|
|
|
|
|
|
@pytest.mark.parametrize("deps_stdout", [True, False])
|
|
@pytest.mark.parametrize("extras_stdout", [True, False])
|
|
def test_allenvs_print_deps_to_file_print_extras_to_other_file(
|
|
tmp_path, deps_stdout, extras_stdout
|
|
):
|
|
if deps_stdout and extras_stdout:
|
|
pytest.skip("Unsupported combination of parameters")
|
|
|
|
depspath = "-" if deps_stdout else tmp_path / "deps"
|
|
extraspath = "-" if extras_stdout else tmp_path / "extras"
|
|
result = tox("--print-deps-to", str(depspath), "--print-extras-to", str(extraspath))
|
|
depslines = result.stdout.splitlines() if deps_stdout else depspath.read_text().splitlines()
|
|
extraslines = result.stdout.splitlines() if extras_stdout else extraspath.read_text().splitlines()
|
|
|
|
assert "six" in depslines
|
|
assert "py" in depslines
|
|
assert "full" in extraslines
|
|
assert "dev" in extraslines
|
|
|
|
assert "six" not in extraslines
|
|
assert "py" not in extraslines
|
|
assert "full" not in depslines
|
|
assert "dev" not in depslines
|
|
|
|
|
|
@pytest.mark.parametrize("deps_stdout", [True, False])
|
|
@pytest.mark.parametrize("extras_stdout", [True, False])
|
|
@pytest.mark.parametrize("dependency_groups_stdout", [True, False])
|
|
def test_allenvs_print_deps_to_file_print_extras_to_other_file_print_dependency_groups_to_other_file(
|
|
tmp_path, deps_stdout, extras_stdout, dependency_groups_stdout, dependency_groups_support
|
|
):
|
|
if deps_stdout + extras_stdout + dependency_groups_stdout > 1:
|
|
pytest.skip("Unsupported combination of parameters")
|
|
|
|
depspath = "-" if deps_stdout else tmp_path / "deps"
|
|
extraspath = "-" if extras_stdout else tmp_path / "extras"
|
|
groupspath = "-" if dependency_groups_stdout else tmp_path / "dependency_groups"
|
|
result = tox("--print-deps-to", str(depspath),
|
|
"--print-extras-to", str(extraspath),
|
|
"--print-dependency-groups-to", str(groupspath))
|
|
depslines = result.stdout.splitlines() if deps_stdout else depspath.read_text().splitlines()
|
|
extraslines = result.stdout.splitlines() if extras_stdout else extraspath.read_text().splitlines()
|
|
groupslines = result.stdout.splitlines() if dependency_groups_stdout else groupspath.read_text().splitlines()
|
|
|
|
assert "six" in depslines
|
|
assert "py" in depslines
|
|
assert "full" in extraslines
|
|
assert "dev" in extraslines
|
|
assert "dg1" in groupslines
|
|
|
|
assert "six" not in extraslines
|
|
assert "py" not in extraslines
|
|
assert "dg1" not in extraslines
|
|
|
|
assert "full" not in depslines
|
|
assert "dev" not in depslines
|
|
assert "dg1" not in depslines
|
|
|
|
assert "six" not in groupslines
|
|
assert "py" not in groupslines
|
|
assert "full" not in groupslines
|
|
assert "dev" not in groupslines
|
|
|
|
|
|
def test_print_deps_extras_to_same_file_is_not_possible(tmp_path):
|
|
depsextraspath = tmp_path / "depsextras"
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
"--print-deps-to",
|
|
str(depsextraspath),
|
|
"--print-extras-to",
|
|
str(depsextraspath),
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
def test_print_deps_dependency_groups_to_same_file_is_not_possible(tmp_path, dependency_groups_support):
|
|
depsgroupspath = tmp_path / "depsgroups"
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
"--print-deps-to",
|
|
str(depsgroupspath),
|
|
"--print-dependency-groups-to",
|
|
str(depsgroupspath),
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
def test_print_extras_dependency_groups_to_same_file_is_not_possible(tmp_path, dependency_groups_support):
|
|
extrasgroupspath = tmp_path / "extrasgroups"
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
"--print-extras-to",
|
|
str(extrasgroupspath),
|
|
"--print-dependency-groups-to",
|
|
str(extrasgroupspath),
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
def test_print_deps_extras_to_stdout_is_not_possible(
|
|
tmp_path,
|
|
print_deps_stdout_arg,
|
|
print_extras_stdout_arg,
|
|
):
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
print_deps_stdout_arg,
|
|
print_extras_stdout_arg,
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
def test_print_deps_dependency_groups_to_stdout_is_not_possible(
|
|
tmp_path,
|
|
print_deps_stdout_arg,
|
|
print_dependency_groups_stdout_arg,
|
|
):
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
print_deps_stdout_arg,
|
|
print_dependency_groups_stdout_arg,
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
def test_print_extras_dependency_groups_to_stdout_is_not_possible(
|
|
tmp_path,
|
|
print_extras_stdout_arg,
|
|
print_dependency_groups_stdout_arg,
|
|
):
|
|
result = tox(
|
|
"-e",
|
|
NATIVE_TOXENV,
|
|
print_extras_stdout_arg,
|
|
print_dependency_groups_stdout_arg,
|
|
check=False,
|
|
)
|
|
assert result.returncode > 0
|
|
assert "cannot be identical" in result.stderr
|
|
|
|
|
|
@needs_all_pythons
|
|
def test_regular_run():
|
|
result = tox()
|
|
lines = result.stdout.splitlines()[:5]
|
|
for line, env in zip(lines, envs_from_tox_ini()):
|
|
assert f"/.tox/{env} is the exec_prefix" in line
|
|
assert "congratulations" in result.stdout
|
|
for env in envs_from_tox_ini():
|
|
major, minor = re.match(r"py(\d)(\d+)", env).groups()
|
|
for pkg in "py", "six", "test":
|
|
sitelib = DOT_TOX / f"{env}/lib/python{major}.{minor}/site-packages"
|
|
assert sitelib.is_dir()
|
|
assert len(list(sitelib.glob(f"{pkg}-*.dist-info"))) == 1
|
|
|
|
|
|
def test_regular_run_native_toxenv():
|
|
result = tox("-e", NATIVE_TOXENV)
|
|
lines = sorted(result.stdout.splitlines()[:1])
|
|
assert f"/.tox/{NATIVE_TOXENV} is the exec_prefix" in lines[0]
|
|
assert "congratulations" in result.stdout
|
|
for pkg in "py", "six", "test":
|
|
sitelib = DOT_TOX / f"{NATIVE_TOXENV}/{NATIVE_SITE_PACKAGES}"
|
|
assert sitelib.is_dir()
|
|
assert len(list(sitelib.glob(f"{pkg}-*.dist-info"))) == 1
|
|
|
|
|
|
def test_print_deps_without_python_command(tmp_path, print_deps_stdout_arg):
|
|
bin = tmp_path / "bin"
|
|
bin.mkdir()
|
|
tox_link = bin / "tox"
|
|
tox_path = shutil.which("tox")
|
|
tox_link.symlink_to(tox_path)
|
|
env = {**os.environ, "PATH": str(bin)}
|
|
|
|
result = tox("-e", NATIVE_TOXENV, print_deps_stdout_arg, env=env)
|
|
expected = textwrap.dedent(
|
|
f"""
|
|
tox
|
|
six
|
|
py
|
|
{tox_footer(NATIVE_TOXENV)}
|
|
"""
|
|
).lstrip()
|
|
assert prep_tox_output(result.stdout) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("flag", ["--print-deps-to=-", "--current-env"])
|
|
def test_recreate_environment(flag):
|
|
flags = (flag,) if flag else ()
|
|
_ = tox("-e", NATIVE_TOXENV, check=False)
|
|
result = tox("-e", NATIVE_TOXENV, *flags, quiet=False, check=False)
|
|
assert f"{NATIVE_TOXENV}: recreate env because env type changed" in prep_tox_output(
|
|
result.stdout
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"flag", ["--print-deps-to=-", "--print-extras-to=-", "--current-env"]
|
|
)
|
|
@pytest.mark.parametrize("usedevelop", [True, False])
|
|
def test_self_is_not_installed(projdir, flag, usedevelop):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["testenv"]["usedevelop"] = str(usedevelop)
|
|
_ = tox("-e", NATIVE_TOXENV, flag, quiet=False)
|
|
egg_link = DOT_TOX / f"{NATIVE_TOXENV}/{NATIVE_SITE_PACKAGES}" / "test.egg-link"
|
|
dist_info = (
|
|
DOT_TOX / f"{NATIVE_TOXENV}/{NATIVE_SITE_PACKAGES}" / "test-0.0.0.dist-info"
|
|
)
|
|
assert not egg_link.exists()
|
|
assert not dist_info.exists()
|
|
|
|
|
|
@pytest.mark.parametrize("usedevelop", [True, False])
|
|
def test_self_is_installed_with_regular_tox(projdir, usedevelop):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["testenv"]["usedevelop"] = str(usedevelop)
|
|
result = tox("-e", NATIVE_TOXENV, "-v", quiet=False)
|
|
assert "test-0.0.0" in result.stdout
|
|
if usedevelop:
|
|
assert "test-0.0.0-0.editable" in result.stdout
|
|
|
|
|
|
@pytest.mark.parametrize("passenv", [None, "different list", "__var", "*"])
|
|
def test_passenv(projdir, passenv):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["testenv"]["commands"] = """python -c 'import os; print(os.getenv("__var"))'"""
|
|
if passenv is not None:
|
|
existing = config["testenv"].get("passenv", "") + " "
|
|
config["testenv"]["passenv"] = existing + passenv
|
|
env = {"__var": "assertme"}
|
|
result = tox("-e", NATIVE_TOXENV, "--current-env", env=env, quiet=False)
|
|
assert result.returncode == 0
|
|
assert "\nassertme\n" in result.stdout
|
|
assert "\nNone\n" not in result.stdout
|
|
|
|
|
|
@pytest.mark.parametrize("pass_env", [None, "different\nlist", "__var", "*"])
|
|
def test_pass_env(projdir, pass_env):
|
|
with modify_config(projdir / "tox.ini") as config:
|
|
config["testenv"]["commands"] = """python -c 'import os; print(os.getenv("__var"))'"""
|
|
if pass_env is not None:
|
|
config["testenv"]["pass_env"] = pass_env
|
|
env = {"__var": "assertme"}
|
|
result = tox("-e", NATIVE_TOXENV, "--current-env", env=env, quiet=False)
|
|
assert result.returncode == 0
|
|
assert "\nassertme\n" in result.stdout
|
|
assert "\nNone\n" not in result.stdout
|
|
|
|
|
|
def test_report_installed(projdir):
|
|
# tox4 only reports installed when a CI is detected
|
|
env = {"CI": "true"}
|
|
result = tox("-e", NATIVE_TOXENV, "--current-env", env=env, quiet=False)
|
|
assert result.returncode == 0
|
|
assert "tox==" in result.stdout
|
|
assert "pytest==" in result.stdout
|