Edit - test_core_metadata.py

Edit: test_core_metadata.py

from __future__ import annotations

import functools
import importlib
import io
from email import message_from_string
from email.generator import Generator
from email.message import EmailMessage, Message
from email.parser import Parser
from email.policy import EmailPolicy
from inspect import cleandoc
from pathlib import Path
from unittest.mock import Mock

import jaraco.path
import pytest
from packaging.metadata import Metadata
from packaging.requirements import Requirement

from setuptools import _reqs, sic
from setuptools._core_metadata import rfc822_escape, rfc822_unescape
from setuptools.command.egg_info import egg_info, write_requirements
from setuptools.config import expand, setupcfg
from setuptools.dist import Distribution

from .config.downloads import retrieve_file, urls_from_file

EXAMPLE_BASE_INFO = dict(
    name="package",
    version="0.0.1",
    author="Foo Bar",
    author_email="foo@bar.net",
    long_description="Long\ndescription",
    description="Short description",
    keywords=["one", "two"],
)

@pytest.mark.parametrize(
    ("content", "result"),
    (
        pytest.param(
            "Just a single line",
            None,
            id="single_line",
        ),
        pytest.param(
            "Multiline\nText\nwithout\nextra indents\n",
            None,
            id="multiline",
        ),
        pytest.param(
            "Multiline\n    With\n\nadditional\n  indentation",
            None,
            id="multiline_with_indentation",
        ),
        pytest.param(
            "  Leading whitespace",
            "Leading whitespace",
            id="remove_leading_whitespace",
        ),
        pytest.param(
            "  Leading whitespace\nIn\n    Multiline comment",
            "Leading whitespace\nIn\n    Multiline comment",
            id="remove_leading_whitespace_multiline",
        ),
    ),
)
def test_rfc822_unescape(content, result):
    assert (result or content) == rfc822_unescape(rfc822_escape(content))

def __read_test_cases():
    base = EXAMPLE_BASE_INFO

params = functools.partial(dict, base)

return [
        ('Metadata version 1.0', params()),
        (
            'Metadata Version 1.0: Short long description',
            params(
                long_description='Short long description',
            ),
        ),
        (
            'Metadata version 1.1: Classifiers',
            params(
                classifiers=[
                    'Programming Language :: Python :: 3',
                    'Programming Language :: Python :: 3.7',
                    'License :: OSI Approved :: MIT License',
                ],
            ),
        ),
        (
            'Metadata version 1.1: Download URL',
            params(
                download_url='https://example.com',
            ),
        ),
        (
            'Metadata Version 1.2: Requires-Python',
            params(
                python_requires='>=3.7',
            ),
        ),
        pytest.param(
            'Metadata Version 1.2: Project-Url',
            params(project_urls=dict(Foo='https://example.bar')),
            marks=pytest.mark.xfail(
                reason="Issue #1578: project_urls not read",
            ),
        ),
        (
            'Metadata Version 2.1: Long Description Content Type',
            params(
                long_description_content_type='text/x-rst; charset=UTF-8',
            ),
        ),
        (
            'License',
            params(
                license='MIT',
            ),
        ),
        (
            'License multiline',
            params(
                license='This is a long license \nover multiple lines',
            ),
        ),
        pytest.param(
            'Metadata Version 2.1: Provides Extra',
            params(provides_extras=['foo', 'bar']),
            marks=pytest.mark.xfail(reason="provides_extras not read"),
        ),
        (
            'Missing author',
            dict(
                name='foo',
                version='1.0.0',
                author_email='snorri@sturluson.name',
            ),
        ),
        (
            'Missing author e-mail',
            dict(
                name='foo',
                version='1.0.0',
                author='Snorri Sturluson',
            ),
        ),
        (
            'Missing author and e-mail',
            dict(
                name='foo',
                version='1.0.0',
            ),
        ),
        (
            'Bypass normalized version',
            dict(
                name='foo',
                version=sic('1.0.0a'),
            ),
        ),
    ]

@pytest.mark.parametrize(("name", "attrs"), __read_test_cases())
def test_read_metadata(name, attrs):
    dist = Distribution(attrs)
    metadata_out = dist.metadata
    dist_class = metadata_out.__class__

# Write to PKG_INFO and then load into a new metadata object
    PKG_INFO = io.StringIO()

metadata_out.write_pkg_file(PKG_INFO)
    PKG_INFO.seek(0)
    pkg_info = PKG_INFO.read()
    assert _valid_metadata(pkg_info)

PKG_INFO.seek(0)
    metadata_in = dist_class()
    metadata_in.read_pkg_file(PKG_INFO)

