Merge ppa-dev-tools:add_suite_module into ppa-dev-tools:main

[Bryce Harrington]

Splits out and fleshes out the Suite class from the Repository class. This will house the major logic for the rdepends testing functionality, but this initial branch just gets the basic structure in place for accessing the packages within an archive.

A Suite is defined as a particular pocket of a release, so that's like lunar-proposed or focal-backports. Internally it is further divided by component, IOW main, restricted, universe, multiverse. The Suite class encapsulates the logic for dealing with all these divisions.

As usual, the unit tests for Repository and Suite can be run via:

  $ pytest-3 tests/test_repository.py tests/test_suite.py

For static testing, I've been using the check-scripts tool from ubuntu-helpers:

  $ check-scripts ./tests/test_suite.py ./tests/test_repository.py ./ppa/repository.py ./ppa/suite.py

Last, there's also a smoketest for the Suite class, which can be used if you have a local mirror of the Apt repository (I made mine using the `apt-mirror` utility). Here's what the output looks like on my system:

  $ python3 -m ppa.suite
lunar-proposed
  series: lunar
  pocket: proposed
  components: main
  architectures: amd64, arm64, armhf, i386, ppc64el, riscv64, s390x
  sources: (203 items)
    0 adsys
    1 apt
    2 at-spi2-core
    [...]
    200 xorg-server
    201 xz-utils
    202 zip
  binaries: (931 items)
    0 adsys:amd64
    1 apt:amd64
    2 apt-doc:amd64
    [...]
    928 xz-utils:amd64
    929 zip:amd64
    930 zstd:amd64
lunar
  series: lunar
  pocket: release
  components: main
  architectures: amd64, arm64, armhf, i386, ppc64el, riscv64, s390x
  sources: (2369 items)
    0 aalib
    1 abseil
    2 accountsservice
    [...]
    2366 zsh
    2367 zsys
    2368 zvmcloudconnector
  binaries: (6045 items)
    0 accountsservice:amd64
    1 acct:amd64
    2 acl:amd64
    [...]
    6042 zstd:amd64
    6043 zsys:amd64
    6044 zvmcloudconnector-common:amd64

[Athos Ribeiro (athos-ribeiro)]

Thanks, Bryce!

Overall, LGTM. I have a few comments inline below.

nitpick: The new Suit class is being imported in a commit created before the class was introduced.

review: Needs Information

[Bryce Harrington (bryce)]

Thanks, I've extracted the import from the lintian commit and put it with the Suite class commit.

[Bryce Harrington (bryce)]

Pushed
To git+ssh://git.launchpad.net/ppa-dev-tools
   6220373..03aadb2 main -> main

diff --git a/.pylintrc b/.pylintrc
new file mode 100644
index 0000000..75e9cfe
--- /dev/null
+++ b/.pylintrc
@@ -0,0 +1,16 @@
+[MASTER]
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=import-error,
+	wrong-import-position
+
+[TYPECHECK]
+generated-members=apt_pkg.*
\ No newline at end of file
diff --git a/ppa/repository.py b/ppa/repository.py
index b763b3e..34c306e 100644
--- a/ppa/repository.py
+++ b/ppa/repository.py
@@ -9,38 +9,12 @@
 # Authors:
 #   Bryce Harrington <[e-mail]>
 
+"""Top-level code for analyzing an Ubuntu Apt repository."""
+
 import os.path
 from functools import lru_cache
-from distro_info import UbuntuDistroInfo
-
-
-# TODO: Move Suite class to its own module
-class Suite:
-    def __init__(self, cache_dir):
-        self.cache_dir = cache_dir
-
-    def __repr__(self):
-        return "<Suite {}>".format(self.cache_dir)
 
-    @property
-    def series_codename(self) -> str:
-        return os.path.basename(self.cache_dir).split('-')[0]
-
-    @property
-    def pocket(self) -> str:
-        suite = os.path.basename(self.cache_dir)
-        if '-' in suite:
-            return suite.split('-')[1]
-        else:
-            return 'release'
-
-    @property
-    def components(self) -> list[str]:
-        return [
-            component
-            for component in os.listdir(self.cache_dir)
-            if os.path.isdir(os.path.join(self.cache_dir, component))
-        ]
+from .suite import Suite
 
 
 class Repository:
