refactor(solver/provider/version_solver): move get_locked() from VersionSolver to Provider

21228d11 · Randy Döring · Bjorn Neergaard · cf213245 · 21228d11 · 21228d11
Commit 21228d11 authored Aug 20, 2022 by Randy Döring Committed by Bjorn Neergaard Aug 31, 2022
8 changed files
--- a/src/poetry/installation/installer.py
+++ b/src/poetry/installation/installer.py
@@ -22,6 +22,7 @@ if TYPE_CHECKING:
    from collections.abc import Iterable
    from cleo.io.io import IO
+    from packaging.utils import NormalizedName
    from poetry.core.packages.project_package import ProjectPackage
    from poetry.config.config import Config
@@ -59,7 +60,7 @@ class Installer:
        self._execute_operations = True
        self._lock = False
-        self._whitelist: list[str] = []
+        self._whitelist: list[NormalizedName] = []
        self._extras: list[str] = []

--- a/src/poetry/mixology/__init__.py
+++ b/src/poetry/mixology/__init__.py
@@ -9,16 +9,10 @@ if TYPE_CHECKING:
    from poetry.core.packages.project_package import ProjectPackage
    from poetry.mixology.result import SolverResult
-    from poetry.packages import DependencyPackage
    from poetry.puzzle.provider import Provider
-def resolve_version(
+def resolve_version(root: ProjectPackage, provider: Provider) -> SolverResult:
-    root: ProjectPackage,
+    solver = VersionSolver(root, provider)
-    provider: Provider,
-    locked: dict[str, list[DependencyPackage]] | None = None,
-    use_latest: list[str] | None = None,
-) -> SolverResult:
-    solver = VersionSolver(root, provider, locked=locked, use_latest=use_latest)
    return solver.solve()
--- a/src/poetry/mixology/version_solver.py
+++ b/src/poetry/mixology/version_solver.py
@@ -18,12 +18,12 @@ from poetry.mixology.partial_solution import PartialSolution
 from poetry.mixology.result import SolverResult
 from poetry.mixology.set_relation import SetRelation
 from poetry.mixology.term import Term
-from poetry.packages import DependencyPackage
 if TYPE_CHECKING:
    from poetry.core.packages.project_package import ProjectPackage
+    from poetry.packages import DependencyPackage
    from poetry.puzzle.provider import Provider
