def test_self_update_does_not_update_non_recommended_installation(
tester: CommandTester,
http: type[httpretty.httpretty],
mocker: MockerFixture,
environ: None,
tmp_venv: VirtualEnv,
):
mocker.patch.object(EnvManager, "get_system_env", return_value=tmp_venv)
command = tester.command
new_version = Version.parse(__version__).next_minor().text
old_poetry = Package("poetry", __version__)
old_poetry.add_dependency(Factory.create_dependency("cleo", "^0.8.2"))
new_poetry = Package("poetry", new_version)
new_poetry.add_dependency(Factory.create_dependency("cleo", "^1.0.0"))
installed_repository = Repository()
installed_repository.add_package(old_poetry)
installed_repository.add_package(Package("cleo", "0.8.2"))
repository = Repository()
repository.add_package(new_poetry)
repository.add_package(Package("cleo", "1.0.0"))
pool = Pool()
pool.add_repository(repository)
command._pool = pool
with pytest.raises(PoetrySimpleConsoleException):
tester.execute()
def test_install_with_non_pypi_default_repository(pool: Pool,
installer: PipInstaller):
default = LegacyRepository("default", "https://default.com")
another = LegacyRepository("another", "https://another.com")
pool.add_repository(default, default=True)
pool.add_repository(another)
foo = Package(
"foo",
"0.0.0",
source_type="legacy",
source_reference=default.name,
source_url=default.url,
)
bar = Package(
"bar",
"0.1.0",
source_type="legacy",
source_reference=another.name,
source_url=another.url,
)
installer.install(foo)
installer.install(bar)
def test_install_with_client_cert():
client_path = "path/to/client.pem"
pool = Pool()
default = LegacyRepository("default",
"https://foo.bar",
client_cert=Path(client_path))
pool.add_repository(default, default=True)
null_env = NullEnv()
installer = PipInstaller(null_env, NullIO(), pool)
foo = Package(
"foo",
"0.0.0",
source_type="legacy",
source_reference=default.name,
source_url=default.url,
)
installer.install(foo)
assert len(null_env.executed) == 1
cmd = null_env.executed[0]
assert "--client-cert" in cmd
cert_index = cmd.index("--client-cert")
# Need to do the str(Path()) bit because Windows paths get modified by Path
assert cmd[cert_index + 1] == str(Path(client_path))
def test_install_with_certs(mocker: MockerFixture, key: str, option: str):
client_path = "path/to/client.pem"
mocker.patch(
"poetry.utils.authenticator.Authenticator.get_certs_for_url",
return_value={key: client_path},
)
default = LegacyRepository("default", "https://foo.bar")
pool = Pool()
pool.add_repository(default, default=True)
null_env = NullEnv()
installer = PipInstaller(null_env, NullIO(), pool)
foo = Package(
"foo",
"0.0.0",
source_type="legacy",
source_reference=default.name,
source_url=default.url,
)
installer.install(foo)
assert len(null_env.executed) == 1
cmd = null_env.executed[0]
assert f"--{option}" in cmd
cert_index = cmd.index(f"--{option}")
# Need to do the str(Path()) bit because Windows paths get modified by Path
assert cmd[cert_index + 1] == str(Path(client_path))
def test_install_with_trusted_host(config: Config):
config.merge({"certificates": {"default": {"cert": False}}})
default = LegacyRepository("default", "https://foo.bar")
pool = Pool()
pool.add_repository(default, default=True)
null_env = NullEnv()
installer = PipInstaller(null_env, NullIO(), pool)
foo = Package(
"foo",
"0.0.0",
source_type="legacy",
source_reference=default.name,
source_url=default.url,
)
installer.install(foo)
assert len(null_env.executed) == 1
cmd = null_env.executed[0]
assert "--trusted-host" in cmd
cert_index = cmd.index("--trusted-host")
assert cmd[cert_index + 1] == "foo.bar"
def test_self_update_can_update_from_recommended_installation(
tester: CommandTester,
http: type[httpretty.httpretty],
mocker: MockerFixture,
environ: None,
tmp_venv: VirtualEnv,
):
mocker.patch.object(EnvManager, "get_system_env", return_value=tmp_venv)
command = tester.command
command._data_dir = tmp_venv.path.parent
new_version = Version.parse(__version__).next_minor().text
old_poetry = Package("poetry", __version__)
old_poetry.add_dependency(Factory.create_dependency("cleo", "^0.8.2"))
new_poetry = Package("poetry", new_version)
new_poetry.add_dependency(Factory.create_dependency("cleo", "^1.0.0"))
installed_repository = Repository()
installed_repository.add_package(old_poetry)
installed_repository.add_package(Package("cleo", "0.8.2"))
repository = Repository()
repository.add_package(new_poetry)
repository.add_package(Package("cleo", "1.0.0"))
pool = Pool()
pool.add_repository(repository)
command._pool = pool
mocker.patch.object(InstalledRepository,
"load",
return_value=installed_repository)
tester.execute()
expected_output = f"""\
Updating Poetry to 1.2.0
Updating dependencies
Resolving dependencies...
Package operations: 0 installs, 2 updates, 0 removals
- Updating cleo (0.8.2 -> 1.0.0)
- Updating poetry ({__version__} -> {new_version})
Updating the poetry script
Poetry ({new_version}) is installed now. Great!
"""
assert tester.io.fetch_output() == expected_output
def _configure_sources(
poetry: Poetry,
sources: Source,
config: Config,
io: IO,
disable_cache: bool = False,
) -> None:
pool = Pool()
pool.add_repository(repo)
poetry.set_pool(pool)
def pool(self) -> Pool:
if self._pool is not None:
return self._pool
from poetry.repositories.pool import Pool
from poetry.repositories.pypi_repository import PyPiRepository
pool = Pool()
pool.add_repository(PyPiRepository())
return pool
def pool(self):
if self._pool is not None:
return self._pool
from poetry.repositories.pool import Pool
from poetry.repositories.pypi_repository import PyPiRepository
pool = Pool()
pool.add_repository(PyPiRepository(fallback=False))
self._pool = pool
return self._pool
def poetry(repo, tmp_dir):
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
def test_solver_chooses_from_correct_repository_if_forced_and_transitive_dependency(
package, installed, locked, io
):
package.python_versions = "^3.7"
package.add_dependency("foo", "^1.0")
package.add_dependency("tomlkit", {"version": "^0.5", "source": "legacy"})
repo = Repository()
foo = get_package("foo", "1.0.0")
foo.add_dependency("tomlkit", "^0.5.0")
repo.add_package(foo)
pool = Pool([MockLegacyRepository(), repo, MockPyPIRepository()])
solver = Solver(package, pool, installed, locked, io)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": get_package("tomlkit", "0.5.2")},
{"job": "install", "package": foo},
],
)
assert "legacy" == ops[0].package.source_type
assert "http://foo.bar" == ops[0].package.source_url
assert "" == ops[1].package.source_type
assert "" == ops[1].package.source_url
def test_solver_can_solve_with_legacy_repository_using_proper_dists(
package, installed, locked, io):
repo = MockLegacyRepository()
pool = Pool([repo])
solver = Solver(package, pool, installed, locked, io)
package.add_dependency("isort", "4.3.4")
ops = solver.solve()
check_solver_result(
ops,
[
{
"job": "install",
"package": get_package("futures", "3.2.0")
},
{
"job": "install",
"package": get_package("isort", "4.3.4")
},
],
)
futures = ops[0].package
assert futures.python_versions == ">=2.6, <3"
def test_requirement_source_type_url():
installer = PipInstaller(NullEnv(), NullIO(), Pool())
foo = Package("foo", "0.0.0")
foo.source_type = "url"
foo.source_url = "https://somehwere.com/releases/foo-1.0.0.tar.gz"
result = installer.requirement(foo, formatted=True)
expected = "{}#egg={}".format(foo.source_url, foo.name)
assert expected == result
def test_solver_chooses_from_secondary_if_explicit(package, installed, locked, io):
package.python_versions = "^3.7"
package.add_dependency("clikit", {"version": "^0.2.0", "source": "PyPI"})
pool = Pool()
pool.add_repository(MockPyPIRepository(), secondary=True)
pool.add_repository(MockLegacyRepository())
solver = Solver(package, pool, installed, locked, io)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": get_package("pastel", "0.1.0")},
{"job": "install", "package": get_package("pylev", "1.3.0")},
{"job": "install", "package": get_package("clikit", "0.2.4")},
],
)
assert "legacy" == ops[0].package.source_type
assert "http://foo.bar" == ops[0].package.source_url
assert "" == ops[1].package.source_type
assert "" == ops[1].package.source_url
assert "" == ops[2].package.source_type
assert "" == ops[2].package.source_url
def pool():
pool = Pool()
pool.add_repository(PyPiRepository(disable_cache=True))
pool.add_repository(
LegacyRepository("foo", "https://foo.bar/simple/", disable_cache=True))
return pool
def test_requirement_source_type_url():
installer = PipInstaller(NullEnv(), NullIO(), Pool())
foo = Package(
"foo",
"0.0.0",
source_type="url",
source_url="https://somewhere.com/releases/foo-1.0.0.tar.gz",
)
result = installer.requirement(foo, formatted=True)
expected = f"{foo.source_url}#egg={foo.name}"
assert result == expected
def test_solver_skips_invalid_versions(package, installed, locked, io):
package.python_versions = "^3.7"
repo = MockPyPIRepository()
pool = Pool([repo])
solver = Solver(package, pool, installed, locked, io)
package.add_dependency("trackpy", "^0.4")
ops = solver.solve()
check_solver_result(
ops, [{"job": "install", "package": get_package("trackpy", "0.4.1")}]
)
def __init__(
self,
file: Path,
local_config: dict,
package: ProjectPackage,
locker: Locker,
config: Config,
):
from poetry.repositories.pool import Pool
super().__init__(file, local_config, package)
self._locker = locker
self._config = config
self._pool = Pool()
self._plugin_manager: PluginManager | None = None
def __init__(
self,
file: "Path",
local_config: dict,
package: "ProjectPackage",
locker: "Locker",
config: "Config",
):
from poetry.repositories.pool import Pool
super().__init__(file, local_config, package)
self._locker = locker
self._config = config
self._pool = Pool()
self._plugin_manager: Optional["PluginManager"] = None
def test_requirement():
installer = PipInstaller(NullEnv(), NullIO(), Pool())
package = Package("ipython", "7.5.0")
package.hashes = [
"md5:dbdc53e3918f28fa335a173432402a00",
"e840810029224b56cd0d9e7719dc3b39cf84d577f8ac686547c8ba7a06eeab26",
]
result = installer.requirement(package, formatted=True)
expected = (
"ipython==7.5.0 "
"--hash md5:dbdc53e3918f28fa335a173432402a00 "
"--hash sha256:e840810029224b56cd0d9e7719dc3b39cf84d577f8ac686547c8ba7a06eeab26"
"\n")
assert expected == result
def test_solver_can_solve_with_legacy_repository_using_proper_python_compatible_dists(
package, installed, locked, io
):
package.python_versions = "^3.7"
repo = MockLegacyRepository()
pool = Pool([repo])
solver = Solver(package, pool, installed, locked, io)
package.add_dependency("isort", "4.3.4")
ops = solver.solve()
check_solver_result(
ops, [{"job": "install", "package": get_package("isort", "4.3.4")}]
)
def test_solver_chooses_from_correct_repository_if_forced(
package, installed, locked, io
):
package.python_versions = "^3.7"
package.add_dependency("tomlkit", {"version": "^0.5", "source": "legacy"})
repo = MockLegacyRepository()
pool = Pool([repo, MockPyPIRepository()])
solver = Solver(package, pool, installed, locked, io)
ops = solver.solve()
check_solver_result(
ops, [{"job": "install", "package": get_package("tomlkit", "0.5.2")}]
)
assert "legacy" == ops[0].package.source_type
assert "http://foo.bar" == ops[0].package.source_url
def test_solver_chooses_most_recent_version_amongst_repositories(
package, installed, locked, io
):
package.python_versions = "^3.7"
package.add_dependency("tomlkit", {"version": "^0.5"})
repo = MockLegacyRepository()
pool = Pool([repo, MockPyPIRepository()])
solver = Solver(package, pool, installed, locked, io)
ops = solver.solve()
check_solver_result(
ops, [{"job": "install", "package": get_package("tomlkit", "0.5.3")}]
)
assert "" == ops[0].package.source_type
assert "" == ops[0].package.source_url
def test_install_with_non_pypi_default_repository():
pool = Pool()
default = LegacyRepository("default", "https://default.com")
another = LegacyRepository("another", "https://another.com")
pool.add_repository(default, default=True)
pool.add_repository(another)
installer = PipInstaller(NullEnv(), NullIO(), pool)
foo = Package("foo", "0.0.0")
foo.source_type = "legacy"
foo.source_reference = default._name
foo.source_url = default._url
bar = Package("bar", "0.1.0")
bar.source_type = "legacy"
bar.source_reference = another._name
bar.source_url = another._url
installer.install(foo)
installer.install(bar)
def pool():
pool = Pool()
pool.add_repository(MockRepository())
return pool
def pool():
return Pool()
def handle(self):
from poetry.core.packages.project_package import ProjectPackage
from poetry.io.null_io import NullIO
from poetry.puzzle import Solver
from poetry.repositories.pool import Pool
from poetry.repositories.repository import Repository
from poetry.utils.env import EnvManager
packages = self.argument("package")
if not packages:
package = self.poetry.package
else:
# Using current pool for determine_requirements()
self._pool = self.poetry.pool
package = ProjectPackage(
self.poetry.package.name, self.poetry.package.version
)
# Silencing output
is_quiet = self.io.output.is_quiet()
if not is_quiet:
self.io.output.set_quiet(True)
requirements = self._determine_requirements(packages)
if not is_quiet:
self.io.output.set_quiet(False)
for constraint in requirements:
name = constraint.pop("name")
dep = package.add_dependency(name, constraint)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
for ex in extras:
dep.extras.append(ex)
package.python_versions = self.option("python") or (
self.poetry.package.python_versions
)
pool = self.poetry.pool
solver = Solver(package, pool, Repository(), Repository(), self._io)
ops = solver.solve()
self.line("")
self.line("Resolution results:")
self.line("")
if self.option("tree"):
show_command = self.application.find("show")
show_command.init_styles(self.io)
packages = [op.package for op in ops]
repo = Repository(packages)
requires = package.requires + package.dev_requires
for pkg in repo.packages:
for require in requires:
if pkg.name == require.name:
show_command.display_package_tree(self.io, pkg, repo)
break
return 0
table = self.table([], style="borderless")
rows = []
if self.option("install"):
env = EnvManager(self.poetry).get()
pool = Pool()
locked_repository = Repository()
for op in ops:
locked_repository.add_package(op.package)
pool.add_repository(locked_repository)
solver = Solver(package, pool, Repository(), Repository(), NullIO())
with solver.use_environment(env):
ops = solver.solve()
for op in ops:
if self.option("install") and op.skipped:
continue
pkg = op.package
row = [
"<c1>{}</c1>".format(pkg.name),
"<b>{}</b>".format(pkg.version),
"",
]
if not pkg.marker.is_any():
row[2] = str(pkg.marker)
rows.append(row)
table.set_rows(rows)
table.render(self.io)
def _configure_sources(poetry, sources, config, io):
pool = Pool()
pool.add_repository(repo)
poetry.set_pool(pool)
def pool(repository: Repository) -> Pool:
pool = Pool()
pool.add_repository(repository)
return pool
def pool(repo):
return Pool([repo])
