def test_add_no_constraint(app, repo, installer):
command = app.find("add")
tester = CommandTester(command)
repo.add_package(get_package("cachy", "0.1.0"))
repo.add_package(get_package("cachy", "0.2.0"))
tester.execute([("command", command.get_name()), ("name", ["cachy"])])
expected = """\
Using version ^0.2.0 for cachy
Updating dependencies
Resolving dependencies...
Package operations: 1 install, 0 updates, 0 removals
Writing lock file
- Installing cachy (0.2.0)
"""
assert tester.get_display(True) == expected
assert len(installer.installs) == 1
content = app.poetry.file.read()["tool"]["poetry"]
assert "cachy" in content["dependencies"]
assert content["dependencies"]["cachy"] == "^0.2.0"
def test_solver_does_not_get_stuck_in_recursion_on_circular_dependency(
solver, repo, package
):
package_a = get_package("A", "1.0")
package_a.add_dependency("B", "^1.0")
package_b = get_package("B", "1.0")
package_b.add_dependency("C", "^1.0")
package_c = get_package("C", "1.0")
package_c.add_dependency("B", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
package.add_dependency("A", "^1.0")
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c},
{"job": "install", "package": package_b},
{"job": "install", "package": package_a},
],
)
def test_install_with_deps_in_order(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B")
package.add_dependency("C")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
package_b.requires.append(get_dependency("A", ">=1.0"))
package_b.requires.append(get_dependency("C", ">=1.0"))
package_c.requires.append(get_dependency("A", ">=1.0"))
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_a},
{"job": "install", "package": package_c},
{"job": "install", "package": package_b},
],
)
def test_install_honours_not_equal(solver, repo, package):
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
new_package_b11 = get_package("B", "1.1")
new_package_b12 = get_package("B", "1.2")
new_package_b13 = get_package("B", "1.3")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(new_package_b11)
repo.add_package(new_package_b12)
repo.add_package(new_package_b13)
package_a.requires.append(get_dependency("B", "<=1.3,!=1.3,!=1.2"))
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": new_package_b11},
{"job": "install", "package": package_a},
],
)
def test_solver_sets_categories(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B", category="dev")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_b.add_dependency("C", "~1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
assert ops[0].package.category == "dev"
assert ops[2].package.category == "dev"
assert ops[1].package.category == "main"
def test_update_with_use_latest(solver, repo, installed, package, locked):
package.add_dependency("A")
package.add_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")
new_package_b = get_package("B", "1.1")
repo.add_package(package_a)
repo.add_package(new_package_a)
repo.add_package(package_b)
repo.add_package(new_package_b)
locked.add_package(package_a)
locked.add_package(package_b)
ops = solver.solve(use_latest=[package_b.name])
check_solver_result(
ops,
[
{"job": "install", "package": package_a, "skipped": True},
{"job": "install", "package": new_package_b},
],
)
def test_add_constraint_dependencies(app, repo, installer):
command = app.find("add")
tester = CommandTester(command)
cachy2 = get_package("cachy", "0.2.0")
msgpack_dep = get_dependency("msgpack-python", ">=0.5 <0.6")
cachy2.requires = [msgpack_dep]
repo.add_package(get_package("cachy", "0.1.0"))
repo.add_package(cachy2)
repo.add_package(get_package("msgpack-python", "0.5.3"))
tester.execute([("command", command.get_name()), ("name", ["cachy=0.2.0"])])
expected = """\
Updating dependencies
Resolving dependencies...
Package operations: 2 installs, 0 updates, 0 removals
Writing lock file
- Installing msgpack-python (0.5.3)
- Installing cachy (0.2.0)
"""
assert tester.get_display(True) == expected
assert len(installer.installs) == 2
def test_solver_respects_root_package_python_versions(solver, repo, package):
package.python_versions = "^3.4"
package.add_dependency("A")
package.add_dependency("B")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_b.python_versions = "^3.6"
package_c = get_package("C", "1.0")
package_c.python_versions = "^3.6"
package_c11 = get_package("C", "1.1")
package_c11.python_versions = "~3.3"
package_b.add_dependency("C", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_c11)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
def test_solver_returns_extras_if_requested(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B", {"version": "*", "extras": ["foo"]})
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_b.extras = {"foo": [get_dependency("C", "^1.0")]}
package_b.add_dependency("C", {"version": "^1.0", "optional": True})
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
def test_run_installs_extras_if_requested(installer, locker, repo, package):
package.extras["foo"] = [get_dependency("D")]
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_d = get_package("D", "1.1")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
package.add_dependency("A", "^1.0")
package.add_dependency("B", "^1.0")
package.add_dependency("C", "^1.0")
package.add_dependency("D", {"version": "^1.0", "optional": True})
installer.extras(["foo"])
installer.run()
expected = fixture("extras")
# Extras are pinned in lock
assert locker.written_data == expected
# But should not be installed
installer = installer.installer
assert len(installer.installs) == 4 # A, B, C, D
def test_solver_does_not_return_prereleases_if_not_requested(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B")
package.add_dependency("C")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_c_dev = get_package("C", "1.1-beta.1")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_c_dev)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
{"job": "install", "package": package_c},
],
)
def test_solver_returns_prereleases_if_requested(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B")
package.add_dependency("C", {"version": "*", "allows-prereleases": True})
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_c_dev = get_package("C", "1.1-beta.1")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_c_dev)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
{"job": "install", "package": package_c_dev},
],
)
def test_solver_sub_dependencies_with_requirements(solver, repo, package):
package.add_dependency("A")
package.add_dependency("B")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_d = get_package("D", "1.0")
package_c.add_dependency("D", {"version": "^1.0", "python": "<4.0"})
package_a.add_dependency("C")
package_b.add_dependency("D", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_d},
{"job": "install", "package": package_c},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
op = ops[1]
assert op.package.requirements == {}
def test_solver_duplicate_dependencies_different_constraints(solver, repo, package):
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_a.add_dependency("B", {"version": "^1.0", "python": "<3.4"})
package_a.add_dependency("B", {"version": "^2.0", "python": ">=3.4"})
package_b10 = get_package("B", "1.0")
package_b20 = get_package("B", "2.0")
repo.add_package(package_a)
repo.add_package(package_b10)
repo.add_package(package_b20)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_b10},
{"job": "install", "package": package_b20},
{"job": "install", "package": package_a},
],
)
op = ops[0]
assert op.package.requirements == {"python": "<3.4"}
op = ops[1]
assert op.package.requirements == {"python": ">=3.4"}
def test_solver_duplicate_dependencies_different_constraints_same_requirements(
solver, repo, package
):
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_a.add_dependency("B", {"version": "^1.0"})
package_a.add_dependency("B", {"version": "^2.0"})
package_b10 = get_package("B", "1.0")
package_b20 = get_package("B", "2.0")
repo.add_package(package_a)
repo.add_package(package_b10)
repo.add_package(package_b20)
with pytest.raises(SolverProblemError) as e:
solver.solve()
expected = """\
Because a (1.0) depends on both B (^1.0) and B (^2.0), a is forbidden.
So, because no versions of a match !=1.0
and root depends on A (*), version solving failed."""
assert str(e.value) == expected
def test_run_update_all_with_lock(installer, locker, repo, package):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "dev",
"optional": True,
"platform": "*",
"python-versions": "*",
"checksum": [],
}
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": []},
},
}
)
package_a = get_package("A", "1.1")
repo.add_package(get_package("A", "1.0"))
repo.add_package(package_a)
package.add_dependency("A")
installer.update(True)
installer.run()
expected = fixture("update-with-lock")
assert locker.written_data == expected
def test_solver_solves_while_respecting_root_platforms(solver, repo, package):
package.platform = "darwin"
package.add_dependency("A")
package.add_dependency("B")
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_b.python_versions = "^3.6"
package_c12 = get_package("C", "1.2")
package_c12.platform = "win32"
package_c10 = get_package("C", "1.0")
package_c10.platform = "darwin"
package_b.add_dependency("C", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c10)
repo.add_package(package_c12)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c10},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
def test_run_installs_extras_with_deps_if_requested_locked(
installer, locker, repo, package
):
locker.locked(True)
locker.mock_lock_data(fixture("extras-with-dependencies"))
package.extras["foo"] = [get_dependency("C")]
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_d = get_package("D", "1.1")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
package.add_dependency("A", "^1.0")
package.add_dependency("B", "^1.0")
package.add_dependency("C", {"version": "^1.0", "optional": True})
package_c.add_dependency("D", "^1.0")
installer.extras(["foo"])
installer.run()
# But should not be installed
installer = installer.installer
assert len(installer.installs) == 4 # A, B, C, D
def test_solver_solves_optional_and_compatible_packages(solver, repo, package):
package.python_versions = "^3.4"
package.extras["foo"] = [get_dependency("B")]
package.add_dependency("A", {"version": "*", "python": "~3.5"})
package.add_dependency("B", {"version": "*", "optional": True})
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_b.python_versions = "^3.6"
package_c = get_package("C", "1.0")
package_c.python_versions = "^3.6"
package_b.add_dependency("C", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_c},
{"job": "install", "package": package_a},
{"job": "install", "package": package_b},
],
)
def test_run_with_optional_and_platform_restricted_dependencies(
installer, locker, repo, package
):
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.1")
package_c12 = get_package("C", "1.2")
package_c13 = get_package("C", "1.3")
package_d = get_package("D", "1.4")
package_c13.add_dependency("D", "^1.2")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c12)
repo.add_package(package_c13)
repo.add_package(package_d)
package.extras = {"foo": [get_dependency("A", "~1.0")]}
package.add_dependency("A", {"version": "~1.0", "optional": True})
package.add_dependency("B", {"version": "^1.0", "platform": "custom"})
package.add_dependency("C", {"version": "^1.0", "platform": "darwin"})
installer.run()
expected = fixture("with-platform-dependencies")
assert locker.written_data == expected
installer = installer.installer
# We should only have 2 installs:
# C,D since the mocked python version is not compatible
# with B's python constraint and A is optional
assert len(installer.installs) == 2
assert installer.installs[0].name == "d"
assert installer.installs[1].name == "c"
def test_add_constraint(app, repo, installer):
command = app.find("add")
tester = CommandTester(command)
repo.add_package(get_package("cachy", "0.1.0"))
repo.add_package(get_package("cachy", "0.2.0"))
tester.execute([("command", command.get_name()), ("name", ["cachy=0.1.0"])])
expected = """\
Updating dependencies
Resolving dependencies...
Package operations: 1 install, 0 updates, 0 removals
Writing lock file
- Installing cachy (0.1.0)
"""
assert tester.get_display(True) == expected
assert len(installer.installs) == 1
def test_show_outdated(app, poetry, installed, repo):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
poetry.locker.mock_lock_data(
{
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"cachy": [], "pendulum": []},
},
}
)
tester.execute([("command", command.get_name()), ("--outdated", True)])
expected = """\
cachy 0.1.0 0.2.0 Cachy package
"""
assert tester.get_display(True) == expected
def test_run_update_uninstalls_after_removal_transient_dependency(
installer, locker, repo, package, installed
):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {"B": {"version": "^1.0", "python": "<2.0"}},
},
{
"name": "B",
"version": "1.0",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": [], "B": []},
},
}
)
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_a.add_dependency("B", {"version": "^1.0", "python": "<2.0"})
package_b10 = get_package("B", "1.0")
repo.add_package(package_a)
repo.add_package(package_b10)
installed.add_package(get_package("A", "1.0"))
installed.add_package(get_package("B", "1.0"))
installer.update(True)
installer.run()
installs = installer.installer.installs
assert len(installs) == 0
updates = installer.installer.updates
assert len(updates) == 0
removals = installer.installer.removals
assert len(removals) == 1
def test_interactive_with_dependencies(app, repo, mocker, poetry):
repo.add_package(get_package("pendulum", "2.0.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)
tester.set_inputs(
[
"my-package", # Package name
"1.2.3", # Version
"This is a description", # Description
"n", # Author
"MIT", # License
"~2.7 || ^3.6", # Python
"", # Interactive packages
"pendulum", # Search for package
"0", # First option
"", # Do not set constraint
"", # Stop searching for packages
"", # Interactive dev packages
"pytest", # Search for package
"0",
"",
"",
"\n", # Generate
]
)
tester.execute([("command", command.name)])
output = tester.get_display(True)
expected = """\
[tool.poetry]
name = "my-package"
version = "1.2.3"
description = "This is a description"
authors = ["Your Name <*****@*****.**>"]
license = "MIT"
[tool.poetry.dependencies]
python = "~2.7 || ^3.6"
pendulum = "^2.0"
[tool.poetry.dev-dependencies]
pytest = "^3.6"
"""
assert expected in output
def test_solver_with_dependency_in_both_main_and_dev_dependencies_with_one_more_dependent(
solver, repo, package
):
package.add_dependency("A")
package.add_dependency("E")
package.add_dependency("A", {"version": "*", "extras": ["foo"]}, category="dev")
package_a = get_package("A", "1.0")
package_a.extras["foo"] = [get_dependency("C")]
package_a.add_dependency("C", {"version": "^1.0", "optional": True})
package_a.add_dependency("B", {"version": "^1.0"})
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_c.add_dependency("D", "^1.0")
package_d = get_package("D", "1.0")
package_e = get_package("E", "1.0")
package_e.add_dependency("A", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
repo.add_package(package_e)
ops = solver.solve()
check_solver_result(
ops,
[
{"job": "install", "package": package_b},
{"job": "install", "package": package_d},
{"job": "install", "package": package_a},
{"job": "install", "package": package_c},
{"job": "install", "package": package_e},
],
)
b = ops[0].package
c = ops[3].package
d = ops[1].package
a = ops[2].package
e = ops[4].package
assert d.category == "dev"
assert c.category == "dev"
assert b.category == "main"
assert a.category == "main"
assert e.category == "main"
def test_show_basic_with_not_installed_packages_decorated(app, poetry, installed):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
installed.add_package(cachy_010)
poetry.locker.mock_lock_data(
{
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"cachy": [], "pendulum": []},
},
}
)
tester.execute([("command", command.get_name())], {"decorated": True})
expected = """\
\033[32mcachy \033[0m \033[36m0.1.0\033[0m Cachy package
\033[31mpendulum\033[0m \033[36m2.0.0\033[0m Pendulum package
"""
assert tester.get_display(True) == expected
def test_run_with_dependencies(installer, locker, repo, package):
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.1")
repo.add_package(package_a)
repo.add_package(package_b)
package.add_dependency("A", "~1.0")
package.add_dependency("B", "^1.0")
installer.run()
expected = fixture("with-dependencies")
assert locker.written_data == expected
def test_run_installs_with_local_directory(installer, locker, repo, package):
file_path = Path("tests/fixtures/project_with_setup/")
package.add_dependency("demo", {"path": str(file_path)})
repo.add_package(get_package("pendulum", "1.4.4"))
repo.add_package(get_package("cachy", "0.2.0"))
installer.run()
expected = fixture("with-directory-dependency")
assert locker.written_data == expected
assert len(installer.installer.installs) == 3
def test_update_installed(solver, repo, installed, package):
package.add_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)
ops = solver.solve()
check_solver_result(
ops, [{"job": "update", "from": package_a, "to": new_package_a}]
)
def test_add_git_constraint_with_poetry(app, repo, installer):
command = app.find("add")
tester = CommandTester(command)
repo.add_package(get_package("pendulum", "1.4.4"))
tester.execute(
[
("command", command.get_name()),
("name", ["demo"]),
("--git", "https://github.com/demo/pyproject-demo.git"),
]
)
expected = """\
Updating dependencies
Resolving dependencies...
Package operations: 2 installs, 0 updates, 0 removals
Writing lock file
- Installing pendulum (1.4.4)
- Installing demo (0.1.2 9cf87a2)
"""
assert tester.get_display(True) == expected
assert len(installer.installs) == 2
def test_show_non_dev_with_basic_installed_packages(tester, poetry, installed):
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pytest_373 = get_package("pytest", "3.7.3")
pytest_373.description = "Pytest package"
pytest_373.category = "dev"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
installed.add_package(pytest_373)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pytest",
"version": "3.7.3",
"description": "Pytest package",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"pytest": []
},
},
})
tester.execute("--no-dev")
expected = """\
cachy 0.1.0 Cachy package
pendulum 2.0.0 Pendulum package
"""
assert expected == tester.io.fetch_output()
def test_show_with_optional_group(tester, poetry, installed):
poetry.package.add_dependency(Factory.create_dependency("cachy", "^0.1.0"))
poetry.package.add_dependency(
Factory.create_dependency("pendulum", "^2.0.0"))
group = DependencyGroup("dev", optional=True)
group.add_dependency(
Factory.create_dependency("pytest", "*", groups=["dev"]))
poetry.package.add_dependency_group(group)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pytest_373 = get_package("pytest", "3.7.3")
pytest_373.description = "Pytest package"
pytest_373.category = "dev"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
installed.add_package(pytest_373)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pytest",
"version": "3.7.3",
"description": "Pytest package",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"pytest": []
},
},
})
tester.execute()
expected = """\
cachy 0.1.0 Cachy package
pendulum 2.0.0 Pendulum package
"""
assert expected == tester.io.fetch_output()
tester.execute("--with dev")
expected = """\
cachy 0.1.0 Cachy package
pendulum 2.0.0 Pendulum package
pytest 3.7.3 Pytest package
"""
assert expected == tester.io.fetch_output()
def test_show_tree_no_dev(tester, poetry, installed):
poetry.package.add_dependency(Factory.create_dependency("cachy", "^0.2.0"))
poetry.package.add_dependency(
Factory.create_dependency("pytest", "^6.1.0", groups=["dev"]))
cachy2 = get_package("cachy", "0.2.0")
cachy2.add_dependency(
Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
installed.add_package(cachy2)
pytest = get_package("pytest", "6.1.1")
installed.add_package(pytest)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.2.0",
"description": "",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"msgpack-python": ">=0.5 <0.6"
},
},
{
"name": "msgpack-python",
"version": "0.5.1",
"description": "",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pytest",
"version": "6.1.1",
"description": "",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"msgpack-python": [],
"pytest": []
},
},
})
tester.execute("--tree --without dev")
expected = """\
cachy 0.2.0
└── msgpack-python >=0.5 <0.6
"""
assert expected == tester.io.fetch_output()
def test_show_latest_decorated(app, poetry, installed, repo):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pendulum_201 = get_package("pendulum", "2.0.1")
pendulum_201.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
repo.add_package(pendulum_201)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": []
},
},
})
tester.io.set_formatter(AnsiFormatter(forced=True))
tester.execute("--latest")
expected = """\
\033[36mcachy \033[0m \033[1m0.1.0\033[0m \033[33m0.2.0\033[0m Cachy package
\033[36mpendulum\033[0m \033[1m2.0.0\033[0m \033[31m2.0.1\033[0m Pendulum package
"""
assert expected == tester.io.fetch_output()
def test_solver_sub_dependencies_with_requirements_complex(solver, repo):
package_a = get_package('A', '1.0')
package_b = get_package('B', '1.0')
package_c = get_package('C', '1.0')
package_d = get_package('D', '1.0')
package_e = get_package('E', '1.0')
package_f = get_package('F', '1.0')
package_a.add_dependency('B', '^1.0')
package_a.add_dependency('D', {'version': '^1.0', 'python': '<4.0'})
package_b.add_dependency('E', {'version': '^1.0', 'platform': 'win32'})
package_b.add_dependency('F')
package_c.add_dependency('F', '^1.0')
package_d.add_dependency('F')
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
repo.add_package(package_e)
repo.add_package(package_f)
dependency_a = get_dependency('A')
dependency_b = get_dependency('B')
dependency_c = get_dependency('C')
request = [
dependency_a,
dependency_b,
dependency_c,
]
ops = solver.solve(request)
check_solver_result(ops, [
{
'job': 'install',
'package': package_d
},
{
'job': 'install',
'package': package_e
},
{
'job': 'install',
'package': package_f
},
{
'job': 'install',
'package': package_a
},
{
'job': 'install',
'package': package_b
},
{
'job': 'install',
'package': package_c
},
])
op = ops[1]
assert op.package.requirements == {'platform': 'win32'}
op = ops[2]
assert op.package.requirements == {}
def test_show_outdated_local_dependencies(tester, poetry, installed, repo):
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
cachy_030 = get_package("cachy", "0.3.0")
cachy_030.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
demo_010 = get_package("demo", "0.1.0")
demo_010.description = ""
my_package_012 = get_package("project-with-setup", "0.1.2")
my_package_012.description = "Demo project."
installed.add_package(cachy_020)
installed.add_package(pendulum_200)
installed.add_package(demo_010)
installed.add_package(my_package_012)
repo.add_package(cachy_020)
repo.add_package(cachy_030)
repo.add_package(pendulum_200)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.2.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "demo",
"version": "0.1.0",
"description": "Demo package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"source": {
"type": "file",
"reference": "",
"url": "../distributions/demo-0.1.0-py2.py3-none-any.whl",
},
},
{
"name": "project-with-setup",
"version": "0.1.1",
"description": "Demo project.",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"pendulum": "pendulum>=1.4.4",
"cachy": {
"version": ">=0.2.0",
"extras": ["msgpack"]
},
},
"source": {
"type": "directory",
"reference": "",
"url": "../project_with_setup",
},
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"demo": [],
"project-with-setup": [],
},
},
})
tester.execute("--outdated")
expected = """\
cachy 0.2.0 0.3.0
project-with-setup 0.1.1 ../project_with_setup 0.1.2 ../project_with_setup
"""
assert expected.rstrip() == "\n".join(
line.rstrip() for line in tester.io.fetch_output().splitlines())
def test_show_outdated_formatting(tester, poetry, installed, repo):
poetry.package.add_dependency(Factory.create_dependency("cachy", "^0.1.0"))
poetry.package.add_dependency(
Factory.create_dependency("pendulum", "^2.0.0"))
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pendulum_201 = get_package("pendulum", "2.0.1")
pendulum_201.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
repo.add_package(pendulum_201)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": []
},
},
})
tester.execute("--outdated")
expected = """\
cachy 0.1.0 0.2.0 Cachy package
pendulum 2.0.0 2.0.1 Pendulum package
"""
assert expected == tester.io.fetch_output()
def test_run_install_duplicate_dependencies_different_constraints_with_lock(
installer, locker, repo, package
):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"B": [
{"version": "^1.0", "python": "<4.0"},
{"version": "^2.0", "python": ">=4.0"},
]
},
},
{
"name": "B",
"version": "1.0",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {"C": "1.2"},
"requirements": {"python": "<4.0"},
},
{
"name": "B",
"version": "2.0",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {"C": "1.5"},
"requirements": {"python": ">=4.0"},
},
{
"name": "C",
"version": "1.2",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "C",
"version": "1.5",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": [], "B": [], "C": []},
},
}
)
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_a.add_dependency("B", {"version": "^1.0", "python": "<4.0"})
package_a.add_dependency("B", {"version": "^2.0", "python": ">=4.0"})
package_b10 = get_package("B", "1.0")
package_b20 = get_package("B", "2.0")
package_b10.add_dependency("C", "1.2")
package_b20.add_dependency("C", "1.5")
package_c12 = get_package("C", "1.2")
package_c15 = get_package("C", "1.5")
repo.add_package(package_a)
repo.add_package(package_b10)
repo.add_package(package_b20)
repo.add_package(package_c12)
repo.add_package(package_c15)
installer.update(True)
installer.run()
expected = fixture("with-duplicate-dependencies")
assert locker.written_data == expected
installs = installer.installer.installs
assert len(installs) == 3
updates = installer.installer.updates
assert len(updates) == 0
removals = installer.installer.removals
assert len(removals) == 0
def test_show_outdated_no_dev_git_dev_dependency(tester, poetry, installed,
repo):
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
demo_011 = get_package("demo", "0.1.1")
demo_011.description = "Demo package"
pytest = get_package("pytest", "3.4.3")
pytest.description = "Pytest"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
installed.add_package(demo_011)
installed.add_package(pytest)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
repo.add_package(pytest)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "demo",
"version": "0.1.1",
"description": "Demo package",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"source": {
"type": "git",
"reference": "9cf87a285a2d3fbb0b9fa621997b3acc3631ed24",
"url": "https://github.com/demo/pyproject-demo.git",
},
},
{
"name": "pytest",
"version": "3.4.3",
"description": "Pytest",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"demo": [],
"pytest": []
},
},
})
tester.execute("--outdated --without dev")
expected = """\
cachy 0.1.0 0.2.0 Cachy package
"""
assert expected == tester.io.fetch_output()
def test_run_update_after_removing_dependencies(
installer, locker, repo, package, installed
):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "B",
"version": "1.1",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "C",
"version": "1.2",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": [], "B": [], "C": []},
},
}
)
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.1")
package_c = get_package("C", "1.2")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
installed.add_package(package_a)
installed.add_package(package_b)
installed.add_package(package_c)
package.add_dependency("A", "~1.0")
package.add_dependency("B", "~1.1")
installer.update(True)
installer.run()
expected = fixture("with-dependencies")
assert locker.written_data == expected
installs = installer.installer.installs
assert len(installs) == 0
updates = installer.installer.updates
assert len(updates) == 0
removals = installer.installer.removals
assert len(removals) == 1
def package():
return get_package('root', '1.0')
def test_run_update_uninstalls_after_removal_transient_dependency(
installer, locker, repo, package, installed):
locker.locked(True)
locker.mock_lock_data({
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"B": {
"version": "^1.0",
"python": "<2.0"
}
},
},
{
"name": "B",
"version": "1.0",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"A": [],
"B": []
},
},
})
package.add_dependency("A")
package_a = get_package("A", "1.0")
package_a.add_dependency("B", {"version": "^1.0", "python": "<2.0"})
package_b10 = get_package("B", "1.0")
repo.add_package(package_a)
repo.add_package(package_b10)
installed.add_package(get_package("A", "1.0"))
installed.add_package(get_package("B", "1.0"))
installer.update(True)
installer.run()
installs = installer.installer.installs
assert len(installs) == 0
updates = installer.installer.updates
assert len(updates) == 0
removals = installer.installer.removals
assert len(removals) == 1
packages = [{include = "my_package"}]
[tool.poetry.dependencies]
python = "~2.7 || ^3.6"
demo = {git = "https://github.com/demo/demo.git"}
[tool.poetry.group.dev.dependencies]
pytest = "^3.6.0"
"""
assert expected in tester.io.fetch_output()
_generate_choice_list_packages_params: List[List["Package"]] = [
[
get_package("flask-blacklist", "1.0.0"),
get_package("Flask-Shelve", "1.0.0"),
get_package("flask-pwa", "1.0.0"),
get_package("Flask-test1", "1.0.0"),
get_package("Flask-test2", "1.0.0"),
get_package("Flask-test3", "1.0.0"),
get_package("Flask-test4", "1.0.0"),
get_package("Flask-test5", "1.0.0"),
get_package("Flask", "1.0.0"),
get_package("Flask-test6", "1.0.0"),
get_package("Flask-test7", "1.0.0"),
],
[
get_package("flask-blacklist", "1.0.0"),
get_package("Flask-Shelve", "1.0.0"),
get_package("flask-pwa", "1.0.0"),
def test_show_outdated_has_prerelease_but_not_allowed(app, poetry, installed, repo):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
cachy_030dev = get_package("cachy", "0.3.0.dev123")
cachy_030dev.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
# sorting isn't used, so this has to be the first element to
# replicate the issue in PR #1548
repo.add_package(cachy_030dev)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
poetry.locker.mock_lock_data(
{
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"cachy": [], "pendulum": []},
},
}
)
tester.execute("--outdated")
expected = """\
cachy 0.1.0 0.2.0 Cachy package
"""
assert expected == tester.io.fetch_output()
def test_show_outdated_local_dependencies(app, poetry, installed, repo):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
demo_010 = get_package("demo", "0.1.0")
demo_010.description = ""
my_package_012 = get_package("my-package", "0.1.2")
my_package_012.description = "Demo project."
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
installed.add_package(demo_010)
installed.add_package(my_package_012)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "demo",
"version": "0.1.0",
"description": "Demo package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"source": {
"type": "file",
"reference": "",
"url": "../distributions/demo-0.1.0-py2.py3-none-any.whl",
},
},
{
"name": "my-package",
"version": "0.1.1",
"description": "Demo project.",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"source": {
"type": "directory",
"reference": "",
"url": "../project_with_setup",
},
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"demo": [],
"my-package": []
},
},
})
tester.execute("--outdated")
expected = """\
cachy 0.1.0 0.2.0
my-package 0.1.1 ../project_with_setup 0.1.2 ../project_with_setup
"""
assert expected == tester.io.fetch_output()
def test_run_update_with_locked_extras(installer, locker, repo, package):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {"B": "^1.0", "C": "^1.0"},
},
{
"name": "B",
"version": "1.0",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "C",
"version": "1.1",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"requirements": {"python": "~2.7"},
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": [], "B": [], "C": []},
},
}
)
package_a = get_package("A", "1.0")
package_a.extras["foo"] = [get_dependency("B")]
b_dependency = get_dependency("B", "^1.0", optional=True)
b_dependency.in_extras.append("foo")
c_dependency = get_dependency("C", "^1.0")
c_dependency.python_versions = "~2.7"
package_a.requires.append(b_dependency)
package_a.requires.append(c_dependency)
repo.add_package(package_a)
repo.add_package(get_package("B", "1.0"))
repo.add_package(get_package("C", "1.1"))
repo.add_package(get_package("D", "1.1"))
package.add_dependency("A", {"version": "^1.0", "extras": ["foo"]})
package.add_dependency("D", "^1.0")
installer.update(True)
installer.whitelist("D")
installer.run()
expected = fixture("update-with-locked-extras")
assert locker.written_data == expected
def _factory(
name: str | None = None,
dependencies: dict[str, str] | None = None,
dev_dependencies: dict[str, str] | None = None,
pyproject_content: str | None = None,
poetry_lock_content: str | None = None,
install_deps: bool = True,
source: Path | None = None,
locker_config: dict[str, Any] | None = None,
) -> Poetry:
project_dir = workspace / f"poetry-fixture-{name}"
dependencies = dependencies or {}
dev_dependencies = dev_dependencies or {}
if pyproject_content or source:
if source:
project_dir.parent.mkdir(parents=True, exist_ok=True)
shutil.copytree(source, project_dir)
else:
project_dir.mkdir(parents=True, exist_ok=True)
if pyproject_content:
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 <*****@*****.**>",
readme_format="md",
python=default_python,
dependencies=dependencies,
dev_dependencies=dev_dependencies,
).create(project_dir, with_tests=False)
if poetry_lock_content:
lock_file = project_dir / "poetry.lock"
lock_file.write_text(data=poetry_lock_content, encoding="utf-8")
poetry = Factory().create_poetry(project_dir)
locker = TestLocker(poetry.locker.lock.path, locker_config
or poetry.locker._local_config)
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
def test_install_non_existing_package_fail(solver, repo):
package_a = get_package('A', '1.0')
repo.add_package(package_a)
with pytest.raises(SolverProblemError):
solver.solve([get_dependency('B', '1')])
def test_locker_dumps_dependency_information_correctly(
locker: Locker, root: ProjectPackage
):
root_dir = Path(__file__).parent.parent.joinpath("fixtures")
package_a = get_package("A", "1.0.0")
package_a.add_dependency(
Factory.create_dependency(
"B", {"path": "project_with_extras", "develop": True}, root_dir=root_dir
)
)
package_a.add_dependency(
Factory.create_dependency(
"C",
{"path": "directory/project_with_transitive_directory_dependencies"},
root_dir=root_dir,
)
)
package_a.add_dependency(
Factory.create_dependency(
"D", {"path": "distributions/demo-0.1.0.tar.gz"}, root_dir=root_dir
)
)
package_a.add_dependency(
Factory.create_dependency(
"E", {"url": "https://python-poetry.org/poetry-1.2.0.tar.gz"}
)
)
package_a.add_dependency(
Factory.create_dependency(
"F", {"git": "https://github.com/python-poetry/poetry.git", "branch": "foo"}
)
)
packages = [package_a]
locker.set_lock_data(root, packages)
with locker.lock.open(encoding="utf-8") as f:
content = f.read()
expected = """[[package]]
name = "A"
version = "1.0.0"
description = ""
category = "main"
optional = false
python-versions = "*"
[package.dependencies]
B = {path = "project_with_extras", develop = true}
C = {path = "directory/project_with_transitive_directory_dependencies"}
D = {path = "distributions/demo-0.1.0.tar.gz"}
E = {url = "https://python-poetry.org/poetry-1.2.0.tar.gz"}
F = {git = "https://github.com/python-poetry/poetry.git", branch = "foo"}
[metadata]
lock-version = "1.1"
python-versions = "*"
content-hash = "178f2cd01dc40e96be23a4a0ae1094816626346346618335e5ff4f0b2c0c5831"
[metadata.files]
A = []
"""
assert content == expected
def test_solver_sub_dependencies_with_requirements_complex(
solver, repo, package):
package.add_dependency("A", {"version": "^1.0", "python": "<5.0"})
package.add_dependency("B", {"version": "^1.0", "python": "<5.0"})
package.add_dependency("C", {"version": "^1.0", "python": "<4.0"})
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_d = get_package("D", "1.0")
package_e = get_package("E", "1.0")
package_f = get_package("F", "1.0")
package_a.add_dependency("B", {"version": "^1.0", "python": "<4.0"})
package_a.add_dependency("D", {"version": "^1.0", "python": "<4.0"})
package_b.add_dependency("E", {"version": "^1.0", "platform": "win32"})
package_b.add_dependency("F", {"version": "^1.0", "python": "<5.0"})
package_c.add_dependency("F", {"version": "^1.0", "python": "<4.0"})
package_d.add_dependency("F")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
repo.add_package(package_e)
repo.add_package(package_f)
ops = solver.solve()
check_solver_result(
ops,
[
{
"job": "install",
"package": package_e
},
{
"job": "install",
"package": package_f
},
{
"job": "install",
"package": package_b
},
{
"job": "install",
"package": package_d
},
{
"job": "install",
"package": package_a
},
{
"job": "install",
"package": package_c
},
],
)
op = ops[3] # d
assert str(op.package.marker) == 'python_version < "4.0"'
op = ops[0] # e
assert str(op.package.marker) == (
'python_version < "4.0" and sys_platform == "win32" '
'or python_version < "5.0" and sys_platform == "win32"')
op = ops[1] # f
assert str(op.package.marker) == 'python_version < "5.0"'
op = ops[4] # a
assert str(op.package.marker) == 'python_version < "5.0"'
def test_show_outdated_has_prerelease_and_allowed(tester, poetry, installed,
repo):
poetry.package.add_dependency(
Factory.create_dependency("cachy", {
"version": "^0.1.0",
"allow-prereleases": True
}))
poetry.package.add_dependency(
Factory.create_dependency("pendulum", "^2.0.0"))
cachy_010dev = get_package("cachy", "0.1.0.dev1")
cachy_010dev.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
cachy_030dev = get_package("cachy", "0.3.0.dev123")
cachy_030dev.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
installed.add_package(cachy_010dev)
installed.add_package(pendulum_200)
# sorting isn't used, so this has to be the first element to
# replicate the issue in PR #1548
repo.add_package(cachy_030dev)
repo.add_package(cachy_010dev)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0.dev1",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": []
},
},
})
tester.execute("--outdated")
expected = """\
cachy 0.1.0.dev1 0.3.0.dev123 Cachy package
"""
assert expected == tester.io.fetch_output()
def test_run_install_no_dev(installer, locker, repo, package, installed):
locker.locked(True)
locker.mock_lock_data(
{
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "B",
"version": "1.1",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "C",
"version": "1.2",
"category": "dev",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"A": [], "B": [], "C": []},
},
}
)
package_a = get_package("A", "1.0")
package_b = get_package("B", "1.1")
package_c = get_package("C", "1.2")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
installed.add_package(package_a)
installed.add_package(package_b)
installed.add_package(package_c)
package.add_dependency("A", "~1.0")
package.add_dependency("B", "~1.1")
package.add_dependency("C", "~1.2", category="dev")
installer.dev_mode(False)
installer.run()
installs = installer.installer.installs
assert len(installs) == 0
updates = installer.installer.updates
assert len(updates) == 0
removals = installer.installer.removals
assert len(removals) == 1
def test_lock_file_data_is_ordered(locker: Locker, root: ProjectPackage):
package_a = get_package("A", "1.0.0")
package_a.add_dependency(Factory.create_dependency("B", "^1.0"))
package_a.files = [{"file": "foo", "hash": "456"}, {"file": "bar", "hash": "123"}]
package_git = Package(
"git-package",
"1.2.3",
source_type="git",
source_url="https://github.com/python-poetry/poetry.git",
source_reference="develop",
source_resolved_reference="123456",
)
packages = [package_a, get_package("B", "1.2"), package_git]
locker.set_lock_data(root, packages)
with locker.lock.open(encoding="utf-8") as f:
content = f.read()
expected = """[[package]]
name = "A"
version = "1.0.0"
description = ""
category = "main"
optional = false
python-versions = "*"
[package.dependencies]
B = "^1.0"
[[package]]
name = "B"
version = "1.2"
description = ""
category = "main"
optional = false
python-versions = "*"
[[package]]
name = "git-package"
version = "1.2.3"
description = ""
category = "main"
optional = false
python-versions = "*"
develop = false
[package.source]
type = "git"
url = "https://github.com/python-poetry/poetry.git"
reference = "develop"
resolved_reference = "123456"
[metadata]
lock-version = "1.1"
python-versions = "*"
content-hash = "178f2cd01dc40e96be23a4a0ae1094816626346346618335e5ff4f0b2c0c5831"
[metadata.files]
A = [
{file = "bar", hash = "123"},
{file = "foo", hash = "456"},
]
B = []
git-package = []
"""
assert content == expected
def test_show_required_by_deps(tester, poetry, installed):
poetry.package.add_dependency(Factory.create_dependency("cachy", "^0.2.0"))
poetry.package.add_dependency(
Factory.create_dependency("pendulum", "2.0.0"))
cachy2 = get_package("cachy", "0.2.0")
cachy2.add_dependency(
Factory.create_dependency("msgpack-python", ">=0.5 <0.6"))
pendulum = get_package("pendulum", "2.0.0")
pendulum.add_dependency(Factory.create_dependency("CachY", "^0.2.0"))
installed.add_package(cachy2)
installed.add_package(pendulum)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.2.0",
"description": "",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"msgpack-python": ">=0.5 <0.6"
},
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"cachy": ">=0.2.0 <0.3.0"
},
},
{
"name": "msgpack-python",
"version": "0.5.1",
"description": "",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": [],
"msgpack-python": []
},
},
})
tester.execute("cachy")
expected = """\
name : cachy
version : 0.2.0
description :
dependencies
- msgpack-python >=0.5 <0.6
required by
- pendulum >=0.2.0 <0.3.0
""".splitlines()
actual = [line.rstrip() for line in tester.io.fetch_output().splitlines()]
assert actual == expected
def test_solver_with_dependency_in_both_main_and_dev_dependencies_with_one_more_dependent(
solver, repo, package):
package.add_dependency("A")
package.add_dependency("E")
package.add_dependency("A", {
"version": "*",
"extras": ["foo"]
},
category="dev")
package_a = get_package("A", "1.0")
package_a.extras["foo"] = [get_dependency("C")]
package_a.add_dependency("C", {"version": "^1.0", "optional": True})
package_a.add_dependency("B", {"version": "^1.0"})
package_b = get_package("B", "1.0")
package_c = get_package("C", "1.0")
package_c.add_dependency("D", "^1.0")
package_d = get_package("D", "1.0")
package_e = get_package("E", "1.0")
package_e.add_dependency("A", "^1.0")
repo.add_package(package_a)
repo.add_package(package_b)
repo.add_package(package_c)
repo.add_package(package_d)
repo.add_package(package_e)
ops = solver.solve()
check_solver_result(
ops,
[
{
"job": "install",
"package": package_b
},
{
"job": "install",
"package": package_d
},
{
"job": "install",
"package": package_a
},
{
"job": "install",
"package": package_c
},
{
"job": "install",
"package": package_e
},
],
)
b = ops[0].package
c = ops[3].package
d = ops[1].package
a = ops[2].package
e = ops[4].package
assert d.category == "dev"
assert c.category == "dev"
assert b.category == "main"
assert a.category == "main"
assert e.category == "main"
def test_update_multiple_times_with_split_dependencies_is_idempotent(
installer, locker, repo, package):
locker.locked(True)
locker.mock_lock_data({
"package": [
{
"name": "A",
"version": "1.0",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
"dependencies": {
"B": ">=1.0"
},
},
{
"name": "B",
"version": "1.0.1",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*",
"checksum": [],
"dependencies": {},
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"A": [],
"B": []
},
},
})
package.python_versions = "~2.7 || ^3.4"
package.add_dependency("A", "^1.0")
a10 = get_package("A", "1.0")
a11 = get_package("A", "1.1")
a11.add_dependency("B", ">=1.0.1")
a11.add_dependency("C", {"version": "^1.0", "python": "~2.7"})
a11.add_dependency("C", {"version": "^2.0", "python": "^3.4"})
b101 = get_package("B", "1.0.1")
b110 = get_package("B", "1.1.0")
repo.add_package(a10)
repo.add_package(a11)
repo.add_package(b101)
repo.add_package(b110)
repo.add_package(get_package("C", "1.0"))
repo.add_package(get_package("C", "2.0"))
expected = fixture("with-multiple-updates")
installer.update(True)
installer.run()
assert expected == locker.written_data
locker.mock_lock_data(locker.written_data)
installer.update(True)
installer.run()
assert expected == locker.written_data
locker.mock_lock_data(locker.written_data)
installer.update(True)
installer.run()
assert expected == locker.written_data
def test_show_latest_decorated(
tester: "CommandTester",
poetry: "Poetry",
installed: "Repository",
repo: "TestRepository",
):
poetry.package.add_dependency(Factory.create_dependency("cachy", "^0.1.0"))
poetry.package.add_dependency(Factory.create_dependency("pendulum", "^2.0.0"))
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pendulum_201 = get_package("pendulum", "2.0.1")
pendulum_201.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
repo.add_package(pendulum_201)
poetry.locker.mock_lock_data(
{
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {"cachy": [], "pendulum": []},
},
}
)
tester.execute("--latest", decorated=True)
expected = """\
\033[36mcachy \033[39m \033[39;1m0.1.0\033[39;22m\
\033[33m0.2.0\033[39m Cachy package
\033[36mpendulum\033[39m \033[39;1m2.0.0\033[39;22m\
\033[31m2.0.1\033[39m Pendulum package
"""
assert expected == tester.io.fetch_output()
def test_show_latest_non_decorated(app, poetry, installed, repo):
command = app.find("show")
tester = CommandTester(command)
cachy_010 = get_package("cachy", "0.1.0")
cachy_010.description = "Cachy package"
cachy_020 = get_package("cachy", "0.2.0")
cachy_020.description = "Cachy package"
pendulum_200 = get_package("pendulum", "2.0.0")
pendulum_200.description = "Pendulum package"
pendulum_201 = get_package("pendulum", "2.0.1")
pendulum_201.description = "Pendulum package"
installed.add_package(cachy_010)
installed.add_package(pendulum_200)
repo.add_package(cachy_010)
repo.add_package(cachy_020)
repo.add_package(pendulum_200)
repo.add_package(pendulum_201)
poetry.locker.mock_lock_data({
"package": [
{
"name": "cachy",
"version": "0.1.0",
"description": "Cachy package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
{
"name": "pendulum",
"version": "2.0.0",
"description": "Pendulum package",
"category": "main",
"optional": False,
"platform": "*",
"python-versions": "*",
"checksum": [],
},
],
"metadata": {
"python-versions": "*",
"platform": "*",
"content-hash": "123456789",
"hashes": {
"cachy": [],
"pendulum": []
},
},
})
tester.execute([("command", command.get_name()), ("--latest", True)])
expected = """\
cachy 0.1.0 0.2.0 Cachy package
pendulum 2.0.0 2.0.1 Pendulum package
"""
assert tester.get_display(True) == expected
def setup(repo: TestRepository) -> None:
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
def setup(repo):
repo.add_package(get_package("foo", "1.0.0"))
repo.add_package(get_package("bar", "1.1.0"))