@@ -82,23 +82,10 @@ class VersionSolver:
    on how this solver works.
    """
-    def __init__(
+    def __init__(self, root: ProjectPackage, provider: Provider) -> None:
-        self,
-        root: ProjectPackage,
-        provider: Provider,
-        locked: dict[str, list[DependencyPackage]] | None = None,
-        use_latest: list[str] | None = None,
-    ) -> None:
        self._root = root
        self._provider = provider
        self._dependency_cache = DependencyCache(provider)
-        self._locked = locked or {}
-        if use_latest is None:
-            use_latest = []
-        self._use_latest = use_latest
        self._incompatibilities: dict[str, list[Incompatibility]] = {}
        self._contradicted_incompatibilities: set[Incompatibility] = set()
        self._solution = PartialSolution()
@@ -384,12 +371,12 @@ class VersionSolver:
            if dependency.is_direct_origin():
                return False, -1
-            if dependency.name in self._use_latest:
+            if dependency.name in self._provider.use_latest:
                # If we're forced to use the latest version of a package, it effectively
                # only has one version to choose from.
                return not dependency.marker.is_any(), 1
-            locked = self._get_locked(dependency)
+            locked = self._provider.get_locked(dependency)
            if locked:
                return not dependency.marker.is_any(), 1
@@ -406,7 +393,7 @@ class VersionSolver:
        else:
            dependency = min(*unsatisfied, key=_get_min)
-        locked = self._get_locked(dependency)
+        locked = self._provider.get_locked(dependency)
        if locked is None:
            try:
                packages = self._dependency_cache.search_for(dependency)
@@ -499,23 +486,5 @@ class VersionSolver:
                incompatibility
            )
-    def _get_locked(self, dependency: Dependency) -> DependencyPackage | None:
-        if dependency.name in self._use_latest:
-            return None
-        locked = self._locked.get(dependency.name, [])
-        for dependency_package in locked:
-            package = dependency_package.package
-            if (
-                # Locked dependencies are always without features.
-                # Thus, we can't use is_same_package_as() here because it compares
-                # the complete_name (including features).
-                dependency.name == package.name
-                and dependency.is_same_source_as(package)
-                and dependency.constraint.allows(package.version)
-            ):
-                return DependencyPackage(dependency, package)
-        return None
    def _log(self, text: str) -> None:
        self._provider.debug(text, self._solution.attempted_solutions)
--- a/src/poetry/puzzle/provider.py
+++ b/src/poetry/puzzle/provider.py
@@ -12,6 +12,7 @@ from collections import defaultdict
 from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING
+from typing import Collection
 from typing import cast
 from cleo.ui.progress_indicator import ProgressIndicator
@@ -42,6 +43,7 @@ if TYPE_CHECKING:
    from collections.abc import Iterator
    from cleo.io.io import IO
+    from packaging.utils import NormalizedName
    from poetry.core.packages.dependency import Dependency
    from poetry.core.packages.directory_dependency import DirectoryDependency
    from poetry.core.packages.file_dependency import FileDependency
@@ -127,6 +129,7 @@ class Provider:
        io: IO,
        *,
        installed: list[Package] | None = None,
+        locked: list[Package] | None = None,
    ) -> None:
        self._package = package
        self._pool = pool
@@ -140,11 +143,27 @@ class Provider:
        self._source_root: Path | None = None
        self._installed_packages = installed if installed is not None else []
        self._direct_origin_packages: dict[str, Package] = {}
+        self._locked: dict[NormalizedName, list[DependencyPackage]] = defaultdict(list)
+        self._use_latest: Collection[NormalizedName] = []
+        for package in locked or []:
+            self._locked[package.name].append(
+                DependencyPackage(package.to_dependency(), package)
+            )
+        for dependency_packages in self._locked.values():
+            dependency_packages.sort(
+                key=lambda p: p.package.version,
+                reverse=True,
+            )
    @property
    def pool(self) -> Pool:
        return self._pool
+    @property
+    def use_latest(self) -> Collection[NormalizedName]:
+        return self._use_latest
    def is_debugging(self) -> bool:
        return self._is_debugging
@@ -161,8 +180,9 @@ class Provider:
        original_source_root = self._source_root
        self._source_root = source_root
+        try:
            yield self
+        finally:
            self._source_root = original_source_root
    @contextmanager
@@ -172,11 +192,21 @@ class Provider:
        self._env = env
        self._python_constraint = Version.parse(env.marker_env["python_full_version"])
+        try:
            yield self
+        finally:
            self._env = None
            self._python_constraint = original_python_constraint
+    @contextmanager
+    def use_latest_for(self, names: Collection[NormalizedName]) -> Iterator[Provider]:
+        self._use_latest = names
+        try:
+            yield self
+        finally:
+            self._use_latest = []
    @staticmethod
    def validate_package_for_dependency(
        dependency: Dependency, package: Package
@@ -801,6 +831,24 @@ class Provider:
        return dependency_package
+    def get_locked(self, dependency: Dependency) -> DependencyPackage | None:
+        if dependency.name in self._use_latest:
+            return None
+        locked = self._locked.get(dependency.name, [])
+        for dependency_package in locked:
+            package = dependency_package.package
+            if (
+                # Locked dependencies are always without features.
+                # Thus, we can't use is_same_package_as() here because it compares
+                # the complete_name (including features).
+                dependency.name == package.name
+                and dependency.is_same_source_as(package)
+                and dependency.constraint.allows(package.version)
+            ):
+                return DependencyPackage(dependency, package)
+        return None
    def debug(self, message: str, depth: int = 0) -> None:
        if not (self._io.is_very_verbose() or self._io.is_debug()):
            return

--- a/src/poetry/puzzle/solver.py
+++ b/src/poetry/puzzle/solver.py
@@ -5,6 +5,7 @@ import time
 from collections import defaultdict
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
+from typing import Collection
 from typing import FrozenSet
 from typing import Tuple
 from typing import TypeVar
@@ -13,7 +14,6 @@ from poetry.core.packages.dependency_group import MAIN_GROUP
 from poetry.mixology import resolve_version
 from poetry.mixology.failure import SolveFailure
-from poetry.packages import DependencyPackage
 from poetry.puzzle.exceptions import OverrideNeeded
 from poetry.puzzle.exceptions import SolverProblemError
 from poetry.puzzle.provider import Indicator
@@ -24,10 +24,12 @@ if TYPE_CHECKING:
    from collections.abc import Iterator
    from cleo.io.io import IO
+    from packaging.utils import NormalizedName
    from poetry.core.packages.dependency import Dependency
    from poetry.core.packages.package import Package
    from poetry.core.packages.project_package import ProjectPackage
+    from poetry.packages import DependencyPackage
    from poetry.puzzle.transaction import Transaction
    from poetry.repositories import Pool
    from poetry.utils.env import Env
@@ -49,7 +51,7 @@ class Solver:
        self._io = io
        self._provider = Provider(
-            self._package, self._pool, self._io, installed=installed
+            self._package, self._pool, self._io, installed=installed, locked=locked
        )
        self._overrides: list[dict[DependencyPackage, dict[str, Dependency]]] = []
@@ -62,12 +64,14 @@ class Solver:
        with self.provider.use_environment(env):
            yield
-    def solve(self, use_latest: list[str] | None = None) -> Transaction:
+    def solve(
+        self, use_latest: Collection[NormalizedName] | None = None
+    ) -> Transaction:
        from poetry.puzzle.transaction import Transaction
-        with self._progress():
+        with self._progress(), self._provider.use_latest_for(use_latest or []):
            start = time.time()
-            packages, depths = self._solve(use_latest=use_latest)
+            packages, depths = self._solve()
            end = time.time()
            if len(self._overrides) > 1:
@@ -116,7 +120,6 @@ class Solver:
    def _solve_in_compatibility_mode(
        self,
        overrides: tuple[dict[DependencyPackage, dict[str, Dependency]], ...],
-        use_latest: list[str] | None = None,
    ) -> tuple[list[Package], list[int]]:
        packages = []
        depths = []
@@ -126,7 +129,7 @@ class Solver:
                f"with the following overrides ({override}).</comment>"
            )
            self._provider.set_overrides(override)
-            _packages, _depths = self._solve(use_latest=use_latest)
+            _packages, _depths = self._solve()
            for index, package in enumerate(_packages):
                if package not in packages:
                    packages.append(package)
@@ -143,31 +146,16 @@ class Solver:
        return packages, depths
-    def _solve(
+    def _solve(self) -> tuple[list[Package], list[int]]:
-        self, use_latest: list[str] | None = None
-    ) -> tuple[list[Package], list[int]]:
        if self._provider._overrides:
            self._overrides.append(self._provider._overrides)
-        locked: dict[str, list[DependencyPackage]] = defaultdict(list)
-        for package in self._locked_packages:
-            locked[package.name].append(
-                DependencyPackage(package.to_dependency(), package)
-            )
-        for dependency_packages in locked.values():
-            dependency_packages.sort(
-                key=lambda p: p.package.version,
-                reverse=True,
-            )
        try:
-            result = resolve_version(
+            result = resolve_version(self._package, self._provider)
-                self._package, self._provider, locked=locked, use_latest=use_latest
-            )
            packages = result.packages
        except OverrideNeeded as e:
-            return self._solve_in_compatibility_mode(e.overrides, use_latest=use_latest)
+            return self._solve_in_compatibility_mode(e.overrides)
        except SolveFailure as e:
            raise SolverProblemError(e)

--- a/tests/mixology/helpers.py
+++ b/tests/mixology/helpers.py
@@ -7,10 +7,11 @@ from poetry.core.packages.package import Package
 from poetry.factory import Factory
 from poetry.mixology.failure import SolveFailure
 from poetry.mixology.version_solver import VersionSolver
-from poetry.packages import DependencyPackage
 if TYPE_CHECKING:
+    from packaging.utils import NormalizedName
+    from poetry.core.factory import DependencyConstraint
    from poetry.core.packages.project_package import ProjectPackage
    from poetry.mixology import SolverResult
@@ -22,7 +23,7 @@ def add_to_repo(
    repository: Repository,
    name: str,
    version: str,
-    deps: dict[str, str] | None = None,
+    deps: dict[str, DependencyConstraint] | None = None,
    python: str | None = None,
    yanked: bool = False,
 ) -> None:
@@ -43,15 +44,10 @@ def check_solver_result(
    result: dict[str, str] | None = None,
    error: str | None = None,
    tries: int | None = None,
-    locked: dict[str, Package] | None = None,
+    use_latest: list[NormalizedName] | None = None,
-    use_latest: list[str] | None = None,
 ) -> SolverResult | None:
-    if locked is not None:
+    solver = VersionSolver(root, provider)
-        locked = {
+    with provider.use_latest_for(use_latest or []):
-            k: [DependencyPackage(l.to_dependency(), l)] for k, l in locked.items()
-        }
-    solver = VersionSolver(root, provider, locked=locked, use_latest=use_latest)
        try:
            solution = solver.solve()
        except SolveFailure as e:
@@ -63,11 +59,10 @@ def check_solver_result(
            return None
-        raise
        except AssertionError as e:
            if error:
                assert str(e) == error
-            return None
+                return
            raise
    packages = {}

--- a/tests/mixology/version_solver/test_with_lock.py
+++ b/tests/mixology/version_solver/test_with_lock.py
@@ -2,21 +2,25 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
+from cleo.io.null_io import NullIO
+from packaging.utils import canonicalize_name
 from poetry.factory import Factory
 from tests.helpers import get_package
 from tests.mixology.helpers import add_to_repo
 from tests.mixology.helpers import check_solver_result
+from tests.mixology.version_solver.conftest import Provider
 if TYPE_CHECKING:
    from poetry.core.packages.project_package import ProjectPackage
+    from poetry.repositories import Pool
    from poetry.repositories import Repository
-    from tests.mixology.version_solver.conftest import Provider
 def test_with_compatible_locked_dependencies(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "*"))
@@ -27,16 +31,18 @@ def test_with_compatible_locked_dependencies(
    add_to_repo(repo, "bar", "1.0.1")
    add_to_repo(repo, "bar", "1.0.2")
+    locked = [get_package("foo", "1.0.1"), get_package("bar", "1.0.1")]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
        result={"foo": "1.0.1", "bar": "1.0.1"},
-        locked={"foo": get_package("foo", "1.0.1"), "bar": get_package("bar", "1.0.1")},
    )
 def test_with_incompatible_locked_dependencies(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", ">1.0.1"))
@@ -47,16 +53,18 @@ def test_with_incompatible_locked_dependencies(
    add_to_repo(repo, "bar", "1.0.1")
    add_to_repo(repo, "bar", "1.0.2")
+    locked = [get_package("foo", "1.0.1"), get_package("bar", "1.0.1")]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
        result={"foo": "1.0.2", "bar": "1.0.2"},
-        locked={"foo": get_package("foo", "1.0.1"), "bar": get_package("bar", "1.0.1")},
    )
 def test_with_unrelated_locked_dependencies(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "*"))
@@ -68,16 +76,18 @@ def test_with_unrelated_locked_dependencies(
    add_to_repo(repo, "bar", "1.0.2")
    add_to_repo(repo, "baz", "1.0.0")
+    locked = [get_package("baz", "1.0.1")]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
        result={"foo": "1.0.2", "bar": "1.0.2"},
-        locked={"baz": get_package("baz", "1.0.1")},
    )
 def test_unlocks_dependencies_if_necessary_to_ensure_that_a_new_dependency_is_satisfied(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "*"))
    root.add_dependency(Factory.create_dependency("newdep", "2.0.0"))
@@ -92,6 +102,14 @@ def test_unlocks_dependencies_if_necessary_to_ensure_that_a_new_dependency_is_sa
    add_to_repo(repo, "qux", "2.0.0")
    add_to_repo(repo, "newdep", "2.0.0", deps={"baz": ">=1.5.0"})
+    locked = [
+        get_package("foo", "2.0.0"),
+        get_package("bar", "1.0.0"),
+        get_package("baz", "1.0.0"),
+        get_package("qux", "1.0.0"),
+    ]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
@@ -102,17 +120,11 @@ def test_unlocks_dependencies_if_necessary_to_ensure_that_a_new_dependency_is_sa
            "qux": "1.0.0",
            "newdep": "2.0.0",
        },
-        locked={
-            "foo": get_package("foo", "2.0.0"),
-            "bar": get_package("bar", "1.0.0"),
-            "baz": get_package("baz", "1.0.0"),
-            "qux": get_package("qux", "1.0.0"),
-        },
    )
 def test_with_compatible_locked_dependencies_use_latest(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "*"))
    root.add_dependency(Factory.create_dependency("baz", "*"))
@@ -126,21 +138,23 @@ def test_with_compatible_locked_dependencies_use_latest(
    add_to_repo(repo, "baz", "1.0.0")
    add_to_repo(repo, "baz", "1.0.1")
+    locked = [
+        get_package("foo", "1.0.1"),
+        get_package("bar", "1.0.1"),
+        get_package("baz", "1.0.0"),
+    ]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
        result={"foo": "1.0.2", "bar": "1.0.2", "baz": "1.0.0"},
-        locked={
+        use_latest=[canonicalize_name("foo")],
-            "foo": get_package("foo", "1.0.1"),
-            "bar": get_package("bar", "1.0.1"),
-            "baz": get_package("baz", "1.0.0"),
-        },
-        use_latest=["foo"],
    )
 def test_with_compatible_locked_dependencies_with_extras(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "^1.0"))
@@ -159,20 +173,22 @@ def test_with_compatible_locked_dependencies_with_extras(
    add_to_repo(repo, "baz", "1.0.0")
    add_to_repo(repo, "baz", "1.0.1")
+    locked = [
+        get_package("foo", "1.0.0"),
+        get_package("bar", "1.0.0"),
+        get_package("baz", "1.0.0"),
+    ]
+    provider = Provider(root, pool, NullIO(), locked=locked)
    check_solver_result(
        root,
        provider,
        result={"foo": "1.0.0", "bar": "1.0.0", "baz": "1.0.0"},
-        locked={
-            "foo": get_package("foo", "1.0.0"),
-            "bar": get_package("bar", "1.0.0"),
-            "baz": get_package("baz", "1.0.0"),
-        },
    )
 def test_with_yanked_package_in_lock(
-    root: ProjectPackage, provider: Provider, repo: Repository
+    root: ProjectPackage, repo: Repository, pool: Pool
 ):
    root.add_dependency(Factory.create_dependency("foo", "*"))
@@ -182,16 +198,17 @@ def test_with_yanked_package_in_lock(
    # yanked version is kept in lock file
    locked_foo = get_package("foo", "2")
    assert not locked_foo.yanked
+    provider = Provider(root, pool, NullIO(), locked=[locked_foo])
    result = check_solver_result(
        root,
        provider,
        result={"foo": "2"},
-        locked={"foo": locked_foo},
    )
    foo = result.packages[0]
    assert foo.yanked
    # without considering the lock file, the other version is chosen
+    provider = Provider(root, pool, NullIO())
    check_solver_result(
        root,
        provider,

--- a/tests/puzzle/test_solver.py
+++ b/tests/puzzle/test_solver.py
@@ -8,6 +8,7 @@ import pytest
 from cleo.io.buffered_io import BufferedIO
 from cleo.io.null_io import NullIO
+from packaging.utils import canonicalize_name
 from poetry.core.packages.dependency import Dependency
 from poetry.core.packages.package import Package
 from poetry.core.packages.project_package import ProjectPackage
@@ -18,7 +19,6 @@ from poetry.factory import Factory
 from poetry.packages import DependencyPackage
 from poetry.puzzle import Solver
 from poetry.puzzle.exceptions import SolverProblemError
-from poetry.repositories.installed_repository import InstalledRepository
 from poetry.repositories.pool import Pool
 from poetry.repositories.repository import Repository
 from poetry.utils.env import MockEnv
@@ -60,16 +60,6 @@ def package() -> ProjectPackage:
 @pytest.fixture()
-def installed() -> InstalledRepository:
-    return InstalledRepository()
-@pytest.fixture()
-def locked() -> Repository:
-    return Repository("locked")
-@pytest.fixture()
 def repo() -> Repository:
    return Repository("repo")
@@ -80,14 +70,8 @@ def pool(repo: Repository) -> Pool:
 @pytest.fixture()
-def solver(
+def solver(package: ProjectPackage, pool: Pool, io: NullIO) -> Solver:
-    package: ProjectPackage,
+    return Solver(package, pool, [], [], io)
-    pool: Pool,
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
-) -> Solver:
-    return Solver(package, pool, installed.packages, locked.packages, io)
 def check_solver_result(
@@ -131,32 +115,30 @@ def test_solver_install_single(
    package_a = get_package("A", "1.0")
    repo.add_package(package_a)
-    transaction = solver.solve([get_dependency("A")])
+    transaction = solver.solve([get_dependency("A").name])
    check_solver_result(transaction, [{"job": "install", "package": package_a}])
 def test_solver_remove_if_no_longer_locked(
-    solver: Solver, locked: Repository, installed: InstalledRepository
+    package: ProjectPackage, pool: Pool, io: NullIO
 ):
    package_a = get_package("A", "1.0")
-    installed.add_package(package_a)
-    locked.add_package(package_a)
+    solver = Solver(package, pool, [package_a], [package_a], io)
    transaction = solver.solve()
    check_solver_result(transaction, [{"job": "remove", "package": package_a}])
-def test_remove_non_installed(solver: Solver, repo: Repository, locked: Repository):
+def test_remove_non_installed(
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
+):
    package_a = get_package("A", "1.0")
-    locked.add_package(package_a)
    repo.add_package(package_a)
-    request = []
+    solver = Solver(package, pool, [], [package_a], io)
+    transaction = solver.solve([])
-    transaction = solver.solve(request)
    check_solver_result(transaction, [])
@@ -174,10 +156,7 @@ def test_install_non_existing_package_fail(
 def test_install_unpublished_package_does_not_fail(
-    installed: InstalledRepository,
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
-    solver: Solver,
-    repo: Repository,
-    package: ProjectPackage,
 ):
    package.add_dependency(Factory.create_dependency("B", "1"))
@@ -186,8 +165,8 @@ def test_install_unpublished_package_does_not_fail(
    package_b.add_dependency(Factory.create_dependency("A", "1.0"))
    repo.add_package(package_a)
-    installed.add_package(package_b)
+    solver = Solver(package, pool, [package_b], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -289,17 +268,14 @@ def test_install_with_deps_in_order(
 def test_install_installed(
-    solver: Solver,
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
-    repo: Repository,
-    installed: InstalledRepository,
-    package: ProjectPackage,
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
    package_a = get_package("A", "1.0")
-    installed.add_package(package_a)
    repo.add_package(package_a)
+    solver = Solver(package, pool, [package_a], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -308,20 +284,16 @@ def test_install_installed(
 def test_update_installed(
-    solver: Solver,
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
-    repo: Repository,
-    installed: InstalledRepository,
-    package: ProjectPackage,
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
-    installed.add_package(get_package("A", "1.0"))
    package_a = get_package("A", "1.0")
    new_package_a = get_package("A", "1.1")
    repo.add_package(package_a)
    repo.add_package(new_package_a)
+    solver = Solver(package, pool, [get_package("A", "1.0")], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -330,17 +302,11 @@ def test_update_installed(
 def test_update_with_use_latest(
-    solver: Solver,
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
-    repo: Repository,
-    installed: InstalledRepository,
-    package: ProjectPackage,
-    locked: Repository,
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
    package.add_dependency(Factory.create_dependency("B", "*"))
-    installed.add_package(get_package("A", "1.0"))
    package_a = get_package("A", "1.0")
    new_package_a = get_package("A", "1.1")
    package_b = get_package("B", "1.0")
@@ -350,9 +316,10 @@ def test_update_with_use_latest(
    repo.add_package(package_b)
    repo.add_package(new_package_b)
-    locked.add_package(package_a)
+    installed = [get_package("A", "1.0")]
-    locked.add_package(package_b)
+    locked = [package_a, package_b]
+    solver = Solver(package, pool, installed, locked, io)
    transaction = solver.solve(use_latest=[package_b.name])
    check_solver_result(
@@ -977,7 +944,7 @@ def test_solver_sub_dependencies_with_requirements_complex(
 def test_solver_sub_dependencies_with_not_supported_python_version(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "^3.5")
    package.add_dependency(Factory.create_dependency("A", "*"))
@@ -999,7 +966,7 @@ def test_solver_sub_dependencies_with_not_supported_python_version(
 def test_solver_sub_dependencies_with_not_supported_python_version_transitive(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "^3.4")
@@ -1043,7 +1010,7 @@ def test_solver_sub_dependencies_with_not_supported_python_version_transitive(
 def test_solver_with_dependency_in_both_main_and_dev_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "^3.5")
    package.add_dependency(Factory.create_dependency("A", "*"))
@@ -1096,7 +1063,7 @@ def test_solver_with_dependency_in_both_main_and_dev_dependencies(
 def test_solver_with_dependency_in_both_main_and_dev_dependencies_with_one_more_dependent(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
    package.add_dependency(Factory.create_dependency("E", "*"))
@@ -1336,7 +1303,7 @@ def test_solver_duplicate_dependencies_different_constraints(
 def test_solver_duplicate_dependencies_different_constraints_same_requirements(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
@@ -1363,7 +1330,7 @@ So, because no versions of a match !=1.0
 def test_solver_duplicate_dependencies_different_constraints_merge_by_marker(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
@@ -1400,7 +1367,7 @@ def test_solver_duplicate_dependencies_different_constraints_merge_by_marker(
 def test_solver_duplicate_dependencies_different_sources_types_are_preserved(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    pendulum = get_package("pendulum", "2.0.3")
    repo.add_package(pendulum)
@@ -1461,7 +1428,7 @@ def test_solver_duplicate_dependencies_different_sources_types_are_preserved(
 def test_solver_duplicate_dependencies_different_constraints_merge_no_markers(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
    package.add_dependency(Factory.create_dependency("B", "1.0"))
@@ -1504,7 +1471,7 @@ def test_solver_duplicate_dependencies_different_constraints_merge_no_markers(
 def test_solver_duplicate_dependencies_ignore_overrides_with_empty_marker_intersection(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    """
    Distinct requirements per marker:
