initial commit

env/lib/python3.10/site-packages/pkginfo/tests/__init__.py

@@ -0,0 +1,37 @@
+# requirements
+
+
+def _checkSample(testcase, installed):
+    try:
+        from importlib import metadata as importlib_metadata
+    except ImportError:  # python < 3.8
+        import importlib_metadata
+
+    version = importlib_metadata.version('pkginfo')
+    testcase.assertEqual(installed.version, version)
+    testcase.assertEqual(installed.name, 'pkginfo')
+    testcase.assertEqual(installed.keywords,
+                        'distribution sdist installed metadata' )
+    testcase.assertEqual(list(installed.supported_platforms), [])
+
+def _checkClassifiers(testcase, installed):
+    testcase.assertEqual(list(installed.classifiers),
+                         [
+      'Intended Audience :: Developers',
+      'License :: OSI Approved :: MIT License',
+      'Operating System :: OS Independent',
+      'Programming Language :: Python :: 3.7',
+      'Programming Language :: Python :: 3.8',
+      'Programming Language :: Python :: 3.9',
+      'Programming Language :: Python :: 3.10',
+      'Programming Language :: Python :: 3.11',
+      'Programming Language :: Python :: 3.12',
+      'Programming Language :: Python :: Implementation :: CPython',
+      'Programming Language :: Python :: Implementation :: PyPy',
+      'Topic :: Software Development :: Libraries :: Python Modules',
+      'Topic :: System :: Software Distribution',
+    ])
+
+
+def _defaultMetadataVersion():
+    return '2.1'

env/lib/python3.10/site-packages/pkginfo/tests/test_bdist.py