tested_attrs = [
        ('name', dist_class.get_name),
        ('version', dist_class.get_version),
        ('author', dist_class.get_contact),
        ('author_email', dist_class.get_contact_email),
        ('metadata_version', dist_class.get_metadata_version),
        ('provides', dist_class.get_provides),
        ('description', dist_class.get_description),
        ('long_description', dist_class.get_long_description),
        ('download_url', dist_class.get_download_url),
        ('keywords', dist_class.get_keywords),
        ('platforms', dist_class.get_platforms),
        ('obsoletes', dist_class.get_obsoletes),
        ('requires', dist_class.get_requires),
        ('classifiers', dist_class.get_classifiers),
        ('project_urls', lambda s: getattr(s, 'project_urls', {})),
        ('provides_extras', lambda s: getattr(s, 'provides_extras', {})),
    ]

for attr, getter in tested_attrs:
        assert getter(metadata_in) == getter(metadata_out)

def __maintainer_test_cases():
    attrs = {"name": "package", "version": "1.0", "description": "xxx"}

def merge_dicts(d1, d2):
        d1 = d1.copy()
        d1.update(d2)

return d1

return [
        ('No author, no maintainer', attrs.copy()),
        (
            'Author (no e-mail), no maintainer',
            merge_dicts(attrs, {'author': 'Author Name'}),
        ),
        (
            'Author (e-mail), no maintainer',
            merge_dicts(
                attrs, {'author': 'Author Name', 'author_email': 'author@name.com'}
            ),
        ),
        (
            'No author, maintainer (no e-mail)',
            merge_dicts(attrs, {'maintainer': 'Maintainer Name'}),
        ),
        (
            'No author, maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'maintainer': 'Maintainer Name',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        (
            'Author (no e-mail), Maintainer (no-email)',
            merge_dicts(
                attrs, {'author': 'Author Name', 'maintainer': 'Maintainer Name'}
            ),
        ),
        (
            'Author (e-mail), Maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'author': 'Author Name',
                    'author_email': 'author@name.com',
                    'maintainer': 'Maintainer Name',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        (
            'No author (e-mail), no maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'author_email': 'author@name.com',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        ('Author unicode', merge_dicts(attrs, {'author': '鉄沢寛'})),
        ('Maintainer unicode', merge_dicts(attrs, {'maintainer': 'Jan Łukasiewicz'})),
    ]

@pytest.mark.parametrize(("name", "attrs"), __maintainer_test_cases())
def test_maintainer_author(name, attrs, tmpdir):
    tested_keys = {
        'author': 'Author',
        'author_email': 'Author-email',
        'maintainer': 'Maintainer',
        'maintainer_email': 'Maintainer-email',
    }

# Generate a PKG-INFO file
    dist = Distribution(attrs)
    fn = tmpdir.mkdir('pkg_info')
    fn_s = str(fn)

dist.metadata.write_pkg_info(fn_s)

with open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f:
        pkg_info = f.read()

assert _valid_metadata(pkg_info)

# Drop blank lines and strip lines from default description
    raw_pkg_lines = pkg_info.splitlines()
    pkg_lines = list(filter(None, raw_pkg_lines[:-2]))

pkg_lines_set = set(pkg_lines)

# Duplicate lines should not be generated
    assert len(pkg_lines) == len(pkg_lines_set)

for fkey, dkey in tested_keys.items():
        val = attrs.get(dkey, None)
        if val is None:
            for line in pkg_lines:
                assert not line.startswith(fkey + ':')
        else:
            line = f'{fkey}: {val}'
            assert line in pkg_lines_set

class TestParityWithMetadataFromPyPaWheel:
    def base_example(self):
        attrs = dict(
            **EXAMPLE_BASE_INFO,
            # Example with complex requirement definition
            python_requires=">=3.8",
            install_requires="""
            packaging==23.2
            more-itertools==8.8.0; extra == "other"
            jaraco.text==3.7.0
            importlib-resources==5.10.2; python_version<"3.8"
            importlib-metadata==6.0.0 ; python_version<"3.8"
            colorama>=0.4.4; sys_platform == "win32"
            """,
            extras_require={
                "testing": """
                    pytest >= 6
                    pytest-checkdocs >= 2.4
                    tomli ; \\
                            # Using stdlib when possible
                            python_version < "3.11"
                    ini2toml[lite]>=0.9
                    """,
                "other": [],
            },
        )
        # Generate a PKG-INFO file using setuptools
        return Distribution(attrs)

def test_requires_dist(self, tmp_path):
        dist = self.base_example()
        pkg_info = _get_pkginfo(dist)
        assert _valid_metadata(pkg_info)

# Ensure Requires-Dist is present
        expected = [
            'Metadata-Version:',
            'Requires-Python: >=3.8',
            'Provides-Extra: other',
            'Provides-Extra: testing',
            'Requires-Dist: tomli; python_version < "3.11" and extra == "testing"',
            'Requires-Dist: more-itertools==8.8.0; extra == "other"',
            'Requires-Dist: ini2toml[lite]>=0.9; extra == "testing"',
        ]
        for line in expected:
            assert line in pkg_info

HERE = Path(__file__).parent
    EXAMPLES_FILE = HERE / "config/setupcfg_examples.txt"

@pytest.fixture(params=[None, *urls_from_file(EXAMPLES_FILE)])
    def dist(self, request, monkeypatch, tmp_path):
        """Example of distribution with arbitrary configuration"""
        monkeypatch.chdir(tmp_path)
        monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.42"))
        monkeypatch.setattr(expand, "read_files", Mock(return_value="hello world"))
        monkeypatch.setattr(
            Distribution, "_finalize_license_files", Mock(return_value=None)
        )
        if request.param is None:
            yield self.base_example()
        else:
            # Real-world usage
            config = retrieve_file(request.param)
            yield setupcfg.apply_configuration(Distribution({}), config)

@pytest.mark.uses_network
    def test_equivalent_output(self, tmp_path, dist):
        """Ensure output from setuptools is equivalent to the one from `pypa/wheel`"""
        # Generate a METADATA file using pypa/wheel for comparison
        wheel_metadata = importlib.import_module("wheel.metadata")
        pkginfo_to_metadata = getattr(wheel_metadata, "pkginfo_to_metadata", None)

if pkginfo_to_metadata is None:  # pragma: nocover
            pytest.xfail(
                "wheel.metadata.pkginfo_to_metadata is undefined, "
                "(this is likely to be caused by API changes in pypa/wheel"
            )

# Generate an simplified "egg-info" dir for pypa/wheel to convert
        pkg_info = _get_pkginfo(dist)
        egg_info_dir = tmp_path / "pkg.egg-info"
        egg_info_dir.mkdir(parents=True)
        (egg_info_dir / "PKG-INFO").write_text(pkg_info, encoding="utf-8")
        write_requirements(egg_info(dist), egg_info_dir, egg_info_dir / "requires.txt")

# Get pypa/wheel generated METADATA but normalize requirements formatting
        metadata_msg = pkginfo_to_metadata(egg_info_dir, egg_info_dir / "PKG-INFO")
        metadata_str = _normalize_metadata(metadata_msg)
        pkg_info_msg = message_from_string(pkg_info)
        pkg_info_str = _normalize_metadata(pkg_info_msg)

# Compare setuptools PKG-INFO x pypa/wheel METADATA
        assert metadata_str == pkg_info_str

# Make sure it parses/serializes well in pypa/wheel
        _assert_roundtrip_message(pkg_info)

class TestPEP643:
    STATIC_CONFIG = {
        "setup.cfg": cleandoc(
            """
            [metadata]
            name = package
            version = 0.0.1
            author = Foo Bar
            author_email = foo@bar.net
            long_description = Long
                               description
            description = Short description
            keywords = one, two
            platforms = abcd
            [options]
            install_requires = requests
            """
        ),
        "pyproject.toml": cleandoc(
            """
            [project]
            name = "package"
            version = "0.0.1"
            authors = [
              {name = "Foo Bar", email = "foo@bar.net"}
            ]
            description = "Short description"
            readme = {text = "Long\\ndescription", content-type = "text/plain"}
            keywords = ["one", "two"]
            dependencies = ["requests"]
            license = "AGPL-3.0-or-later"
            [tool.setuptools]
            provides = ["abcd"]
            obsoletes = ["abcd"]
            """
        ),
    }

@pytest.mark.parametrize("file", STATIC_CONFIG.keys())
    def test_static_config_has_no_dynamic(self, file, tmpdir_cwd):
        Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
        metadata = _get_metadata()
        assert metadata.get_all("Dynamic") is None
        assert metadata.get_all("dynamic") is None

@pytest.mark.parametrize("file", STATIC_CONFIG.keys())
    @pytest.mark.parametrize(
        "fields",
        [
            # Single dynamic field
            {"requires-python": ("python_requires", ">=3.12")},
            {"author-email": ("author_email", "snoopy@peanuts.com")},
            {"keywords": ("keywords", ["hello", "world"])},
            {"platform": ("platforms", ["abcd"])},
            # Multiple dynamic fields
            {
                "summary": ("description", "hello world"),
                "description": ("long_description", "bla bla bla bla"),
                "requires-dist": ("install_requires", ["hello-world"]),
            },
        ],
    )
    def test_modified_fields_marked_as_dynamic(self, file, fields, tmpdir_cwd):
        # We start with a static config
        Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
        dist = _makedist()

# ... but then we simulate the effects of a plugin modifying the distribution
        for attr, value in fields.values():
            # `dist` and `dist.metadata` are complicated...
            # Some attributes work when set on `dist`, others on `dist.metadata`...
            # Here we set in both just in case (this also avoids calling `_finalize_*`)
            setattr(dist, attr, value)
            setattr(dist.metadata, attr, value)

# Then we should be able to list the modified fields as Dynamic
        metadata = _get_metadata(dist)
        assert set(metadata.get_all("Dynamic")) == set(fields)

@pytest.mark.parametrize(
        "extra_toml",
        [
            "# Let setuptools autofill license-files",
            "license-files = ['LICENSE*', 'AUTHORS*', 'NOTICE']",
        ],
    )
    def test_license_files_dynamic(self, extra_toml, tmpdir_cwd):
        # For simplicity (and for the time being) setuptools is not making
        # any special handling to guarantee `License-File` is considered static.
        # Instead we rely in the fact that, although suboptimal, it is OK to have
        # it as dynamics, as per:
        # https://github.com/pypa/setuptools/issues/4629#issuecomment-2331233677
        files = {
            "pyproject.toml": self.STATIC_CONFIG["pyproject.toml"].replace(
                'license = "AGPL-3.0-or-later"',
                f"dynamic = ['license']\n{extra_toml}",
            ),
            "LICENSE.md": "--- mock license ---",
            "NOTICE": "--- mock notice ---",
            "AUTHORS.txt": "--- me ---",
        }
        # Sanity checks:
        assert extra_toml in files["pyproject.toml"]
        assert 'license = "AGPL-3.0-or-later"' not in extra_toml

jaraco.path.build(files)
        dist = _makedist(license_expression="AGPL-3.0-or-later")
        metadata = _get_metadata(dist)
        assert set(metadata.get_all("Dynamic")) == {
            'license-file',
            'license-expression',
        }
        assert metadata.get("License-Expression") == "AGPL-3.0-or-later"
        assert set(metadata.get_all("License-File")) == {
            "NOTICE",
            "AUTHORS.txt",
            "LICENSE.md",
        }

def _makedist(**attrs):
    dist = Distribution(attrs)
    dist.parse_config_files()
    return dist

def _assert_roundtrip_message(metadata: str) -> None:
    """Emulate the way wheel.bdist_wheel parses and regenerates the message,
    then ensures the metadata generated by setuptools is compatible.
    """
    with io.StringIO(metadata) as buffer:
        msg = Parser(EmailMessage).parse(buffer)

serialization_policy = EmailPolicy(
        utf8=True,
        mangle_from_=False,
        max_line_length=0,
    )
    with io.BytesIO() as buffer:
        out = io.TextIOWrapper(buffer, encoding="utf-8")
        Generator(out, policy=serialization_policy).flatten(msg)
        out.flush()
        regenerated = buffer.getvalue()

raw_metadata = bytes(metadata, "utf-8")
    # Normalise newlines to avoid test errors on Windows:
    raw_metadata = b"\n".join(raw_metadata.splitlines())
    regenerated = b"\n".join(regenerated.splitlines())
    assert regenerated == raw_metadata

def _normalize_metadata(msg: Message) -> str:
    """Allow equivalent metadata to be compared directly"""
    # The main challenge regards the requirements and extras.
    # Both setuptools and wheel already apply some level of normalization
    # but they differ regarding which character is chosen, according to the
    # following spec it should be "-":
    # https://packaging.python.org/en/latest/specifications/name-normalization/

# Related issues:
    # https://github.com/pypa/packaging/issues/845
    # https://github.com/pypa/packaging/issues/644#issuecomment-2429813968

extras = {x.replace("_", "-"): x for x in msg.get_all("Provides-Extra", [])}
    reqs = [
        _normalize_req(req, extras)
        for req in _reqs.parse(msg.get_all("Requires-Dist", []))
    ]
    del msg["Requires-Dist"]
    del msg["Provides-Extra"]

# Ensure consistent ord
    for req in sorted(reqs):
        msg["Requires-Dist"] = req
    for extra in sorted(extras):
        msg["Provides-Extra"] = extra

# TODO: Handle lack of PEP 643 implementation in pypa/wheel?
    del msg["Metadata-Version"]

return msg.as_string()

def _normalize_req(req: Requirement, extras: dict[str, str]) -> str:
    """Allow equivalent requirement objects to be compared directly"""
    as_str = str(req).replace(req.name, req.name.replace("_", "-"))
    for norm, orig in extras.items():
        as_str = as_str.replace(orig, norm)
    return as_str

def _get_pkginfo(dist: Distribution):
    with io.StringIO() as fp:
        dist.metadata.write_pkg_file(fp)
        return fp.getvalue()

def _get_metadata(dist: Distribution | None = None):
    return message_from_string(_get_pkginfo(dist or _makedist()))

def _valid_metadata(text: str) -> bool:
    metadata = Metadata.from_email(text, validate=True)  # can raise exceptions
    return metadata is not None

Cancel