def test_create_venv_accepts_fallback_version_w_nonzero_patchlevel(
manager: EnvManager,
poetry: "Poetry",
config: "Config",
mocker: "MockerFixture",
config_virtualenvs_path: Path,
):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "~3.5.1"
venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent))
check_output = mocker.patch(
"subprocess.check_output",
side_effect=lambda cmd, *args, **kwargs: str(
"3.5.12" if "python3.5" in cmd else "3.7.1"
),
)
m = mocker.patch(
"poetry.utils.env.EnvManager.build_venv", side_effect=lambda *args, **kwargs: ""
)
manager.create_venv(NullIO())
assert check_output.called
m.assert_called_with(
config_virtualenvs_path / f"{venv_name}-py3.5",
executable="python3.5",
flags={"always-copy": False, "system-site-packages": False},
with_pip=True,
with_setuptools=True,
with_wheel=True,
)
def test_create_venv_tries_to_find_a_compatible_python_executable_using_specific_ones(
manager: EnvManager,
poetry: "Poetry",
config: "Config",
mocker: "MockerFixture",
config_virtualenvs_path: Path,
):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "^3.6"
venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent))
mocker.patch("sys.version_info", (2, 7, 16))
mocker.patch("subprocess.check_output", side_effect=["3.5.3", "3.9.0"])
m = mocker.patch(
"poetry.utils.env.EnvManager.build_venv", side_effect=lambda *args, **kwargs: ""
)
manager.create_venv(NullIO())
m.assert_called_with(
config_virtualenvs_path / f"{venv_name}-py3.9",
executable="python3.9",
flags={"always-copy": False, "system-site-packages": False},
with_pip=True,
with_setuptools=True,
with_wheel=True,
)
def test_create_venv_tries_to_find_a_compatible_python_executable_using_generic_ones_first( # noqa: E501
manager: EnvManager,
poetry: Poetry,
config: Config,
mocker: MockerFixture,
config_virtualenvs_path: Path,
):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "^3.6"
venv_name = manager.generate_env_name("simple-project",
str(poetry.file.parent))
mocker.patch("sys.version_info", (2, 7, 16))
mocker.patch(
"subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.7.5")),
)
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
manager.create_venv(NullIO())
m.assert_called_with(
config_virtualenvs_path / f"{venv_name}-py3.7",
executable="python3",
flags={
"always-copy": False,
"system-site-packages": False,
"no-pip": False,
"no-setuptools": False,
},
prompt="simple-project-py3.7",
)
def set_env(self, event, event_name, _): # type: (PreHandleEvent, str, _) -> None
from poetry.semver import parse_constraint
from poetry.utils.env import EnvManager
command = event.command.config.handler # type: EnvCommand
if not isinstance(command, EnvCommand):
return
io = event.io
poetry = command.poetry
env_manager = EnvManager(poetry.config)
# Checking compatibility of the current environment with
# the python dependency specified in pyproject.toml
current_env = env_manager.get(poetry.file.parent)
supported_python = poetry.package.python_constraint
current_python = parse_constraint(
".".join(str(v) for v in current_env.version_info[:3])
)
if not supported_python.allows(current_python):
raise RuntimeError(
"The current Python version ({}) is not supported by the project ({})\n"
"Please activate a compatible Python version.".format(
current_python, poetry.package.python_versions
)
)
env = env_manager.create_venv(poetry.file.parent, io, poetry.package.name)
if env.is_venv() and io.is_verbose():
io.write_line("Using virtualenv: <comment>{}</>".format(env.path))
command.set_env(env)
def test_create_venv_fails_if_no_compatible_python_version_could_be_found(
manager: EnvManager, poetry: Poetry, config: Config,
mocker: MockerFixture):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "^4.8"
mocker.patch("subprocess.check_output", side_effect=["", "", "", ""])
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
with pytest.raises(NoCompatiblePythonVersionFound) as e:
manager.create_venv(NullIO())
expected_message = ("Poetry was unable to find a compatible version. "
"If you have one, you can explicitly use it "
'via the "env use" command.')
assert str(e.value) == expected_message
assert m.call_count == 0
def test_create_venv_uses_patch_version_to_detect_compatibility(
manager: EnvManager,
poetry: Poetry,
config: Config,
mocker: MockerFixture,
config_virtualenvs_path: Path,
):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
version = Version.from_parts(*sys.version_info[:3])
poetry.package.python_versions = "^" + ".".join(
str(c) for c in sys.version_info[:3])
venv_name = manager.generate_env_name("simple-project",
str(poetry.file.parent))
mocker.patch("sys.version_info",
(version.major, version.minor, version.patch + 1))
check_output = mocker.patch(
"subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.6.9")),
)
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
manager.create_venv(NullIO())
assert not check_output.called
m.assert_called_with(
config_virtualenvs_path /
f"{venv_name}-py{version.major}.{version.minor}",
executable=None,
flags={
"always-copy": False,
"system-site-packages": False,
"no-pip": False,
"no-setuptools": False,
},
prompt=f"simple-project-py{version.major}.{version.minor}",
)
def test_create_venv_does_not_try_to_find_compatible_versions_with_executable(
manager: EnvManager, poetry: Poetry, config: Config,
mocker: MockerFixture):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "^4.8"
mocker.patch("subprocess.check_output", side_effect=["3.8.0"])
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
with pytest.raises(NoCompatiblePythonVersionFound) as e:
manager.create_venv(NullIO(), executable="3.8")
expected_message = (
"The specified Python version (3.8.0) is not supported by the project (^4.8).\n"
"Please choose a compatible version or loosen the python constraint "
"specified in the pyproject.toml file.")
assert str(e.value) == expected_message
assert m.call_count == 0
def test_create_venv_uses_patch_version_to_detect_compatibility_with_executable(
manager: EnvManager,
poetry: "Poetry",
config: "Config",
mocker: "MockerFixture",
config_virtualenvs_path: Path,
):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
version = Version.from_parts(*sys.version_info[:3])
poetry.package.python_versions = f"~{version.major}.{version.minor-1}.0"
venv_name = manager.generate_env_name("simple-project",
str(poetry.file.parent))
check_output = mocker.patch(
"subprocess.check_output",
side_effect=check_output_wrapper(
Version.parse(f"{version.major}.{version.minor - 1}.0")),
)
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
manager.create_venv(
NullIO(), executable=f"python{version.major}.{version.minor - 1}")
assert check_output.called
m.assert_called_with(
config_virtualenvs_path /
f"{venv_name}-py{version.major}.{version.minor - 1}",
executable=f"python{version.major}.{version.minor - 1}",
flags={
"always-copy": False,
"system-site-packages": False
},
with_pip=True,
with_setuptools=True,
with_wheel=True,
)
def test_create_venv_fails_if_current_python_version_is_not_supported(
manager: EnvManager, poetry: Poetry):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
manager.create_venv(NullIO())
current_version = Version.parse(".".join(
str(c) for c in sys.version_info[:3]))
next_version = ".".join(
str(c) for c in (current_version.major, current_version.minor + 1, 0))
package_version = "~" + next_version
poetry.package.python_versions = package_version
with pytest.raises(InvalidCurrentPythonVersionError) as e:
manager.create_venv(NullIO())
expected_message = (
f"Current Python version ({current_version}) is not allowed by the project"
f' ({package_version}).\nPlease change python executable via the "env use"'
" command.")
assert expected_message == str(e.value)
def set_env(self, event, event_name, _): # type: (PreHandleEvent, str, Any) -> None
from poetry.utils.env import EnvManager
command = event.command.config.handler # type: EnvCommand
if not isinstance(command, EnvCommand):
return
io = event.io
poetry = command.poetry
env_manager = EnvManager(poetry)
env = env_manager.create_venv(io)
if env.is_venv() and io.is_verbose():
io.write_line("Using virtualenv: <comment>{}</>".format(env.path))
command.set_env(env)
def set_env(self, event: ConsoleCommandEvent, event_name: str, _: Any):
from .commands.env_command import EnvCommand
command: EnvCommand = cast(EnvCommand, event.command)
if not isinstance(command, EnvCommand):
return
if command.env is not None:
return
from poetry.utils.env import EnvManager
io = event.io
poetry = command.poetry
env_manager = EnvManager(poetry)
env = env_manager.create_venv(io)
if env.is_venv() and io.is_verbose():
io.write_line("Using virtualenv: <comment>{}</>".format(env.path))
command.set_env(env)
