Skip to content

P
python-poetry
Commit a979dabe by Arun Babu Neelicattu
Options

tests: clean up fixtures and console tests 

This change cleans up a few of the fixtures used in the test suite to
be more consistent and also renames ambiguous helper classes.
parent 5312cdcf
Showing with 571 additions and 774 deletions
tests/conftest.py
import os import os
import re
import shutil import shutil
import sys
import tempfile import tempfile
from typing import Any from typing import Any
...@@ -8,13 +10,25 @@ from typing import Dict ...@@ -8,13 +10,25 @@ from typing import Dict
import httpretty import httpretty
import pytest import pytest
from cleo import CommandTester
from poetry.config.config import Config as BaseConfig from poetry.config.config import Config as BaseConfig
from poetry.config.dict_config_source import DictConfigSource from poetry.config.dict_config_source import DictConfigSource
from poetry.factory import Factory
from poetry.inspection.info import PackageInfo from poetry.inspection.info import PackageInfo
from poetry.inspection.info import PackageInfoError from poetry.inspection.info import PackageInfoError
from poetry.installation import Installer
from poetry.layouts import layout
from poetry.repositories import Pool
from poetry.repositories import Repository
from poetry.utils._compat import Path from poetry.utils._compat import Path
from poetry.utils.env import EnvManager from poetry.utils.env import EnvManager
from poetry.utils.env import SystemEnv
from poetry.utils.env import VirtualEnv from poetry.utils.env import VirtualEnv
from tests.helpers import TestExecutor
from tests.helpers import TestLocker
from tests.helpers import TestRepository
from tests.helpers import get_package
from tests.helpers import mock_clone from tests.helpers import mock_clone
from tests.helpers import mock_download from tests.helpers import mock_download
...@@ -168,3 +182,130 @@ def tmp_venv(tmp_dir): ...@@ -168,3 +182,130 @@ def tmp_venv(tmp_dir):
yield venv yield venv
shutil.rmtree(str(venv.path)) shutil.rmtree(str(venv.path))
@pytest.fixture
def installed():
return Repository()
@pytest.fixture(scope="session")
def current_env():
return SystemEnv(Path(sys.executable))
@pytest.fixture(scope="session")
def current_python(current_env):
return current_env.version_info[:3]
@pytest.fixture(scope="session")
def default_python(current_python):
return "^{}".format(".".join(str(v) for v in current_python[:2]))
@pytest.fixture
def repo(http):
http.register_uri(
http.GET, re.compile("^https?://foo.bar/(.+?)$"),
)
return TestRepository(name="foo")
@pytest.fixture
def project_factory(tmp_dir, config, repo, installed, default_python):
workspace = Path(tmp_dir)
def _factory(
name=None,
dependencies=None,
dev_dependencies=None,
pyproject_content=None,
install_deps=True,
):
project_dir = workspace / "poetry-fixture-{}".format(name)
dependencies = dependencies or {}
dev_dependencies = dev_dependencies or {}
if pyproject_content:
project_dir.mkdir(parents=True, exist_ok=True)
with project_dir.joinpath("pyproject.toml").open(
"w", encoding="utf-8"
) as f:
f.write(pyproject_content)
else:
layout("src")(
name,
"0.1.0",
author="PyTest Tester <mc.testy@testface.com>",
readme_format="md",
python=default_python,
dependencies=dependencies,
dev_dependencies=dev_dependencies,
).create(project_dir, with_tests=False)
poetry = Factory().create_poetry(project_dir)
locker = TestLocker(
poetry.locker.lock.path, poetry.locker._local_config
) # noqa
locker.write()
poetry.set_locker(locker)
poetry.set_config(config)
pool = Pool()
pool.add_repository(repo)
poetry.set_pool(pool)
if install_deps:
for deps in [dependencies, dev_dependencies]:
for name, version in deps.items():
pkg = get_package(name, version)
repo.add_package(pkg)
installed.add_package(pkg)
return poetry
return _factory
@pytest.fixture
def command_tester_factory(app, env):
def _tester(command, poetry=None, installer=None, executor=None, environment=None):
command = app.find(command)
tester = CommandTester(command)
if poetry:
app._poetry = poetry
poetry = app.poetry
command._pool = poetry.pool
if hasattr(command, "set_env"):
command.set_env(environment or env)
if hasattr(command, "set_installer"):
installer = installer or Installer(
tester.io,
env,
poetry.package,
poetry.locker,
poetry.pool,
poetry.config,
executor=executor
or TestExecutor(env, poetry.pool, poetry.config, tester.io),
)
installer.use_executor(True)
command.set_installer(installer)
return tester
return _tester
@pytest.fixture
def do_lock(command_tester_factory, poetry):
command_tester_factory("lock").execute()
assert poetry.locker.lock.exists()
tests/console/commands/debug/test_resolve.py
from cleo.testers import CommandTester import pytest
from poetry.factory import Factory from poetry.factory import Factory
from tests.helpers import get_package from tests.helpers import get_package
def test_debug_resolve_gives_resolution_results(app, repo): @pytest.fixture()
command = app.find("debug resolve") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("debug resolve")
def test_debug_resolve_gives_resolution_results(tester, repo):
cachy2 = get_package("cachy", "0.2.0") cachy2 = get_package("cachy", "0.2.0")
cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6")) cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
...@@ -29,10 +31,7 @@ cachy 0.2.0 ...@@ -29,10 +31,7 @@ cachy 0.2.0
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_debug_resolve_tree_option_gives_the_dependency_tree(app, repo): def test_debug_resolve_tree_option_gives_the_dependency_tree(tester, repo):
command = app.find("debug resolve")
tester = CommandTester(command)
cachy2 = get_package("cachy", "0.2.0") cachy2 = get_package("cachy", "0.2.0")
cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6")) cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
...@@ -54,13 +53,10 @@ cachy 0.2.0 ...@@ -54,13 +53,10 @@ cachy 0.2.0
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_debug_resolve_git_dependency(app, repo): def test_debug_resolve_git_dependency(tester, repo):
repo.add_package(get_package("pendulum", "2.0.3")) repo.add_package(get_package("pendulum", "2.0.3"))
repo.add_package(get_package("cleo", "0.6.5")) repo.add_package(get_package("cleo", "0.6.5"))
command = app.find("debug resolve")
tester = CommandTester(command)
tester.execute("git+https://github.com/demo/demo.git") tester.execute("git+https://github.com/demo/demo.git")
expected = """\ expected = """\
......
tests/console/commands/env/conftest.py 0 → 100644
import os
import pytest
from poetry.utils._compat import Path
from poetry.utils.env import EnvManager
@pytest.fixture
def venv_name(app):
return EnvManager.generate_env_name("simple-project", str(app.poetry.file.parent))
@pytest.fixture
def venv_cache(tmp_dir):
return Path(tmp_dir)
@pytest.fixture(scope="module")
def python_versions():
return ["3.6", "3.7"]
@pytest.fixture
def venvs_in_cache_config(app, venv_cache):
app.poetry.config.merge({"virtualenvs": {"path": str(venv_cache)}})
@pytest.fixture
def venvs_in_cache_dirs(
app, venvs_in_cache_config, venv_name, venv_cache, python_versions
):
directories = []
for version in python_versions:
directory = venv_cache.joinpath("{}-py{}".format(venv_name, version))
directory.mkdir(parents=True, exist_ok=True)
directories.append(directory.name)
return directories
@pytest.fixture
def venvs_in_project_dir(app):
os.environ.pop("VIRTUAL_ENV", None)
venv_dir = app.poetry.file.parent.joinpath(".venv")
venv_dir.mkdir(exist_ok=True)
app.poetry.config.merge({"virtualenvs": {"in-project": True}})
try:
yield venv_dir
finally:
venv_dir.rmdir()
tests/console/commands/env/helpers.py 0 → 100644
from typing import Optional
from typing import Union
from poetry.core.semver import Version
from poetry.utils._compat import Path
def build_venv(path, executable=None): # type: (Union[Path,str], Optional[str]) -> ()
Path(path).mkdir(parents=True, exist_ok=True)
def check_output_wrapper(version=Version.parse("3.7.1")):
def check_output(cmd, *args, **kwargs):
if "sys.version_info[:3]" in cmd:
return version.text
elif "sys.version_info[:2]" in cmd:
return "{}.{}".format(version.major, version.minor)
else:
return str(Path("/prefix"))
return check_output
tests/console/commands/env/test_info.py
import pytest import pytest
from cleo.testers import CommandTester
from poetry.utils._compat import Path from poetry.utils._compat import Path
from poetry.utils.env import MockEnv from poetry.utils.env import MockEnv
...@@ -16,10 +14,12 @@ def setup(mocker): ...@@ -16,10 +14,12 @@ def setup(mocker):
) )
def test_env_info_displays_complete_info(app): @pytest.fixture
command = app.find("env info") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("env info")
def test_env_info_displays_complete_info(tester):
tester.execute() tester.execute()
expected = """ expected = """
...@@ -40,12 +40,7 @@ Python: {base_prefix} ...@@ -40,12 +40,7 @@ Python: {base_prefix}
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_env_info_displays_path_only(app): def test_env_info_displays_path_only(tester):
command = app.find("env info")
tester = CommandTester(command)
tester.execute("--path") tester.execute("--path")
expected = str(Path("/prefix")) expected = str(Path("/prefix"))
assert expected + "\n" == tester.io.fetch_output() assert expected + "\n" == tester.io.fetch_output()
tests/console/commands/env/test_list.py
import os import pytest
import tomlkit import tomlkit
from cleo.testers import CommandTester
from poetry.utils._compat import Path
from poetry.utils.env import EnvManager
from poetry.utils.toml_file import TomlFile from poetry.utils.toml_file import TomlFile
def test_none_activated(app, tmp_dir, mocker, env): @pytest.fixture
mocker.patch("poetry.utils.env.EnvManager.get", return_value=env) def venv_activate_37(venv_cache, venv_name):
envs_file = TomlFile(venv_cache / "envs.toml")
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}})
venv_name = EnvManager.generate_env_name(
"simple-project", str(app.poetry.file.parent)
)
(Path(tmp_dir) / "{}-py3.7".format(venv_name)).mkdir()
(Path(tmp_dir) / "{}-py3.6".format(venv_name)).mkdir()
command = app.find("env list")
tester = CommandTester(command)
tester.execute()
expected = """\
{}-py3.6
{}-py3.7
""".format(
venv_name, venv_name
)
assert expected == tester.io.fetch_output()
def test_activated(app, tmp_dir):
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}})
venv_name = EnvManager.generate_env_name(
"simple-project", str(app.poetry.file.parent)
)
(Path(tmp_dir) / "{}-py3.7".format(venv_name)).mkdir()
(Path(tmp_dir) / "{}-py3.6".format(venv_name)).mkdir()
envs_file = TomlFile(Path(tmp_dir) / "envs.toml")
doc = tomlkit.document() doc = tomlkit.document()
doc[venv_name] = {"minor": "3.7", "patch": "3.7.0"} doc[venv_name] = {"minor": "3.7", "patch": "3.7.0"}
envs_file.write(doc) envs_file.write(doc)
command = app.find("env list")
tester = CommandTester(command)
tester.execute()
expected = """\ @pytest.fixture
{}-py3.6 def tester(command_tester_factory):
{}-py3.7 (Activated) return command_tester_factory("env list")
""".format(
venv_name, venv_name
)
assert expected == tester.io.fetch_output()
def test_in_project_venv(app, tmpdir): def test_none_activated(tester, venvs_in_cache_dirs, mocker, env):
os.environ.pop("VIRTUAL_ENV", None) mocker.patch("poetry.utils.env.EnvManager.get", return_value=env)
app.poetry.config.merge({"virtualenvs": {"in-project": True}}) tester.execute()
expected = "\n".join(venvs_in_cache_dirs).strip()
assert expected == tester.io.fetch_output().strip()
(app.poetry.file.parent / ".venv").mkdir(exist_ok=True)
command = app.find("env list") def test_activated(tester, venvs_in_cache_dirs, venv_cache, venv_activate_37):
tester = CommandTester(command)
tester.execute() tester.execute()
expected = (
"\n".join(venvs_in_cache_dirs).strip().replace("py3.7", "py3.7 (Activated)")
)
assert expected == tester.io.fetch_output().strip()
expected = ".venv (Activated)\n"
def test_in_project_venv(tester, venvs_in_project_dir):
tester.execute()
expected = ".venv (Activated)\n"
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
(app.poetry.file.parent / ".venv").rmdir()
tests/console/commands/env/test_remove.py
from cleo.testers import CommandTester import pytest
from poetry.utils._compat import Path from poetry.core.semver.version import Version
from poetry.utils.env import EnvManager from tests.console.commands.env.helpers import check_output_wrapper
from .test_use import Version
from .test_use import check_output_wrapper
@pytest.fixture
def tester(command_tester_factory):
return command_tester_factory("env remove")
def test_remove_by_python_version(app, tmp_dir, mocker):
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}})
venv_name = EnvManager.generate_env_name(
"simple-project", str(app.poetry.file.parent)
)
(Path(tmp_dir) / "{}-py3.7".format(venv_name)).mkdir()
(Path(tmp_dir) / "{}-py3.6".format(venv_name)).mkdir()
def test_remove_by_python_version(
mocker, tester, venvs_in_cache_dirs, venv_name, venv_cache
):
check_output = mocker.patch( check_output = mocker.patch(
"poetry.utils._compat.subprocess.check_output", "poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.6.6")), side_effect=check_output_wrapper(Version.parse("3.6.6")),
) )
command = app.find("env remove")
tester = CommandTester(command)
tester.execute("3.6") tester.execute("3.6")
assert check_output.called assert check_output.called
assert not (Path(tmp_dir) / "{}-py3.6".format(venv_name)).exists() assert not (venv_cache / "{}-py3.6".format(venv_name)).exists()
expected = "Deleted virtualenv: {}\n".format( expected = "Deleted virtualenv: {}\n".format(
(Path(tmp_dir) / "{}-py3.6".format(venv_name)) (venv_cache / "{}-py3.6".format(venv_name))
) )
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_remove_by_name(app, tmp_dir): def test_remove_by_name(tester, venvs_in_cache_dirs, venv_name, venv_cache):
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}}) expected = ""
venv_name = EnvManager.generate_env_name( for name in venvs_in_cache_dirs:
"simple-project", str(app.poetry.file.parent) tester.execute(name)
)
(Path(tmp_dir) / "{}-py3.7".format(venv_name)).mkdir()
(Path(tmp_dir) / "{}-py3.6".format(venv_name)).mkdir()
command = app.find("env remove") assert not (venv_cache / name).exists()
tester = CommandTester(command)
tester.execute("{}-py3.6".format(venv_name))
assert not (Path(tmp_dir) / "{}-py3.6".format(venv_name)).exists() expected += "Deleted virtualenv: {}\n".format((venv_cache / name))
expected = "Deleted virtualenv: {}\n".format(
(Path(tmp_dir) / "{}-py3.6".format(venv_name))
)
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
tests/console/commands/env/test_use.py
import os import os
import sys
from typing import Optional
from typing import Union
import pytest
import tomlkit import tomlkit
from cleo.testers import CommandTester
from poetry.core.semver import Version from poetry.core.semver import Version
from poetry.utils._compat import Path from poetry.utils._compat import Path
from poetry.utils.env import EnvManager
from poetry.utils.env import MockEnv from poetry.utils.env import MockEnv
from poetry.utils.toml_file import TomlFile from poetry.utils.toml_file import TomlFile
from tests.console.commands.env.helpers import build_venv
from tests.console.commands.env.helpers import check_output_wrapper
CWD = Path(__file__).parent.parent / "fixtures" / "simple_project" @pytest.fixture(autouse=True)
def setup(mocker):
def build_venv(path, executable=None): # type: (Union[Path,str], Optional[str]) -> ()
os.mkdir(str(path))
def check_output_wrapper(version=Version.parse("3.7.1")):
def check_output(cmd, *args, **kwargs):
if "sys.version_info[:3]" in cmd:
return version.text
elif "sys.version_info[:2]" in cmd:
return "{}.{}".format(version.major, version.minor)
else:
return str(Path("/prefix"))
return check_output
def test_activate_activates_non_existing_virtualenv_no_envs_file(app, tmp_dir, mocker):
mocker.stopall() mocker.stopall()
if "VIRTUAL_ENV" in os.environ: if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"] del os.environ["VIRTUAL_ENV"]
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}})
@pytest.fixture(autouse=True)
def mock_subprocess_calls(setup, current_python, mocker):
mocker.patch( mocker.patch(
"poetry.utils._compat.subprocess.check_output", "poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(), side_effect=check_output_wrapper(Version(*current_python)),
) )
mocker.patch( mocker.patch(
"poetry.utils._compat.subprocess.Popen.communicate", "poetry.utils._compat.subprocess.Popen.communicate",
side_effect=[("/prefix", None), ("/prefix", None)], side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)],
) )
m = mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=build_venv)
command = app.find("env use")
tester = CommandTester(command)
tester.execute("3.7")
venv_name = EnvManager.generate_env_name( @pytest.fixture
"simple-project", str(app.poetry.file.parent) def tester(command_tester_factory):
return command_tester_factory("env use")
def test_activate_activates_non_existing_virtualenv_no_envs_file(
mocker, tester, venv_cache, venv_name, venvs_in_cache_config
):
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(),
) )
m.assert_called_with( mock_build_env = mocker.patch(
Path(tmp_dir) / "{}-py3.7".format(venv_name), executable="python3.7" "poetry.utils.env.EnvManager.build_venv", side_effect=build_venv
) )
envs_file = TomlFile(Path(tmp_dir) / "envs.toml") tester.execute("3.7")
venv_py37 = venv_cache / "{}-py3.7".format(venv_name)
mock_build_env.assert_called_with(venv_py37, executable="python3.7")
envs_file = TomlFile(venv_cache / "envs.toml")
assert envs_file.exists() assert envs_file.exists()
envs = envs_file.read() envs = envs_file.read()
assert envs[venv_name]["minor"] == "3.7" assert envs[venv_name]["minor"] == "3.7"
...@@ -73,70 +62,45 @@ def test_activate_activates_non_existing_virtualenv_no_envs_file(app, tmp_dir, m ...@@ -73,70 +62,45 @@ def test_activate_activates_non_existing_virtualenv_no_envs_file(app, tmp_dir, m
Creating virtualenv {} in {} Creating virtualenv {} in {}
Using virtualenv: {} Using virtualenv: {}
""".format( """.format(
"{}-py3.7".format(venv_name), venv_py37.name, venv_py37.parent, venv_py37,
tmp_dir,
os.path.join(tmp_dir, "{}-py3.7".format(venv_name)),
) )
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_get_prefers_explicitly_activated_virtualenvs_over_env_var( def test_get_prefers_explicitly_activated_virtualenvs_over_env_var(
app, tmp_dir, mocker tester, current_python, venv_cache, venv_name, venvs_in_cache_config
): ):
mocker.stopall()
os.environ["VIRTUAL_ENV"] = "/environment/prefix" os.environ["VIRTUAL_ENV"] = "/environment/prefix"
venv_name = EnvManager.generate_env_name(
"simple-project", str(app.poetry.file.parent)
)
current_python = sys.version_info[:3]
python_minor = ".".join(str(v) for v in current_python[:2]) python_minor = ".".join(str(v) for v in current_python[:2])
python_patch = ".".join(str(v) for v in current_python) python_patch = ".".join(str(v) for v in current_python[:3])
venv_dir = venv_cache / "{}-py{}".format(venv_name, python_minor)
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}}) venv_dir.mkdir(parents=True, exist_ok=True)
(Path(tmp_dir) / "{}-py{}".format(venv_name, python_minor)).mkdir()
envs_file = TomlFile(Path(tmp_dir) / "envs.toml") envs_file = TomlFile(venv_cache / "envs.toml")
doc = tomlkit.document() doc = tomlkit.document()
doc[venv_name] = {"minor": python_minor, "patch": python_patch} doc[venv_name] = {"minor": python_minor, "patch": python_patch}
envs_file.write(doc) envs_file.write(doc)
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version(*current_python)),
)
mocker.patch(
"poetry.utils._compat.subprocess.Popen.communicate",
side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)],
)
command = app.find("env use")
tester = CommandTester(command)
tester.execute(python_minor) tester.execute(python_minor)
expected = """\ expected = """\
Using virtualenv: {} Using virtualenv: {}
""".format( """.format(
os.path.join(tmp_dir, "{}-py{}".format(venv_name, python_minor)) venv_dir
) )
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_get_prefers_explicitly_activated_non_existing_virtualenvs_over_env_var( def test_get_prefers_explicitly_activated_non_existing_virtualenvs_over_env_var(
app, tmp_dir, mocker mocker, tester, current_python, venv_cache, venv_name, venvs_in_cache_config
): ):
mocker.stopall()
os.environ["VIRTUAL_ENV"] = "/environment/prefix" os.environ["VIRTUAL_ENV"] = "/environment/prefix"
venv_name = EnvManager.generate_env_name(
"simple-project", str(app.poetry.file.parent)
)
current_python = sys.version_info[:3]
python_minor = ".".join(str(v) for v in current_python[:2]) python_minor = ".".join(str(v) for v in current_python[:2])
venv_dir = venv_cache / "{}-py{}".format(venv_name, python_minor)
app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}})
mocker.patch( mocker.patch(
"poetry.utils.env.EnvManager._env", "poetry.utils.env.EnvManager._env",
...@@ -148,28 +112,15 @@ def test_get_prefers_explicitly_activated_non_existing_virtualenvs_over_env_var( ...@@ -148,28 +112,15 @@ def test_get_prefers_explicitly_activated_non_existing_virtualenvs_over_env_var(
is_venv=True, is_venv=True,
), ),
) )
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version(*current_python)),
)
mocker.patch(
"poetry.utils._compat.subprocess.Popen.communicate",
side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)],
)
mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=build_venv) mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=build_venv)
command = app.find("env use")
tester = CommandTester(command)
tester.execute(python_minor) tester.execute(python_minor)
expected = """\ expected = """\
Creating virtualenv {} in {} Creating virtualenv {} in {}
Using virtualenv: {} Using virtualenv: {}
""".format( """.format(
"{}-py{}".format(venv_name, python_minor), venv_dir.name, venv_dir.parent, venv_dir,
tmp_dir,
os.path.join(tmp_dir, "{}-py{}".format(venv_name, python_minor)),
) )
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
tests/console/commands/self/test_update.py
import os import os
from cleo.testers import CommandTester import pytest
from poetry.__version__ import __version__ from poetry.__version__ import __version__
from poetry.core.packages.package import Package from poetry.core.packages.package import Package
...@@ -12,12 +12,17 @@ from poetry.utils._compat import Path ...@@ -12,12 +12,17 @@ from poetry.utils._compat import Path
FIXTURES = Path(__file__).parent.joinpath("fixtures") FIXTURES = Path(__file__).parent.joinpath("fixtures")
@pytest.fixture()
def tester(command_tester_factory):
return command_tester_factory("self update")
def test_self_update_should_install_all_necessary_elements( def test_self_update_should_install_all_necessary_elements(
app, http, mocker, environ, tmp_dir tester, http, mocker, environ, tmp_dir
): ):
os.environ["POETRY_HOME"] = tmp_dir os.environ["POETRY_HOME"] = tmp_dir
command = app.find("self update") command = tester._command
version = Version.parse(__version__).next_minor.text version = Version.parse(__version__).next_minor.text
mocker.patch( mocker.patch(
...@@ -41,7 +46,6 @@ def test_self_update_should_install_all_necessary_elements( ...@@ -41,7 +46,6 @@ def test_self_update_should_install_all_necessary_elements(
body=FIXTURES.joinpath("poetry-1.0.5-darwin.tar.gz").read_bytes(), body=FIXTURES.joinpath("poetry-1.0.5-darwin.tar.gz").read_bytes(),
) )
tester = CommandTester(command)
tester.execute() tester.execute()
bin_ = Path(tmp_dir).joinpath("bin") bin_ = Path(tmp_dir).joinpath("bin")
......
tests/console/commands/test_about.py
from cleo.testers import CommandTester import pytest
def test_about(app): @pytest.fixture()
command = app.find("about") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("about")
tester.execute()
def test_about(tester):
tester.execute()
expected = """\ expected = """\
Poetry - Package Management for Python Poetry - Package Management for Python
......
tests/console/commands/test_add.py
...@@ -5,10 +5,7 @@ import sys ...@@ -5,10 +5,7 @@ import sys
import pytest import pytest
from cleo.testers import CommandTester
from poetry.core.semver import Version from poetry.core.semver import Version
from poetry.installation.installer import Installer
from poetry.repositories.legacy_repository import LegacyRepository from poetry.repositories.legacy_repository import LegacyRepository
from poetry.utils._compat import Path from poetry.utils._compat import Path
from tests.helpers import get_dependency from tests.helpers import get_dependency
...@@ -16,25 +13,8 @@ from tests.helpers import get_package ...@@ -16,25 +13,8 @@ from tests.helpers import get_package
@pytest.fixture() @pytest.fixture()
def tester(app, poetry, config, executor, env): def tester(command_tester_factory):
tester = CommandTester(app.find("add")) return command_tester_factory("add")
executor._io = tester.io
installer = Installer(
tester.io,
env,
poetry.package,
poetry.locker,
poetry.pool,
config,
executor=executor,
)
installer.use_executor(True)
tester._command.set_installer(installer)
tester._command.set_env(env)
return tester
@pytest.fixture() @pytest.fixture()
......
tests/console/commands/test_cache.py
...@@ -2,8 +2,6 @@ import uuid ...@@ -2,8 +2,6 @@ import uuid
import pytest import pytest
from cleo.testers import CommandTester
@pytest.fixture @pytest.fixture
def repository_cache_dir(monkeypatch, tmpdir): def repository_cache_dir(monkeypatch, tmpdir):
...@@ -32,10 +30,12 @@ def mock_caches(repository_cache_dir, repository_one, repository_two): ...@@ -32,10 +30,12 @@ def mock_caches(repository_cache_dir, repository_one, repository_two):
(repository_cache_dir / repository_two).mkdir() (repository_cache_dir / repository_two).mkdir()
def test_cache_list(app, mock_caches, repository_one, repository_two): @pytest.fixture
command = app.find("cache list") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("cache list")
def test_cache_list(tester, mock_caches, repository_one, repository_two):
tester.execute() tester.execute()
expected = """\ expected = """\
...@@ -48,10 +48,7 @@ def test_cache_list(app, mock_caches, repository_one, repository_two): ...@@ -48,10 +48,7 @@ def test_cache_list(app, mock_caches, repository_one, repository_two):
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_cache_list_empty(app, repository_cache_dir): def test_cache_list_empty(tester, repository_cache_dir):
command = app.find("cache list")
tester = CommandTester(command)
tester.execute() tester.execute()
expected = """\ expected = """\
......
tests/console/commands/test_check.py
from cleo.testers import CommandTester import pytest
from poetry.utils._compat import PY2 from poetry.utils._compat import PY2
from poetry.utils._compat import Path from poetry.utils._compat import Path
def test_check_valid(app): @pytest.fixture()
command = app.find("check") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("check")
def test_check_valid(tester):
tester.execute() tester.execute()
expected = """\ expected = """\
...@@ -17,7 +19,7 @@ All set! ...@@ -17,7 +19,7 @@ All set!
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_check_invalid(app, mocker): def test_check_invalid(mocker, tester):
mocker.patch( mocker.patch(
"poetry.factory.Factory.locate", "poetry.factory.Factory.locate",
return_value=Path(__file__).parent.parent.parent return_value=Path(__file__).parent.parent.parent
...@@ -26,9 +28,6 @@ def test_check_invalid(app, mocker): ...@@ -26,9 +28,6 @@ def test_check_invalid(app, mocker):
/ "pyproject.toml", / "pyproject.toml",
) )
command = app.find("check")
tester = CommandTester(command)
tester.execute() tester.execute()
if PY2: if PY2:
......
tests/console/commands/test_config.py
import json import json
import os import os
from cleo.testers import CommandTester import pytest
from poetry.config.config_source import ConfigSource from poetry.config.config_source import ConfigSource
from poetry.factory import Factory from poetry.factory import Factory
def test_list_displays_default_value_if_not_set(app, config): @pytest.fixture()
command = app.find("config") def tester(command_tester_factory):
tester = CommandTester(command) return command_tester_factory("config")
def test_list_displays_default_value_if_not_set(tester, config):
tester.execute("--list") tester.execute("--list")
expected = """cache-dir = "/foo" expected = """cache-dir = "/foo"
...@@ -24,10 +27,7 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs ...@@ -24,10 +27,7 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_list_displays_set_get_setting(app, config): def test_list_displays_set_get_setting(tester, config):
command = app.find("config")
tester = CommandTester(command)
tester.execute("virtualenvs.create false") tester.execute("virtualenvs.create false")
tester.execute("--list") tester.execute("--list")
...@@ -45,10 +45,7 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs ...@@ -45,10 +45,7 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_display_single_setting(app, config): def test_display_single_setting(tester, config):
command = app.find("config")
tester = CommandTester(command)
tester.execute("virtualenvs.create") tester.execute("virtualenvs.create")
expected = """true expected = """true
...@@ -57,13 +54,10 @@ def test_display_single_setting(app, config): ...@@ -57,13 +54,10 @@ def test_display_single_setting(app, config):
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_display_single_local_setting(app, config, fixture_dir): def test_display_single_local_setting(command_tester_factory, fixture_dir):
poetry = Factory().create_poetry(fixture_dir("with_local_config")) tester = command_tester_factory(
app._poetry = poetry "config", poetry=Factory().create_poetry(fixture_dir("with_local_config"))
)
command = app.find("config")
tester = CommandTester(command)
tester.execute("virtualenvs.create") tester.execute("virtualenvs.create")
expected = """false expected = """false
...@@ -72,10 +66,7 @@ def test_display_single_local_setting(app, config, fixture_dir): ...@@ -72,10 +66,7 @@ def test_display_single_local_setting(app, config, fixture_dir):
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_list_displays_set_get_local_setting(app, config): def test_list_displays_set_get_local_setting(tester, config):
command = app.find("config")
tester = CommandTester(command)
tester.execute("virtualenvs.create false --local") tester.execute("virtualenvs.create false --local")
tester.execute("--list") tester.execute("--list")
...@@ -93,21 +84,15 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs ...@@ -93,21 +84,15 @@ virtualenvs.path = {path} # /foo{sep}virtualenvs
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_set_pypi_token(app, config, config_source, auth_config_source): def test_set_pypi_token(tester, auth_config_source):
command = app.find("config")
tester = CommandTester(command)
tester.execute("pypi-token.pypi mytoken") tester.execute("pypi-token.pypi mytoken")
tester.execute("--list") tester.execute("--list")
assert "mytoken" == auth_config_source.config["pypi-token"]["pypi"] assert "mytoken" == auth_config_source.config["pypi-token"]["pypi"]
def test_set_client_cert(app, config_source, auth_config_source, mocker): def test_set_client_cert(tester, auth_config_source, mocker):
mocker.spy(ConfigSource, "__init__") mocker.spy(ConfigSource, "__init__")
command = app.find("config")
tester = CommandTester(command)
tester.execute("certificates.foo.client-cert path/to/cert.pem") tester.execute("certificates.foo.client-cert path/to/cert.pem")
...@@ -117,10 +102,8 @@ def test_set_client_cert(app, config_source, auth_config_source, mocker): ...@@ -117,10 +102,8 @@ def test_set_client_cert(app, config_source, auth_config_source, mocker):
) )
def test_set_cert(app, config_source, auth_config_source, mocker): def test_set_cert(tester, auth_config_source, mocker):
mocker.spy(ConfigSource, "__init__") mocker.spy(ConfigSource, "__init__")
command = app.find("config")
tester = CommandTester(command)
tester.execute("certificates.foo.cert path/to/ca.pem") tester.execute("certificates.foo.cert path/to/ca.pem")
......
tests/console/commands/test_export.py
...@@ -3,16 +3,8 @@ from __future__ import unicode_literals ...@@ -3,16 +3,8 @@ from __future__ import unicode_literals
import pytest import pytest
from cleo.testers import CommandTester
from poetry.factory import Factory
from poetry.repositories.pool import Pool
from tests.helpers import get_package from tests.helpers import get_package
from ..conftest import Application
from ..conftest import Locker
from ..conftest import Path
PYPROJECT_CONTENT = """\ PYPROJECT_CONTENT = """\
[tool.poetry] [tool.poetry]
...@@ -48,166 +40,76 @@ feature_bar = ["bar"] ...@@ -48,166 +40,76 @@ feature_bar = ["bar"]
""" """
@pytest.fixture @pytest.fixture(autouse=True)
def poetry(repo, tmp_dir): def setup(repo):
with (Path(tmp_dir) / "pyproject.toml").open("w", encoding="utf-8") as f:
f.write(PYPROJECT_CONTENT)
p = Factory().create_poetry(Path(tmp_dir))
locker = Locker(p.locker.lock.path, p.locker._local_config)
locker.write()
p.set_locker(locker)
pool = Pool()
pool.add_repository(repo)
p.set_pool(pool)
yield p
@pytest.fixture
def app(poetry):
return Application(poetry)
def test_export_exports_requirements_txt_file_locks_if_no_lock_file(app, repo):
command = app.find("export")
tester = CommandTester(command)
assert not app.poetry.locker.lock.exists()
repo.add_package(get_package("foo", "1.0.0")) repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0")) repo.add_package(get_package("bar", "1.1.0"))
tester.execute("--format requirements.txt --output requirements.txt")
requirements = app.poetry.file.parent / "requirements.txt"
assert requirements.exists()
with requirements.open(encoding="utf-8") as f:
content = f.read()
assert app.poetry.locker.lock.exists() @pytest.fixture
def poetry(project_factory):
expected = """\ return project_factory(name="export", pyproject_content=PYPROJECT_CONTENT)
foo==1.0.0
"""
assert expected == content
assert "The lock file does not exist. Locking." in tester.io.fetch_output()
def test_export_exports_requirements_txt_uses_lock_file(app, repo):
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
command = app.find("lock")
tester = CommandTester(command)
tester.execute()
assert app.poetry.locker.lock.exists() @pytest.fixture
def tester(command_tester_factory, poetry):
return command_tester_factory("export", poetry=poetry)
command = app.find("export")
tester = CommandTester(command)
def _export_requirements(tester, poetry):
tester.execute("--format requirements.txt --output requirements.txt") tester.execute("--format requirements.txt --output requirements.txt")
requirements = app.poetry.file.parent / "requirements.txt" requirements = poetry.file.parent / "requirements.txt"
assert requirements.exists() assert requirements.exists()
with requirements.open(encoding="utf-8") as f: with requirements.open(encoding="utf-8") as f:
content = f.read() content = f.read()
assert app.poetry.locker.lock.exists() assert poetry.locker.lock.exists()
expected = """\ expected = """\
foo==1.0.0 foo==1.0.0
""" """
assert expected == content assert expected == content
assert "The lock file does not exist. Locking." not in tester.io.fetch_output()
def test_export_fails_on_invalid_format(app, repo): def test_export_exports_requirements_txt_file_locks_if_no_lock_file(tester, poetry):
repo.add_package(get_package("foo", "1.0.0")) assert not poetry.locker.lock.exists()
repo.add_package(get_package("bar", "1.1.0")) _export_requirements(tester, poetry)
assert "The lock file does not exist. Locking." in tester.io.fetch_output()
command = app.find("lock")
tester = CommandTester(command)
tester.execute()
assert app.poetry.locker.lock.exists() def test_export_exports_requirements_txt_uses_lock_file(tester, poetry, do_lock):
_export_requirements(tester, poetry)
assert "The lock file does not exist. Locking." not in tester.io.fetch_output()
command = app.find("export")
tester = CommandTester(command)
def test_export_fails_on_invalid_format(tester, do_lock):
with pytest.raises(ValueError): with pytest.raises(ValueError):
tester.execute("--format invalid") tester.execute("--format invalid")
def test_export_prints_to_stdout_by_default(app, repo): def test_export_prints_to_stdout_by_default(tester, do_lock):
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
command = app.find("lock")
tester = CommandTester(command)
tester.execute()
assert app.poetry.locker.lock.exists()
command = app.find("export")
tester = CommandTester(command)
tester.execute("--format requirements.txt") tester.execute("--format requirements.txt")
expected = """\ expected = """\
foo==1.0.0 foo==1.0.0
""" """
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_export_uses_requirements_txt_format_by_default(app, repo): def test_export_uses_requirements_txt_format_by_default(tester, do_lock):
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
command = app.find("lock")
tester = CommandTester(command)
tester.execute()
assert app.poetry.locker.lock.exists()
command = app.find("export")
tester = CommandTester(command)
tester.execute() tester.execute()
expected = """\ expected = """\
foo==1.0.0 foo==1.0.0
""" """
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
def test_export_includes_extras_by_flag(app, repo): def test_export_includes_extras_by_flag(tester, do_lock):
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
command = app.find("lock")
tester = CommandTester(command)
tester.execute()
assert app.poetry.locker.lock.exists()
command = app.find("export")
tester = CommandTester(command)
tester.execute("--format requirements.txt --extras feature_bar") tester.execute("--format requirements.txt --extras feature_bar")
expected = """\ expected = """\
bar==1.1.0 bar==1.1.0
foo==1.0.0 foo==1.0.0
""" """
assert expected == tester.io.fetch_output() assert expected == tester.io.fetch_output()
tests/console/commands/test_init.py
import sys import sys
from cleo.testers import CommandTester import pytest
from poetry.utils._compat import Path from poetry.utils._compat import Path
from tests.helpers import get_package from tests.helpers import get_package
def test_basic_interactive(app, mocker, poetry): @pytest.fixture(autouse=True)
command = app.find("init") def patches(mocker, mocked_open_files):
command._pool = poetry.pool mocked_open_files.append("pyproject.toml")
patch = mocker.patch("poetry.utils._compat.Path.cwd")
patch.return_value = Path(__file__).parent
@pytest.fixture
def tester(command_tester_factory):
return command_tester_factory("init")
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command) def test_basic_interactive(tester):
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -45,19 +49,11 @@ python = "~2.7 || ^3.6" ...@@ -45,19 +49,11 @@ python = "~2.7 || ^3.6"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_dependencies(app, repo, mocker, poetry): def test_interactive_with_dependencies(tester, repo):
repo.add_package(get_package("django-pendulum", "0.1.6-pre4")) repo.add_package(get_package("django-pendulum", "0.1.6-pre4"))
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -98,15 +94,7 @@ pytest = "^3.6.0" ...@@ -98,15 +94,7 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_empty_license(app, mocker, poetry): def test_empty_license(tester):
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -138,20 +126,10 @@ python = "^{python}" ...@@ -138,20 +126,10 @@ python = "^{python}"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_git_dependencies( def test_interactive_with_git_dependencies(tester, repo):
app, repo, mocker, poetry, mocked_open_files
):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocked_open_files.append("pyproject.toml")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -190,20 +168,10 @@ pytest = "^3.6.0" ...@@ -190,20 +168,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_git_dependencies_with_reference( def test_interactive_with_git_dependencies_with_reference(tester, repo):
app, repo, mocker, poetry, mocked_open_files
):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocked_open_files.append("pyproject.toml")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -242,20 +210,10 @@ pytest = "^3.6.0" ...@@ -242,20 +210,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_git_dependencies_and_other_name( def test_interactive_with_git_dependencies_and_other_name(tester, repo):
app, repo, mocker, poetry, mocked_open_files
):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocked_open_files.append("pyproject.toml")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -294,20 +252,10 @@ pytest = "^3.6.0" ...@@ -294,20 +252,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_directory_dependency( def test_interactive_with_directory_dependency(tester, repo):
app, repo, mocker, poetry, mocked_open_files
):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocked_open_files.append("pyproject.toml")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -346,20 +294,10 @@ pytest = "^3.6.0" ...@@ -346,20 +294,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_directory_dependency_and_other_name( def test_interactive_with_directory_dependency_and_other_name(tester, repo):
app, repo, mocker, poetry
):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -398,18 +336,10 @@ pytest = "^3.6.0" ...@@ -398,18 +336,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_interactive_with_file_dependency(app, repo, mocker, poetry): def test_interactive_with_file_dependency(tester, repo):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__).parent
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -448,15 +378,7 @@ pytest = "^3.6.0" ...@@ -448,15 +378,7 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_python_option(app, mocker, poetry): def test_python_option(tester):
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -486,17 +408,9 @@ python = "~2.7 || ^3.6" ...@@ -486,17 +408,9 @@ python = "~2.7 || ^3.6"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_predefined_dependency(app, repo, mocker, poetry): def test_predefined_dependency(tester, repo):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -528,18 +442,10 @@ pendulum = "^2.0.0" ...@@ -528,18 +442,10 @@ pendulum = "^2.0.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_predefined_and_interactive_dependencies(app, repo, mocker, poetry): def test_predefined_and_interactive_dependencies(tester, repo):
repo.add_package(get_package("pendulum", "2.0.0")) repo.add_package(get_package("pendulum", "2.0.0"))
repo.add_package(get_package("pyramid", "1.10")) repo.add_package(get_package("pyramid", "1.10"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -575,17 +481,9 @@ python = "~2.7 || ^3.6" ...@@ -575,17 +481,9 @@ python = "~2.7 || ^3.6"
assert 'pyramid = "^1.10"' in output assert 'pyramid = "^1.10"' in output
def test_predefined_dev_dependency(app, repo, mocker, poetry): def test_predefined_dev_dependency(tester, repo):
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
...@@ -618,18 +516,10 @@ pytest = "^3.6.0" ...@@ -618,18 +516,10 @@ pytest = "^3.6.0"
assert expected in tester.io.fetch_output() assert expected in tester.io.fetch_output()
def test_predefined_and_interactive_dev_dependencies(app, repo, mocker, poetry): def test_predefined_and_interactive_dev_dependencies(tester, repo):
repo.add_package(get_package("pytest", "3.6.0")) repo.add_package(get_package("pytest", "3.6.0"))
repo.add_package(get_package("pytest-requests", "0.2.0")) repo.add_package(get_package("pytest-requests", "0.2.0"))
command = app.find("init")
command._pool = poetry.pool
mocker.patch("poetry.utils._compat.Path.open")
p = mocker.patch("poetry.utils._compat.Path.cwd")
p.return_value = Path(__file__)
tester = CommandTester(command)
inputs = [ inputs = [
"my-package", # Package name "my-package", # Package name
"1.2.3", # Version "1.2.3", # Version
......
tests/console/commands/test_run.py
from cleo.testers import CommandTester import pytest
def test_run_passes_all_args(app, mocker, env): @pytest.fixture
def tester(command_tester_factory):
return command_tester_factory("run")
@pytest.fixture(autouse=True)
def patches(mocker, env):
mocker.patch("poetry.utils.env.EnvManager.get", return_value=env) mocker.patch("poetry.utils.env.EnvManager.get", return_value=env)
command = app.find("run")
tester = CommandTester(command)
def test_run_passes_all_args(tester, env):
tester.execute("python -V") tester.execute("python -V")
assert [["python", "-V"]] == env.executed assert [["python", "-V"]] == env.executed
tests/console/commands/test_search.py
from cleo.testers import CommandTester import pytest
from poetry.utils._compat import Path from poetry.utils._compat import Path
...@@ -9,15 +9,20 @@ FIXTURES_DIRECTORY = ( ...@@ -9,15 +9,20 @@ FIXTURES_DIRECTORY = (
) )
def test_search(app, http): @pytest.fixture(autouse=True)
def mock_search_http_response(http):
with FIXTURES_DIRECTORY.joinpath("search.html").open(encoding="utf-8") as f: with FIXTURES_DIRECTORY.joinpath("search.html").open(encoding="utf-8") as f:
search_results = f.read() http.register_uri("GET", "https://pypi.org/search", f.read())
http.register_uri("GET", "https://pypi.org/search", search_results)
command = app.find("search") @pytest.fixture
tester = CommandTester(command) def tester(command_tester_factory):
return command_tester_factory("search")
def test_search(
tester, http,
):
tester.execute("sqlalchemy") tester.execute("sqlalchemy")
expected = """ expected = """
......
tests/console/commands/test_version.py
import pytest import pytest
from cleo import CommandTester
from poetry.console.commands import VersionCommand from poetry.console.commands import VersionCommand
...@@ -10,6 +8,11 @@ def command(): ...@@ -10,6 +8,11 @@ def command():
return VersionCommand() return VersionCommand()
@pytest.fixture
def tester(command_tester_factory):
return command_tester_factory("version")
@pytest.mark.parametrize( @pytest.mark.parametrize(
"version, rule, expected", "version, rule, expected",
[ [
...@@ -40,15 +43,11 @@ def test_increment_version(version, rule, expected, command): ...@@ -40,15 +43,11 @@ def test_increment_version(version, rule, expected, command):
assert expected == command.increment_version(version, rule).text assert expected == command.increment_version(version, rule).text
def test_version_show(app): def test_version_show(tester):
command = app.find("version")
tester = CommandTester(command)
tester.execute() tester.execute()
assert "simple-project 1.2.3\n" == tester.io.fetch_output() assert "simple-project 1.2.3\n" == tester.io.fetch_output()
def test_short_version_show(app): def test_short_version_show(tester):
command = app.find("version")
tester = CommandTester(command)
tester.execute("--short") tester.execute("--short")
assert "1.2.3\n" == tester.io.fetch_output() assert "1.2.3\n" == tester.io.fetch_output()
tests/console/conftest.py
import os import os
import re
import pytest import pytest
from cleo import ApplicationTester from cleo import ApplicationTester
from poetry.console import Application as BaseApplication
from poetry.core.masonry.utils.helpers import escape_name
from poetry.core.masonry.utils.helpers import escape_version
from poetry.core.packages.utils.link import Link
from poetry.factory import Factory from poetry.factory import Factory
from poetry.installation.executor import Executor as BaseExecutor
from poetry.installation.noop_installer import NoopInstaller from poetry.installation.noop_installer import NoopInstaller
from poetry.io.null_io import NullIO from poetry.io.null_io import NullIO
from poetry.packages import Locker as BaseLocker
from poetry.poetry import Poetry as BasePoetry
from poetry.repositories import Pool from poetry.repositories import Pool
from poetry.repositories import Repository as BaseRepository
from poetry.repositories.exceptions import PackageNotFound
from poetry.utils._compat import Path from poetry.utils._compat import Path
from poetry.utils.env import MockEnv from poetry.utils.env import MockEnv
from poetry.utils.toml_file import TomlFile from tests.helpers import TestApplication
from tests.helpers import TestExecutor
from tests.helpers import TestLocker
from tests.helpers import mock_clone from tests.helpers import mock_clone
class Executor(BaseExecutor):
def __init__(self, *args, **kwargs):
super(Executor, self).__init__(*args, **kwargs)
self._installs = []
self._updates = []
self._uninstalls = []
@property
def installations(self):
return self._installs
@property
def updates(self):
return self._updates
@property
def removals(self):
return self._uninstalls
def _do_execute_operation(self, operation):
super(Executor, self)._do_execute_operation(operation)
if not operation.skipped:
getattr(self, "_{}s".format(operation.job_type)).append(operation.package)
def _execute_install(self, operation):
return 0
def _execute_update(self, operation):
return 0
def _execute_remove(self, operation):
return 0
@pytest.fixture() @pytest.fixture()
def installer(): def installer():
return NoopInstaller() return NoopInstaller()
@pytest.fixture @pytest.fixture
def installed():
return BaseRepository()
@pytest.fixture
def env(): def env():
return MockEnv(path=Path("/prefix"), base=Path("/base/prefix"), is_venv=True) return MockEnv(path=Path("/prefix"), base=Path("/base/prefix"), is_venv=True)
...@@ -114,98 +65,6 @@ def setup(mocker, installer, installed, config, env): ...@@ -114,98 +65,6 @@ def setup(mocker, installer, installed, config, env):
os.environ.update(environ) os.environ.update(environ)
class Application(BaseApplication):
def __init__(self, poetry):
super(Application, self).__init__()
self._poetry = poetry
def reset_poetry(self):
poetry = self._poetry
self._poetry = Factory().create_poetry(self._poetry.file.path.parent)
self._poetry.set_pool(poetry.pool)
self._poetry.set_config(poetry.config)
self._poetry.set_locker(
Locker(poetry.locker.lock.path, self._poetry.local_config)
)
class Locker(BaseLocker):
def __init__(self, lock, local_config):
self._lock = TomlFile(lock)
self._local_config = local_config
self._lock_data = None
self._content_hash = self._get_content_hash()
self._locked = False
self._lock_data = None
self._write = False
def write(self, write=True):
self._write = write
def is_locked(self):
return self._locked
def locked(self, is_locked=True):
self._locked = is_locked
return self
def mock_lock_data(self, data):
self.locked()
self._lock_data = data
def is_fresh(self):
return True
def _write_lock_data(self, data):
if self._write:
super(Locker, self)._write_lock_data(data)
self._locked = True
return
self._lock_data = data
class Poetry(BasePoetry):
def __init__(self, file, local_config, package, locker, config):
self._file = TomlFile(file)
self._package = package
self._local_config = local_config
self._locker = Locker(locker.lock.path, locker._local_config)
self._config = config
# Configure sources
self._pool = Pool()
class Repository(BaseRepository):
def find_packages(self, dependency):
packages = super(Repository, self).find_packages(dependency)
if len(packages) == 0:
raise PackageNotFound("Package [{}] not found.".format(dependency.name))
return packages
def find_links_for_package(self, package):
return [
Link(
"https://foo.bar/files/{}-{}-py2.py3-none-any.whl".format(
escape_name(package.name), escape_version(package.version.text)
)
)
]
@pytest.fixture
def repo(http):
http.register_uri(
http.GET, re.compile("^https?://foo.bar/(.+?)$"),
)
return Repository(name="foo")
@pytest.fixture @pytest.fixture
def project_directory(): def project_directory():
return "simple_project" return "simple_project"
...@@ -216,7 +75,7 @@ def poetry(repo, project_directory, config): ...@@ -216,7 +75,7 @@ def poetry(repo, project_directory, config):
p = Factory().create_poetry( p = Factory().create_poetry(
Path(__file__).parent.parent / "fixtures" / project_directory Path(__file__).parent.parent / "fixtures" / project_directory
) )
p.set_locker(Locker(p.locker.lock.path, p.locker._local_config)) p.set_locker(TestLocker(p.locker.lock.path, p.locker._local_config))
with p.file.path.open(encoding="utf-8") as f: with p.file.path.open(encoding="utf-8") as f:
content = f.read() content = f.read()
...@@ -235,7 +94,7 @@ def poetry(repo, project_directory, config): ...@@ -235,7 +94,7 @@ def poetry(repo, project_directory, config):
@pytest.fixture @pytest.fixture
def app(poetry): def app(poetry):
app_ = Application(poetry) app_ = TestApplication(poetry)
app_.config.set_terminate_after_run(False) app_.config.set_terminate_after_run(False)
return app_ return app_
...@@ -253,4 +112,4 @@ def new_installer_disabled(config): ...@@ -253,4 +112,4 @@ def new_installer_disabled(config):
@pytest.fixture() @pytest.fixture()
def executor(poetry, config, env): def executor(poetry, config, env):
return Executor(env, poetry.pool, config, NullIO()) return TestExecutor(env, poetry.pool, config, NullIO())
tests/helpers.py
import os import os
import shutil import shutil
from poetry.console import Application
from poetry.core.masonry.utils.helpers import escape_name
from poetry.core.masonry.utils.helpers import escape_version
from poetry.core.packages import Dependency from poetry.core.packages import Dependency
from poetry.core.packages import Link
from poetry.core.packages import Package from poetry.core.packages import Package
from poetry.core.vcs.git import ParsedUrl from poetry.core.vcs.git import ParsedUrl
from poetry.factory import Factory
from poetry.installation.executor import Executor
from poetry.packages import Locker
from poetry.repositories import Repository
from poetry.repositories.exceptions import PackageNotFound
from poetry.utils._compat import PY2 from poetry.utils._compat import PY2
from poetry.utils._compat import WINDOWS from poetry.utils._compat import WINDOWS
from poetry.utils._compat import Path from poetry.utils._compat import Path
from poetry.utils._compat import urlparse from poetry.utils._compat import urlparse
from poetry.utils.toml_file import TomlFile
FIXTURE_PATH = Path(__file__).parent / "fixtures" FIXTURE_PATH = Path(__file__).parent / "fixtures"
...@@ -88,3 +98,110 @@ def mock_download(url, dest, **__): ...@@ -88,3 +98,110 @@ def mock_download(url, dest, **__):
fixture = fixtures / parts.path.lstrip("/") fixture = fixtures / parts.path.lstrip("/")
copy_or_symlink(fixture, Path(dest)) copy_or_symlink(fixture, Path(dest))
class TestExecutor(Executor):
def __init__(self, *args, **kwargs):
super(TestExecutor, self).__init__(*args, **kwargs)
self._installs = []
self._updates = []
self._uninstalls = []
@property
def installations(self):
return self._installs
@property
def updates(self):
return self._updates
@property
def removals(self):
return self._uninstalls
def _do_execute_operation(self, operation):
super(TestExecutor, self)._do_execute_operation(operation)
if not operation.skipped:
getattr(self, "_{}s".format(operation.job_type)).append(operation.package)
def _execute_install(self, operation):
return 0
def _execute_update(self, operation):
return 0
def _execute_remove(self, operation):
return 0
class TestApplication(Application):
def __init__(self, poetry):
super(TestApplication, self).__init__()
self._poetry = poetry
def reset_poetry(self):
poetry = self._poetry
self._poetry = Factory().create_poetry(self._poetry.file.path.parent)
self._poetry.set_pool(poetry.pool)
self._poetry.set_config(poetry.config)
self._poetry.set_locker(
TestLocker(poetry.locker.lock.path, self._poetry.local_config)
)
class TestLocker(Locker):
def __init__(self, lock, local_config): # noqa
self._lock = TomlFile(lock)
self._local_config = local_config
self._lock_data = None
self._content_hash = self._get_content_hash()
self._locked = False
self._lock_data = None
self._write = False
def write(self, write=True):
self._write = write
def is_locked(self):
return self._locked
def locked(self, is_locked=True):
self._locked = is_locked
return self
def mock_lock_data(self, data):
self.locked()
self._lock_data = data
def is_fresh(self):
return True
def _write_lock_data(self, data):
if self._write:
super(TestLocker, self)._write_lock_data(data)
self._locked = True
return
self._lock_data = data
class TestRepository(Repository):
def find_packages(self, dependency):
packages = super(TestRepository, self).find_packages(dependency)
if len(packages) == 0:
raise PackageNotFound("Package [{}] not found.".format(dependency.name))
return packages
def find_links_for_package(self, package):
return [
Link(
"https://foo.bar/files/{}-{}-py2.py3-none-any.whl".format(
escape_name(package.name), escape_version(package.version.text)
)
)
]
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment