def test_dont_create_wrapper_when_file_has_same_name(tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
os.makedirs(str(bin_dir))
# It should not create a wrapper for run-in, otherwise it will overwrite
_create_executable_file(bin_dir.join("run-in"))
create_conda_wrappers(
[str(bin_dir.join("python")),
str(bin_dir.join("gcc"))],
str(wrappers_dir),
"miniconda/envs/test",
inline=False,
)
run_in_template_path = os.path.join(get_templates_dir(), "conda",
"run-in" + get_wrapper_extension())
with open(run_in_template_path) as f:
expected_run_in_content = (f.read().replace(
"__CONDA_PREFIX__",
os.path.abspath("miniconda/envs/test")).replace(
"__CONDA_DEFAULT_ENV__", "test").replace("__COMMAND__", ""))
assert (wrappers_dir.join("run-in" + get_wrapper_extension()).read() ==
expected_run_in_content)
def test_dont_create_wrapper_when_file_has_same_name(tmpdir):
wrappers_dir = tmpdir.join('wrappers')
bin_dir = tmpdir.join('bin')
os.makedirs(str(bin_dir))
# It should not create a wrapper for run-in, otherwise it will overwrite
_create_executable_file(bin_dir.join('run-in'))
create_conda_wrappers(
[str(bin_dir.join('python')),
str(bin_dir.join('gcc'))],
str(wrappers_dir),
'miniconda/envs/test',
inline=False)
run_in_template_path = os.path.join(get_templates_dir(), 'conda',
'run-in' + get_wrapper_extension())
with open(run_in_template_path) as f:
expected_run_in_content = f.read() \
.replace('__CONDA_PREFIX__',
os.path.abspath('miniconda/envs/test')) \
.replace('__CONDA_DEFAULT_ENV__', 'test') \
.replace('__COMMAND__', '')
assert wrappers_dir.join('run-in' + get_wrapper_extension()).read() == \
expected_run_in_content
def test_dont_create_wrapper_when_file_has_same_name(tmpdir):
wrappers_dir = tmpdir.join("wrappers")
bin_dir = tmpdir.join("bin")
os.makedirs(str(bin_dir))
# It should not create a wrapper for run-in, otherwise it will overwrite
_create_executable_file(bin_dir.join("run-in"))
create_conda_wrappers(
[str(bin_dir.join("python")), str(bin_dir.join("gcc"))],
str(wrappers_dir),
"miniconda/envs/test",
inline=False,
)
run_in_template_path = os.path.join(
get_templates_dir(), "conda", "run-in" + get_wrapper_extension()
)
with open(run_in_template_path) as f:
expected_run_in_content = (
f.read()
.replace("__CONDA_PREFIX__", os.path.abspath("miniconda/envs/test"))
.replace("__CONDA_DEFAULT_ENV__", "test")
.replace("__COMMAND__", "")
)
assert (
wrappers_dir.join("run-in" + get_wrapper_extension()).read()
== expected_run_in_content
)
def _environ_from_wrapper():
python_wrapper = os.path.normpath("wrappers/python") + get_wrapper_extension()
output = subprocess.check_output(
[python_wrapper, "-c", "from os import environ; print(dict(environ))"]
)
environ_from_wrapper = eval(output)
return environ_from_wrapper
def _check_wrappers(wrappers_dir, basenames):
obtained_wrappers = sorted([f.basename for f in wrappers_dir.listdir()])
expected_wrappers = sorted([f + get_wrapper_extension() for f in basenames])
assert obtained_wrappers == expected_wrappers
for f in wrappers_dir.listdir():
assert os.access(str(f), os.X_OK)
def _check_wrappers(wrappers_dir, basenames):
obtained_wrappers = sorted([f.basename for f in wrappers_dir.listdir()])
expected_wrappers = sorted(
[f + get_wrapper_extension() for f in basenames])
assert obtained_wrappers == expected_wrappers
for f in wrappers_dir.listdir():
assert os.access(str(f), os.X_OK)
def _environ_from_wrapper():
python_wrapper = os.path.normpath('wrappers/python') + \
get_wrapper_extension()
output = subprocess.check_output([
python_wrapper,
'-c',
'from os import environ; print(dict(environ))',
])
environ_from_wrapper = eval(output)
return environ_from_wrapper
def _environ_from_activate(activate_script, tmpdir):
activate_file = tmpdir.join('environ-from-activate') + \
get_wrapper_extension()
activate_file.write('''%s
python -c "from os import environ; print(dict(environ))"
''' % activate_script)
activate_file.chmod(activate_file.stat().mode | stat.S_IXUSR)
output = subprocess.check_output(str(activate_file))
environ_from_activate = eval(output)
return environ_from_activate
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_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 _create_custom_run_in_file(tmpdir):
if sys.platform == "win32":
run_in_content = "echo %~1 %~2\r\n"
else:
run_in_content = '#/bin/sh\necho "$@"\n'
run_in_filepath = tmpdir.join("custom-run-in" + get_wrapper_extension())
_create_executable_file(run_in_filepath)
run_in_filepath.write(run_in_content)
return run_in_filepath
def _environ_from_activate(activate_script, tmpdir):
activate_file = tmpdir.join("environ-from-activate") + get_wrapper_extension()
activate_file.write(
"""%s
python -c "from os import environ; print(dict(environ))"
"""
% activate_script
)
activate_file.chmod(activate_file.stat().mode | stat.S_IXUSR)
output = subprocess.check_output(str(activate_file))
environ_from_activate = eval(output)
return environ_from_activate
def _create_custom_run_in_file(tmpdir):
if sys.platform == 'win32':
run_in_content = 'echo %*\r\n'
else:
run_in_content = '#/bin/sh\necho "$@"\n'
run_in_filepath = tmpdir.join('custom-run-in' + get_wrapper_extension())
_create_executable_file(run_in_filepath)
run_in_filepath.write(run_in_content)
return run_in_filepath
def _create_custom_run_in_file(tmpdir):
if sys.platform == "win32":
run_in_content = "echo %~1 %~2\r\n"
else:
run_in_content = '#/bin/sh\necho "$@"\n'
run_in_filepath = tmpdir.join("custom-run-in" + get_wrapper_extension())
_create_executable_file(run_in_filepath)
run_in_filepath.write(run_in_content)
return run_in_filepath
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_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_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 _environ_from_wrapper():
python_wrapper = os.path.normpath("wrappers/python") + get_wrapper_extension()
with pytest.raises(subprocess.CalledProcessError) as exc_info:
# Return a non-zero exit code on purpose, to make sure wrapper returns it.
subprocess.check_output(
[
python_wrapper,
"-c",
"from os import environ; print(dict(environ))"
"; import sys; sys.exit(42)",
]
)
assert exc_info.value.returncode == 42
output = exc_info.value.output
environ_from_wrapper = eval(output)
return environ_from_wrapper
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_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_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_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_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_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_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_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_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_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()
