"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "tests/masonry/builders/test_editable_builder.py" between
poetry-1.1.15.tar.gz and poetry-1.2.0.tar.gz

About: Poetry is a tool for dependency management and packaging in Python.

test_editable_builder.py  (poetry-1.1.15):test_editable_builder.py  (poetry-1.2.0)
# -*- coding: utf-8 -*- from __future__ import annotations
from __future__ import unicode_literals
import csv
import json
import os import os
import shutil import shutil
from pathlib import Path
from typing import TYPE_CHECKING
import pytest import pytest
from cleo.io.null_io import NullIO
from deepdiff import DeepDiff
from poetry.core.semver.version import Version
from poetry.factory import Factory from poetry.factory import Factory
from poetry.io.null_io import NullIO
from poetry.masonry.builders.editable import EditableBuilder from poetry.masonry.builders.editable import EditableBuilder
from poetry.utils._compat import Path from poetry.repositories.installed_repository import InstalledRepository
from poetry.utils.env import EnvCommandError
from poetry.utils.env import EnvManager from poetry.utils.env import EnvManager
from poetry.utils.env import MockEnv from poetry.utils.env import MockEnv
from poetry.utils.env import VirtualEnv from poetry.utils.env import VirtualEnv
from poetry.utils.env import ephemeral_environment
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from poetry.poetry import Poetry
@pytest.fixture() @pytest.fixture()
def simple_poetry(): def simple_poetry() -> Poetry:
poetry = Factory().create_poetry( poetry = Factory().create_poetry(
Path(__file__).parent.parent.parent / "fixtures" / "simple_project" Path(__file__).parent.parent.parent / "fixtures" / "simple_project"
) )
return poetry return poetry
@pytest.fixture() @pytest.fixture()
def project_with_include(): def project_with_include() -> Poetry:
poetry = Factory().create_poetry( poetry = Factory().create_poetry(
Path(__file__).parent.parent.parent / "fixtures" / "with-include" Path(__file__).parent.parent.parent / "fixtures" / "with-include"
) )
return poetry return poetry
@pytest.fixture() @pytest.fixture()
def extended_poetry(): def extended_poetry() -> Poetry:
poetry = Factory().create_poetry( poetry = Factory().create_poetry(
Path(__file__).parent.parent.parent / "fixtures" / "extended_project" Path(__file__).parent.parent.parent / "fixtures" / "extended_project"
) )
return poetry return poetry
@pytest.fixture() @pytest.fixture()
def extended_without_setup_poetry(): def extended_without_setup_poetry() -> Poetry:
poetry = Factory().create_poetry( poetry = Factory().create_poetry(
Path(__file__).parent.parent.parent Path(__file__).parent.parent.parent
/ "fixtures" / "fixtures"
/ "extended_project_without_setup" / "extended_project_without_setup"
) )
return poetry return poetry
@pytest.fixture() @pytest.fixture()
def env_manager(simple_poetry): def env_manager(simple_poetry: Poetry) -> EnvManager:
return EnvManager(simple_poetry) return EnvManager(simple_poetry)
@pytest.fixture @pytest.fixture
def tmp_venv(tmp_dir, env_manager): def tmp_venv(tmp_dir: str, env_manager: EnvManager) -> VirtualEnv:
venv_path = Path(tmp_dir) / "venv" venv_path = Path(tmp_dir) / "venv"
env_manager.build_venv(str(venv_path)) env_manager.build_venv(str(venv_path))
venv = VirtualEnv(venv_path) venv = VirtualEnv(venv_path)
yield venv yield venv
shutil.rmtree(str(venv.path)) shutil.rmtree(str(venv.path))
def test_builder_installs_proper_files_for_standard_packages(simple_poetry, tmp_ def test_builder_installs_proper_files_for_standard_packages(
venv): simple_poetry: Poetry, tmp_venv: VirtualEnv
):
builder = EditableBuilder(simple_poetry, tmp_venv, NullIO()) builder = EditableBuilder(simple_poetry, tmp_venv, NullIO())
builder.build() builder.build()
assert tmp_venv._bin_dir.joinpath("foo").exists() assert tmp_venv._bin_dir.joinpath("foo").exists()
assert tmp_venv.site_packages.path.joinpath("simple_project.pth").exists() pth_file = "simple_project.pth"
assert simple_poetry.file.parent.resolve().as_posix() == tmp_venv.site_packa assert tmp_venv.site_packages.exists(pth_file)
ges.path.joinpath( assert (
"simple_project.pth" simple_poetry.file.parent.resolve().as_posix()
).read_text().strip( == tmp_venv.site_packages.find(pth_file)[0].read_text().strip(os.linesep
os.linesep )
) )
dist_info = tmp_venv.site_packages.path.joinpath("simple_project-1.2.3.dist- dist_info = "simple_project-1.2.3.dist-info"
info") assert tmp_venv.site_packages.exists(dist_info)
assert dist_info.exists()
dist_info = tmp_venv.site_packages.find(dist_info)[0]
assert dist_info.joinpath("INSTALLER").exists() assert dist_info.joinpath("INSTALLER").exists()
assert dist_info.joinpath("METADATA").exists() assert dist_info.joinpath("METADATA").exists()
assert dist_info.joinpath("RECORD").exists() assert dist_info.joinpath("RECORD").exists()
assert dist_info.joinpath("entry_points.txt").exists() assert dist_info.joinpath("entry_points.txt").exists()
assert dist_info.joinpath("direct_url.json").exists()
assert not DeepDiff(
{
"dir_info": {"editable": True},
"url": simple_poetry.file.path.parent.as_uri(),
},
json.loads(dist_info.joinpath("direct_url.json").read_text()),
)
assert "poetry" == dist_info.joinpath("INSTALLER").read_text() assert dist_info.joinpath("INSTALLER").read_text() == "poetry"
assert ( assert (
"[console_scripts]\nbaz=bar:baz.boom.bim\nfoo=foo:bar\nfox=fuz.foo:bar.b dist_info.joinpath("entry_points.txt").read_text()
az\n\n" == "[console_scripts]\nbaz=bar:baz.boom.bim\nfoo=foo:bar\n"
== dist_info.joinpath("entry_points.txt").read_text() "fox=fuz.foo:bar.baz\n\n"
) )
metadata = """\ metadata = """\
Metadata-Version: 2.1 Metadata-Version: 2.1
Name: simple-project Name: simple-project
Version: 1.2.3 Version: 1.2.3
Summary: Some description. Summary: Some description.
Home-page: https://python-poetry.org Home-page: https://python-poetry.org
License: MIT License: MIT
Keywords: packaging,dependency,poetry Keywords: packaging,dependency,poetry
Author: S├ębastien Eustace Author: S├ębastien Eustace
Author-email: sebastien@eustace.io Author-email: sebastien@eustace.io
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.* Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Classifier: License :: OSI Approved :: MIT License Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Topic :: Software Development :: Build Tools Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Software Development :: Libraries :: Python Modules
Project-URL: Documentation, https://python-poetry.org/docs Project-URL: Documentation, https://python-poetry.org/docs
Project-URL: Repository, https://github.com/python-poetry/poetry Project-URL: Repository, https://github.com/python-poetry/poetry
Description-Content-Type: text/x-rst Description-Content-Type: text/x-rst
My Package My Package
========== ==========
""" """
assert metadata == dist_info.joinpath("METADATA").read_text(encoding="utf-8" ) assert metadata == dist_info.joinpath("METADATA").read_text(encoding="utf-8" )
records = dist_info.joinpath("RECORD").read_text() with open(dist_info.joinpath("RECORD"), encoding="utf-8", newline="") as f:
assert str(tmp_venv.site_packages.path.joinpath("simple_project.pth")) in re reader = csv.reader(f)
cords records = list(reader)
assert str(tmp_venv._bin_dir.joinpath("foo")) in records
assert str(tmp_venv._bin_dir.joinpath("baz")) in records assert all(len(row) == 3 for row in records)
assert str(dist_info.joinpath("METADATA")) in records record_entries = {row[0] for row in records}
assert str(dist_info.joinpath("INSTALLER")) in records pth_file = "simple_project.pth"
assert str(dist_info.joinpath("entry_points.txt")) in records assert tmp_venv.site_packages.exists(pth_file)
assert str(dist_info.joinpath("RECORD")) in records assert str(tmp_venv.site_packages.find(pth_file)[0]) in record_entries
assert str(tmp_venv._bin_dir.joinpath("foo")) in record_entries
baz_script = """\ assert str(tmp_venv._bin_dir.joinpath("baz")) in record_entries
#!{python} assert str(dist_info.joinpath("METADATA")) in record_entries
assert str(dist_info.joinpath("INSTALLER")) in record_entries
assert str(dist_info.joinpath("entry_points.txt")) in record_entries
assert str(dist_info.joinpath("RECORD")) in record_entries
assert str(dist_info.joinpath("direct_url.json")) in record_entries
baz_script = f"""\
#!{tmp_venv.python}
import sys
from bar import baz from bar import baz
if __name__ == '__main__': if __name__ == '__main__':
baz.boom.bim() sys.exit(baz.boom.bim())
""".format( """
python=tmp_venv._bin("python")
)
assert baz_script == tmp_venv._bin_dir.joinpath("baz").read_text() assert baz_script == tmp_venv._bin_dir.joinpath("baz").read_text()
foo_script = """\ foo_script = f"""\
#!{python} #!{tmp_venv.python}
import sys
from foo import bar from foo import bar
if __name__ == '__main__': if __name__ == '__main__':
bar() sys.exit(bar())
""".format( """
python=tmp_venv._bin("python")
)
assert foo_script == tmp_venv._bin_dir.joinpath("foo").read_text() assert foo_script == tmp_venv._bin_dir.joinpath("foo").read_text()
fox_script = """\ fox_script = f"""\
#!{python} #!{tmp_venv.python}
import sys
from fuz.foo import bar from fuz.foo import bar
if __name__ == '__main__': if __name__ == '__main__':
bar.baz() sys.exit(bar.baz())
""".format( """
python=tmp_venv._bin("python")
)
assert fox_script == tmp_venv._bin_dir.joinpath("fox").read_text() assert fox_script == tmp_venv._bin_dir.joinpath("fox").read_text()
def test_builder_falls_back_on_setup_and_pip_for_packages_with_build_scripts( def test_builder_falls_back_on_setup_and_pip_for_packages_with_build_scripts(
extended_poetry, mocker: MockerFixture, extended_poetry: Poetry, tmp_dir: str
): ):
env = MockEnv(path=Path("/foo")) pip_install = mocker.patch("poetry.masonry.builders.editable.pip_install")
env = MockEnv(path=Path(tmp_dir) / "foo")
builder = EditableBuilder(extended_poetry, env, NullIO()) builder = EditableBuilder(extended_poetry, env, NullIO())
builder.build() builder.build()
pip_install.assert_called_once_with(
extended_poetry.pyproject.file.path.parent, env, upgrade=True, editable=
True
)
assert [] == env.executed
assert [ def test_builder_setup_generation_runs_with_pip_editable(tmp_dir: str) -> None:
[ # create an isolated copy of the project
"python", fixture = Path(__file__).parent.parent.parent / "fixtures" / "extended_proje
"-m", ct"
"pip", extended_project = Path(tmp_dir) / "extended_project"
"install",
"-e", shutil.copytree(fixture, extended_project)
str(extended_poetry.file.parent), assert extended_project.exists()
"--no-deps",
] poetry = Factory().create_poetry(extended_project)
] == env.executed
# we need a venv with setuptools since we are verifying setup.py builds
with ephemeral_environment(flags={"no-setuptools": False}) as venv:
builder = EditableBuilder(poetry, venv, NullIO())
builder.build()
# is the package installed?
repository = InstalledRepository.load(venv)
package = repository.package("extended-project", Version.parse("1.2.3"))
assert package.name == "extended-project"
# check for the module built by build.py
try:
output = venv.run_python_script(
"from extended_project import built; print(built.__file__)"
).strip()
except EnvCommandError:
pytest.fail("Unable to import built module")
else:
built_py = Path(output).resolve()
expected = extended_project / "extended_project" / "built.py"
# ensure the package was installed as editable
assert built_py == expected.resolve()
def test_builder_installs_proper_files_when_packages_configured( def test_builder_installs_proper_files_when_packages_configured(
project_with_include, tmp_venv project_with_include: Poetry, tmp_venv: VirtualEnv
): ):
builder = EditableBuilder(project_with_include, tmp_venv, NullIO()) builder = EditableBuilder(project_with_include, tmp_venv, NullIO())
builder.build() builder.build()
pth_file = tmp_venv.site_packages.path.joinpath("with_include.pth") pth_file = "with_include.pth"
assert pth_file.is_file() assert tmp_venv.site_packages.exists(pth_file)
pth_file = tmp_venv.site_packages.find(pth_file)[0]
paths = set() paths = set()
with pth_file.open() as f: with pth_file.open() as f:
for line in f.readlines(): for line in f.readlines():
line = line.strip(os.linesep) line = line.strip(os.linesep)
if line: if line:
paths.add(line) paths.add(line)
project_root = project_with_include.file.parent.resolve() project_root = project_with_include.file.parent.resolve()
expected = {project_root.as_posix(), project_root.joinpath("src").as_posix() } expected = {project_root.as_posix(), project_root.joinpath("src").as_posix() }
assert paths.issubset(expected) assert paths.issubset(expected)
assert len(paths) == len(expected) assert len(paths) == len(expected)
def test_builder_should_execute_build_scripts(extended_without_setup_poetry): def test_builder_should_execute_build_scripts(
env = MockEnv(path=Path("/foo")) mocker: MockerFixture, extended_without_setup_poetry: Poetry, tmp_dir: str
):
env = MockEnv(path=Path(tmp_dir) / "foo")
mocker.patch(
"poetry.masonry.builders.editable.build_environment"
).return_value.__enter__.return_value = env
builder = EditableBuilder(extended_without_setup_poetry, env, NullIO()) builder = EditableBuilder(extended_without_setup_poetry, env, NullIO())
builder.build() builder.build()
assert [ assert [
["python", str(extended_without_setup_poetry.file.parent / "build.py")] ["python", str(extended_without_setup_poetry.file.parent / "build.py")]
] == env.executed ] == env.executed
 End of changes. 34 change blocks. 
72 lines changed or deleted 140 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)