from __future__ import annotations from typing import TYPE_CHECKING from typing import Any 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.constraints.version import Version from poetry.core.packages.dependency import Dependency from poetry.core.packages.dependency_group import MAIN_GROUP from poetry.core.version.markers import MarkerUnion from poetry.core.version.markers import parse_marker from poetry.factory import Factory from poetry.packages import Locker as BaseLocker from poetry.repositories.legacy_repository import LegacyRepository from poetry.repositories.repository_pool import Priority from poetry_plugin_export.exporter import Exporter from poetry_plugin_export.walker import DependencyWalkerError from tests.markers import MARKER_CPYTHON from tests.markers import MARKER_DARWIN from tests.markers import MARKER_LINUX from tests.markers import MARKER_PY from tests.markers import MARKER_PY27 from tests.markers import MARKER_PY36 from tests.markers import MARKER_PY36_38 from tests.markers import MARKER_PY36_ONLY from tests.markers import MARKER_PY36_PY362 from tests.markers import MARKER_PY36_PY362_ALT from tests.markers import MARKER_PY37 from tests.markers import MARKER_PY362_PY40 from tests.markers import MARKER_PY_DARWIN from tests.markers import MARKER_PY_LINUX from tests.markers import MARKER_PY_WIN32 from tests.markers import MARKER_PY_WINDOWS from tests.markers import MARKER_WIN32 from tests.markers import MARKER_WINDOWS if TYPE_CHECKING: from collections.abc import Collection from pathlib import Path from packaging.utils import NormalizedName from poetry.poetry import Poetry from tests.conftest import Config class Locker(BaseLocker): def __init__(self, fixture_root: Path) -> None: super().__init__(fixture_root / "poetry.lock", {}) self._locked = True def locked(self, is_locked: bool = True) -> Locker: self._locked = is_locked return self def mock_lock_data(self, data: dict[str, Any]) -> None: self._lock_data = data def is_locked(self) -> bool: return self._locked def is_fresh(self) -> bool: return True def _get_content_hash(self) -> str: return "123456789" @pytest.fixture def locker(fixture_root: Path) -> Locker: return Locker(fixture_root) @pytest.fixture def poetry(fixture_root: Path, locker: Locker) -> Poetry: p = Factory().create_poetry(fixture_root / "sample_project") p._locker = locker return p def set_package_requires( poetry: Poetry, skip: set[str] | None = None, dev: set[str] | None = None, markers: dict[str, str] | None = None, ) -> None: skip = skip or set() dev = dev or set() packages = poetry.locker.locked_repository().packages package = poetry.package.with_dependency_groups([], only=True) for pkg in packages: if pkg.name not in skip: dep = pkg.to_dependency() if pkg.name in dev: try: dep.groups = frozenset([canonicalize_name("dev")]) # type: ignore[misc] except AttributeError: dep._groups = frozenset(["dev"]) if markers and pkg.name in markers: dep._marker = parse_marker(markers[pkg.name]) package.add_dependency(dep) poetry._package = package def fix_lock_data(lock_data: dict[str, Any]) -> None: if Version.parse(lock_data["metadata"]["lock-version"]) >= Version.parse("2.1"): for locked_package in lock_data["package"]: locked_package["groups"] = ["main"] locked_package["files"] = lock_data["metadata"]["files"][ locked_package["name"] ] del lock_data["metadata"]["files"] @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_standard_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_standard_packages_and_markers( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" lock_data["package"][2]["markers"] = "sys_platform == 'win32'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] markers = { "foo": "python_version < '3.7'", "bar": "extra =='foo'", "baz": "sys_platform == 'win32'", } set_package_requires(poetry, markers=markers) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} baz==7.8.9 ; {MARKER_PY_WIN32} foo==1.2.3 ; {MarkerUnion(MARKER_PY27, MARKER_PY36_ONLY)} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_poetry( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: """Regression test for #3254""" lock_data: dict[str, Any] = { "package": [ { "name": "poetry", "version": "1.1.4", "optional": False, "python-versions": "*", "dependencies": {"keyring": "*"}, }, { "name": "junit-xml", "version": "1.9", "optional": False, "python-versions": "*", "dependencies": {"six": "*"}, }, { "name": "keyring", "version": "21.8.0", "optional": False, "python-versions": "*", "dependencies": { "SecretStorage": { "version": "*", "markers": "sys_platform == 'linux'", } }, }, { "name": "secretstorage", "version": "3.3.0", "optional": False, "python-versions": "*", "dependencies": {"cryptography": "*"}, }, { "name": "cryptography", "version": "3.2", "optional": False, "python-versions": "*", "dependencies": {"six": "*"}, }, { "name": "six", "version": "1.15.0", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "poetry": [], "keyring": [], "secretstorage": [], "cryptography": [], "six": [], "junit-xml": [], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][3]["markers"] = "sys_platform == 'linux'" lock_data["package"][4]["markers"] = "sys_platform == 'linux'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires( poetry, skip={"keyring", "secretstorage", "cryptography", "six"} ) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() # The dependency graph: # junit-xml 1.9 Creates JUnit XML test result documents that can be read by tools # └── six * such as Jenkins # poetry 1.1.4 Python dependency management and packaging made easy. # ├── keyring >=21.2.0,<22.0.0 # │ ├── importlib-metadata >=1 # │ │ └── zipp >=0.5 # │ ├── jeepney >=0.4.2 # │ ├── pywin32-ctypes <0.1.0 || >0.1.0,<0.1.1 || >0.1.1 # │ └── secretstorage >=3.2 -- On linux only # │ ├── cryptography >=2.0 # │ │ └── six >=1.4.1 # │ └── jeepney >=0.6 (circular dependency aborted here) expected = { "poetry": Dependency.create_from_pep_508(f"poetry==1.1.4; {MARKER_PY}"), "junit-xml": Dependency.create_from_pep_508(f"junit-xml==1.9 ; {MARKER_PY}"), "keyring": Dependency.create_from_pep_508(f"keyring==21.8.0 ; {MARKER_PY}"), "secretstorage": Dependency.create_from_pep_508( f"secretstorage==3.3.0 ; {MARKER_PY_LINUX}" ), "cryptography": Dependency.create_from_pep_508( f"cryptography==3.2 ; {MARKER_PY_LINUX}" ), "six": Dependency.create_from_pep_508( f"six==1.15.0 ; {MARKER_PY.union(MARKER_PY_LINUX)}" ), } for line in content.strip().split("\n"): dependency = Dependency.create_from_pep_508(line) assert dependency.name in expected expected_dependency = expected.pop(dependency.name) assert dependency == expected_dependency assert dependency.marker == expected_dependency.marker @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_pyinstaller( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: """Regression test for #3254""" lock_data: dict[str, Any] = { "package": [ { "name": "pyinstaller", "version": "4.0", "optional": False, "python-versions": "*", "dependencies": { "altgraph": "*", "macholib": { "version": "*", "markers": "sys_platform == 'darwin'", }, }, }, { "name": "altgraph", "version": "0.17", "optional": False, "python-versions": "*", }, { "name": "macholib", "version": "1.8", "optional": False, "python-versions": "*", "dependencies": {"altgraph": ">=0.15"}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"pyinstaller": [], "altgraph": [], "macholib": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][2]["markers"] = "sys_platform == 'darwin'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, skip={"altgraph", "macholib"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() # Rationale for the results: # * PyInstaller has an explicit dependency on altgraph, so it must always be # installed. # * PyInstaller requires macholib on Darwin, which in turn requires altgraph. # The dependency graph: # pyinstaller 4.0 PyInstaller bundles a Python application and all its # ├── altgraph * dependencies into a single package. # ├── macholib >=1.8 -- only on Darwin # │ └── altgraph >=0.15 expected = { "pyinstaller": Dependency.create_from_pep_508( f"pyinstaller==4.0 ; {MARKER_PY}" ), "altgraph": Dependency.create_from_pep_508( f"altgraph==0.17 ; {MARKER_PY.union(MARKER_PY_DARWIN)}" ), "macholib": Dependency.create_from_pep_508( f"macholib==1.8 ; {MARKER_PY_DARWIN}" ), } for line in content.strip().split("\n"): dependency = Dependency.create_from_pep_508(line) assert dependency.name in expected expected_dependency = expected.pop(dependency.name) assert dependency == expected_dependency assert dependency.marker == expected_dependency.marker @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_packages_and_markers( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "a", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": { "b": { "version": ">=0.0.0", "markers": "platform_system == 'Windows'", }, "c": { "version": ">=0.0.0", "markers": "sys_platform == 'win32'", }, }, }, { "name": "b", "version": "4.5.6", "optional": False, "python-versions": "*", "dependencies": {"d": ">=0.0.0"}, }, { "name": "c", "version": "7.8.9", "optional": False, "python-versions": "*", "dependencies": {"d": ">=0.0.0"}, }, { "name": "d", "version": "0.0.1", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"a": [], "b": [], "c": [], "d": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" lock_data["package"][1]["markers"] = ( "python_version < '3.7' and platform_system == 'Windows'" ) lock_data["package"][2]["markers"] = ( "python_version < '3.7' and sys_platform == 'win32'" ) lock_data["package"][3]["markers"] = ( "python_version < '3.7' and platform_system == 'Windows'" " or python_version < '3.7' and sys_platform == 'win32'" ) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires( poetry, skip={"b", "c", "d"}, markers={"a": "python_version < '3.7'"} ) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() marker_py = MarkerUnion(MARKER_PY27, MARKER_PY36_ONLY) marker_py_win32 = marker_py.intersect(MARKER_WIN32) marker_py_windows = marker_py.intersect(MARKER_WINDOWS) expected = { "a": Dependency.create_from_pep_508(f"a==1.2.3 ; {marker_py}"), "b": Dependency.create_from_pep_508(f"b==4.5.6 ; {marker_py_windows}"), "c": Dependency.create_from_pep_508(f"c==7.8.9 ; {marker_py_win32}"), "d": Dependency.create_from_pep_508( f"d==0.0.1 ; {marker_py_windows.union(marker_py_win32)}" ), } for line in content.strip().split("\n"): dependency = Dependency.create_from_pep_508(line) assert dependency.name in expected expected_dependency = expected.pop(dependency.name) assert dependency == expected_dependency assert dependency.marker == expected_dependency.marker assert expected == {} @pytest.mark.parametrize( ["dev", "lines"], [ ( False, [f"a==1.2.3 ; {MarkerUnion(MARKER_PY27, MARKER_PY36_38)}"], ), ( True, [ f"a==1.2.3 ; {MarkerUnion(MARKER_PY27, MARKER_PY36_38.union(MARKER_PY36))}", f"b==4.5.6 ; {MARKER_PY}", ], ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_packages_and_markers_any( tmp_path: Path, poetry: Poetry, dev: bool, lines: list[str], lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "a", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "b", "version": "4.5.6", "optional": False, "python-versions": "*", "dependencies": {"a": ">=1.2.3"}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"a": [], "b": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["groups"] = ["main", "dev"] lock_data["package"][0]["markers"] = {"main": "python_version < '3.8'"} lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.add_dependency( Factory.create_dependency( name="a", constraint={"version": "^1.2.3", "python": "<3.8"} ) ) root.add_dependency( Factory.create_dependency( name="b", constraint={"version": "^4.5.6"}, groups=["dev"] ) ) poetry._package = root exporter = Exporter(poetry, NullIO()) if dev: exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() assert content.strip() == "\n".join(lines) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_standard_packages_and_hashes( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_standard_packages_and_sorted_hashes( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [ {"name": "foo1.whl", "hash": "67890"}, {"name": "foo2.whl", "hash": "12345"}, ], "bar": [ {"name": "bar1.whl", "hash": "67890"}, {"name": "bar2.whl", "hash": "12345"}, ], }, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:12345 \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 \\ --hash=sha256:67890 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_standard_packages_and_hashes_disabled( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.with_hashes(False) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_without_dev_packages_by_default( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_dev_packages_if_opted_in( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_without_groups_if_set_explicitly( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() assert content == "\n" @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_without_optional_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": True, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] lock_data["package"][1]["markers"] = 'extra == "feature-bar"' poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize( ["extras", "lines"], [ ( ["feature-bar"], [ f"bar==4.5.6 ; {MARKER_PY}", f"foo==1.2.3 ; {MARKER_PY}", f"spam==0.1.0 ; {MARKER_PY}", ], ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_optional_packages( tmp_path: Path, poetry: Poetry, extras: Collection[NormalizedName], lines: list[str], lock_version: str, ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": True, "python-versions": "*", "dependencies": {"spam": ">=0.1"}, }, { "name": "spam", "version": "0.1.0", "optional": True, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], "spam": [{"name": "spam.whl", "hash": "abcde"}], }, }, "extras": {"feature_bar": ["bar"]}, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["markers"] = 'extra == "feature-bar"' lock_data["package"][2]["markers"] = 'extra == "feature-bar"' poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.with_hashes(False) exporter.with_extras(extras) exporter.export( "requirements.txt", tmp_path, "requirements.txt", ) with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = "\n".join(lines) assert content.strip() == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_git_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "git", "url": "https://github.com/foo/foo.git", "reference": "123456", "resolved_reference": "abcdef", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo @ git+https://github.com/foo/foo.git@abcdef ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "git", "url": "https://github.com/foo/foo.git", "reference": "123456", "resolved_reference": "abcdef", }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "dependencies": { "foo": { "git": "https://github.com/foo/foo.git", "rev": "123456", } }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, skip={"foo"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} foo @ git+https://github.com/foo/foo.git@abcdef ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_packages_cyclic( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": {"bar": {"version": "4.5.6"}}, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "dependencies": {"baz": {"version": "7.8.9"}}, }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", "dependencies": {"foo": {"version": "1.2.3"}}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, skip={"bar", "baz"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} baz==7.8.9 ; {MARKER_PY} foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_circular_root_dependency( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": {poetry.package.pretty_name: {"version": "1.2.3"}}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_packages_and_multiple_markers( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": { "bar": [ { "version": ">=1.2.3,<7.8.10", "markers": 'platform_system != "Windows"', }, { "version": ">=4.5.6,<7.8.10", "markers": 'platform_system == "Windows"', }, ] }, }, { "name": "bar", "version": "7.8.9", "optional": True, "python-versions": "*", "dependencies": { "baz": { "version": "!=10.11.12", "markers": 'platform_system == "Windows"', } }, }, { "name": "baz", "version": "10.11.13", "optional": True, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][2]["markers"] = 'platform_system == "Windows"' poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.with_hashes(False) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() marker_py_not_windows = MARKER_PY.intersect( parse_marker('platform_system != "Windows"') ) expected = f"""\ bar==7.8.9 ; {marker_py_not_windows.union(MARKER_PY_WINDOWS)} baz==10.11.13 ; {MARKER_PY_WINDOWS} foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_git_packages_and_markers( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "git", "url": "https://github.com/foo/foo.git", "reference": "123456", "resolved_reference": "abcdef", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, markers={"foo": "python_version < '3.7'"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo @ git+https://github.com/foo/foo.git@abcdef ; {MARKER_PY27.union(MARKER_PY36_ONLY)} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_directory_packages( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project", "reference": "", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo @ {fixture_root_uri}/sample_project ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_directory_packages_editable( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "develop": True, "source": { "type": "directory", "url": "sample_project", "reference": "", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ -e {fixture_root_uri}/sample_project ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_nested_directory_packages( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project", "reference": "", }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project/../project_with_nested_local/bar", "reference": "", }, }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project/../project_with_nested_local/bar/..", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar @ {fixture_root_uri}/project_with_nested_local/bar ; {MARKER_PY} baz @ {fixture_root_uri}/project_with_nested_local ; {MARKER_PY} foo @ {fixture_root_uri}/sample_project ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_directory_packages_and_markers( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project", "reference": "", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, markers={"foo": "python_version < '3.7'"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo @ {fixture_root_uri}/sample_project ;\ {MARKER_PY27.union(MARKER_PY36_ONLY)} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_file_packages( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "file", "url": "distributions/demo-0.1.0.tar.gz", "reference": "", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ foo @ {fixture_root_uri}/distributions/demo-0.1.0.tar.gz ;\ {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_can_export_requirements_txt_with_file_packages_and_markers( tmp_path: Path, poetry: Poetry, fixture_root_uri: str, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "file", "url": "distributions/demo-0.1.0.tar.gz", "reference": "", }, } ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, markers={"foo": "python_version < '3.7'"}) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() uri = f"{fixture_root_uri}/distributions/demo-0.1.0.tar.gz" expected = f"""\ foo @ {uri} ; {MARKER_PY27.union(MARKER_PY36_ONLY)} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_legacy_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.add_repository( LegacyRepository( "custom", "https://example.com/simple", ) ) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --extra-index-url https://example.com/simple bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_url_false( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.add_repository( LegacyRepository( "custom", "https://example.com/simple", ) ) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.with_urls(False) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_legacy_packages_trusted_host( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.add_repository( LegacyRepository( "custom", "http://example.com/simple", ) ) lock_data: dict[str, Any] = { "package": [ { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "http://example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --trusted-host example.com --extra-index-url http://example.com/simple bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 """ assert content == expected @pytest.mark.parametrize( ["dev", "expected"], [ ( True, [ f"bar==1.2.2 ; {MARKER_PY}", f"baz==1.2.3 ; {MARKER_PY}", f"foo==1.2.1 ; {MARKER_PY}", ], ), ( False, [ f"bar==1.2.2 ; {MARKER_PY}", f"foo==1.2.1 ; {MARKER_PY}", ], ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_dev_extras( tmp_path: Path, poetry: Poetry, dev: bool, expected: list[str], lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.1", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "1.2.2", "optional": False, "python-versions": "*", "dependencies": { "baz": { "version": ">=0.1.0", "optional": True, "markers": "extra == 'baz'", } }, "extras": {"baz": ["baz (>=0.1.0)"]}, }, { "name": "baz", "version": "1.2.3", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][2]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"baz"}) exporter = Exporter(poetry, NullIO()) if dev: exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() assert content == "\n".join(expected) + "\n" @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_legacy_packages_and_duplicate_sources( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.add_repository( LegacyRepository( "custom-example", "https://example.com/simple", ) ) poetry.pool.add_repository( LegacyRepository( "custom-foobaz", "https://foobaz.com/simple", ) ) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://example.com/simple", "reference": "", }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://example.com/simple", "reference": "", }, }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://foobaz.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], "baz": [{"name": "baz.whl", "hash": "24680"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] lock_data["package"][2]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar", "baz"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --extra-index-url https://example.com/simple --extra-index-url https://foobaz.com/simple bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 baz==7.8.9 ; {MARKER_PY} \\ --hash=sha256:24680 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_two_primary_sources( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.remove_repository("PyPI") poetry.config.merge( { "repositories": { "custom-a": {"url": "https://a.example.com/simple"}, "custom-b": {"url": "https://b.example.com/simple"}, }, "http-basic": { "custom-a": {"username": "foo", "password": "bar"}, "custom-b": {"username": "baz", "password": "qux"}, }, } ) poetry.pool.add_repository( LegacyRepository( "custom-b", "https://b.example.com/simple", config=poetry.config, ), ) poetry.pool.add_repository( LegacyRepository( "custom-a", "https://a.example.com/simple", config=poetry.config, ), ) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://a.example.com/simple", "reference": "", }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://b.example.com/simple", "reference": "", }, }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://b.example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], "baz": [{"name": "baz.whl", "hash": "24680"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] lock_data["package"][2]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar", "baz"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.with_credentials() exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --index-url https://baz:qux@b.example.com/simple --extra-index-url https://foo:bar@a.example.com/simple bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 baz==7.8.9 ; {MARKER_PY} \\ --hash=sha256:24680 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_with_legacy_packages_and_credentials( tmp_path: Path, poetry: Poetry, config: Config, lock_version: str ) -> None: poetry.config.merge( { "repositories": {"custom": {"url": "https://example.com/simple"}}, "http-basic": {"custom": {"username": "foo", "password": "bar"}}, } ) poetry.pool.add_repository( LegacyRepository("custom", "https://example.com/simple", config=poetry.config) ) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][1]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.with_credentials() exporter.export( "requirements.txt", tmp_path, "requirements.txt", ) with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --extra-index-url https://foo:bar@example.com/simple bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_requirements_txt_to_standard_output( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) io = BufferedIO() exporter.export("requirements.txt", tmp_path, io) expected = f"""\ bar==4.5.6 ; {MARKER_PY} foo==1.2.3 ; {MARKER_PY} """ assert io.fetch_output() == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_doesnt_confuse_repeated_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: # Testcase derived from . lock_data: dict[str, Any] = { "package": [ { "name": "celery", "version": "5.1.2", "optional": False, "python-versions": "<3.7", "dependencies": { "click": ">=7.0,<8.0", "click-didyoumean": ">=0.0.3", "click-plugins": ">=1.1.1", }, }, { "name": "celery", "version": "5.2.3", "optional": False, "python-versions": ">=3.7", "dependencies": { "click": ">=8.0.3,<9.0", "click-didyoumean": ">=0.0.3", "click-plugins": ">=1.1.1", }, }, { "name": "click", "version": "7.1.2", "optional": False, "python-versions": ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*", }, { "name": "click", "version": "8.0.3", "optional": False, "python-versions": ">=3.6", "dependencies": {}, }, { "name": "click-didyoumean", "version": "0.0.3", "optional": False, "python-versions": "*", "dependencies": {"click": "*"}, }, { "name": "click-didyoumean", "version": "0.3.0", "optional": False, "python-versions": ">=3.6.2,<4.0.0", "dependencies": {"click": ">=7"}, }, { "name": "click-plugins", "version": "1.1.1", "optional": False, "python-versions": "*", "dependencies": {"click": ">=4.0"}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.6", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), "files": { "celery": [], "click-didyoumean": [], "click-plugins": [], "click": [], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.7'" lock_data["package"][1]["markers"] = "python_version >= '3.7'" lock_data["package"][2]["markers"] = "python_version < '3.7'" lock_data["package"][3]["markers"] = "python_version >= '3.7'" lock_data["package"][4]["markers"] = "python_full_version < '3.6.2'" lock_data["package"][5]["markers"] = "python_full_version >= '3.6.2'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.6" root.add_dependency( Factory.create_dependency( name="celery", constraint={"version": "5.1.2", "python": "<3.7"} ) ) root.add_dependency( Factory.create_dependency( name="celery", constraint={"version": "5.2.3", "python": ">=3.7"} ) ) poetry._package = root exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) io = BufferedIO() exporter.export("requirements.txt", tmp_path, io) expected = f"""\ celery==5.1.2 ; {MARKER_PY36_ONLY} celery==5.2.3 ; {MARKER_PY37} click-didyoumean==0.0.3 ; {MARKER_PY36_PY362 if lock_version == "2.1" else MARKER_PY36_PY362_ALT} click-didyoumean==0.3.0 ; {MARKER_PY362_PY40} click-plugins==1.1.1 ; {MARKER_PY36} click==7.1.2 ; {MARKER_PY36_ONLY} click==8.0.3 ; {MARKER_PY37} """ assert io.fetch_output() == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_handles_extras_next_to_non_extras( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: # Testcase similar to the solver testcase added at #5305. lock_data = { "package": [ { "name": "localstack", "python-versions": "*", "version": "1.0.0", "optional": False, "dependencies": { "localstack-ext": [ {"version": ">=1.0.0"}, { "version": ">=1.0.0", "extras": ["bar"], "markers": 'extra == "foo"', }, ] }, "extras": {"foo": ["localstack-ext[bar] (>=1.0.0)"]}, }, { "name": "localstack-ext", "python-versions": "*", "version": "1.0.0", "optional": False, "dependencies": { "something": "*", "something-else": { "version": ">=1.0.0", "markers": 'extra == "bar"', }, "another-thing": { "version": ">=1.0.0", "markers": 'extra == "baz"', }, }, "extras": { "bar": ["something-else (>=1.0.0)"], "baz": ["another-thing (>=1.0.0)"], }, }, { "name": "something", "python-versions": "*", "version": "1.0.0", "optional": False, "dependencies": {}, }, { "name": "something-else", "python-versions": "*", "version": "1.0.0", "optional": False, "dependencies": {}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.6", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), "files": { "localstack": [], "localstack-ext": [], "something": [], "something-else": [], "another-thing": [], }, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.6" root.add_dependency( Factory.create_dependency( name="localstack", constraint={"version": "^1.0.0", "extras": ["foo"]} ) ) poetry._package = root exporter = Exporter(poetry, NullIO()) io = BufferedIO() exporter.export("requirements.txt", tmp_path, io) # It does not matter whether packages are exported with extras or not # because all dependencies are listed explicitly. if lock_version == "1.1": expected = f"""\ localstack-ext==1.0.0 ; {MARKER_PY36} localstack-ext[bar]==1.0.0 ; {MARKER_PY36} localstack[foo]==1.0.0 ; {MARKER_PY36} something-else==1.0.0 ; {MARKER_PY36} something==1.0.0 ; {MARKER_PY36} """ else: expected = f"""\ localstack-ext==1.0.0 ; {MARKER_PY36} localstack==1.0.0 ; {MARKER_PY36} something-else==1.0.0 ; {MARKER_PY36} something==1.0.0 ; {MARKER_PY36} """ assert io.fetch_output() == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_handles_overlapping_python_versions( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: # Testcase derived from # https://github.com/python-poetry/poetry-plugin-export/issues/32. lock_data: dict[str, Any] = { "package": [ { "name": "ipython", "python-versions": ">=3.6", "version": "7.16.3", "optional": False, "dependencies": {}, }, { "name": "ipython", "python-versions": ">=3.7", "version": "7.34.0", "optional": False, "dependencies": {}, }, { "name": "slash", "python-versions": ">=3.6.*", "version": "1.13.0", "optional": False, "dependencies": { "ipython": [ { "version": "*", "markers": ( 'python_version >= "3.6" and implementation_name !=' ' "pypy"' ), }, { "version": "<7.17.0", "markers": ( 'python_version < "3.6" and implementation_name !=' ' "pypy"' ), }, ], }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.6", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), "files": { "ipython": [], "slash": [], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = ( "python_version >= '3.6' and python_version < '3.7'" ) lock_data["package"][1]["markers"] = "python_version >= '3.7'" lock_data["package"][2]["markers"] = "implementation_name == 'cpython'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.6" root.add_dependency( Factory.create_dependency( name="ipython", constraint={"version": "*", "python": "~3.6"}, ) ) root.add_dependency( Factory.create_dependency( name="ipython", constraint={"version": "^7.17", "python": "^3.7"}, ) ) root.add_dependency( Factory.create_dependency( name="slash", constraint={ "version": "^1.12", "markers": "implementation_name == 'cpython'", }, ) ) poetry._package = root exporter = Exporter(poetry, NullIO()) io = BufferedIO() exporter.export("requirements.txt", tmp_path, io) expected = f"""\ ipython==7.16.3 ; {MARKER_PY36_ONLY} ipython==7.34.0 ; {MARKER_PY37} slash==1.13.0 ; {MARKER_PY36} and {MARKER_CPYTHON} """ assert io.fetch_output() == expected @pytest.mark.parametrize( ["with_extras", "expected"], [ ( True, [f"foo[test]==1.0.0 ; {MARKER_PY36}", f"pytest==6.24.0 ; {MARKER_PY36}"], ), ( False, [f"foo==1.0.0 ; {MARKER_PY36}"], ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_omits_unwanted_extras( tmp_path: Path, poetry: Poetry, with_extras: bool, expected: list[str], lock_version: str, ) -> None: # Testcase derived from # https://github.com/python-poetry/poetry/issues/5779 lock_data: dict[str, Any] = { "package": [ { "name": "foo", "python-versions": ">=3.6", "version": "1.0.0", "optional": False, "dependencies": {"pytest": {"version": "^6.2.4", "optional": True}}, "extras": {"test": ["pytest (>=6.2.4,<7.0.0)"]}, }, { "name": "pytest", "python-versions": ">=3.6", "version": "6.24.0", "optional": False, "dependencies": {}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.6", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), "files": { "foo": [], "pytest": [], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["groups"] = ["main", "with-extras"] lock_data["package"][1]["groups"] = ["with-extras"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.6" root.add_dependency( Factory.create_dependency( name="foo", constraint={"version": "*"}, ) ) root.add_dependency( Factory.create_dependency( name="foo", constraint={"version": "*", "extras": ["test"]}, groups=["with-extras"], ) ) poetry._package = root io = BufferedIO() exporter = Exporter(poetry, NullIO()) if with_extras: exporter.only_groups(["with-extras"]) # It does not matter whether packages are exported with extras or not # because all dependencies are listed explicitly. if lock_version == "2.1": expected = [req.replace("foo[test]", "foo") for req in expected] exporter.export("requirements.txt", tmp_path, io) assert io.fetch_output() == "\n".join(expected) + "\n" @pytest.mark.parametrize( ["fmt", "expected"], [ ( "constraints.txt", [ f"bar==4.5.6 ; {MARKER_PY}", f"baz==7.8.9 ; {MARKER_PY}", f"foo==1.2.3 ; {MARKER_PY}", ], ), ( "requirements.txt", [ f"bar==4.5.6 ; {MARKER_PY}", f"bar[baz]==4.5.6 ; {MARKER_PY}", f"baz==7.8.9 ; {MARKER_PY}", f"foo==1.2.3 ; {MARKER_PY}", ], ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_omits_and_includes_extras_for_txt_formats( tmp_path: Path, poetry: Poetry, fmt: str, expected: list[str], lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": { "bar": { "extras": ["baz"], "version": ">=0.1.0", } }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "dependencies": { "baz": { "version": ">=0.1.0", "optional": True, "markers": "extra == 'baz'", } }, "extras": {"baz": ["baz (>=0.1.0)"]}, }, { "name": "baz", "version": "7.8.9", "optional": False, "python-versions": "*", }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export(fmt, tmp_path, "exported.txt") with (tmp_path / "exported.txt").open(encoding="utf-8") as f: content = f.read() # It does not matter whether packages are exported with extras or not # because all dependencies are listed explicitly. if lock_version == "2.1": expected = [req for req in expected if not req.startswith("bar[baz]")] assert content == "\n".join(expected) + "\n" @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_prints_warning_for_constraints_txt_with_editable_packages( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "git", "url": "https://github.com/foo/foo.git", "reference": "123456", }, "develop": True, }, { "name": "bar", "version": "7.8.9", "optional": False, "python-versions": "*", }, { "name": "baz", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "directory", "url": "sample_project", "reference": "", }, "develop": True, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": [], "baz": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) io = BufferedIO() exporter = Exporter(poetry, io) exporter.export("constraints.txt", tmp_path, "constraints.txt") expected_error_out = ( "Warning: foo is locked in develop (editable) mode, which is " "incompatible with the constraints.txt format.\n" "Warning: baz is locked in develop (editable) mode, which is " "incompatible with the constraints.txt format.\n" ) assert io.fetch_error() == expected_error_out with (tmp_path / "constraints.txt").open(encoding="utf-8") as f: content = f.read() assert content == f"bar==7.8.9 ; {MARKER_PY}\n" @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_respects_package_sources( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: lock_data: dict[str, Any] = { "package": [ { "name": "foo", "python-versions": ">=3.6", "version": "1.0.0", "optional": False, "dependencies": {}, "source": { "type": "url", "url": "https://example.com/foo-darwin.whl", }, }, { "name": "foo", "python-versions": ">=3.6", "version": "1.0.0", "optional": False, "dependencies": {}, "source": { "type": "url", "url": "https://example.com/foo-linux.whl", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.6", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), "files": { "foo": [], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "sys_platform == 'darwin'" lock_data["package"][1]["markers"] = "sys_platform == 'linux'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.6" root.add_dependency( Factory.create_dependency( name="foo", constraint={ "url": "https://example.com/foo-linux.whl", "platform": "linux", }, ) ) root.add_dependency( Factory.create_dependency( name="foo", constraint={ "url": "https://example.com/foo-darwin.whl", "platform": "darwin", }, ) ) poetry._package = root io = BufferedIO() exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, io) expected = f"""\ foo @ https://example.com/foo-darwin.whl ; {MARKER_PY36} and {MARKER_DARWIN} foo @ https://example.com/foo-linux.whl ; {MARKER_PY36} and {MARKER_LINUX} """ assert io.fetch_output() == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_tolerates_non_existent_extra( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: # foo actually has a 'bar' extra, but pyproject.toml mistakenly references a 'baz' # extra. lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": { "bar": { "version": ">=0.1.0", "optional": True, "markers": "extra == 'bar'", } }, "extras": {"bar": ["bar (>=0.1.0)"]}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.add_dependency( Factory.create_dependency( name="foo", constraint={"version": "^1.2", "extras": ["baz"]} ) ) poetry._package = root exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() if lock_version == "1.1": expected = f"""\ foo[baz]==1.2.3 ; {MARKER_PY27} or {MARKER_PY36} """ else: expected = f"""\ foo==1.2.3 ; {MARKER_PY27} or {MARKER_PY36} """ assert content == expected @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_exports_extra_index_url_and_trusted_host( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: poetry.pool.add_repository( LegacyRepository( "custom", "http://example.com/simple", ), priority=Priority.EXPLICIT, ) lock_data = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "dependencies": {"bar": "*"}, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "http://example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry) exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = f"""\ --trusted-host example.com --extra-index-url http://example.com/simple bar==4.5.6 ; {MARKER_PY} foo==1.2.3 ; {MARKER_PY} """ assert content == expected @pytest.mark.parametrize("lock_version", ("2.0", "2.1")) def test_exporter_not_confused_by_extras_in_sub_dependencies( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: # Testcase derived from # https://github.com/python-poetry/poetry-plugin-export/issues/208 lock_data: dict[str, Any] = { "package": [ { "name": "typer", "python-versions": ">=3.6", "version": "0.9.0", "optional": False, "files": [], "dependencies": { "click": ">=7.1.1,<9.0.0", "colorama": { "version": ">=0.4.3,<0.5.0", "optional": True, "markers": 'extra == "all"', }, }, "extras": {"all": ["colorama (>=0.4.3,<0.5.0)"]}, }, { "name": "click", "python-versions": ">=3.7", "version": "8.1.3", "optional": False, "files": [], "dependencies": { "colorama": { "version": "*", "markers": 'platform_system == "Windows"', } }, }, { "name": "colorama", "python-versions": ">=3.7", "version": "0.4.6", "optional": False, "files": [], }, ], "metadata": { "lock-version": lock_version, "python-versions": "^3.11", "content-hash": ( "832b13a88e5020c27cbcd95faa577bf0dbf054a65c023b45dc9442b640d414e6" ), }, } if lock_version == "2.1": for locked_package in lock_data["package"]: locked_package["groups"] = ["main"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] root = poetry.package.with_dependency_groups([], only=True) root.python_versions = "^3.11" root.add_dependency( Factory.create_dependency( name="typer", constraint={"version": "^0.9.0", "extras": ["all"]}, ) ) poetry._package = root io = BufferedIO() exporter = Exporter(poetry, NullIO()) exporter.export("requirements.txt", tmp_path, io) if lock_version == "2.0": expected = """\ click==8.1.3 ; python_version >= "3.11" and python_version < "4.0" colorama==0.4.6 ; python_version >= "3.11" and python_version < "4.0" typer[all]==0.9.0 ; python_version >= "3.11" and python_version < "4.0" """ else: expected = """\ click==8.1.3 ; python_version >= "3.11" and python_version < "4.0" colorama==0.4.6 ; python_version >= "3.11" and python_version < "4.0" typer==0.9.0 ; python_version >= "3.11" and python_version < "4.0" """ assert io.fetch_output() == expected @pytest.mark.parametrize( ("priorities", "expected"), [ ([("custom-a", Priority.PRIMARY), ("custom-b", Priority.PRIMARY)], ("a", "b")), ([("custom-b", Priority.PRIMARY), ("custom-a", Priority.PRIMARY)], ("b", "a")), ( [("custom-b", Priority.SUPPLEMENTAL), ("custom-a", Priority.PRIMARY)], ("a", "b"), ), ([("custom-b", Priority.EXPLICIT), ("custom-a", Priority.PRIMARY)], ("a", "b")), ( [ ("PyPI", Priority.PRIMARY), ("custom-a", Priority.PRIMARY), ("custom-b", Priority.PRIMARY), ], ("", "a", "b"), ), ( [ ("PyPI", Priority.EXPLICIT), ("custom-a", Priority.PRIMARY), ("custom-b", Priority.PRIMARY), ], ("", "a", "b"), ), ( [ ("custom-a", Priority.PRIMARY), ("custom-b", Priority.PRIMARY), ("PyPI", Priority.SUPPLEMENTAL), ], ("", "a", "b"), ), ], ) @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_exporter_index_urls( tmp_path: Path, poetry: Poetry, priorities: list[tuple[str, Priority]], expected: tuple[str, ...], lock_version: str, ) -> None: pypi = poetry.pool.repository("PyPI") poetry.pool.remove_repository("PyPI") for name, prio in priorities: if name.lower() == "pypi": repo = pypi else: repo = LegacyRepository(name, f"https://{name[-1]}.example.com/simple") poetry.pool.add_repository(repo, priority=prio) lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1.2.3", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://a.example.com/simple", "reference": "", }, }, { "name": "bar", "version": "4.5.6", "optional": False, "python-versions": "*", "source": { "type": "legacy", "url": "https://b.example.com/simple", "reference": "", }, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": { "foo": [{"name": "foo.whl", "hash": "12345"}], "bar": [{"name": "bar.whl", "hash": "67890"}], }, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["groups"] = ["dev"] poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] set_package_requires(poetry, dev={"bar"}) exporter = Exporter(poetry, NullIO()) exporter.only_groups([MAIN_GROUP, "dev"]) exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected_urls = [ f"--extra-index-url https://{name[-1]}.example.com/simple" for name in expected[1:] ] if expected[0]: expected_urls = [ f"--index-url https://{expected[0]}.example.com/simple", *expected_urls, ] url_string = "\n".join(expected_urls) expected_content = f"""\ {url_string} bar==4.5.6 ; {MARKER_PY} \\ --hash=sha256:67890 foo==1.2.3 ; {MARKER_PY} \\ --hash=sha256:12345 """ assert content == expected_content @pytest.mark.parametrize("lock_version", ("1.1", "2.1")) def test_dependency_walk_error( tmp_path: Path, poetry: Poetry, lock_version: str ) -> None: """ With lock file version 2.1 we can export lock files that resulted in a DependencyWalkerError with lower lock file versions. root ├── foo >=0 ; python_version < "3.9" ├── foo >=1 ; python_version >= "3.9" ├── bar ==1 ; python_version < "3.9" │ └── foo ==1 ; python_version < "3.9" └── bar ==2 ; python_version >= "3.9" └── foo ==2 ; python_version >= "3.9" Only considering the root dependency, foo 2 is a valid solution for all environments. However, due to bar depending on foo, foo 1 must be chosen for Python 3.8 and lower. """ lock_data: dict[str, Any] = { "package": [ { "name": "foo", "version": "1", "optional": False, "python-versions": "*", }, { "name": "foo", "version": "2", "optional": False, "python-versions": "*", }, { "name": "bar", "version": "1", "optional": False, "python-versions": "*", "dependencies": {"foo": "1"}, }, { "name": "bar", "version": "2", "optional": False, "python-versions": "*", "dependencies": {"foo": "2"}, }, ], "metadata": { "lock-version": lock_version, "python-versions": "*", "content-hash": "123456789", "files": {"foo": [], "bar": []}, }, } fix_lock_data(lock_data) if lock_version == "2.1": lock_data["package"][0]["markers"] = "python_version < '3.9'" lock_data["package"][1]["markers"] = "python_version >= '3.9'" lock_data["package"][2]["markers"] = "python_version < '3.9'" lock_data["package"][3]["markers"] = "python_version >= '3.9'" poetry.locker.mock_lock_data(lock_data) # type: ignore[attr-defined] poetry.package.python_versions = "^3.8" poetry.package.add_dependency( Factory.create_dependency( name="foo", constraint={"version": ">=0", "python": "<3.9"} ) ) poetry.package.add_dependency( Factory.create_dependency( name="foo", constraint={"version": ">=1", "python": ">=3.9"} ) ) poetry.package.add_dependency( Factory.create_dependency( name="bar", constraint={"version": "1", "python": "<3.9"} ) ) poetry.package.add_dependency( Factory.create_dependency( name="bar", constraint={"version": "2", "python": ">=3.9"} ) ) exporter = Exporter(poetry, NullIO()) if lock_version == "1.1": with pytest.raises(DependencyWalkerError): exporter.export("requirements.txt", tmp_path, "requirements.txt") return exporter.export("requirements.txt", tmp_path, "requirements.txt") with (tmp_path / "requirements.txt").open(encoding="utf-8") as f: content = f.read() expected = """\ bar==1 ; python_version == "3.8" bar==2 ; python_version >= "3.9" and python_version < "4.0" foo==1 ; python_version == "3.8" foo==2 ; python_version >= "3.9" and python_version < "4.0" """ assert content == expected