@@ -1575,7 +1542,7 @@ def test_solver_duplicate_dependencies_ignore_overrides_with_empty_marker_inters
 def test_solver_duplicate_dependencies_ignore_overrides_with_empty_marker_intersection2(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    """
    Empty intersection between top level dependency and transient dependency.
@@ -1729,7 +1696,7 @@ def test_solver_fails_if_dependency_name_does_not_match_package(
 def test_solver_does_not_get_stuck_in_recursion_on_circular_dependency(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package_a = get_package("A", "1.0")
    package_a.add_dependency(Factory.create_dependency("B", "^1.0"))
@@ -1832,7 +1799,7 @@ def test_solver_can_resolve_git_dependencies_with_extras(
    ids=["branch", "tag", "rev"],
 )
 def test_solver_can_resolve_git_dependencies_with_ref(
-    solver: Solver, repo: Repository, package: Package, ref: dict[str, str]
+    solver: Solver, repo: Repository, package: ProjectPackage, ref: dict[str, str]
 ):
    pendulum = get_package("pendulum", "2.0.3")
    cleo = get_package("cleo", "1.0.0")
@@ -1867,7 +1834,7 @@ def test_solver_can_resolve_git_dependencies_with_ref(
 def test_solver_does_not_trigger_conflict_for_python_constraint_if_python_requirement_is_compatible(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.4")
    package.add_dependency(
@@ -1885,7 +1852,7 @@ def test_solver_does_not_trigger_conflict_for_python_constraint_if_python_requir
 def test_solver_does_not_trigger_conflict_for_python_constraint_if_python_requirement_is_compatible_multiple(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.4")
    package.add_dependency(
@@ -1917,7 +1884,7 @@ def test_solver_does_not_trigger_conflict_for_python_constraint_if_python_requir
 def test_solver_triggers_conflict_for_dependency_python_not_fully_compatible_with_package_python(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.4")
    package.add_dependency(
@@ -1934,7 +1901,7 @@ def test_solver_triggers_conflict_for_dependency_python_not_fully_compatible_wit
 def test_solver_finds_compatible_package_for_dependency_python_not_fully_compatible_with_package_python(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.4")
    package.add_dependency(
@@ -1956,7 +1923,7 @@ def test_solver_finds_compatible_package_for_dependency_python_not_fully_compati
 def test_solver_does_not_trigger_new_resolution_on_duplicate_dependencies_if_only_extras(  # noqa: E501
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    dep1 = Dependency.create_from_pep_508('B (>=1.0); extra == "foo"')
    dep1.activate()
@@ -1994,7 +1961,7 @@ def test_solver_does_not_trigger_new_resolution_on_duplicate_dependencies_if_onl
 def test_solver_does_not_raise_conflict_for_locked_conditional_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.4")
    package.add_dependency(
@@ -2026,7 +1993,7 @@ def test_solver_does_not_raise_conflict_for_locked_conditional_dependencies(
 def test_solver_returns_extras_if_requested_in_dependencies_and_not_in_root_package(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "*"))
    package.add_dependency(Factory.create_dependency("B", "*"))
@@ -2065,7 +2032,7 @@ def test_solver_returns_extras_if_requested_in_dependencies_and_not_in_root_pack
 def test_solver_should_not_resolve_prerelease_version_if_not_requested(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.add_dependency(Factory.create_dependency("A", "~1.8.0"))
    package.add_dependency(Factory.create_dependency("B", "^0.5.0"))
@@ -2084,7 +2051,7 @@ def test_solver_should_not_resolve_prerelease_version_if_not_requested(
 def test_solver_ignores_dependencies_with_incompatible_python_full_version_marker(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "^3.6")
    package.add_dependency(Factory.create_dependency("A", "^1.0"))
@@ -2117,7 +2084,7 @@ def test_solver_ignores_dependencies_with_incompatible_python_full_version_marke
 def test_solver_git_dependencies_update(
-    solver: Solver, repo: Repository, package: Package, installed: InstalledRepository
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
 ):
    pendulum = get_package("pendulum", "2.0.3")
    cleo = get_package("cleo", "1.0.0")
@@ -2140,12 +2107,12 @@ def test_solver_git_dependencies_update(
        source_reference=DEFAULT_SOURCE_REF,
        source_resolved_reference=MOCK_DEFAULT_GIT_REVISION,
    )
-    installed.add_package(demo_installed)
    package.add_dependency(
        Factory.create_dependency("demo", {"git": "https://github.com/demo/demo.git"})
    )
+    solver = Solver(package, pool, [demo_installed], [], io)
    transaction = solver.solve()
    ops = check_solver_result(
@@ -2166,7 +2133,7 @@ def test_solver_git_dependencies_update(
 def test_solver_git_dependencies_update_skipped(
-    solver: Solver, repo: Repository, package: Package, installed: InstalledRepository
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
 ):
    pendulum = get_package("pendulum", "2.0.3")
    cleo = get_package("cleo", "1.0.0")
@@ -2181,12 +2148,12 @@ def test_solver_git_dependencies_update_skipped(
        source_reference="master",
        source_resolved_reference=MOCK_DEFAULT_GIT_REVISION,
    )
-    installed.add_package(demo)
    package.add_dependency(
        Factory.create_dependency("demo", {"git": "https://github.com/demo/demo.git"})
    )
+    solver = Solver(package, pool, [demo], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -2199,7 +2166,7 @@ def test_solver_git_dependencies_update_skipped(
 def test_solver_git_dependencies_short_hash_update_skipped(
-    solver: Solver, repo: Repository, package: Package, installed: InstalledRepository
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
 ):
    pendulum = get_package("pendulum", "2.0.3")
    cleo = get_package("cleo", "1.0.0")
@@ -2214,7 +2181,6 @@ def test_solver_git_dependencies_short_hash_update_skipped(
        source_reference=MOCK_DEFAULT_GIT_REVISION,
        source_resolved_reference=MOCK_DEFAULT_GIT_REVISION,
    )
-    installed.add_package(demo)
    package.add_dependency(
        Factory.create_dependency(
@@ -2222,6 +2188,7 @@ def test_solver_git_dependencies_short_hash_update_skipped(
        )
    )
+    solver = Solver(package, pool, [demo], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -2281,15 +2248,13 @@ def test_solver_can_resolve_directory_dependencies(
 def test_solver_can_resolve_directory_dependencies_nested_editable(
    repo: Repository,
    pool: Pool,
-    installed: InstalledRepository,
-    locked: Repository,
    io: NullIO,
 ):
    base = Path(__file__).parent.parent / "fixtures" / "project_with_nested_local"
    poetry = Factory().create_poetry(cwd=base)
    package = poetry.package
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2521,15 +2486,12 @@ def test_solver_can_resolve_wheel_dependencies_with_extras(
 def test_solver_can_solve_with_legacy_repository_using_proper_dists(
-    package: ProjectPackage,
+    package: ProjectPackage, io: NullIO
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
 ):
    repo = MockLegacyRepository()
    pool = Pool([repo])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    package.add_dependency(Factory.create_dependency("isort", "4.3.4"))
@@ -2567,8 +2529,6 @@ def test_solver_can_solve_with_legacy_repository_using_proper_dists(
 def test_solver_can_solve_with_legacy_repository_using_proper_python_compatible_dists(
    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
    io: NullIO,
 ):
    package.python_versions = "^3.7"
@@ -2576,7 +2536,7 @@ def test_solver_can_solve_with_legacy_repository_using_proper_python_compatible_
    repo = MockLegacyRepository()
    pool = Pool([repo])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    package.add_dependency(Factory.create_dependency("isort", "4.3.4"))
@@ -2599,18 +2559,13 @@ def test_solver_can_solve_with_legacy_repository_using_proper_python_compatible_
    )
-def test_solver_skips_invalid_versions(
+def test_solver_skips_invalid_versions(package: ProjectPackage, io: NullIO):
-    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
-):
    package.python_versions = "^3.7"
    repo = MockPyPIRepository()
    pool = Pool([repo])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    package.add_dependency(Factory.create_dependency("trackpy", "^0.4"))
@@ -2646,10 +2601,7 @@ def test_multiple_constraints_on_root(
 def test_solver_chooses_most_recent_version_amongst_repositories(
-    package: ProjectPackage,
+    package: ProjectPackage, io: NullIO
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
 ):
    package.python_versions = "^3.7"
    package.add_dependency(Factory.create_dependency("tomlkit", {"version": "^0.5"}))
@@ -2657,7 +2609,7 @@ def test_solver_chooses_most_recent_version_amongst_repositories(
    repo = MockLegacyRepository()
    pool = Pool([repo, MockPyPIRepository()])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2670,10 +2622,7 @@ def test_solver_chooses_most_recent_version_amongst_repositories(
 def test_solver_chooses_from_correct_repository_if_forced(
-    package: ProjectPackage,
+    package: ProjectPackage, io: NullIO
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
 ):
    package.python_versions = "^3.7"
    package.add_dependency(
@@ -2683,7 +2632,7 @@ def test_solver_chooses_from_correct_repository_if_forced(
    repo = MockLegacyRepository()
    pool = Pool([repo, MockPyPIRepository()])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2708,8 +2657,6 @@ def test_solver_chooses_from_correct_repository_if_forced(
 def test_solver_chooses_from_correct_repository_if_forced_and_transitive_dependency(
    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
    io: NullIO,
 ):
    package.python_versions = "^3.7"
@@ -2724,7 +2671,7 @@ def test_solver_chooses_from_correct_repository_if_forced_and_transitive_depende
    repo.add_package(foo)
    pool = Pool([MockLegacyRepository(), repo, MockPyPIRepository()])
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2752,10 +2699,7 @@ def test_solver_chooses_from_correct_repository_if_forced_and_transitive_depende
 def test_solver_does_not_choose_from_secondary_repository_by_default(
-    package: ProjectPackage,
+    package: ProjectPackage, io: NullIO
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
 ):
    package.python_versions = "^3.7"
    package.add_dependency(Factory.create_dependency("clikit", {"version": "^0.2.0"}))
@@ -2764,7 +2708,7 @@ def test_solver_does_not_choose_from_secondary_repository_by_default(
    pool.add_repository(MockPyPIRepository(), secondary=True)
    pool.add_repository(MockLegacyRepository())
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2803,8 +2747,6 @@ def test_solver_does_not_choose_from_secondary_repository_by_default(
 def test_solver_chooses_from_secondary_if_explicit(
    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
    io: NullIO,
 ):
    package.python_versions = "^3.7"
@@ -2816,7 +2758,7 @@ def test_solver_chooses_from_secondary_if_explicit(
    pool.add_repository(MockPyPIRepository(), secondary=True)
    pool.add_repository(MockLegacyRepository())
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2847,11 +2789,9 @@ def test_solver_chooses_from_secondary_if_explicit(
 def test_solver_discards_packages_with_empty_markers(
    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
-    pool: Pool,
    repo: Repository,
+    pool: Pool,
+    io: NullIO,
 ):
    package.python_versions = "~2.7 || ^3.4"
    package.add_dependency(
@@ -2873,7 +2813,7 @@ def test_solver_discards_packages_with_empty_markers(
    repo.add_package(package_b)
    repo.add_package(package_c)
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
@@ -2887,7 +2827,7 @@ def test_solver_discards_packages_with_empty_markers(
 def test_solver_does_not_raise_conflict_for_conditional_dev_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.5")
    package.add_dependency(
@@ -2919,7 +2859,7 @@ def test_solver_does_not_raise_conflict_for_conditional_dev_dependencies(
 def test_solver_does_not_loop_indefinitely_on_duplicate_constraints_with_extras(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.5")
    package.add_dependency(
@@ -2950,11 +2890,9 @@ def test_solver_does_not_loop_indefinitely_on_duplicate_constraints_with_extras(
 def test_solver_does_not_fail_with_locked_git_and_non_git_dependencies(
+    package: ProjectPackage,
    repo: Repository,
-    package: Package,
-    locked: Repository,
    pool: Pool,
-    installed: InstalledRepository,
    io: NullIO,
 ):
    package.add_dependency(
@@ -2971,16 +2909,13 @@ def test_solver_does_not_fail_with_locked_git_and_non_git_dependencies(
        source_resolved_reference=MOCK_DEFAULT_GIT_REVISION,
    )
-    installed.add_package(git_package)
-    locked.add_package(get_package("a", "1.2.3"))
-    locked.add_package(git_package)
    repo.add_package(get_package("a", "1.2.3"))
    repo.add_package(Package("pendulum", "2.1.2"))
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    installed = [git_package]
+    locked = [get_package("a", "1.2.3"), git_package]
+    solver = Solver(package, pool, installed, locked, io)
    transaction = solver.solve()
    check_solver_result(
@@ -3018,7 +2953,7 @@ def test_ignore_python_constraint_no_overlap_dependencies(
 def test_solver_should_not_go_into_an_infinite_loop_on_duplicate_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.5")
    package.add_dependency(Factory.create_dependency("A", "^1.0"))
@@ -3050,17 +2985,10 @@ def test_solver_should_not_go_into_an_infinite_loop_on_duplicate_dependencies(
    )
-def test_solver_synchronize_single(
+def test_solver_synchronize_single(package: ProjectPackage, pool: Pool, io: NullIO):
-    package: ProjectPackage,
-    pool: Pool,
-    installed: InstalledRepository,
-    locked: Repository,
-    io: NullIO,
-):
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
    package_a = get_package("a", "1.0")
-    installed.add_package(package_a)
+    solver = Solver(package, pool, [package_a], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -3072,21 +3000,18 @@ def test_solver_synchronize_single(
 def test_solver_with_synchronization_keeps_critical_package(
    package: ProjectPackage,
    pool: Pool,
-    installed: InstalledRepository,
-    locked: Repository,
    io: NullIO,
 ):
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
    package_pip = get_package("setuptools", "1.0")
-    installed.add_package(package_pip)
+    solver = Solver(package, pool, [package_pip], [], io)
    transaction = solver.solve()
    check_solver_result(transaction, [])
 def test_solver_cannot_choose_another_version_for_directory_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    pendulum = get_package("pendulum", "2.0.3")
    demo = get_package("demo", "0.1.0")
@@ -3115,7 +3040,7 @@ def test_solver_cannot_choose_another_version_for_directory_dependencies(
 def test_solver_cannot_choose_another_version_for_file_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    pendulum = get_package("pendulum", "2.0.3")
    demo = get_package("demo", "0.0.8")
@@ -3142,7 +3067,7 @@ def test_solver_cannot_choose_another_version_for_file_dependencies(
 def test_solver_cannot_choose_another_version_for_git_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    pendulum = get_package("pendulum", "2.0.3")
    demo = get_package("demo", "0.0.8")
@@ -3166,7 +3091,7 @@ def test_solver_cannot_choose_another_version_for_git_dependencies(
 def test_solver_cannot_choose_another_version_for_url_dependencies(
    solver: Solver,
    repo: Repository,
-    package: Package,
+    package: ProjectPackage,
    http: type[httpretty.httpretty],
 ):
    path = (
@@ -3205,7 +3130,7 @@ def test_solver_cannot_choose_another_version_for_url_dependencies(
 def test_solver_should_not_update_same_version_packages_if_installed_has_no_source_type(
-    solver: Solver, repo: Repository, package: Package, installed: InstalledRepository
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
 ):
    package.add_dependency(Factory.create_dependency("foo", "1.0.0"))
@@ -3217,8 +3142,8 @@ def test_solver_should_not_update_same_version_packages_if_installed_has_no_sour
        source_reference="custom",
    )
    repo.add_package(foo)
-    installed.add_package(get_package("foo", "1.0.0"))
+    solver = Solver(package, pool, [get_package("foo", "1.0.0")], [], io)
    transaction = solver.solve()
    check_solver_result(
@@ -3227,7 +3152,7 @@ def test_solver_should_not_update_same_version_packages_if_installed_has_no_sour
 def test_solver_should_use_the_python_constraint_from_the_environment_if_available(
-    solver: Solver, repo: Repository, package: Package, installed: InstalledRepository
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    set_package_python_versions(solver.provider, "~2.7 || ^3.5")
    package.add_dependency(Factory.create_dependency("A", "^1.0"))
@@ -3254,7 +3179,7 @@ def test_solver_should_use_the_python_constraint_from_the_environment_if_availab
 def test_solver_should_resolve_all_versions_for_multiple_duplicate_dependencies(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.python_versions = "~2.7 || ^3.5"
    package.add_dependency(
@@ -3302,7 +3227,7 @@ def test_solver_should_resolve_all_versions_for_multiple_duplicate_dependencies(
 def test_solver_should_not_raise_errors_for_irrelevant_python_constraints(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.python_versions = "^3.6"
    set_package_python_versions(solver.provider, "^3.6")
@@ -3395,7 +3320,7 @@ def test_solver_can_resolve_for_packages_with_missing_extras(
 def test_solver_can_resolve_python_restricted_package_dependencies(
-    solver: Solver, repo: Repository, package: Package, locked: Repository
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
 ):
    package.add_dependency(
        Factory.create_dependency("futures", {"version": "^3.3.0", "python": "~2.7"})
@@ -3410,13 +3335,11 @@ def test_solver_can_resolve_python_restricted_package_dependencies(
    pre_commit = Package("pre-commit", "2.7.1")
    pre_commit.python_versions = ">=3.6.1"
-    locked.add_package(futures)
-    locked.add_package(pre_commit)
    repo.add_package(futures)
    repo.add_package(pre_commit)
-    transaction = solver.solve(use_latest=["pre-commit"])
+    solver = Solver(package, pool, [], [futures, pre_commit], io)
+    transaction = solver.solve(use_latest=[canonicalize_name("pre-commit")])
    check_solver_result(
        transaction,
@@ -3428,7 +3351,7 @@ def test_solver_can_resolve_python_restricted_package_dependencies(
 def test_solver_should_not_raise_errors_for_irrelevant_transitive_python_constraints(
-    solver: Solver, repo: Repository, package: Package
+    solver: Solver, repo: Repository, package: ProjectPackage
 ):
    package.python_versions = "~2.7 || ^3.5"
    set_package_python_versions(solver.provider, "~2.7 || ^3.5")
@@ -3479,13 +3402,12 @@ def test_solver_should_not_raise_errors_for_irrelevant_transitive_python_constra
 @pytest.mark.parametrize("is_locked", [False, True])
 def test_solver_keeps_multiple_locked_dependencies_for_same_package(
-    solver: Solver,
+    package: ProjectPackage,
    repo: Repository,
-    package: Package,
+    pool: Pool,
-    locked: Repository,
+    io: NullIO,
    is_locked: bool,
 ):
-    set_package_python_versions(solver.provider, "^3.6")
    package.add_dependency(
        Factory.create_dependency("A", {"version": "~1.1", "python": "<3.7"})
    )
@@ -3511,13 +3433,14 @@ def test_solver_keeps_multiple_locked_dependencies_for_same_package(
    if is_locked:
        a11_locked = a11.clone()
        a11_locked.python_versions = "<3.7"
-        locked.add_package(a11_locked)
        a12_locked = a12.clone()
        a12_locked.python_versions = ">=3.7"
-        locked.add_package(a12_locked)
+        locked = [a11_locked, a12_locked, b03.clone(), b04.clone()]
-        locked.add_package(b03.clone())
+    else:
-        locked.add_package(b04.clone())
+        locked = []
+    solver = Solver(package, pool, [], locked, io)
+    set_package_python_versions(solver.provider, "^3.6")
    transaction = solver.solve()
    check_solver_result(
@@ -3636,21 +3559,14 @@ def test_solver_incompatible_dependency_with_and_without_extras(
 def test_update_with_prerelease_and_no_solution(
-    solver: Solver,
+    package: ProjectPackage, repo: Repository, pool: Pool, io: NullIO
-    repo: Repository,
-    installed: InstalledRepository,
-    package: ProjectPackage,
-    locked: Repository,
 ):
    # Locked and installed: cleo which depends on an old version of crashtest.
    cleo = get_package("cleo", "1.0.0a5")
    crashtest = get_package("crashtest", "0.3.0")
    cleo.add_dependency(Factory.create_dependency("crashtest", {"version": "<0.4.0"}))
-    locked.add_package(cleo)
+    installed = [cleo, crashtest]
-    locked.add_package(crashtest)
+    locked = [cleo, crashtest]
-    installed.add_package(cleo)
-    installed.add_package(crashtest)
    # Try to upgrade to a new version of crashtest, this will be disallowed by the
    # dependency from cleo.
@@ -3664,14 +3580,14 @@ def test_update_with_prerelease_and_no_solution(
    repo.add_package(newer_crashtest)
    repo.add_package(even_newer_crashtest)
+    solver = Solver(package, pool, installed, locked, io)
    with pytest.raises(SolverProblemError):
        solver.solve()
 def test_solver_yanked_warning(
    package: ProjectPackage,
-    installed: InstalledRepository,
-    locked: Repository,
    pool: Pool,
    repo: Repository,
 ) -> None:
@@ -3686,7 +3602,7 @@ def test_solver_yanked_warning(
    repo.add_package(baz)
    io = BufferedIO(decorated=False)
-    solver = Solver(package, pool, installed.packages, locked.packages, io)
+    solver = Solver(package, pool, [], [], io)
    transaction = solver.solve()
    check_solver_result(