@@ -0,0 +1,60 @@
+import unittest
+
+class BDistTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.bdist import BDist
+        return BDist
+
+    def _makeOne(self, filename=None, metadata_version=None):
+        if metadata_version is not None:
+            return self._getTargetClass()(filename, metadata_version)
+        return self._getTargetClass()(filename)
+
+    def _checkSample(self, bdist, filename):
+        self.assertEqual(bdist.filename, filename)
+        self.assertEqual(bdist.name, 'mypackage')
+        self.assertEqual(bdist.version, '0.1')
+        self.assertEqual(bdist.keywords, None)
+
+    def _checkClassifiers(self, bdist):
+        self.assertEqual(list(bdist.classifiers),
+                         ['Development Status :: 4 - Beta',
+                          'Environment :: Console (Text Based)',
+                         ])
+        self.assertEqual(list(bdist.supported_platforms), [])
+
+    def test_ctor_w_bogus_filename(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nonesuch-0.1-py2.6.egg' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_w_non_egg(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_wo_PKG_INFO(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nopkginfo-0.1.egg' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_w_egg(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1-py2.6.egg' % d
+        bdist = self._makeOne(filename)
+        self.assertEqual(bdist.metadata_version, '1.0')
+        self._checkSample(bdist, filename)
+
+    def test_ctor_w_egg_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1-py2.6.egg' % d
+        bdist = self._makeOne(filename, metadata_version='1.1')
+        self.assertEqual(bdist.metadata_version, '1.1')
+        self._checkSample(bdist, filename)
+        self._checkClassifiers(bdist)

env/lib/python3.10/site-packages/pkginfo/tests/test_commandline.py

@@ -0,0 +1,345 @@
+import collections
+import io
+import json as json_module
+import sys
+import unittest
+
+class Test__parse_options(unittest.TestCase):
+
+    def _callFUT(self, args):
+        from pkginfo.commandline import _parse_options
+        return _parse_options(args)
+
+    def test_empty(self):
+        from pkginfo.commandline import __doc__ as usage
+
+        firstline = usage.splitlines()[0]
+        buf = io.StringIO()
+
+        with _Monkey(sys, stderr=buf):
+            self.assertRaises(SystemExit, self._callFUT, [])
+        self.assertTrue(firstline in buf.getvalue())
+
+    def test_nonempty(self):
+        options, args = self._callFUT(['foo'])
+        self.assertEqual(args, ['foo'])
+
+class BaseTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import Base
+
+        return Base
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___init___defaults(self):
+        base = self._makeOne(_Options(fields=()))
+        self.assertTrue(base._fields is None)
+
+    def test___init___w_fields(self):
+        fields = object()
+        base = self._makeOne(_Options(fields=fields))
+        self.assertTrue(base._fields is fields)
+
+class _FormatterBase(object):
+
+    def _capture_output(self, func, *args, **kw):
+        buf = io.StringIO()
+
+        with _Monkey(sys, stdout=buf):
+            func(*args, **kw)
+        return buf.getvalue()
+
+    def _no_output(self, simple, meta):
+        with _Monkey(sys, stdout=object()):  # raise if write
+            simple(meta)
+
+class SimpleTests(unittest.TestCase, _FormatterBase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import Simple
+        return Simple
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___init___(self):
+        simple = self._makeOne(_Options(fields=None, skip=True))
+        self.assertTrue(simple._skip)
+
+    def test___call___w_empty_fields(self):
+        simple = self._makeOne(_Options(fields=(), skip=False))
+        meta = _Meta()
+        self._no_output(simple, meta)
+
+    def test___call___w_skip_and_value_None_no_fields(self):
+        simple = self._makeOne(_Options(fields=(), skip=True))
+        meta = _Meta(foo=None)
+        self._no_output(simple, meta)
+
+    def test___call___w_skip_and_value_empty_tuple_explicit_fields(self):
+        simple = self._makeOne(_Options(fields=('foo',), skip=True))
+        meta = _Meta(foo=(), bar='Bar')
+        self._no_output(simple, meta)
+
+    def test___call___w_skip_but_values_explicit_fields(self):
+        simple = self._makeOne(_Options(fields=('foo',), skip=True))
+        meta = _Meta(foo='Foo')
+        output = self._capture_output(simple, meta)
+        self.assertEqual(output, 'foo: Foo\n')
+
+class SingleLineTests(unittest.TestCase, _FormatterBase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import SingleLine
+
+        return SingleLine
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___init___(self):
+        single = self._makeOne(
+            _Options(fields=None, item_delim='I', sequence_delim='S'))
+        self.assertEqual(single._item_delim, 'I')
+        self.assertEqual(single._sequence_delim, 'S')
+
+    def test___call__wo_fields_wo_list(self):
+        single = self._makeOne(
+            _Options(fields=(), item_delim='|',
+                     sequence_delim=object()))  # raise if used
+        meta = _Meta(foo='Foo', bar='Bar')
+        output = self._capture_output(single, meta)
+        self.assertEqual(output, 'Bar|Foo\n')
+
+    def test___call__w_fields_w_list(self):
+        single = self._makeOne(
+            _Options(fields=('foo', 'bar'), item_delim='|',
+                     sequence_delim='*'))
+        meta = _Meta(foo='Foo', bar=['Bar1', 'Bar2'], baz='Baz')
+        output = self._capture_output(single, meta)
+        self.assertEqual(output, 'Foo|Bar1*Bar2\n')
+
+class CSVTests(unittest.TestCase, _FormatterBase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import CSV
+
+        return CSV
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___init___(self):
+        csv = self._makeOne(
+            _Options(fields=None, sequence_delim='S'))
+        self.assertEqual(csv._sequence_delim, 'S')
+
+    def test___call__wo_fields_wo_list(self):
+        meta = _Meta(foo='Foo', bar='Bar')
+        csv = self._makeOne(
+            _Options(fields=None,
+                     sequence_delim=object()))  # raise if used
+        output = self._capture_output(csv, meta)
+        self.assertEqual(output, 'bar,foo\r\nBar,Foo\r\n')
+
+    def test___call__w_fields_w_list(self):
+        meta = _Meta(foo='Foo', bar=['Bar1', 'Bar2'], baz='Baz')
+        csv = self._makeOne(
+            _Options(fields=('foo', 'bar'), item_delim='|',
+                     sequence_delim='*'))
+        output = self._capture_output(csv, meta)
+        self.assertEqual(output, 'foo,bar\r\nFoo,Bar1*Bar2\r\n')
+
+class INITests(unittest.TestCase, _FormatterBase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import INI
+
+        return INI
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___call___duplicate(self):
+        ini = self._makeOne(_Options(fields=('foo',)))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        ini._parser.add_section('foo-0.1')
+        self.assertRaises(ValueError, ini, meta)
+
+    def test___call___wo_fields_wo_list(self):
+        ini = self._makeOne(_Options(fields=None))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        ini(meta)
+        cp = ini._parser
+        self.assertEqual(cp.sections(), ['foo-0.1'])
+        self.assertEqual(sorted(cp.options('foo-0.1')),
+                         ['foo', 'name', 'version'])
+        self.assertEqual(cp.get('foo-0.1', 'name'), 'foo')
+        self.assertEqual(cp.get('foo-0.1', 'version'), '0.1')
+        self.assertEqual(cp.get('foo-0.1', 'foo'), 'Foo')
+
+    def test___call___w_fields_w_list(self):
+        ini = self._makeOne(_Options(fields=('foo', 'bar')))
+        meta = _Meta(name='foo', version='0.1',
+                     foo='Foo', bar=['Bar1', 'Bar2'], baz='Baz')
+        ini(meta)
+        cp = ini._parser
+        self.assertEqual(cp.sections(), ['foo-0.1'])
+        self.assertEqual(sorted(cp.options('foo-0.1')), ['bar', 'foo'])
+        self.assertEqual(cp.get('foo-0.1', 'foo'), 'Foo')
+        self.assertEqual(cp.get('foo-0.1', 'bar'), 'Bar1\n\tBar2')
+
+class JSONtests(unittest.TestCase, _FormatterBase):
+
+    def _getTargetClass(self):
+        from pkginfo.commandline import JSON
+
+        return JSON
+
+    def _makeOne(self, options):
+        return self._getTargetClass()(options)
+
+    def test___call___duplicate_with_meta_and_fields(self):
+        json = self._makeOne(_Options(fields=('name',)))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        json._mapping['name'] = 'foo'
+        self.assertRaises(ValueError, json, meta)
+
+    def test___call___duplicate_with_meta_wo_fields(self):
+        json = self._makeOne(_Options(fields=None))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        json._mapping['name'] = 'foo'
+        self.assertRaises(ValueError, json, meta)
+
+    def test___call___wo_fields_wo_list(self):
+
+        json = self._makeOne(_Options(fields=None))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        json(meta)
+        expected = collections.OrderedDict([
+            ('foo', 'Foo'), ('name', 'foo'), ('version', '0.1')])
+        self.assertEqual(expected, json._mapping)
+
+    def test___call___w_fields_w_list(self):
+        json = self._makeOne(_Options(fields=('foo', 'bar')))
+        meta = _Meta(name='foo', version='0.1',
+                     foo='Foo', bar=['Bar1', 'Bar2'], baz='Baz')
+        json(meta)
+        expected = collections.OrderedDict([
+            ('foo', 'Foo'), ('bar', ['Bar1', 'Bar2'])])
+        self.assertEqual(expected, json._mapping)
+
+    def test___call___output(self):
+        json = self._makeOne(_Options(fields=None))
+        meta = _Meta(name='foo', version='0.1', foo='Foo')
+        json(meta)
+        output = self._capture_output(json.finish)
+        output = json_module.loads(
+            output, object_pairs_hook=collections.OrderedDict)
+        expected = collections.OrderedDict([
+            ('foo', 'Foo'), ('name', 'foo'), ('version', '0.1')])
+        self.assertEqual(expected, output)
+
+class Test_main(unittest.TestCase):
+
+    def _callFUT(self, args, monkey='simple'):
+        from pkginfo.commandline import main
+        from pkginfo.commandline import _FORMATTERS
+
+        before = _FORMATTERS[monkey]
+        dummy = _Formatter()
+        _FORMATTERS[monkey] = lambda *options: dummy
+        try:
+            main(args)
+        finally:
+            _FORMATTERS[monkey] = before
+        return dummy
+
+    def test_w_mising_dist(self):
+        from pkginfo import commandline as MUT
+
+        def _get_metadata(path_or_module, md_version):
+            self.assertEqual(path_or_module, 'foo')
+            self.assertEqual(md_version, None)
+            return None
+        with _Monkey(MUT, get_metadata=_get_metadata):
+            formatter = self._callFUT(['foo'])
+        self.assertEqual(formatter._called_with, [])
+        self.assertTrue(formatter._finished)
+
+    def test_w_dist_wo_download_url(self):
+        from pkginfo import commandline as MUT
+
+        meta = _Meta(download_url=None)
+        def _get_metadata(path_or_module, md_version):
+            self.assertEqual(path_or_module, '/path/to/foo')
+            self.assertEqual(md_version, None)
+            return meta
+        with _Monkey(MUT, get_metadata=_get_metadata):
+            formatter = self._callFUT(
+                ['-d', 'http://example.com', '/path/to/foo'])
+        self.assertEqual(formatter._called_with, [meta])
+        self.assertTrue(formatter._finished)
+        self.assertEqual(meta.download_url, 'http://example.com/foo')
+
+    def test_w_dist_w_download_url(self):
+        from pkginfo import commandline as MUT
+
+        meta = _Meta(download_url='http://example.com/dist/foo')
+        def _get_metadata(path_or_module, md_version):
+            self.assertEqual(path_or_module, '/path/to/foo')
+            self.assertEqual(md_version, None)
+            return meta
+        with _Monkey(MUT, get_metadata=_get_metadata):
+            formatter = self._callFUT(
+                ['-d', 'http://example.com', '/path/to/foo'])
+        self.assertEqual(formatter._called_with, [meta])
+        self.assertTrue(formatter._finished)
+        self.assertEqual(meta.download_url, 'http://example.com/dist/foo')
+
+class _Options(object):
+
+    def __init__(self, **kw):
+        for k in kw:
+            self.__dict__[k] = kw[k]
+
+class _Meta(object):
+
+    def __init__(self, **kw):
+        for k in kw:
+            self.__dict__[k] = kw[k]
+
+    def __iter__(self):
+        return iter(sorted(self.__dict__))
+
+class _Monkey(object):
+    # context-manager for replacing module names in the scope of a test.
+
+    def __init__(self, module, **kw):
+        self.module = module
+        self.to_restore = dict([(key, getattr(module, key)) for key in kw])
+        for key, value in kw.items():
+            setattr(module, key, value)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        for key, value in self.to_restore.items():
+            setattr(self.module, key, value)
+
+class _Formatter(object):
+
+    _finished = False
+
+    def __init__(self):
+        self._called_with = []
+
+    def __call__(self, meta):
+        self._called_with.append(meta)
+
+    def finish(self):
+        self._finished = True

env/lib/python3.10/site-packages/pkginfo/tests/test_develop.py

@@ -0,0 +1,27 @@
+import unittest
+
+class DevelopTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.develop import Develop
+        return Develop
+
+    def _makeOne(self, dirname=None):
+        return self._getTargetClass()(dirname)
+
+    def test_ctor_w_path(self):
+        from pkginfo.tests import _checkSample
+        develop = self._makeOne('.')
+        _checkSample(self, develop)
+
+    def test_ctor_w_invalid_path(self):
+        import warnings 
+        old_filters = warnings.filters[:]
+        warnings.filterwarnings('ignore')
+        try:
+            develop = self._makeOne('/nonesuch')
+            self.assertEqual(develop.metadata_version, None)
+            self.assertEqual(develop.name, None)
+            self.assertEqual(develop.version, None)
+        finally:
+            warnings.filters[:] = old_filters

env/lib/python3.10/site-packages/pkginfo/tests/test_distribution.py

@@ -0,0 +1,485 @@
+import unittest
+
+class Test__must_decode(unittest.TestCase):
+
+    def _callFUT(self, arg):
+        from pkginfo.distribution import _must_decode
+        return _must_decode(arg)
+
+    def test_w_bytes_latin1(self):
+        TO_ENCODE = u'\u00C9'  # capital E w/ acute accent
+        encoded = TO_ENCODE.encode("latin-1")
+        decoded = self._callFUT(encoded)
+        self.assertEqual(decoded, TO_ENCODE)
+
+    def test_w_bytes_utf8(self):
+        TO_ENCODE = u'\u00C9'  # capital E w/ acute accent
+        encoded = TO_ENCODE.encode("utf-8")
+        decoded = self._callFUT(encoded)
+        self.assertEqual(decoded, TO_ENCODE)
+
+    def test_w_unicode(self):
+        ARG = u'\u00C9'  # capital E w/ acute accent
+        decoded = self._callFUT(ARG)
+        self.assertEqual(decoded, ARG)
+
+    def test_w_object(self):
+        ARG = object()
+        decoded = self._callFUT(ARG)
+        self.assertIs(decoded, ARG)
+
+class DistributionTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.distribution import Distribution
+        return Distribution
+
+    def _makeOne(self, metadata_version='1.0'):
+        dist = self._getTargetClass()()
+        if metadata_version is not None:
+            dist.metadata_version = metadata_version
+        return dist
+
+    def test_ctor_defaults(self):
+        sdist = self._makeOne(None)
+        self.assertEqual(sdist.metadata_version, None)
+        # version 1.0
+        self.assertEqual(sdist.name, None)
+        self.assertEqual(sdist.version, None)
+        self.assertEqual(sdist.platforms, ())
+        self.assertEqual(sdist.supported_platforms, ())
+        self.assertEqual(sdist.summary, None)
+        self.assertEqual(sdist.description, None)
+        self.assertEqual(sdist.keywords, None)
+        self.assertEqual(sdist.home_page, None)
+        self.assertEqual(sdist.download_url, None)
+        self.assertEqual(sdist.author, None)
+        self.assertEqual(sdist.author_email, None)
+        self.assertEqual(sdist.license, None)
+        # version 1.1
+        self.assertEqual(sdist.classifiers, ())
+        self.assertEqual(sdist.requires, ())
+        self.assertEqual(sdist.provides, ())
+        self.assertEqual(sdist.obsoletes, ())
+        # version 1.2
+        self.assertEqual(sdist.maintainer, None)
+        self.assertEqual(sdist.maintainer_email, None)
+        self.assertEqual(sdist.requires_python, None)
+        self.assertEqual(sdist.requires_external, ())
+        self.assertEqual(sdist.requires_dist, ())
+        self.assertEqual(sdist.provides_dist, ())
+        self.assertEqual(sdist.obsoletes_dist, ())
+        self.assertEqual(sdist.project_urls, ())
+        # version 2.1
+        self.assertEqual(sdist.provides_extras, ())
+        self.assertEqual(sdist.description_content_type, None)
+        # version 2.2
+        self.assertEqual(sdist.dynamic, ())
+
+    def test_extractMetadata_raises_NotImplementedError(self):
+        # 'extractMetadata' calls 'read', which subclasses must override.
+        dist = self._makeOne(None)
+        self.assertRaises(NotImplementedError, dist.extractMetadata)
+
+    def test_read_raises_NotImplementedError(self):
+        # Subclasses must override 'read'.
+        dist = self._makeOne(None)
+        self.assertRaises(NotImplementedError, dist.read)
+
+    def test_parse_given_unicode(self):
+        dist = self._makeOne()
+        dist.parse(u'Metadata-Version: 1.0\nName: lp722928_c3') # no raise
+
+    def test_parse_Metadata_Version_1_0(self):
+        from pkginfo.distribution import HEADER_ATTRS_1_0
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 1.0')
+        self.assertEqual(dist.metadata_version, '1.0')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_1_0])
+
+    def test_parse_Metadata_Version_1_1(self):
+        from pkginfo.distribution import HEADER_ATTRS_1_1
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_1_1])
+
+    def test_parse_Metadata_Version_1_2(self):
+        from pkginfo.distribution import HEADER_ATTRS_1_2
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 1.2')
+        self.assertEqual(dist.metadata_version, '1.2')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_1_2])
+
+    def test_parse_Metadata_Version_2_1(self):
+        from pkginfo.distribution import HEADER_ATTRS_2_1
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 2.1')
+        self.assertEqual(dist.metadata_version, '2.1')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_2_1])
+
+    def test_parse_Metadata_Version_2_2(self):
+        from pkginfo.distribution import HEADER_ATTRS_2_2
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 2.2')
+        self.assertEqual(dist.metadata_version, '2.2')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_2_2])
+
+    def test_parse_Metadata_Version_2_3(self):
+        from pkginfo.distribution import HEADER_ATTRS_2_3
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 2.3')
+        self.assertEqual(dist.metadata_version, '2.3')
+        self.assertEqual(list(dist),
+                         [x[1] for x in HEADER_ATTRS_2_3])
+
+    def test_parse_Metadata_Version_unknown(self):
+        dist = self._makeOne(None)
+        dist.parse('Metadata-Version: 1.3')
+        self.assertEqual(dist.metadata_version, '1.3')
+        self.assertEqual(list(dist), [])
+
+    def test_parse_Metadata_Version_override(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Metadata-Version: 1.0')
+        self.assertEqual(dist.metadata_version, '1.2')
+
+    def test_parse_Name(self):
+        dist = self._makeOne()
+        dist.parse('Name: foobar')
+        self.assertEqual(dist.name, 'foobar')
+
+    def test_parse_Version(self):
+        dist = self._makeOne()
+        dist.parse('Version: 2.1.3b5')
+        self.assertEqual(dist.version, '2.1.3b5')
+
+    def test_parse_Platform_single(self):
+        dist = self._makeOne()
+        dist.parse('Platform: Plan9')
+        self.assertEqual(list(dist.platforms), ['Plan9'])
+
+    def test_parse_Platform_multiple(self):
+        dist = self._makeOne()
+        dist.parse('Platform: Plan9\nPlatform: AIX')
+        self.assertEqual(list(dist.platforms), ['Plan9', 'AIX'])
+
+    def test_parse_Supported_Platform_single(self):
+        dist = self._makeOne()
+        dist.parse('Supported-Platform: Plan9')
+        self.assertEqual(list(dist.supported_platforms), ['Plan9'])
+
+    def test_parse_Supported_Platform_multiple(self):
+        dist = self._makeOne()
+        dist.parse('Supported-Platform: i386-win32\n'
+                   'Supported-Platform: RedHat 7.2')
+        self.assertEqual(list(dist.supported_platforms),
+                        ['i386-win32', 'RedHat 7.2'])
+
+    def test_parse_Summary(self):
+        dist = self._makeOne()
+        dist.parse('Summary: Package for foo')
+        self.assertEqual(dist.summary, 'Package for foo')
+
+    def test_parse_Description(self):
+        dist = self._makeOne()
+        dist.parse('Description: This package enables integration with '
+                   'foo servers.')
+        self.assertEqual(dist.description,
+                         'This package enables integration with '
+                         'foo servers.')
+
+    def test_parse_Description_multiline(self):
+        dist = self._makeOne()
+        dist.parse('Description: This package enables integration with\n'
+                   '        foo servers.')
+        self.assertEqual(dist.description,
+                         'This package enables integration with\n'
+                         'foo servers.')
+
+    def test_parse_Description_in_payload(self):
+        dist = self._makeOne()
+        dist.parse('Foo: Bar\n'
+                   '\n'
+                   'This package enables integration with\n'
+                   'foo servers.')
+        self.assertEqual(dist.description,
+                         'This package enables integration with\n'
+                         'foo servers.')
+
+    def test_parse_Keywords(self):
+        dist = self._makeOne()
+        dist.parse('Keywords: bar foo qux')
+        self.assertEqual(dist.keywords, 'bar foo qux')
+
+    def test_parse_Home_page(self):
+        dist = self._makeOne()
+        dist.parse('Home-page: http://example.com/package')
+        self.assertEqual(dist.home_page, 'http://example.com/package')
+
+    def test_parse_Author(self):
+        dist = self._makeOne()
+        dist.parse('Author: J. Phredd Bloggs')
+        self.assertEqual(dist.author, 'J. Phredd Bloggs')
+
+    def test_parse_Author_Email(self):
+        dist = self._makeOne()
+        dist.parse('Author-email: phreddy@example.com')
+        self.assertEqual(dist.author_email, 'phreddy@example.com')
+
+    def test_parse_License(self):
+        dist = self._makeOne()
+        dist.parse('License: Poetic')
+        self.assertEqual(dist.license, 'Poetic')
+
+    # Metadata version 1.1, defined in PEP 314.
+    def test_parse_Classifier_single(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Classifier: Some :: Silly Thing')
+        self.assertEqual(list(dist.classifiers), ['Some :: Silly Thing'])
+
+    def test_parse_Classifier_multiple(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Classifier: Some :: Silly Thing\n'
+                   'Classifier: Or :: Other')
+        self.assertEqual(list(dist.classifiers),
+                         ['Some :: Silly Thing', 'Or :: Other'])
+
+    def test_parse_Download_URL(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Download-URL: '
+                   'http://example.com/package/mypackage-0.1.zip')
+        self.assertEqual(dist.download_url,
+                         'http://example.com/package/mypackage-0.1.zip')
+
+    def test_parse_Requires_single_wo_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Requires: SpanishInquisition')
+        self.assertEqual(list(dist.requires), ['SpanishInquisition'])
+
+    def test_parse_Requires_single_w_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Requires: SpanishInquisition (>=1.3)')
+        self.assertEqual(list(dist.requires), ['SpanishInquisition (>=1.3)'])
+
+    def test_parse_Requires_multiple(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Requires: SpanishInquisition\n'
+                   'Requires: SillyWalks (1.4)\n'
+                   'Requires: kniggits (>=2.3,<3.0)')
+        self.assertEqual(list(dist.requires),
+                         ['SpanishInquisition',
+                          'SillyWalks (1.4)',
+                          'kniggits (>=2.3,<3.0)',
+                         ])
+
+    def test_parse_Provides_single_wo_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Provides: SillyWalks')
+        self.assertEqual(list(dist.provides), ['SillyWalks'])
+
+    def test_parse_Provides_single_w_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Provides: SillyWalks (1.4)')
+        self.assertEqual(list(dist.provides), ['SillyWalks (1.4)'])
+
+    def test_parse_Provides_multiple(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Provides: SillyWalks\n'
+                   'Provides: DeadlyJoke (3.1.4)')
+        self.assertEqual(list(dist.provides),
+                         ['SillyWalks',
+                          'DeadlyJoke (3.1.4)',
+                         ])
+
+    def test_parse_Obsoletes_single_no_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Obsoletes: SillyWalks')
+        self.assertEqual(list(dist.obsoletes), ['SillyWalks'])
+
+    def test_parse_Obsoletes_single_w_version(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Obsoletes: SillyWalks (<=1.3)')
+        self.assertEqual(list(dist.obsoletes), ['SillyWalks (<=1.3)'])
+
+    def test_parse_Obsoletes_multiple(self):
+        dist = self._makeOne('1.1')
+        dist.parse('Obsoletes: kniggits\n'
+                   'Obsoletes: SillyWalks (<=2.0)')
+        self.assertEqual(list(dist.obsoletes),
+                         ['kniggits',
+                          'SillyWalks (<=2.0)',
+                         ])
+
+
+    # Metadata version 1.2, defined in PEP 345.
+    def test_parse_Maintainer(self):
+        dist = self._makeOne(metadata_version='1.2')
+        dist.parse('Maintainer: J. Phredd Bloggs')
+        self.assertEqual(dist.maintainer, 'J. Phredd Bloggs')
+
+    def test_parse_Maintainer_Email(self):
+        dist = self._makeOne(metadata_version='1.2')
+        dist.parse('Maintainer-email: phreddy@example.com')
+        self.assertEqual(dist.maintainer_email, 'phreddy@example.com')
+
+    def test_parse_Requires_Python_single_spec(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-Python: >2.4')
+        self.assertEqual(dist.requires_python, '>2.4')
+
+    def test_parse_Requires_External_single_wo_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-External: libfoo')
+        self.assertEqual(list(dist.requires_external), ['libfoo'])
+
+    def test_parse_Requires_External_single_w_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-External: libfoo (>=1.3)')
+        self.assertEqual(list(dist.requires_external), ['libfoo (>=1.3)'])
+
+    def test_parse_Requires_External_multiple(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-External: libfoo\n'
+                   'Requires-External: libbar (1.4)\n'
+                   'Requires-External: libbaz (>=2.3,<3.0)')
+        self.assertEqual(list(dist.requires_external),
+                         ['libfoo',
+                          'libbar (1.4)',
+                          'libbaz (>=2.3,<3.0)',
+                         ])
+
+
+    def test_parse_Requires_Dist_single_wo_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-Dist: SpanishInquisition')
+        self.assertEqual(list(dist.requires_dist), ['SpanishInquisition'])
+
+    def test_parse_Requires_Dist_single_w_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Requires-Dist: SpanishInquisition (>=1.3)')
+        self.assertEqual(list(dist.requires_dist),
+                         ['SpanishInquisition (>=1.3)'])
+
+    def test_parse_Requires_Dist_single_w_env_marker(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Requires-Dist: SpanishInquisition; "
+                        "python_version == '1.4'")
+        self.assertEqual(list(dist.requires_dist),
+                         ["SpanishInquisition; python_version == '1.4'"])
+
+    def test_parse_Requires_Dist_multiple(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Requires-Dist: SpanishInquisition\n"
+                   "Requires-Dist: SillyWalks; python_version == '1.4'\n"
+                   "Requires-Dist: kniggits (>=2.3,<3.0)")
+        self.assertEqual(list(dist.requires_dist),
+                         ["SpanishInquisition",
+                          "SillyWalks; python_version == '1.4'",
+                          "kniggits (>=2.3,<3.0)",
+                         ])
+
+    def test_parse_Provides_Dist_single_wo_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Provides-Dist: SillyWalks')
+        self.assertEqual(list(dist.provides_dist), ['SillyWalks'])
+
+    def test_parse_Provides_Dist_single_w_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Provides-Dist: SillyWalks (1.4)')
+        self.assertEqual(list(dist.provides_dist), ['SillyWalks (1.4)'])
+
+    def test_parse_Provides_Dist_single_w_env_marker(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Provides-Dist: SillyWalks; sys.platform == 'os2'")
+        self.assertEqual(list(dist.provides_dist),
+                         ["SillyWalks; sys.platform == 'os2'"])
+
+    def test_parse_Provides_Dist_multiple(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Provides-Dist: SillyWalks\n"
+                   "Provides-Dist: SpanishInquisition; sys.platform == 'os2'\n"
+                   "Provides-Dist: DeadlyJoke (3.1.4)")
+        self.assertEqual(list(dist.provides_dist),
+                         ["SillyWalks",
+                          "SpanishInquisition; sys.platform == 'os2'",
+                          "DeadlyJoke (3.1.4)",
+                         ])
+
+    def test_parse_Obsoletes_Dist_single_no_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Obsoletes-Dist: SillyWalks')
+        self.assertEqual(list(dist.obsoletes_dist), ['SillyWalks'])
+
+    def test_parse_Obsoletes_Dist_single_w_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Obsoletes-Dist: SillyWalks (<=1.3)')
+        self.assertEqual(list(dist.obsoletes_dist), ['SillyWalks (<=1.3)'])
+
+    def test_parse_Obsoletes_Dist_single_w_env_marker(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Obsoletes-Dist: SillyWalks; sys.platform == 'os2'")
+        self.assertEqual(list(dist.obsoletes_dist),
+                         ["SillyWalks; sys.platform == 'os2'"])
+
+    def test_parse_Obsoletes_Dist_multiple(self):
+        dist = self._makeOne('1.2')
+        dist.parse("Obsoletes-Dist: kniggits\n"
+                   "Obsoletes-Dist: SillyWalks; sys.platform == 'os2'\n"
+                   "Obsoletes-Dist: DeadlyJoke (<=2.0)\n"
+                  )
+        self.assertEqual(list(dist.obsoletes_dist),
+                         ["kniggits",
+                          "SillyWalks; sys.platform == 'os2'",
+                          "DeadlyJoke (<=2.0)",
+                         ])
+
+    def test_parse_Project_URL_single_no_version(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Project-URL: Bug tracker, http://bugs.example.com/grail')
+        self.assertEqual(list(dist.project_urls),
+                         ['Bug tracker, http://bugs.example.com/grail'])
+
+    def test_parse_Project_URL_multiple(self):
+        dist = self._makeOne('1.2')
+        dist.parse('Project-URL: Bug tracker, http://bugs.example.com/grail\n'
+                   'Project-URL: Repository, http://svn.example.com/grail')
+        self.assertEqual(list(dist.project_urls),
+                         ['Bug tracker, http://bugs.example.com/grail',
+                          'Repository, http://svn.example.com/grail',
+                         ])
+
+    # Metadata version 2.1, defined in PEP 566.
+    def test_parse_Provides_Extra_single(self):
+        dist = self._makeOne('2.1')
+        dist.parse('Provides-Extra: pdf')
+        self.assertEqual(list(dist.provides_extras), ['pdf'])
+
+    def test_parse_Provides_Extra_multiple(self):
+        dist = self._makeOne('2.1')
+        dist.parse('Provides-Extra: pdf\n'
+                   'Provides-Extra: tex')
+        self.assertEqual(list(dist.provides_extras), ['pdf', 'tex'])
+
+    def test_parse_Distribution_Content_Type_single(self):
+        dist = self._makeOne('2.1')
+        dist.parse('Description-Content-Type: text/plain')
+        self.assertEqual(dist.description_content_type, 'text/plain')
+
+    # Metadata version 2.2, defined in PEP 643.
+    def test_parse_Dynamic_single(self):
+        dist = self._makeOne('2.2')
+        dist.parse('Dynamic: Platforms')
+        self.assertEqual(list(dist.dynamic), ['Platforms'])
+
+    def test_parse_Dynamic_multiple(self):
+        dist = self._makeOne('2.2')
+        dist.parse('Dynamic: Platforms\n'
+                   'Dynamic: Supported-Platforms')
+        self.assertEqual(list(dist.dynamic),
+                         ['Platforms', 'Supported-Platforms'])

env/lib/python3.10/site-packages/pkginfo/tests/test_index.py

@@ -0,0 +1,76 @@
+import unittest
+
+class IndexTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.index import Index
+        return Index
+
+    def _makeOne(self):
+        return self._getTargetClass()()
+
+    def test_empty(self):
+        index = self._makeOne()
+        self.assertEqual(len(index), 0)
+        self.assertEqual(len(index.keys()), 0)
+        self.assertEqual(len(index.values()), 0)
+        self.assertEqual(len(index.items()), 0)
+
+    def _makeDummy(self):
+        from pkginfo.distribution import Distribution
+        class DummyDistribution(Distribution):
+            name = 'dummy'
+            version = '1.0'
+
+        return DummyDistribution()
+
+    def test___getitem___miss(self):
+        index = self._makeOne()
+        self.assertRaises(KeyError, index.__getitem__, 'nonesuch')
+
+    def test___setitem___value_not_dist(self):
+        class NotDistribution:
+            name = 'dummy'
+            version = '1.0'
+        dummy = NotDistribution()
+        index = self._makeOne()
+        self.assertRaises(ValueError, index.__setitem__, 'dummy-1.0', dummy)
+
+    def test___setitem___bad_key(self):
+        index = self._makeOne()
+        dummy = self._makeDummy()
+        self.assertRaises(ValueError, index.__setitem__, 'nonesuch', dummy)
+
+    def test___setitem___valid_key(self):
+        index = self._makeOne()
+        dummy = self._makeDummy()
+        index['dummy-1.0'] = dummy
+        self.assertTrue(index['dummy-1.0'] is dummy)
+        self.assertEqual(len(index), 1)
+        self.assertEqual(len(index.keys()), 1)
+        self.assertEqual(list(index.keys())[0], 'dummy-1.0')
+        self.assertEqual(len(index.values()), 1)
+        self.assertEqual(list(index.values())[0], dummy)
+        self.assertEqual(len(index.items()), 1)
+        self.assertEqual(list(index.items())[0], ('dummy-1.0', dummy))
+
+    def test_add_not_dist(self):
+        index = self._makeOne()
+        class NotDistribution:
+            name = 'dummy'
+            version = '1.0'
+        dummy = NotDistribution()
+        self.assertRaises(ValueError, index.add, dummy)
+
+    def test_add_valid_dist(self):
+        index = self._makeOne()
+        dummy = self._makeDummy()
+        index.add(dummy)
+        self.assertTrue(index['dummy-1.0'] is dummy)
+        self.assertEqual(len(index), 1)
+        self.assertEqual(len(index.keys()), 1)
+        self.assertEqual(list(index.keys())[0], 'dummy-1.0')
+        self.assertEqual(len(index.values()), 1)
+        self.assertEqual(list(index.values())[0], dummy)
+        self.assertEqual(len(index.items()), 1)
+        self.assertEqual(list(index.items())[0], ('dummy-1.0', dummy))

env/lib/python3.10/site-packages/pkginfo/tests/test_installed.py

@@ -0,0 +1,141 @@
+import os
+import sys
+import types
+import unittest
+import wsgiref
+import warnings
+
+class InstalledTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.installed import Installed
+
+        return Installed
+
+    def _makeOne(self, filename=None, metadata_version=None):
+        if metadata_version is not None:
+            return self._getTargetClass()(filename, metadata_version)
+        return self._getTargetClass()(filename)
+
+    def test_ctor_w_package_no___file__(self):
+        with warnings.catch_warnings(record=True):
+            installed = self._makeOne(sys)
+            self.assertEqual(installed.package, sys)
+            self.assertEqual(installed.package_name, 'sys')
+            self.assertEqual(installed.metadata_version, None)
+
+    def test_ctor_w_package(self):
+        import pkginfo
+        from pkginfo.tests import _checkSample
+        from pkginfo.tests import _defaultMetadataVersion
+
+        EXPECTED =  _defaultMetadataVersion()
+        installed = self._makeOne(pkginfo)
+        self.assertEqual(installed.package, pkginfo)
+        self.assertEqual(installed.package_name, 'pkginfo')
+        self.assertEqual(installed.metadata_version, EXPECTED)
+        _checkSample(self, installed)
+
+    def test_ctor_w_no___package___falls_back_to___name__(self):
+
+        with warnings.catch_warnings(record=True):
+            installed = self._makeOne(wsgiref)
+            self.assertEqual(installed.package, wsgiref)
+            self.assertEqual(installed.package_name, 'wsgiref')
+            self.assertEqual(installed.metadata_version, None)
+
+    def test_ctor_w_package_no_PKG_INFO(self):
+        with warnings.catch_warnings(record=True):
+            installed = self._makeOne(types)
+            self.assertEqual(installed.package, types)
+            self.assertEqual(installed.package_name, 'types')
+            self.assertEqual(installed.metadata_version, None)
+
+    def test_ctor_w_package_and_metadata_version(self):
+        import pkginfo
+        from pkginfo.tests import _checkSample
+
+        installed = self._makeOne(pkginfo, metadata_version='1.2')
+        self.assertEqual(installed.metadata_version, '1.2')
+        self.assertEqual(installed.package.__name__, 'pkginfo')
+        _checkSample(self, installed)
+
+    def test_ctor_w_name(self):
+        import pkginfo
+        from pkginfo.tests import _checkSample
+        from pkginfo.tests import _defaultMetadataVersion
+
+        EXPECTED = _defaultMetadataVersion()
+        installed = self._makeOne('pkginfo')
+        self.assertEqual(installed.metadata_version, EXPECTED)
+        self.assertEqual(installed.package, pkginfo)
+        self.assertEqual(installed.package_name, 'pkginfo')
+        _checkSample(self, installed)
+
+    def test_ctor_w_name_and_metadata_version(self):
+        import pkginfo
+        from pkginfo.tests import _checkSample
+
+        installed = self._makeOne('pkginfo', metadata_version='1.2')
+        self.assertEqual(installed.metadata_version, '1.2')
+        self.assertEqual(installed.package, pkginfo)
+        self.assertEqual(installed.package_name, 'pkginfo')
+        _checkSample(self, installed)
+
+    def test_ctor_w_invalid_name(self):
+        with warnings.catch_warnings(record=True):
+            installed = self._makeOne('nonesuch')
+            self.assertEqual(installed.package, None)
+            self.assertEqual(installed.package_name, 'nonesuch')
+            self.assertEqual(installed.metadata_version, None)
+
+    def test_ctor_w_egg_info_as_file(self):
+        import pkginfo.tests.funny
+
+        installed = self._makeOne('pkginfo.tests.funny')
+        self.assertEqual(installed.metadata_version, '1.0')
+        self.assertEqual(installed.package, pkginfo.tests.funny)
+        self.assertEqual(installed.package_name, 'pkginfo.tests.funny')
+
+    def test_ctor_w_dist_info(self):
+        import wheel
+
+        installed = self._makeOne('wheel')
+        self.assertEqual(installed.metadata_version, '2.1')
+        self.assertEqual(installed.package, wheel)
+        self.assertEqual(installed.package_name, 'wheel')
+
+    def test_namespaced_pkg_installed_via_setuptools(self):
+        where, _ = os.path.split(__file__)
+        wonky = os.path.join(where, 'wonky')
+        oldpath = sys.path[:]
+        try:
+            sys.path.append(wonky)
+            with warnings.catch_warnings(record=True):
+                import namespaced.wonky
+            installed = self._makeOne('namespaced.wonky')
+            self.assertEqual(installed.metadata_version, '1.0')
+            self.assertEqual(installed.package, namespaced.wonky)
+            self.assertEqual(installed.package_name, 'namespaced.wonky')
+        finally:
+            sys.path[:] = oldpath
+            sys.modules.pop('namespaced.wonky', None)
+            sys.modules.pop('namespaced', None)
+
+    def test_namespaced_pkg_installed_via_pth(self):
+        # E.g., installed by a Linux distro
+        where, _ = os.path.split(__file__)
+        manky = os.path.join(where, 'manky')
+        oldpath = sys.path[:]
+        try:
+            sys.path.append(manky)
+            with warnings.catch_warnings(record=True):
+                import namespaced.manky
+            installed = self._makeOne('namespaced.manky')
+            self.assertEqual(installed.metadata_version, '1.0')
+            self.assertEqual(installed.package, namespaced.manky)
+            self.assertEqual(installed.package_name, 'namespaced.manky')
+        finally:
+            sys.path[:] = oldpath
+            sys.modules.pop('namespaced.manky', None)
+            sys.modules.pop('namespaced', None)

env/lib/python3.10/site-packages/pkginfo/tests/test_sdist.py

@@ -0,0 +1,165 @@
+import pathlib
+import shutil
+import sys
+import tempfile
+import unittest
+
+class SDistTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.sdist import SDist
+        return SDist
+
+    def _makeOne(self, filename=None, metadata_version=None):
+        if metadata_version is not None:
+            return self._getTargetClass()(filename, metadata_version)
+        return self._getTargetClass()(filename)
+
+    def _checkSample(self, sdist, filename):
+        self.assertEqual(sdist.filename, filename)
+        self.assertEqual(sdist.name, 'mypackage')
+        self.assertEqual(sdist.version, '0.1')
+        self.assertEqual(sdist.keywords, None)
+        self.assertEqual(list(sdist.supported_platforms), [])
+
+    def _checkClassifiers(self, sdist):
+        self.assertEqual(list(sdist.classifiers),
+                         ['Development Status :: 4 - Beta',
+                          'Environment :: Console (Text Based)',
+                         ])
+
+    def test_ctor_w_invalid_filename(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nonesuch-0.1.tar.gz' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_wo_PKG_INFO(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nopkginfo-0.1.zip' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_w_tar(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar' % d
+        sdist = self._makeOne(filename)
+        self.assertEqual(sdist.metadata_version, '1.0')
+        self._checkSample(sdist, filename)
+
+    def test_ctor_w_gztar(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.gz' % d
+        sdist = self._makeOne(filename)
+        self.assertEqual(sdist.metadata_version, '1.0')
+        self._checkSample(sdist, filename)
+
+    def test_ctor_w_gztar_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.gz' % d
+        sdist = self._makeOne(filename, metadata_version='1.1')
+        self._checkSample(sdist, filename)
+        self.assertEqual(sdist.metadata_version, '1.1')
+        self._checkClassifiers(sdist)
+
+    def test_ctor_w_bztar(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.bz2' % d
+        sdist = self._makeOne(filename)
+        self.assertEqual(sdist.metadata_version, '1.0')
+        self._checkSample(sdist, filename)
+
+    def test_ctor_w_bztar_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.bz2' % d
+        sdist = self._makeOne(filename, metadata_version='1.1')
+        self.assertEqual(sdist.metadata_version, '1.1')
+        self._checkSample(sdist, filename)
+        self._checkClassifiers(sdist)
+
+    def test_ctor_w_zip(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        sdist = self._makeOne(filename)
+        self.assertEqual(sdist.metadata_version, '1.0')
+        self._checkSample(sdist, filename)
+
+    def test_ctor_w_zip_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        sdist = self._makeOne(filename, metadata_version='1.1')
+        self.assertEqual(sdist.metadata_version, '1.1')
+        self._checkSample(sdist, filename)
+        self._checkClassifiers(sdist)
+
+    def test_ctor_w_bogus(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.bogus' % d
+
+        with self.assertRaises(ValueError):
+            self._makeOne(filename, metadata_version='1.1')
+
+
+class UnpackedMixin(object):
+    def setUp(self):
+        super(UnpackedMixin, self).setUp()
+        self.__tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.__tmpdir)
+        super(UnpackedMixin, self).tearDown()
+
+    def _getTargetClass(self):
+        from pkginfo.sdist import UnpackedSDist
+        return UnpackedSDist
+
+    def _getTopDirectory(self):
+        import os
+        topnames = os.listdir(self.__tmpdir)
+        assert len(topnames) == 1
+        return os.path.join(self.__tmpdir, topnames[0])
+
+    def _getLoadFilename(self):
+        return self._getTopDirectory()
+
+    def _makeOne(self, filename=None, metadata_version=None):
+        archive, _, _ = self._getTargetClass()._get_archive(filename)
+
+        # Work around Python 3.12 tarfile warning.
+        kwargs = {}
+        if sys.version_info >= (3, 12):
+            fn_path = pathlib.Path(filename)
+            if ".tar" in fn_path.suffixes:
+                kwargs["filter"] = "data"
+
+        try:
+            archive.extractall(self.__tmpdir, **kwargs)
+        finally:
+            archive.close()
+
+        load_filename = self._getLoadFilename()
+
+        if metadata_version is not None:
+            return self._getTargetClass()(load_filename, metadata_version)
+        return self._getTargetClass()(load_filename)
+
+    def _checkSample(self, sdist, filename):
+        filename = self._getTopDirectory()
+        super(UnpackedMixin, self)._checkSample(sdist, filename)
+
+
+class UnpackedSDistGivenDirectoryTests(UnpackedMixin, SDistTests):
+    pass
+
+class UnpackedSDistGivenFileSDistTests(UnpackedMixin, SDistTests):
+    def _getLoadFilename(self):
+        import os
+        return os.path.join(self._getTopDirectory(), 'setup.py')

env/lib/python3.10/site-packages/pkginfo/tests/test_utils.py

@@ -0,0 +1,176 @@
+import unittest
+
+class Test_get_metadata(unittest.TestCase):
+
+    def _callFUT(self, path, metadata_version=None):
+        from pkginfo.utils import get_metadata
+        if metadata_version is not None:
+            return get_metadata(path, metadata_version)
+        return get_metadata(path)
+
+    def _checkMyPackage(self, dist, filename):
+        self.assertEqual(dist.filename, filename)
+        self.assertEqual(dist.name, 'mypackage')
+        self.assertEqual(dist.version, '0.1')
+        self.assertEqual(dist.keywords, None)
+        self.assertEqual(list(dist.supported_platforms), [])
+
+    def _checkClassifiers(self, dist):
+        self.assertEqual(list(dist.classifiers),
+                         ['Development Status :: 4 - Beta',
+                          'Environment :: Console (Text Based)',
+                         ])
+
+    def test_w_gztar(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.gz' % d
+        dist = self._callFUT(filename)
+        self.assertEqual(dist.metadata_version, '1.0')
+        self._checkMyPackage(dist, filename)
+
+    def test_w_gztar_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.gz' % d
+        dist = self._callFUT(filename, metadata_version='1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self._checkMyPackage(dist, filename)
+        self._checkClassifiers(dist)
+
+    def test_w_bztar(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.bz2' % d
+        dist = self._callFUT(filename)
+        self.assertEqual(dist.metadata_version, '1.0')
+        self._checkMyPackage(dist, filename)
+
+    def test_w_bztar_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.tar.bz2' % d
+        dist = self._callFUT(filename, metadata_version='1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self._checkMyPackage(dist, filename)
+        self._checkClassifiers(dist)
+
+    def test_w_zip(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        dist = self._callFUT(filename)
+        self.assertEqual(dist.metadata_version, '1.0')
+        self._checkMyPackage(dist, filename)
+
+    def test_w_zip_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        dist = self._callFUT(filename, metadata_version='1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self._checkMyPackage(dist, filename)
+        self._checkClassifiers(dist)
+
+    def test_w_egg(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1-py2.6.egg' % d
+        dist = self._callFUT(filename)
+        self.assertEqual(dist.metadata_version, '1.0')
+        self._checkMyPackage(dist, filename)
+
+    def test_w_egg_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1-py2.6.egg' % d
+        dist = self._callFUT(filename, metadata_version='1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self._checkMyPackage(dist, filename)
+        self._checkClassifiers(dist)
+
+    def test_w_wheel(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'mypackage-0.1-cp26-none-linux_x86_64.whl') % d
+        dist = self._callFUT(filename)
+        self.assertEqual(dist.metadata_version, '2.0')
+        self._checkMyPackage(dist, filename)
+
+    def test_w_wheel_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'mypackage-0.1-cp26-none-linux_x86_64.whl') % d
+        dist = self._callFUT(filename, metadata_version='1.1')
+        self.assertEqual(dist.metadata_version, '1.1')
+        self._checkMyPackage(dist, filename)
+        self._checkClassifiers(dist)
+
+    def test_w_module(self):
+        from pkginfo.tests import _defaultMetadataVersion
+        EXPECTED =  _defaultMetadataVersion()
+        import pkginfo
+        from pkginfo.tests import _checkSample
+        dist = self._callFUT(pkginfo)
+        self.assertEqual(dist.metadata_version, EXPECTED)
+        _checkSample(self, dist)
+
+    def test_w_module_and_metadata_version(self):
+        import pkginfo
+        from pkginfo.tests import _checkSample
+        from pkginfo.tests import _checkClassifiers
+        dist = self._callFUT(pkginfo, metadata_version='1.2')
+        self.assertEqual(dist.metadata_version, '1.2')
+        _checkSample(self, dist)
+        _checkClassifiers(self, dist)
+
+    def test_w_package_name(self):
+        from pkginfo.tests import _defaultMetadataVersion
+        EXPECTED =  _defaultMetadataVersion()
+        from pkginfo.tests import _checkSample
+        dist = self._callFUT('pkginfo')
+        self.assertEqual(dist.metadata_version, EXPECTED)
+        _checkSample(self, dist)
+
+    def test_w_package_name_and_metadata_version(self):
+        from pkginfo.tests import _checkSample
+        from pkginfo.tests import _checkClassifiers
+        dist = self._callFUT('pkginfo', metadata_version='1.2')
+        self.assertEqual(dist.metadata_version, '1.2')
+        _checkSample(self, dist)
+        _checkClassifiers(self, dist)
+
+    def test_w_directory_no_EGG_INFO(self):
+        import os
+        import warnings
+        dir, name = os.path.split(__file__)
+        subdir = os.path.join(dir, 'funny')
+        old_filters = warnings.filters[:]
+        warnings.filterwarnings('ignore')
+        try:
+            dist = self._callFUT(subdir)
+            self.assertEqual(dist.path, subdir)
+            self.assertEqual(dist.name, None)
+            self.assertEqual(dist.version, None)
+        finally:
+            warnings.filters[:] = old_filters
+
+    def test_w_directory(self):
+        import os
+        dir, name = os.path.split(__file__)
+        subdir = os.path.join(dir, 'silly')
+        dist = self._callFUT(subdir)
+        self.assertEqual(dist.metadata_version, '1.0')
+        self.assertEqual(dist.name, 'silly')
+        self.assertEqual(dist.version, '0.1')
+
+    def test_w_directory_and_metadata_version(self):
+        import os
+        dir, name = os.path.split(__file__)
+        subdir = os.path.join(dir, 'silly')
+        dist = self._callFUT(subdir, metadata_version='1.2')
+        self.assertEqual(dist.metadata_version, '1.2')
+        self.assertEqual(dist.name, 'silly')
+        self.assertEqual(dist.version, '0.1')

env/lib/python3.10/site-packages/pkginfo/tests/test_wheel.py

@@ -0,0 +1,117 @@
+import unittest
+
+class WheelTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from pkginfo.wheel import Wheel
+        return Wheel
+
+    def _makeOne(self, filename=None, metadata_version=None):
+        if metadata_version is not None:
+            return self._getTargetClass()(filename, metadata_version)
+        return self._getTargetClass()(filename)
+
+    def _checkSample(self, wheel, filename):
+        self.assertEqual(wheel.filename, filename)
+        self.assertEqual(wheel.name, 'mypackage')
+        self.assertEqual(wheel.version, '0.1')
+        self.assertEqual(wheel.keywords, None)
+
+    def _checkClassifiers(self, wheel):
+        self.assertEqual(list(wheel.classifiers),
+                         ['Development Status :: 4 - Beta',
+                          'Environment :: Console (Text Based)',
+                         ])
+        self.assertEqual(list(wheel.supported_platforms), [])
+
+    def test_ctor_w_bogus_filename(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nonesuch-0.1-any.whl' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_w_non_wheel(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/mypackage-0.1.zip' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_wo_dist_info(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = '%s/../../docs/examples/nodistinfo-0.1-any.whl' % d
+        self.assertRaises(ValueError, self._makeOne, filename)
+
+    def test_ctor_w_valid_wheel(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'mypackage-0.1-cp26-none-linux_x86_64.whl') % d
+        wheel = self._makeOne(filename)
+        self.assertEqual(wheel.metadata_version, '2.0')
+        self._checkSample(wheel, filename)
+        self._checkClassifiers(wheel)
+
+    def test_ctor_w_installed_wheel(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = (
+            '%s/../../docs/examples/mypackage-0.1.dist-info') % d
+        wheel = self._makeOne(filename)
+        self.assertEqual(wheel.metadata_version, '2.0')
+        self._checkSample(wheel, filename)
+        self._checkClassifiers(wheel)
+
+    def test_ctor_w_valid_wheel_and_metadata_version(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'mypackage-0.1-cp26-none-linux_x86_64.whl') % d
+        wheel = self._makeOne(filename, metadata_version='1.1')
+        self.assertEqual(wheel.metadata_version, '1.1')
+        self._checkSample(wheel, filename)
+        self._checkClassifiers(wheel)
+
+    def test_ctor_w_valid_wheel_w_description_header(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'distlib-0.3.1-py2.py3-none-any.whl') % d
+        wheel = self._makeOne(filename, metadata_version='1.1')
+        self.assertEqual(wheel.metadata_version, '1.1')
+        self.assertTrue(wheel.description)
+
+    def test_ctor_w_valid_wheel_w_description_body(self):
+        import os
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'testlp1974172-0.0.0-py3-none-any.whl') % d
+        wheel = self._makeOne(filename, metadata_version='2.1')
+        self.assertEqual(wheel.metadata_version, '2.1')
+        self.assertIn(
+            "https://bugs.launchpad.net/pkginfo/+bug/1885458",
+            wheel.description
+        )
+
+    def test_ctor_w_valid_installed_wheel(self):
+        import os
+        import shutil
+        import tempfile
+        import zipfile
+
+        d, _ = os.path.split(__file__)
+        filename = ('%s/../../docs/examples/'
+                    'mypackage-0.1-cp26-none-linux_x86_64.whl') % d
+
+        try:
+            # note: we mock a wheel installation by unzipping
+            test_dir = tempfile.mkdtemp()
+            with zipfile.ZipFile(filename) as zipf:
+                zipf.extractall(test_dir)
+            wheel = self._makeOne(filename)
+            self.assertEqual(wheel.metadata_version, '2.0')
+            self._checkSample(wheel, filename)
+            self._checkClassifiers(wheel)
+        finally:
+            if os.path.exists(test_dir):
+                shutil.rmtree(test_dir)