@@ -78,10 +52,10 @@ class Repository:
         :rtype: dict[str, Suite]
         """
         return {
-            release_pocket: Suite(os.path.join(self.cache_dir, release_pocket))
-            for release_pocket
+            suite_name: Suite(suite_name, os.path.join(self.cache_dir, suite_name))
+            for suite_name
             in os.listdir(self.cache_dir)
-            if os.path.isdir(os.path.join(self.cache_dir, release_pocket))
+            if os.path.isdir(os.path.join(self.cache_dir, suite_name))
         }
 
     def get_suite(self, series_codename: str, pocket: str) -> Suite:
@@ -104,11 +78,12 @@ class Repository:
 
 
 if __name__ == "__main__":
+    import sys
     from pprint import PrettyPrinter
     pp = PrettyPrinter(indent=4)
 
-    local_repository_path = "/var/spool/apt-mirror/skel/archive.ubuntu.com/ubuntu"
-    local_dists_path = os.path.join(local_repository_path, "dists")
+    LOCAL_REPOSITORY_PATH = "/var/spool/apt-mirror/skel/archive.ubuntu.com/ubuntu"
+    local_dists_path = os.path.join(LOCAL_REPOSITORY_PATH, "dists")
     if not os.path.exists(local_dists_path):
         print("Error: Missing checkout")
         sys.exit(1)
diff --git a/ppa/suite.py b/ppa/suite.py
new file mode 100644
index 0000000..58fc8bc
--- /dev/null
+++ b/ppa/suite.py
@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+# Copyright (C) 2022 Authors
+#
+# Released under GNU GPLv2 or later, read the file 'LICENSE.GPLv2+' for
+# more information.
+#
+# Authors:
+#   Bryce Harrington <[e-mail]>
+
+"""Interprets and analyzes an Ubuntu Apt suite (aka release-pocket)."""
+
+import os.path
+from functools import lru_cache
+
+# pylint: disable = no-name-in-module
+import apt_pkg
+
+
+class Suite:
+    """A pocket of a Ubuntu series collecting source and binary package releases.
+
+    Suites are named "<series>-<pocket>", such as "focal-updates" or
+    "jammy-proposed".  The same package can have different versions in
+    each Suite, but within a Suite each package will have no more than
+    one version available at a time.
+    """
+    def __init__(self, suite_name: str, cache_dir: str):
+        """Initializes a new Suite object for a given release pocket.
+
+        :param str series_codename: The textual name of the Ubuntu release.
+        :param str pocket: The pocket name ('release', 'proposed', 'backports', etc.)
+        :param str cache_dir: The path to the given suite in the local Apt mirror.
+        """
+        if not suite_name:
+            raise ValueError('undefined suite_name.')
+        if not cache_dir:
+            raise ValueError('undefined cache_dir.')
+
+        self._suite_name = suite_name
+        self._cache_dir = cache_dir
+
+    def __repr__(self) -> str:
+        """Machine-parsable unique representation of object.
+
+        :rtype: str
+        :returns: Official string representation of the object.
+        """
+        return (
+            f'{self.__class__.__name__}('
+            f'suite_name={self._suite_name!r}, '
+            f'cache_dir={self._cache_dir!r})'
+        )
+
+    def __str__(self) -> str:
+        """Human-readable textual description of the Suite.
+
+        :rtype: str
+        :returns: Human-readable string.
+        """
+        return f'{self._suite_name}'
+
+    @property
+    @lru_cache
+    def info(self) -> dict[str, str]:
+        """The parsed Apt Release file for the suite as a dict.
+
+        :rtype: dict[str, str]
+        """
+        with apt_pkg.TagFile(f'{self._cache_dir}/Release') as tagfile:
+            info = next(tagfile)
+
+        if not info:
+            raise ValueError('Could not load {self._cache_dir}/Release')
+
+        return info
+
+    @property
+    def name(self) -> str:
+        """The name of the suite as recorded in the apt database.
+
+        :rtype: str
+        """
+        return self.info.get('Suite', None)
+
+    @property
+    def series_codename(self) -> str:
+        """The textual name of the Ubuntu release for this suite.
+
+        :rtype: str
+        """
+        return self.name.split('-')[0]
+
+    @property
+    def pocket(self) -> str:
+        """The category of the archive (release, proposed, security, et al).
+
+        :rtype: str
+        """
+        if '-' not in self.name:
+            return 'release'
+        return self.name.split('-')[1]
+
+    @property
+    def architectures(self) -> list[str]:
+        """The list of CPU hardware types supported by this suite.
+
+        :rtype: list[str]
+        """
+        return self.info.get('Architectures', None).split()
+
+    @property
+    def components(self) -> list[str]:
+        """The sections of the archive (main, universe, etc.) provided
+        in this suite.
+
+        :rtype: list[str]
+        """
+        return [
+            component
+            for component in os.listdir(self._cache_dir)
+            if os.path.isdir(os.path.join(self._cache_dir, component))
+        ]
+
+    @property
+    @lru_cache
+    def sources(self) -> dict[str, str]:
+        """The collection of source packages included in this suite.
+
+        All source packages in all components are returned.
+
+        :rtype: dict[str, str]
+        """
+        sources = {}
+        for comp in self.components:
+            source_packages_dir = f'{self._cache_dir}/{comp}/source'
+            with apt_pkg.TagFile(f'{source_packages_dir}/Sources.xz') as pkgs:
+                for pkg in pkgs:
+                    name = pkg['Package']
+                    sources[name] = f'SourcePackage({name})'
+
+        if not sources:
+            raise ValueError(f'Could not load {source_packages_dir}/Sources.xz')
+
+        return sources
+
+    @property
+    @lru_cache
+    def binaries(self) -> dict[str, str]:
+        """The collection of binary Deb packages included in this suite.
+
+        All binary packages in all components are returned.
+
+        :rtype: dict[str, str]
+        """
+        binaries = {}
+        for comp in self.components:
+            for arch in self.architectures:
+                binary_packages_dir = f'{self._cache_dir}/{comp}/binary-{arch}'
+                try:
+                    with apt_pkg.TagFile(f'{binary_packages_dir}/Packages.xz') as pkgs:
+                        for pkg in pkgs:
+                            name = f'{pkg["Package"]}:{arch}'
+                            binaries[name] = f'BinaryPackage({pkg})'
+                except apt_pkg.Error:
+                    # If an Apt repository is incomplete, such as if
+                    # a given architecture was not mirrored, still
+                    # note the binaries exist but mark their records
+                    # as missing.
+                    binaries[name] = None
+
+        if not binaries:
+            raise ValueError(f'Could not load {binary_packages_dir}/Packages.xz')
+
+        return binaries
+
+
+if __name__ == '__main__':
+    # pylint: disable=invalid-name
+    import sys
+    from .repository import Repository
+
+    from pprint import PrettyPrinter
+    pp = PrettyPrinter(indent=4)
+
+    LOCAL_REPOSITORY_PATH = '/var/spool/apt-mirror/skel/archive.ubuntu.com/ubuntu'
+    local_dists_path = os.path.join(LOCAL_REPOSITORY_PATH, 'dists')
+    if not os.path.exists(local_dists_path):
+        print('Error: Missing checkout')
+        sys.exit(1)
+
+    repository = Repository(cache_dir=local_dists_path)
+    for suite in repository.suites.values():
+        print(suite)
+        print(f'  series:         {suite.series_codename}')
+        print(f'  pocket:         {suite.pocket}')
+        print(f'  components:     {", ".join(suite.components)}')
+        print(f'  architectures:  {", ".join(suite.architectures)}')
+
+        num_sources = len(suite.sources)
+        ellipses_shown = False
+        print(f'  sources:        ({num_sources} items)')
+        for i, source in enumerate(suite.sources):
+            if i < 3 or i >= num_sources - 3:
+                print(f'    {i} {source}')
+            elif not ellipses_shown:
+                print('    [...]')
+                ellipses_shown = True
+
+        num_binaries = len(suite.binaries)
+        ellipses_shown = False
+        print(f'  binaries:       ({num_binaries} items)')
+        for i, binary in enumerate(suite.binaries):
+            if i < 3 or i >= num_binaries - 3:
+                print(f'    {i} {binary}')
+            elif not ellipses_shown:
+                print('    [...]')
+                ellipses_shown = True
diff --git a/tests/test_repository.py b/tests/test_repository.py
index 774b6bd..84cc734 100644
--- a/tests/test_repository.py
+++ b/tests/test_repository.py
@@ -8,15 +8,16 @@
 # Released under GNU GPLv2 or later, read the file 'LICENSE.GPLv2+' for
 # more information.
 
+"""Tests the Repository class as an interface to an Apt repository."""
+
 import os
 import sys
 
-import pytest
-
 sys.path.insert(0, os.path.realpath(
     os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")))
 
-from ppa.repository import Repository, Suite
+from ppa.repository import Repository
+from ppa.suite import Suite
 
 
 def test_object(tmp_path):
@@ -29,27 +30,23 @@ def test_suites(tmp_path):
     """Checks getting all suites from the repository."""
     suites = ['a', 'b', 'b-0', 'b-1']
     for suite in suites:
-        d = tmp_path / suite
-        d.mkdir()
+        suite_dir = tmp_path / suite
+        suite_dir.mkdir()
 
     repository = Repository(tmp_path)
     assert sorted(repository.suites.keys()) == sorted(suites)
     for suite in repository.suites.values():
-        assert type(suite) is Suite
+        assert isinstance(suite, Suite)
 
 
 def test_get_suite(tmp_path):
     """Checks getting a specific suite from the repository."""
     suites = ['a', 'b', 'b-0', 'b-1']
     for suite in suites:
-        d = tmp_path / suite
-        d.mkdir()
-        for component in ['x', 'y', 'z']:
-            c = d / component
-            c.mkdir()
+        suite_dir = tmp_path / suite
+        suite_dir.mkdir()
 
     repository = Repository(tmp_path)
     suite = repository.get_suite('b', '1')
-    assert suite.cache_dir == str(tmp_path / 'b-1')
-    assert suite.pocket == '1'
-    assert sorted(suite.components) == sorted(['x', 'y', 'z'])
+    assert suite
+    assert str(suite) == 'b-1'
diff --git a/tests/test_suite.py b/tests/test_suite.py
new file mode 100644
index 0000000..7bfcaa1
--- /dev/null
+++ b/tests/test_suite.py
@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+# Author:  Bryce Harrington <[e-mail]>
+#
+# Copyright (C) 2023 Bryce W. Harrington
+#
+# Released under GNU GPLv2 or later, read the file 'LICENSE.GPLv2+' for
+# more information.
+
+"""Tests the Suite class as an interface to Apt suite records."""
+
+import os
+import sys
+
+import lzma as xz
+import pytest
+
+sys.path.insert(0, os.path.realpath(
+    os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')))
+
+from ppa.suite import Suite
+
+
[e-mail]('suite_name, cache_dir, expected_repr, expected_str', [
+    ('x', 'x', "Suite(suite_name='x', cache_dir='x')", "x"),
+    ('a-1', 'x', "Suite(suite_name='a-1', cache_dir='x')", "a-1"),
+    ('b-2', '/tmp', "Suite(suite_name='b-2', cache_dir='/tmp')", "b-2"),
+])
+def test_object(suite_name, cache_dir, expected_repr, expected_str):
+    """Checks that Suite objects can be instantiated."""
+    suite = Suite(suite_name, cache_dir)
+
+    assert suite
+    assert repr(suite) == expected_repr
+    assert str(suite) == expected_str
+
+
[e-mail]('suite_name, cache_dir, expected_exception', [
+    ('x', '', ValueError),
+    ('', 'x', ValueError),
+    ('', '', ValueError),
+    ('a-1', None, ValueError),
+    (None, 'x', ValueError),
+    (None, None, ValueError),
+])
+def test_object_error(suite_name, cache_dir, expected_exception):
+    """Checks that Suite objects handle invalid input properly."""
+    with pytest.raises(expected_exception):
+        suite = Suite(suite_name, cache_dir)
+        assert suite
+
+
[e-mail]('release_contents, expected_info', [
+    ('a: 1', {'a': '1'}),
+    ("""
+Origin: Ubuntu
+Label: Ubuntu
+Suite: lunar
+Version: 23.04
+Codename: lunar
+Date: Tue, 28 Feb 2023 19:49:32 UTC
+Architectures: amd64 arm64 armhf i386 ppc64el riscv64 s390x
+Components: main restricted universe multiverse
+Description: Ubuntu Lunar 23.04
+    """, {
+        'Suite': 'lunar',
+        'Codename': 'lunar',
+        'Architectures': 'amd64 arm64 armhf i386 ppc64el riscv64 s390x',
+        'Components': 'main restricted universe multiverse',
+    }), ("""
+Origin: Ubuntu
+Label: Ubuntu
+Suite: lunar-proposed
+Version: 23.04
+Codename: lunar
+Date: Tue, 28 Feb 2023 19:50:27 UTC
+Architectures: amd64 arm64 armhf i386 ppc64el riscv64 s390x
+Components: main restricted universe multiverse
+Description: Ubuntu Lunar Proposed
+NotAutomatic: yes
+ButAutomaticUpgrades: yes
+MD5Sum:
+ 7de6b7c0ed6b4bfb662e07fbc449dfdd        148112816 Contents-amd64
+    """, {
+        'Suite': 'lunar-proposed',
+        'Codename': 'lunar',
+        'NotAutomatic': 'yes'
+    }),
+])
+def test_info(tmp_path, release_contents, expected_info):
+    """Checks the parsing of info loaded from the Release file."""
+    # Create Release file using release_contents in synthetic tree
+    suite_dir = tmp_path / 'x'
+    suite_dir.mkdir()
+    release_file = suite_dir / 'Release'
+    release_file.write_text(release_contents)
+
+    suite = Suite(suite_dir.name, suite_dir)
+
+    # Verify the expected items are present in the suite's info dict
+    for key, value in expected_info.items():
+        assert key in suite.info.keys()
+        assert suite.info[key] == value
+
+
[e-mail]('info, expected_series_codename', [
+    ({'Suite': 'x'}, 'x'),
+    ({'Suite': 'x-y'}, 'x'),
+    ({'Suite': 'lunar'}, 'lunar'),
+    ({'Suite': 'lunar-proposed'}, 'lunar'),
+    ({'Suite': 'focal-security'}, 'focal'),
+])
+def test_series_codename(monkeypatch, info, expected_series_codename):
+    """Checks the codename is extracted properly from the suite name."""
+    suite = Suite('x', '/tmp')
+
+    # Substitute in our fake test info in place of Suite's info() routine
+    monkeypatch.setattr(Suite, "info", info)
+
+    assert suite.series_codename == expected_series_codename
+
+
[e-mail]('info, expected_pocket', [
+    ({'Suite': 'x'}, 'release'),
+    ({'Suite': 'x-y'}, 'y'),
+    ({'Suite': 'lunar'}, 'release'),
+    ({'Suite': 'lunar-proposed'}, 'proposed'),
+    ({'Suite': 'focal-security'}, 'security'),
+])
+def test_pocket(monkeypatch, info, expected_pocket):
+    """Checks the pocket is extracted properly from the suite name."""
+    suite = Suite('x', '/tmp')
+
+    # Substitute in our fake test info in place of Suite's info() routine
+    monkeypatch.setattr(Suite, "info", info)
+
+    assert suite.pocket == expected_pocket
+
+
[e-mail]('info, expected_architectures', [
+    ({'Architectures': 'x y z'}, ['x', 'y', 'z']),
+    ({'Architectures': 'x y z'}, ['x', 'y', 'z']),
+    ({'Architectures': 'amd64 arm64 armhf i386 ppc64el riscv64 s390x'},
+     ['amd64', 'arm64', 'armhf', 'i386', 'ppc64el', 'riscv64', 's390x']),
+])
+def test_architectures(monkeypatch, info, expected_architectures):
+    """Checks that the architecture list is parsed from the info dict."""
+    suite = Suite('x', '/tmp')
+
+    # Substitute in our fake test info in place of Suite's info() routine
+    monkeypatch.setattr(Suite, "info", info)
+
+    assert sorted(suite.architectures) == sorted(expected_architectures)
+
+
[e-mail]('suite_name, component_paths, expected_components', [
+    ('a-1', ['a-1/x', 'a-1/y', 'a-1/z'], ['x', 'y', 'z']),
+    ('a-1', ['a-1/x', 'b-1/y', 'c-1/z'], ['x']),
+    ('a-1', ['a-1/x', 'a-1/x/y', 'c-1/z/x'], ['x']),
+    ('x', ['x/main', 'x/restricted', 'x/universe', 'x/multiverse'],
+     ['main', 'restricted', 'universe', 'multiverse']),
+])
+def test_components(tmp_path, suite_name, component_paths, expected_components):
+    """Checks that the components are read from the Apt directory tree.
+
+    The repository could have multiple suites (b-1, c-1, ...)
+    so we specify that we're just looking for the components in
+    @param suite_name.
+    """
+    # Stub in suite's directory structure with component subdirs
+    for component_path in component_paths:
+        component_dir = tmp_path / component_path
+        component_dir.mkdir(parents=True)
+
+    suite = Suite(suite_name, tmp_path / suite_name)
+
+    assert sorted(suite.components) == sorted(expected_components)
+
+
[e-mail]('sources_contents, expected_sources', [
+    ('Package: a', {'a': 'SourcePackage(a)'}),
+    ("""
+Package: aalib
+
+Package: abseil
+
+Package: accountsservice
+
+Package: acct
+    """, {
+        'aalib': 'SourcePackage(aalib)',
+        'abseil': 'SourcePackage(abseil)',
+        'accountsservice': 'SourcePackage(accountsservice)',
+        'acct': 'SourcePackage(acct)',
+    }),
+    ("""
+Package: libsigc++-2.0
+Format: 3.0 (quilt)
+Binary: libsigc++-2.0-0v5, libsigc++-2.0-dev, libsigc++-2.0-doc
+Architecture: any all
+Version: 2.12.0-1
+Priority: optional
+Section: devel
+Maintainer: Debian GNOME Maintainers <[e-mail]>
+Uploaders: Jeremy Bicha <[e-mail]>, Michael Biebl <[e-mail]>
+Standards-Version: 4.6.1
+Build-Depends: debhelper-compat (= 13), dh-sequence-gnome, docbook-xml, docbook-xsl, doxygen, graphviz, libxml2-utils <!nocheck>, meson (>= 0.50.0), mm-common (>= 1.0.0), python3-distutils, xsltproc
+Homepage: https://libsigcplusplus.github.io/libsigcplusplus/
+Vcs-Browser: https://salsa.debian.org/gnome-team/libsigcplusplus
+Vcs-Git: https://salsa.debian.org/gnome-team/libsigcplusplus.git
+Directory: pool/main/libs/libsigc++-2.0
+Package-List:
+ libsigc++-2.0-0v5 deb libs optional arch=any
+ libsigc++-2.0-dev deb libdevel optional arch=any
+ libsigc++-2.0-doc deb doc optional arch=all
+Files:
+ 23feb2cc5036384f94a3882c760a7eb4 2336 libsigc++-2.0_2.12.0-1.dsc
+ 8685af8355138b1c48a6cd032e395303 163724 libsigc++-2.0_2.12.0.orig.tar.xz
+ d60ca8c15750319f52d3b7eaeb6d99e1 10800 libsigc++-2.0_2.12.0-1.debian.tar.xz
+Checksums-Sha1:
+ 81840b1d39dc48350de207566c86b9f1ea1e22d2 2336 libsigc++-2.0_2.12.0-1.dsc
+ f66e696482c4ff87968823ed17b294c159712824 163724 libsigc++-2.0_2.12.0.orig.tar.xz
+ a699c88f7c91157af4c5cdd0f4d0ddebeea9092e 10800 libsigc++-2.0_2.12.0-1.debian.tar.xz
+    """,  # noqa: E501
+        {
+            'libsigc++-2.0': 'SourcePackage(libsigc++-2.0)',
+        }),
+])
+def test_sources(tmp_path, sources_contents, expected_sources):
+    """Checks that the source packages are read from the Apt record.
+
+    We don't care about the SourcePackage object itself (the value in
+    @param expected_sources is just a placeholder), but need to ensure
+    the Sources.xz file is read and the expected list of packages
+    parsed out of it.
+    """
+    # Create Sources.xz file using sources_contents in synthetic tree
+    suite_dir = tmp_path / 'x'
+    suite_dir.mkdir()
+    component_dir = suite_dir / 'main'
+    component_dir.mkdir()
+    arch_dir = component_dir / 'source'
+    arch_dir.mkdir()
+    sources_file = arch_dir / 'Sources.xz'
+    sources_file.write_bytes(xz.compress(str.encode(sources_contents)))
+
+    # Create the suite to wrapper our path and access Sources.xz
+    suite = Suite(suite_dir.name, suite_dir)
+
+    assert sorted(suite.sources) == sorted(expected_sources)
+
+
[e-mail]('architectures, packages_contents, expected_binaries', [
+    (['x'], 'Package: a', {'a:x': 'BinaryPackage(a)'}),
+    (['amd64'], """
+Package: aalib
+
+Package: abseil
+
+Package: accountsservice
+
+Package: acct
+    """, {
+        'aalib:amd64': 'BinaryPackage(aalib)',
+        'abseil:amd64': 'BinaryPackage(abseil)',
+        'accountsservice:amd64': 'BinaryPackage(accountsservice)',
+        'acct:amd64': 'BinaryPackage(acct)',
+    }),
+    (['amd64'], """
+Package: accountsservice
+Architecture: amd64
+Version: 22.08.8-1ubuntu4
+Priority: optional
+Section: gnome
+Origin: Ubuntu
+Maintainer: Ubuntu Developers <[e-mail]>
+Original-Maintainer: Debian freedesktop.org maintainers <[e-mail]>
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Installed-Size: 504
+Depends: dbus (>= 1.9.18), libaccountsservice0 (= 22.08.8-1ubuntu4), libc6 (>= 2.34), libglib2.0-0 (>= 2.63.5), libpolkit-gobject-1-0 (>= 0.99)
+Recommends: default-logind | logind
+Suggests: gnome-control-center
+Filename: pool/main/a/accountsservice/accountsservice_22.08.8-1ubuntu4_amd64.deb
+Size: 68364
+MD5sum: a10447714f0ce3c5f607b7b27c0f9299
+SHA1: 252482d8935d16b7fc5ced0c88819eeb7cad6c65
+SHA256: 4e341a8e288d8f8f9ace6cf90a1dcc3211f06751d9bec3a68a6c539b0c711282
+SHA512: eb91e21b4dfe38e9768e8ca50f30f94298d86f07e78525ab17df12eb3071ea21cfbdc2ade3e48bd4e22790aa6ce3406bb10fbd17d8d668f84de1c8adeee249cb
+Homepage: https://www.freedesktop.org/wiki/Software/AccountsService/
+Description: query and manipulate user account information
+Task: ubuntu-desktop-minimal, ubuntu-desktop, ubuntu-desktop-raspi, ubuntu-wsl, kubuntu-desktop, xubuntu-minimal, xubuntu-desktop, lubuntu-desktop, ubuntustudio-desktop-core, ubuntustudio-desktop, ubuntukylin-desktop, ubuntu-mate-core, ubuntu-mate-desktop, ubuntu-budgie-desktop, ubuntu-budgie-desktop-raspi, ubuntu-unity-desktop, edubuntu-desktop-minimal, edubuntu-desktop, edubuntu-desktop-raspi, edubuntu-wsl
+Description-md5: 8aeed0a03c7cd494f0c4b8d977483d7e
+    """, {  # noqa: E501
+            'accountsservice:amd64': 'BinaryPackage(accountsservice)'
+    }),
+    (
+        ['amd64', 'arm64', 'armhf', 'i386', 'ppc64el', 'riscv64', 's390x'],
+        'Package: libsigc++-2.0', {
+            'libsigc++-2.0:amd64': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:arm64': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:armhf': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:i386': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:ppc64el': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:riscv64': 'BinaryPackage(libsigc++-2.0)',
+            'libsigc++-2.0:s390x': 'BinaryPackage(libsigc++-2.0)',
+        }
+    ),
+])
+def test_binaries(tmp_path, architectures, packages_contents, expected_binaries):
+    """Checks that the binary packages are read from the Apt record.
+
+    We don't care about the BinaryPackage (the value) itself, just that
+    the package name and arch are registered correctly, and that typical
+    Packages.xz files are processed as intended.
+    """
+    suite_dir = tmp_path / 'x'
+    suite_dir.mkdir()
+    release_file = suite_dir / 'Release'
+    release_file.write_text(f'Architectures: {" ".join(architectures)}')
+    component_dir = suite_dir / 'main'
+    component_dir.mkdir()
+    for arch in architectures:
+        arch_dir = component_dir / f'binary-{arch}'
+        arch_dir.mkdir()
+        packages_file = arch_dir / 'Packages.xz'
+        packages_file.write_bytes(xz.compress(str.encode(packages_contents)))
+
+    # Create the suite to wrapper our path and access Packages.xz
+    suite = Suite(suite_dir.name, suite_dir)
+    assert sorted(suite.binaries.keys()) == sorted(expected_binaries.keys())