def test_execute_virtualenv_wrappers(tmpdir, monkeypatch):
import virtualenv
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
virtualenv.create_environment(
"virtual envs/test", no_setuptools=True, no_pip=True, no_wheel=True
)
if sys.platform != "win32":
bin_dir = "virtual envs/test/bin"
else:
bin_dir = "virtual envs/test/Scripts"
create_wrappers._main(
[
"-t",
"virtualenv",
"--virtual-env-dir",
"virtual envs/test",
"--bin-dir",
bin_dir,
"--dest-dir",
"wrappers",
]
)
environ_from_activate = _environ_from_activate(
_activate_virtualenv_script(), tmpdir
)
# Remove some variables we don't care
if sys.platform != "win32":
environ_from_activate.pop("PS1", None)
environ_from_activate.pop("SHLVL")
else:
environ_from_activate.pop("_OLD_VIRTUAL_PATH")
environ_from_activate.pop("_OLD_VIRTUAL_PROMPT")
environ_from_activate.pop("PROMPT")
environ_from_activate["PATH"] = os.path.normcase(environ_from_activate["PATH"])
environ_from_activate["VIRTUAL_ENV"] = os.path.normcase(
environ_from_activate["VIRTUAL_ENV"]
)
environ_from_wrapper = _environ_from_wrapper()
if sys.platform != "win32":
environ_from_wrapper.pop("SHLVL")
else:
environ_from_wrapper.pop("PROMPT")
environ_from_wrapper["PATH"] = os.path.normcase(environ_from_wrapper["PATH"])
environ_from_wrapper["VIRTUAL_ENV"] = os.path.normcase(
environ_from_wrapper["VIRTUAL_ENV"]
)
assert environ_from_activate == environ_from_wrapper
def test_execute_virtualenv_wrappers(tmpdir, monkeypatch):
import virtualenv
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
virtualenv.create_environment(
"virtual envs/test", no_setuptools=True, no_pip=True, no_wheel=True
)
if sys.platform != "win32":
bin_dir = "virtual envs/test/bin"
else:
bin_dir = "virtual envs/test/Scripts"
create_wrappers._main(
[
"-t",
"virtualenv",
"--virtual-env-dir",
"virtual envs/test",
"--bin-dir",
bin_dir,
"--dest-dir",
"wrappers",
]
)
environ_from_activate = _environ_from_activate(
_activate_virtualenv_script(), tmpdir
)
# Remove some variables we don't care
if sys.platform != "win32":
environ_from_activate.pop("PS1", None)
environ_from_activate.pop("SHLVL")
else:
environ_from_activate.pop("_OLD_VIRTUAL_PATH")
environ_from_activate.pop("_OLD_VIRTUAL_PROMPT")
environ_from_activate.pop("PROMPT")
environ_from_activate["PATH"] = os.path.normcase(environ_from_activate["PATH"])
environ_from_activate["VIRTUAL_ENV"] = os.path.normcase(
environ_from_activate["VIRTUAL_ENV"]
)
environ_from_wrapper = _environ_from_wrapper()
if sys.platform != "win32":
environ_from_wrapper.pop("SHLVL")
else:
environ_from_wrapper.pop("PROMPT")
environ_from_wrapper["PATH"] = os.path.normcase(environ_from_wrapper["PATH"])
environ_from_wrapper["VIRTUAL_ENV"] = os.path.normcase(
environ_from_wrapper["VIRTUAL_ENV"]
)
assert environ_from_activate == environ_from_wrapper
def test_create_only_specified_wrappers(wrapper_type, extra_args, contents,
tmpdir):
wrappers_dir = tmpdir.join('wrappers')
create_wrappers._main([
'-t',
wrapper_type,
'--files-to-wrap',
'python:gcc',
'--dest-dir',
str(wrappers_dir),
] + extra_args)
_check_wrappers(wrappers_dir, ['run-in', 'python', 'gcc'])
def test_create_only_specified_wrappers(wrapper_type, extra_args, contents,
tmpdir):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main([
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
] + extra_args)
_check_wrappers(wrappers_dir, ["run-in", "python", "gcc"])
def test_execute_virtualenv_wrappers(tmpdir, monkeypatch):
import virtualenv
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
virtualenv.create_environment('virtual envs/test',
no_setuptools=True,
no_pip=True,
no_wheel=True)
if sys.platform != 'win32':
bin_dir = 'virtual envs/test/bin'
else:
bin_dir = 'virtual envs/test/Scripts'
create_wrappers._main([
'-t', 'virtualenv',
'--virtual-env-dir', 'virtual envs/test',
'--bin-dir', bin_dir,
'--dest-dir', 'wrappers',
])
environ_from_activate = _environ_from_activate(
_activate_virtualenv_script(), tmpdir)
# Remove some variables we don't care
if sys.platform != 'win32':
environ_from_activate.pop('PS1', None)
environ_from_activate.pop('SHLVL')
else:
environ_from_activate.pop('_OLD_VIRTUAL_PATH')
environ_from_activate.pop('_OLD_VIRTUAL_PROMPT')
environ_from_activate.pop('PROMPT')
environ_from_activate['PATH'] = \
os.path.normcase(environ_from_activate['PATH'])
environ_from_activate['VIRTUAL_ENV'] = \
os.path.normcase(environ_from_activate['VIRTUAL_ENV'])
environ_from_wrapper = _environ_from_wrapper()
if sys.platform != 'win32':
environ_from_wrapper.pop('SHLVL')
else:
environ_from_wrapper.pop('PROMPT')
environ_from_wrapper['PATH'] = \
os.path.normcase(environ_from_wrapper['PATH'])
environ_from_wrapper['VIRTUAL_ENV'] = \
os.path.normcase(environ_from_wrapper['VIRTUAL_ENV'])
assert environ_from_activate == environ_from_wrapper
def test_automatic_wrappers_should_use_absolute_path_by_default(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join("python"))
create_wrappers._main([
"-t", wrapper_type, "--bin-dir",
str(bin_dir), "--dest-dir",
str(wrappers_dir)
] + extra_args)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be absolute
assert str(python_bin) in wrapper.read()
def test_specified_wrappers_should_use_relative_path_by_default(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main([
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
] + extra_args)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be exactly as we passed to command line
assert ' "python" ' in wrapper.read()
def test_automatic_wrappers_should_use_absolute_path_by_default(
wrapper_type, extra_args, contents, tmpdir
):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join("python"))
create_wrappers._main(
["-t", wrapper_type, "--bin-dir", str(bin_dir), "--dest-dir", str(wrappers_dir)]
+ extra_args
)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be absolute
assert str(python_bin) in wrapper.read()
def test_specified_wrappers_should_use_relative_path_by_default(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
create_wrappers._main([
'-t',
wrapper_type,
'--files-to-wrap',
'python:gcc',
'--dest-dir',
str(wrappers_dir),
] + extra_args)
wrapper = wrappers_dir.join('python' + get_wrapper_extension())
# The wrapped command should be exactly as we passed to command line
assert ' python ' in wrapper.read()
def test_create_only_specified_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main(
[
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
]
+ extra_args
)
_check_wrappers(wrappers_dir, ["run-in", "python", "gcc"])
def test_specified_wrappers_should_use_absolute_path_when_given_bin_dir(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
bin_dir = tmpdir.join('bin')
create_wrappers._main([
'-t',
wrapper_type,
'--bin-dir',
str(bin_dir),
'--files-to-wrap',
'python:gcc',
'--dest-dir',
str(wrappers_dir),
] + extra_args)
wrapper = wrappers_dir.join('python' + get_wrapper_extension())
# The wrapped command should be absolute
assert str(bin_dir.join('python')) in wrapper.read()
def test_automatic_wrappers_should_use_absolute_path_by_default(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
bin_dir = tmpdir.join('bin')
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join('python'))
create_wrappers._main([
'-t',
wrapper_type,
'--bin-dir',
str(bin_dir),
'--dest-dir',
str(wrappers_dir),
] + extra_args)
wrapper = wrappers_dir.join('python' + get_wrapper_extension())
# The wrapped command should be absolute
assert str(python_bin) in wrapper.read()
def test_create_automatic_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
_create_executable_file(bin_dir.join("python"))
_create_executable_file(bin_dir.join("gcc"))
create_wrappers._main(
["-t", wrapper_type, "--bin-dir", str(bin_dir), "--dest-dir", str(wrappers_dir)]
+ extra_args
)
_check_wrappers(wrappers_dir, ["run-in", "python", "gcc"])
wrapper = wrappers_dir.join("run-in" + get_wrapper_extension())
# The wrapped command should be absolute
wrapper_contents = wrapper.read()
assert contents in wrapper_contents
assert "__COMMAND__" not in wrapper_contents
def test_specified_wrappers_should_use_absolute_path_when_given_bin_dir(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
create_wrappers._main([
"-t",
wrapper_type,
"--bin-dir",
str(bin_dir),
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
] + extra_args)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be absolute
assert str(bin_dir.join("python")) in wrapper.read()
def test_inline_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main([
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
"--inline",
] + extra_args)
# No run-in file
_check_wrappers(wrappers_dir, ["python", "gcc"])
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
assert contents in wrapper.read()
wrapper = wrappers_dir.join("gcc" + get_wrapper_extension())
assert contents in wrapper.read()
def test_create_automatic_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
_create_executable_file(bin_dir.join("python"))
_create_executable_file(bin_dir.join("gcc"))
create_wrappers._main([
"-t", wrapper_type, "--bin-dir",
str(bin_dir), "--dest-dir",
str(wrappers_dir)
] + extra_args)
_check_wrappers(wrappers_dir, ["run-in", "python", "gcc"])
wrapper = wrappers_dir.join("run-in" + get_wrapper_extension())
# The wrapped command should be absolute
wrapper_contents = wrapper.read()
assert contents in wrapper_contents
assert "__COMMAND__" not in wrapper_contents
def test_inline_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
create_wrappers._main([
'-t',
wrapper_type,
'--files-to-wrap',
'python:gcc',
'--dest-dir',
str(wrappers_dir),
'--inline',
] + extra_args)
# No run-in file
_check_wrappers(wrappers_dir, ['python', 'gcc'])
wrapper = wrappers_dir.join('python' + get_wrapper_extension())
assert contents in wrapper.read()
wrapper = wrappers_dir.join('gcc' + get_wrapper_extension())
assert contents in wrapper.read()
def test_automatic_wrappers_should_use_basename_when_asked(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join("python"))
create_wrappers._main([
"-t",
wrapper_type,
"--bin-dir",
str(bin_dir),
"--dest-dir",
str(wrappers_dir),
"--use-basename",
] + extra_args)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be the basename only
assert '"{}"'.format(python_bin.basename) in wrapper.read()
def test_automatic_wrappers_should_use_basename_when_asked(
wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
bin_dir = tmpdir.join('bin')
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join('python'))
create_wrappers._main([
'-t',
wrapper_type,
'--bin-dir',
str(bin_dir),
'--dest-dir',
str(wrappers_dir),
'--use-basename',
] + extra_args)
wrapper = wrappers_dir.join('python' + get_wrapper_extension())
# The wrapped command should be the basename only
assert ' {} '.format(python_bin.basename) in wrapper.read()
def test_specified_wrappers_should_use_relative_path_by_default(
wrapper_type, extra_args, contents, tmpdir
):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main(
[
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
]
+ extra_args
)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be exactly as we passed to command line
assert ' "python" ' in wrapper.read()
def test_create_custom_wrappers(tmpdir):
wrappers_dir = tmpdir.join('wrappers')
run_in_file = _create_custom_run_in_file(tmpdir)
create_wrappers._main([
'-t',
'custom',
'--custom-script',
str(run_in_file),
'--files-to-wrap',
'python',
'--dest-dir',
str(wrappers_dir),
])
_check_wrappers(wrappers_dir, ['run-in', 'python'])
python_wrapper = str(wrappers_dir.join('python' + get_wrapper_extension()))
python_output = str(
subprocess.check_output([python_wrapper, '--version']).decode())
assert python_output.strip('\r\n') == 'python --version'
def test_create_custom_wrappers(tmpdir):
wrappers_dir = tmpdir.join("wrappers")
run_in_file = _create_custom_run_in_file(tmpdir)
create_wrappers._main([
"-t",
"custom",
"--custom-script",
str(run_in_file),
"--files-to-wrap",
"python",
"--dest-dir",
str(wrappers_dir),
])
_check_wrappers(wrappers_dir, ["run-in", "python"])
python_wrapper = str(wrappers_dir.join("python" + get_wrapper_extension()))
python_output = str(
subprocess.check_output([python_wrapper, "--version"]).decode())
assert python_output.strip("\r\n") == "python --version"
def test_create_custom_wrappers(tmpdir):
wrappers_dir = tmpdir.join("wrappers")
run_in_file = _create_custom_run_in_file(tmpdir)
create_wrappers._main(
[
"-t",
"custom",
"--custom-script",
str(run_in_file),
"--files-to-wrap",
"python",
"--dest-dir",
str(wrappers_dir),
]
)
_check_wrappers(wrappers_dir, ["run-in", "python"])
python_wrapper = str(wrappers_dir.join("python" + get_wrapper_extension()))
python_output = str(subprocess.check_output([python_wrapper, "--version"]).decode())
assert python_output.strip("\r\n") == "python --version"
def test_inline_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join("wrappers")
create_wrappers._main(
[
"-t",
wrapper_type,
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
"--inline",
]
+ extra_args
)
# No run-in file
_check_wrappers(wrappers_dir, ["python", "gcc"])
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
assert contents in wrapper.read()
wrapper = wrappers_dir.join("gcc" + get_wrapper_extension())
assert contents in wrapper.read()
def test_specified_wrappers_should_use_absolute_path_when_given_bin_dir(
wrapper_type, extra_args, contents, tmpdir
):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
create_wrappers._main(
[
"-t",
wrapper_type,
"--bin-dir",
str(bin_dir),
"--files-to-wrap",
"python:gcc",
"--dest-dir",
str(wrappers_dir),
]
+ extra_args
)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be absolute
assert str(bin_dir.join("python")) in wrapper.read()
def test_create_automatic_wrappers(wrapper_type, extra_args, contents, tmpdir):
wrappers_dir = tmpdir.join('wrappers')
bin_dir = tmpdir.join('bin')
bin_dir.mkdir()
_create_executable_file(bin_dir.join('python'))
_create_executable_file(bin_dir.join('gcc'))
create_wrappers._main([
'-t',
wrapper_type,
'--bin-dir',
str(bin_dir),
'--dest-dir',
str(wrappers_dir),
] + extra_args)
_check_wrappers(wrappers_dir, ['run-in', 'python', 'gcc'])
wrapper = wrappers_dir.join('run-in' + get_wrapper_extension())
# The wrapped command should be absolute
wrapper_contents = wrapper.read()
assert contents in wrapper_contents
assert '__COMMAND__' not in wrapper_contents
def test_automatic_wrappers_should_use_basename_when_asked(
wrapper_type, extra_args, contents, tmpdir
):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
bin_dir.mkdir()
python_bin = _create_executable_file(bin_dir.join("python"))
create_wrappers._main(
[
"-t",
wrapper_type,
"--bin-dir",
str(bin_dir),
"--dest-dir",
str(wrappers_dir),
"--use-basename",
]
+ extra_args
)
wrapper = wrappers_dir.join("python" + get_wrapper_extension())
# The wrapped command should be the basename only
assert '"{}"'.format(python_bin.basename) in wrapper.read()
def test_execute_conda_wrappers(tmpdir, monkeypatch):
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
if not which("conda"):
pytest.fail(
"This test needs conda. Make sure you have miniconda "
"installed and added to PATH env var"
)
subprocess.check_call(
["conda", "create", "--clone", "root", "-p", "conda envs/test"]
)
activate_scripts_path = tmpdir.join("conda envs/test/etc/conda/activate.d")
if sys.platform != "win32":
bin_dir = "conda envs/test/bin"
# Create a custom activate script to ensure that the wrapper runs it.
activate_scripts_path.join("custom_activate.sh").write(
textwrap.dedent(
"""
export ENV_VAR_FROM_ACTIVATE='SOME_VALUE'
"""
),
ensure=True,
)
else:
bin_dir = "conda envs/test"
# Create a custom activate script to ensure that the wrapper runs it.
activate_scripts_path.join("custom_activate.bat").write(
textwrap.dedent(
"""
@set "ENV_VAR_FROM_ACTIVATE=SOME_VALUE"
"""
),
ensure=True,
)
create_wrappers._main(
[
"-t",
"conda",
"--conda-env-dir",
"conda envs/test",
"--bin-dir",
bin_dir,
"--dest-dir",
"wrappers",
]
)
environ_from_activate = _environ_from_activate(_activate_conda_script(), tmpdir)
environ_from_wrapper = _environ_from_wrapper()
assert environ_from_wrapper["CONDA_DEFAULT_ENV"] == "test"
assert environ_from_wrapper["CONDA_ENV_PATH"] == str(tmpdir.join("conda envs/test"))
assert environ_from_wrapper["ENV_VAR_FROM_ACTIVATE"] == "SOME_VALUE"
if sys.platform != "win32":
# conda 4.6 began to add a path like <conda_root_dir>/condabin, but
# we have no easy way to find out the root dir from the wrapper script.
# So let's just filter it for now.
path = environ_from_activate["PATH"].split(":")
filtered_path = [p for p in path if "/condabin" not in p]
environ_from_activate["PATH"] = ":".join(filtered_path)
path = environ_from_wrapper["PATH"].split(":")
filtered_path = [p for p in path if "/condabin" not in p]
environ_from_wrapper["PATH"] = ":".join(filtered_path)
# Remove some variables we don't care about
variables_to_ignore = [
# It's an absolute path when activating but just the env name when
# using the wrapper
"CONDA_DEFAULT_ENV",
# Only present on old conda versions
"CONDA_ENV_PATH",
# Only present on recent conda versions (>=4.4)
"CONDA_PROMPT_MODIFIER",
"CONDA_SHLVL",
"CONDA_PYTHON_EXE",
# Not present on conda >=4.4
"CONDA_PATH_BACKUP",
"CONDA_PS1_BACKUP",
# Only present on conda >=4.5
"CONDA_EXE",
# Only present on conda >=4.6.9
# Those variables seem to be used for dev mode only
# https://github.com/conda/conda/pull/8435/commits/9a4589a1fabc66c122fb0c20fa1f3aa2c8b1758b
"_CE_CONDA",
"_CE_M",
]
if sys.platform != "win32":
variables_to_ignore.extend(["PS1", "SHLVL"])
else:
variables_to_ignore.extend(
[
"CONDA_ROOT",
"PROMPT",
# Only present on conda >=4.5
"PYTHONIOENCODING",
]
)
for variable_name in variables_to_ignore:
environ_from_activate.pop(variable_name, None)
environ_from_wrapper.pop(variable_name, None)
assert environ_from_activate == environ_from_wrapper
def test_execute_conda_wrappers(tmpdir, monkeypatch):
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
if not which('conda'):
pytest.fail('This test needs conda. Make sure you have miniconda '
'installed and added to PATH env var')
subprocess.check_call(['conda',
'create',
'--clone',
'root',
'-p', 'conda envs/test'])
if sys.platform != 'win32':
bin_dir = 'conda envs/test/bin'
else:
bin_dir = 'conda envs/test'
create_wrappers._main([
'-t', 'conda',
'--conda-env-dir', 'conda envs/test',
'--bin-dir', bin_dir,
'--dest-dir', 'wrappers',
])
environ_from_activate = _environ_from_activate(
_activate_conda_script(), tmpdir)
environ_from_wrapper = _environ_from_wrapper()
assert environ_from_wrapper['CONDA_DEFAULT_ENV'] == 'test'
assert environ_from_wrapper['CONDA_ENV_PATH'] == \
str(tmpdir.join('conda envs/test'))
# Remove some variables we don't care about
variables_to_ignore = [
# It's an absolute path when activating but just the env name when
# using the wrapper
'CONDA_DEFAULT_ENV',
# Only present on old conda versions
'CONDA_ENV_PATH',
# Only present on recent conda versions (>=4.4)
'CONDA_PROMPT_MODIFIER',
'CONDA_SHLVL',
'CONDA_PYTHON_EXE',
# Not present on conda >=4.4
'CONDA_PATH_BACKUP',
'CONDA_PS1_BACKUP',
# Only present on conda >=4.5
'CONDA_EXE',
]
if sys.platform != 'win32':
variables_to_ignore.extend(['PS1', 'SHLVL'])
else:
variables_to_ignore.extend([
'CONDA_ROOT',
'PROMPT',
# Only present on conda >=4.5
'PYTHONIOENCODING',
])
for variable_name in variables_to_ignore:
environ_from_activate.pop(variable_name, None)
environ_from_wrapper.pop(variable_name, None)
assert environ_from_activate == environ_from_wrapper
def test_execute_conda_wrappers(tmpdir, monkeypatch):
# monkey patch the current dir to make sure we convert the relative paths
# passed as arguments to absolute
monkeypatch.chdir(tmpdir)
if not which("conda"):
pytest.fail(
"This test needs conda. Make sure you have miniconda "
"installed and added to PATH env var"
)
subprocess.check_call(
["conda", "create", "--clone", "root", "-p", "conda envs/test"]
)
activate_scripts_path = tmpdir.join("conda envs/test/etc/conda/activate.d")
if sys.platform != "win32":
bin_dir = "conda envs/test/bin"
# Create a custom activate script to ensure that the wrapper runs it.
activate_scripts_path.join("custom_activate.sh").write(
textwrap.dedent(
"""
export ENV_VAR_FROM_ACTIVATE='SOME_VALUE'
"""
),
ensure=True,
)
else:
bin_dir = "conda envs/test"
# Create a custom activate script to ensure that the wrapper runs it.
activate_scripts_path.join("custom_activate.bat").write(
textwrap.dedent(
"""
@set "ENV_VAR_FROM_ACTIVATE=SOME_VALUE"
"""
),
ensure=True,
)
create_wrappers._main(
[
"-t",
"conda",
"--conda-env-dir",
"conda envs/test",
"--bin-dir",
bin_dir,
"--dest-dir",
"wrappers",
]
)
environ_from_activate = _environ_from_activate(_activate_conda_script(), tmpdir)
environ_from_wrapper = _environ_from_wrapper()
assert environ_from_wrapper["CONDA_DEFAULT_ENV"] == "test"
assert environ_from_wrapper["CONDA_ENV_PATH"] == str(tmpdir.join("conda envs/test"))
assert environ_from_wrapper["ENV_VAR_FROM_ACTIVATE"] == "SOME_VALUE"
if sys.platform != "win32":
# conda 4.6 began to add a path like <conda_root_dir>/condabin, but
# we have no easy way to find out the root dir from the wrapper script.
# So let's just filter it for now.
path = environ_from_activate["PATH"].split(":")
filtered_path = [p for p in path if "/condabin" not in p]
environ_from_activate["PATH"] = ":".join(filtered_path)
path = environ_from_wrapper["PATH"].split(":")
filtered_path = [p for p in path if "/condabin" not in p]
environ_from_wrapper["PATH"] = ":".join(filtered_path)
# Remove some variables we don't care about
variables_to_ignore = [
# It's an absolute path when activating but just the env name when
# using the wrapper
"CONDA_DEFAULT_ENV",
# Only present on old conda versions
"CONDA_ENV_PATH",
# Only present on recent conda versions (>=4.4)
"CONDA_PROMPT_MODIFIER",
"CONDA_SHLVL",
"CONDA_PYTHON_EXE",
# Not present on conda >=4.4
"CONDA_PATH_BACKUP",
"CONDA_PS1_BACKUP",
# Only present on conda >=4.5
"CONDA_EXE",
]
if sys.platform != "win32":
variables_to_ignore.extend(["PS1", "SHLVL"])
else:
variables_to_ignore.extend(
[
"CONDA_ROOT",
"PROMPT",
# Only present on conda >=4.5
"PYTHONIOENCODING",
]
)
for variable_name in variables_to_ignore:
environ_from_activate.pop(variable_name, None)
environ_from_wrapper.pop(variable_name, None)
assert environ_from_activate == environ_from_wrapper
