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.

tests/conftest.py

@@ -1,5 +1,7 @@
 import os
+import re
 import shutil
+import sys
 import tempfile
 
 from typing import Any
@@ -8,13 +10,25 @@
 import httpretty
 import pytest
 
+from cleo import CommandTester
+
 from poetry.config.config import Config as BaseConfig
 from poetry.config.dict_config_source import DictConfigSource
+from poetry.factory import Factory
 from poetry.inspection.info import PackageInfo
 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.env import EnvManager
+from poetry.utils.env import SystemEnv
 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_download
 
@@ -168,3 +182,130 @@ def tmp_venv(tmp_dir):
     yield venv
 
     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

@@ -1,13 +1,15 @@
-from cleo.testers import CommandTester
+import pytest
 
 from poetry.factory import Factory
 from tests.helpers import get_package
 
 
-def test_debug_resolve_gives_resolution_results(app, repo):
-    command = app.find("debug resolve")
-    tester = CommandTester(command)
+@pytest.fixture()
+def tester(command_tester_factory):
+    return command_tester_factory("debug resolve")
 
+
+def test_debug_resolve_gives_resolution_results(tester, repo):
     cachy2 = get_package("cachy", "0.2.0")
     cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
 
@@ -29,10 +31,7 @@ def test_debug_resolve_gives_resolution_results(app, repo):
     assert expected == tester.io.fetch_output()
 
 
-def test_debug_resolve_tree_option_gives_the_dependency_tree(app, repo):
-    command = app.find("debug resolve")
-    tester = CommandTester(command)
-
+def test_debug_resolve_tree_option_gives_the_dependency_tree(tester, repo):
     cachy2 = get_package("cachy", "0.2.0")
     cachy2.add_dependency(Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
 
@@ -54,13 +53,10 @@ def test_debug_resolve_tree_option_gives_the_dependency_tree(app, repo):
     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("cleo", "0.6.5"))
 
-    command = app.find("debug resolve")
-    tester = CommandTester(command)
-
     tester.execute("git+https://github.com/demo/demo.git")
 
     expected = """\

tests/console/commands/env/conftest.py

@@ -0,0 +1,51 @@
+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,0 +1,21 @@
+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

@@ -1,7 +1,5 @@
 import pytest
 
-from cleo.testers import CommandTester
-
 from poetry.utils._compat import Path
 from poetry.utils.env import MockEnv
 
@@ -16,10 +14,12 @@ def setup(mocker):
     )
 
 
-def test_env_info_displays_complete_info(app):
-    command = app.find("env info")
-    tester = CommandTester(command)
+@pytest.fixture
+def tester(command_tester_factory):
+    return command_tester_factory("env info")
+
 
+def test_env_info_displays_complete_info(tester):
     tester.execute()
 
     expected = """
@@ -40,12 +40,7 @@ def test_env_info_displays_complete_info(app):
     assert expected == tester.io.fetch_output()
 
 
-def test_env_info_displays_path_only(app):
-    command = app.find("env info")
-    tester = CommandTester(command)
-
+def test_env_info_displays_path_only(tester):
     tester.execute("--path")
-
     expected = str(Path("/prefix"))
-
     assert expected + "\n" == tester.io.fetch_output()