Merge lp:~james-w/linaro-image-tools/architecture-support into lp:linaro-image-tools/11.11

[James Westby]

Hi,

Here's a rather simple branch to add architecture support through the code
we have now.

I just updated the spec to state that ARCHITECTURE is a required field in
the metadata, so that's now a required argument to the constructor of the
corresponding class, and it is output in the __str__ method.

Also the Package classes get architecture as an ivar, such that we can
track which architecture they are for, which leads to the change in the
get_packages_file function, which can now stop hardcoding "all".

The dummy test package object defaults to "all" as that way the tests
will work on multiple architectures without updating.

However, that leaves a gap, so I added a couple of new tests to ensure
that we fetch packages from the right architecture.

In order to support cross-build of hardware packs I stole a trick from
the chdist tool, which allows us to tell apt to pretend it is on a
different architecture. I added a test to peek inside the implementation
and check we were writing the config correctly, but the two added tests
check that it has the desired effect.

There's still a gap, as noted in the spec, about how we specify the
architectures to build for, as I'm not sure whether it should be in
the configuration file or on the command line, or some combination
of the two. This will mainly depend on how we want to hook it in to
lexbuilder I think. At least now all the infrastructure is in place
to build for any arch that we like.

Thanks,

James

[lp:~james-w/linaro-image-tools/architecture-support]

102. By James Westby on 2010-09-02

Merge add-packages-to-hwpack.

103. By James Westby on 2010-09-02

Merged add-packages-to-hwpack into architecture-support.

104. By James Westby on 2010-09-02

Use the new name of AptSourceFixture.

105. By James Westby on 2010-09-02

Merge add-packages-to-hwpack in to architecture-support.

Unmerged revisions

=== modified file 'hwpack/hardwarepack.py'
--- hwpack/hardwarepack.py	2010-09-02 18:58:01 +0000
+++ hwpack/hardwarepack.py	2010-09-02 18:58:01 +0000
@@ -26,8 +26,8 @@
     :type support: str or None
     """
 
-    def __init__(self, name, version, origin=None, maintainer=None,
-                 support=None):
+    def __init__(self, name, version, architecture, origin=None,
+                 maintainer=None, support=None):
         """Create the Metadata for a hardware pack.
 
         See the instance variables for a description of the arguments.
@@ -37,11 +37,13 @@
         self.origin = origin
         self.maintainer = maintainer
         self.support = support
+        self.architecture = architecture
 
     def __str__(self):
         """Get the contents of the metadata file."""
         metadata = "NAME=%s\n" % self.name
         metadata += "VERSION=%s\n" % self.version
+        metadata += "ARCHITECTURE=%s\n" % self.architecture
         if self.origin is not None:
             metadata += "ORIGIN=%s\n" % self.origin
         if self.maintainer is not None:

=== modified file 'hwpack/packages.py'
--- hwpack/packages.py	2010-09-02 18:58:01 +0000
+++ hwpack/packages.py	2010-09-02 18:58:01 +0000
@@ -8,6 +8,13 @@
 
 
 def get_packages_file(packages):
+    """Get the Packages file contents indexing `packages`.
+
+    :param packages: the packages to index.
+    :type packages: an iterable of FetchedPackages.
+    :return: the Packages file contents indexing `packages`.
+    :rtype: str
+    """
     content = ""
     for package in packages:
         parts = []
@@ -15,8 +22,7 @@
         parts.append(('Version', package.version))
         parts.append(('Filename', package.filename))
         parts.append(('Size', str(package.size)))
-        # TODO: architecture support
-        parts.append(('Architecture', 'all'))
+        parts.append(('Architecture', package.architecture))
         parts.append(('MD5sum', package.md5))
         content += "\n".join([": ".join(p) for p in parts])
         content += "\n\n"
@@ -24,6 +30,11 @@
 
 
 class DummyProgress(object):
+    """An AcquireProgress that silences all output.
+
+    This can be used to ensure that apt produces no output
+    when fetching files.
+    """
 
     def start(self):
         pass
@@ -63,9 +74,13 @@
     :ivar md5: the hex representation of the md5sum of the contents of
         the package.
     :type md5: str
+    :ivar architecture: the architecture that the package is for, may be
+        'all'.
+    :type architecture: str
     """
 
-    def __init__(self, name, version, filename, content, size, md5):
+    def __init__(self, name, version, filename, content, size, md5,
+                 architecture):
         """Create a FetchedPackage.
 
         See the instance variables for the arguments.
@@ -76,6 +91,7 @@
         self.content = content
         self.size = size
         self.md5 = md5
+        self.architecture = architecture
 
     def __eq__(self, other):
         return (self.name == other.name
@@ -83,7 +99,8 @@
                 and self.filename == other.filename
                 and self.content.read() == other.content.read()
                 and self.size == other.size
-                and self.md5 == other.md5)
+                and self.md5 == other.md5
+                and self.architecture == other.architecture)
 
     def __hash__(self):
         return hash(
@@ -93,7 +110,7 @@
 class PackageFetcher(object):
     """A class to fetch packages from a defined list of sources."""
 
-    def __init__(self, sources):
+    def __init__(self, sources, architecture=None):
         """Create a PackageFetcher.
 
         Once created a PackageFetcher should have its `prepare` method
@@ -102,8 +119,11 @@
         :param sources: a list of sources such that they can be prefixed
             with "deb " and fed to apt.
         :type sources: an iterable of str
+        :param architecture: the architecture to fetch packages for.
+        :type architecture: str
         """
         self.sources = sources
+        self.architecture = architecture
         self.tempdir = None
 
     def prepare(self):
@@ -131,6 +151,10 @@
         with open(sources_list, 'w') as f:
             for source in self.sources:
                 f.write("deb %s\n" % source)
+        if self.architecture is not None:
+            apt_conf = os.path.join(self.tempdir, "etc", "apt", "apt.conf")
+            with open(apt_conf, 'w') as f:
+                f.write('Apt {\nArchitecture "%s";\n}\n' % self.architecture)
         self.cache = Cache(rootdir=self.tempdir, memonly=True)
         self.cache.update()
         self.cache.open()
@@ -149,10 +173,9 @@
 
         :param packages: a list of package names to install
         :type packages: an iterable of str
-        :return: a dict containing the filenames of the .debs that were
-            fetched as the keys, and file objects with the contents of
-            those debs as the values.
-        :rtype: a dict mapping str to file-like objects.
+        :return: a list of the packages that were fetched, with relevant
+            metdata and the contents of the files available.
+        :rtype: an iterable of FetchedPackages.
         :raises KeyError: if any of the package names in the list couldn't
             be found.
         """
@@ -172,6 +195,7 @@
                     (acqfile.destfile, acqfile.error_text))
             result_package = FetchedPackage(
                 candidate.package.name, candidate.version, base,
-                open(destfile), candidate.size, candidate.md5)
+                open(destfile), candidate.size, candidate.md5,
+                candidate.architecture)
             results.append(result_package)
         return results

=== modified file 'hwpack/testing.py'
--- hwpack/testing.py	2010-09-02 18:58:01 +0000
+++ hwpack/testing.py	2010-09-02 18:58:01 +0000
@@ -47,10 +47,15 @@
 
 
 class DummyFetchedPackage(FetchedPackage):
-
-    def __init__(self, name, version):
+    """A FetchedPackage with dummy information.
+
+    See FetchedPackage for the instance variables.
+    """
+
+    def __init__(self, name, version, architecture="all"):
         self.name = name
         self.version = version
+        self.architecture = architecture
 
     @property
     def filename(self):
@@ -71,9 +76,24 @@
         return md5sum.hexdigest()
 
 
-class AptSource(object):
+class AptSourceFixture(object):
+    """A fixture that provides an apt source, with packages and indices.
+
+    An apt source provides a set of package files, and a Packages file
+    that allows apt to determine the contents of the source.
+
+    :ivar sources_entry: the URI and suite to give to apt to view the
+        source (i.e. a sources.list line without the "deb" prefix
+    :type sources_entry: str
+    """
 
     def __init__(self, packages):
+        """Create an AptSourceFixture.
+
+        :param packages: a list of packages to add to the source
+            and index.
+        :type packages: an iterable of FetchedPackages
+        """
         self.packages = packages
 
     def setUp(self):
@@ -95,8 +115,24 @@
 
 
 class TestCaseWithFixtures(TestCase):
+    """A TestCase with the ability to easily add 'fixtures'.
+
+    A fixture is an object which can be created and cleaned up, and
+    this test case knows how to manage them to ensure that they will
+    always be cleaned up at the end of the test.
+    """
 
     def useFixture(self, fixture):
+        """Make use of a fixture, ensuring that it will be cleaned up.
+
+        Given a fixture, this method will run the `setUp` method of
+        the fixture, and ensure that its `tearDown` method will be
+        called at the end of the test, regardless of success or failure.
+
+        :param fixture: the fixture to use.
+        :type fixture: an object with setUp and tearDown methods.
+        :return: the fixture that was passed in.
+        """
         self.addCleanup(fixture.tearDown)
         fixture.setUp()
         return fixture

=== modified file 'hwpack/tests/test_hardwarepack.py'
--- hwpack/tests/test_hardwarepack.py	2010-09-02 18:58:01 +0000
+++ hwpack/tests/test_hardwarepack.py	2010-09-02 18:58:01 +0000
@@ -12,56 +12,67 @@
 class MetadataTests(TestCase):
 
     def test_name(self):
-        metadata = Metadata("ahwpack", "3")
+        metadata = Metadata("ahwpack", "3", "armel")
         self.assertEqual("ahwpack", metadata.name)
 
     def test_version(self):
-        metadata = Metadata("ahwpack", "3")
+        metadata = Metadata("ahwpack", "3", "armel")
         self.assertEqual("3", metadata.version)
 
+    def test_architecture(self):
+        metadata = Metadata("ahwpack", "3", "armel")
+        self.assertEqual("armel", metadata.architecture)
+
     def test_default_origin_is_None(self):
-        metadata = Metadata("ahwpack", "4")
+        metadata = Metadata("ahwpack", "4", "armel")
         self.assertEqual(None, metadata.origin)
 
     def test_origin(self):
-        metadata = Metadata("ahwpack", "4", origin="linaro")
+        metadata = Metadata("ahwpack", "4", "armel", origin="linaro")
         self.assertEqual("linaro", metadata.origin)
 
     def test_default_maintainer_is_None(self):
-        metadata = Metadata("ahwpack", "4")
+        metadata = Metadata("ahwpack", "4", "armel")
         self.assertEqual(None, metadata.maintainer)
 
     def test_maintainer(self):
-        metadata = Metadata("ahwpack", "4", maintainer="Some maintainer")
+        metadata = Metadata(
+            "ahwpack", "4", "armel", maintainer="Some maintainer")
         self.assertEqual("Some maintainer", metadata.maintainer)
 
     def test_default_support_is_None(self):
-        metadata = Metadata("ahwpack", "4")
+        metadata = Metadata("ahwpack", "4", "armel")
         self.assertEqual(None, metadata.support)
 
     def test_support(self):
-        metadata = Metadata("ahwpack", "4", support="supported")
+        metadata = Metadata("ahwpack", "4", "armel", support="supported")
         self.assertEqual("supported", metadata.support)
 
     def test_str(self):
-        metadata = Metadata("ahwpack", "4")
-        self.assertEqual("NAME=ahwpack\nVERSION=4\n", str(metadata))
+        metadata = Metadata("ahwpack", "4", "armel")
+        self.assertEqual(
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n", str(metadata))
 
     def test_str_with_origin(self):
-        metadata = Metadata("ahwpack", "4", origin="linaro")
+        metadata = Metadata("ahwpack", "4", "armel", origin="linaro")
         self.assertEqual(
-            "NAME=ahwpack\nVERSION=4\nORIGIN=linaro\n", str(metadata))
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\nORIGIN=linaro\n",
+            str(metadata))
 
     def test_str_with_maintainer(self):
-        metadata = Metadata("ahwpack", "4", maintainer="Some Maintainer")
+        metadata = Metadata(
+            "ahwpack", "4", "armel", maintainer="Some Maintainer")
         self.assertEqual(
-            "NAME=ahwpack\nVERSION=4\nMAINTAINER=Some Maintainer\n",
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n"
+            "MAINTAINER=Some Maintainer\n",
             str(metadata))
 
     def test_str_with_support(self):
-        metadata = Metadata("ahwpack", "4", support="unsupported")
+        metadata = Metadata("ahwpack", "4", "armel", support="unsupported")
         self.assertEqual(
-            "NAME=ahwpack\nVERSION=4\nSUPPORT=unsupported\n", str(metadata))
+            "NAME=ahwpack\nVERSION=4\nARCHITECTURE=armel\n"
+            "SUPPORT=unsupported\n",
+            str(metadata))
 
 
 class HardwarePackHasFile(TarfileHasFile):
@@ -111,7 +122,7 @@
 
     def setUp(self):
         super(HardwarePackTests, self).setUp()
-        self.metadata = Metadata("ahwpack", 4)
+        self.metadata = Metadata("ahwpack", 4, "armel")
 
     def test_format_is_1_0(self):
         hwpack = HardwarePack(self.metadata)
@@ -122,7 +133,7 @@
         self.assertEqual("hwpack_ahwpack_4.tar.gz", hwpack.filename())
 
     def test_filename_with_support(self):
-        metadata = Metadata("ahwpack", "4", support="supported")
+        metadata = Metadata("ahwpack", "4", "armel", support="supported")
         hwpack = HardwarePack(metadata)
         self.assertEqual(
             "hwpack_ahwpack_4_supported.tar.gz", hwpack.filename())
@@ -144,7 +155,7 @@
 
     def test_creates_metadata_file(self):
         metadata = Metadata(
-            "ahwpack", "4", origin="linaro",
+            "ahwpack", "4", "armel", origin="linaro",
             maintainer="Some Maintainer", support="unsupported")
         hwpack = HardwarePack(metadata)
         tf = self.get_tarfile(hwpack)

=== modified file 'hwpack/tests/test_packages.py'
--- hwpack/tests/test_packages.py	2010-09-02 18:58:01 +0000
+++ hwpack/tests/test_packages.py	2010-09-02 18:58:01 +0000
@@ -9,7 +9,7 @@
     PackageFetcher,
     )
 from hwpack.testing import (
-    AptSource,
+    AptSourceFixture,
     DummyFetchedPackage,
     TestCaseWithFixtures,
     )
@@ -18,12 +18,12 @@
 class GetPackagesFileTests(TestCase):
 
     def test_single_stanza(self):
-        package = DummyFetchedPackage("foo", "1.1")
+        package = DummyFetchedPackage("foo", "1.1", architecture="armel")
         self.assertEqual("""Package: foo
 Version: 1.1
 Filename: %(filename)s
 Size: %(size)d
-Architecture: all
+Architecture: armel
 MD5sum: %(md5)s
 
 """ % {
@@ -44,68 +44,77 @@
 
     def test_attributes(self):
         package = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa",
+            "armel")
         self.assertEqual("foo", package.name)
         self.assertEqual("1.1", package.version)
         self.assertEqual("foo_1.1.deb", package.filename)
         self.assertEqual("xxxx", package.content.read())
         self.assertEqual(4, package.size)
         self.assertEqual("aaaa", package.md5)
+        self.assertEqual("armel", package.architecture)
 
     def test_equal(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertEqual(package1, package2)
 
     def test_not_equal_different_name(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "bar", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "bar", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertNotEqual(package1, package2)
 
     def test_not_equal_different_version(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.2", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.2", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertNotEqual(package1, package2)
 
     def test_not_equal_different_filename(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.1", "afoo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "afoo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertNotEqual(package1, package2)
 
     def test_not_equal_different_content(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("yyyy"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("yyyy"), 4, "aaaa", "armel")
         self.assertNotEqual(package1, package2)
 
     def test_not_equal_different_size(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 5, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 5, "aaaa", "armel")
         self.assertNotEqual(package1, package2)
 
     def test_not_equal_different_md5(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
-        package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "bbbb")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "bbbb", "armel")
+        self.assertNotEqual(package1, package2)
+
+    def test_not_equal_different_architecture(self):
+        package1 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
+        package2 = FetchedPackage(
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "i386")
         self.assertNotEqual(package1, package2)
 
     def test_equal_hash_equal(self):
         package1 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         package2 = FetchedPackage(
-            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa")
+            "foo", "1.1", "foo_1.1.deb", StringIO("xxxx"), 4, "aaaa", "armel")
         self.assertEqual(hash(package1), hash(package2))
 
 
@@ -164,8 +173,8 @@
                 fetcher.tempdir, "var", "lib", "apt", "lists", "partial")))
 
     def test_prepare_creates_etc_apt_sources_list_file(self):
-        source1 = self.useFixture(AptSource([]))
-        source2 = self.useFixture(AptSource([]))
+        source1 = self.useFixture(AptSourceFixture([]))
+        source2 = self.useFixture(AptSourceFixture([]))
         fetcher = PackageFetcher(
             [source1.sources_entry, source2.sources_entry])
         self.addCleanup(fetcher.cleanup)
@@ -176,8 +185,18 @@
             open(os.path.join(
                 fetcher.tempdir, "etc", "apt", "sources.list")).read())
 
-    def get_fetcher(self, sources):
-        fetcher = PackageFetcher([s.sources_entry for s in sources])
+    def test_prepare_with_arch_creates_etc_apt_apt_conf(self):
+        fetcher = PackageFetcher([], architecture="arch")
+        self.addCleanup(fetcher.cleanup)
+        fetcher.prepare()
+        self.assertEqual(
+            'Apt {\nArchitecture "arch";\n}\n',
+            open(os.path.join(
+                fetcher.tempdir, "etc", "apt", "apt.conf")).read())
+
+    def get_fetcher(self, sources, architecture=None):
+        fetcher = PackageFetcher(
+            [s.sources_entry for s in sources], architecture=architecture)
         self.addCleanup(fetcher.cleanup)
         fetcher.prepare()
         return fetcher
@@ -188,32 +207,32 @@
 
     def test_fetch_packages_not_found_because_not_in_sources(self):
         available_package = DummyFetchedPackage("foo", "1.0")
-        source = self.useFixture(AptSource([available_package]))
+        source = self.useFixture(AptSourceFixture([available_package]))
         fetcher = self.get_fetcher([source])
         self.assertRaises(KeyError, fetcher.fetch_packages, ["nothere"])
 
     def test_fetch_packages_not_found_one_of_two_missing(self):
         available_package = DummyFetchedPackage("foo", "1.0")
-        source = self.useFixture(AptSource([available_package]))
+        source = self.useFixture(AptSourceFixture([available_package]))
         fetcher = self.get_fetcher([source])
         self.assertRaises(
             KeyError, fetcher.fetch_packages, ["foo", "nothere"])
 
     def test_fetch_packges_fetches_no_packages(self):
         available_package = DummyFetchedPackage("foo", "1.0")
-        source = self.useFixture(AptSource([available_package]))
+        source = self.useFixture(AptSourceFixture([available_package]))
         fetcher = self.get_fetcher([source])
         self.assertEqual(0, len(fetcher.fetch_packages([])))
 
     def test_fetch_packges_fetches_single_package(self):
         available_package = DummyFetchedPackage("foo", "1.0")
-        source = self.useFixture(AptSource([available_package]))
+        source = self.useFixture(AptSourceFixture([available_package]))
         fetcher = self.get_fetcher([source])
         self.assertEqual(1, len(fetcher.fetch_packages(["foo"])))
 
-    def test_fetch_packges_fetches_correct_packge(self):
+    def test_fetch_packges_fetches_correct_package(self):
         available_package = DummyFetchedPackage("foo", "1.0")
-        source = self.useFixture(AptSource([available_package]))
+        source = self.useFixture(AptSourceFixture([available_package]))
         fetcher = self.get_fetcher([source])
         self.assertEqual(
             available_package, fetcher.fetch_packages(["foo"])[0])
@@ -223,7 +242,7 @@
             DummyFetchedPackage("bar", "1.0"),
             DummyFetchedPackage("foo", "1.0"),
         ]
-        source = self.useFixture(AptSource(available_packages))
+        source = self.useFixture(AptSourceFixture(available_packages))
         fetcher = self.get_fetcher([source])
         self.assertEqual(2, len(fetcher.fetch_packages(["foo", "bar"])))
 
@@ -232,7 +251,7 @@
             DummyFetchedPackage("foo", "1.0"),
             DummyFetchedPackage("bar", "1.0"),
         ]
-        source = self.useFixture(AptSource(available_packages))
+        source = self.useFixture(AptSourceFixture(available_packages))
         fetcher = self.get_fetcher([source])
         fetched = fetcher.fetch_packages(["foo", "bar"])
         self.assertEqual(available_packages[0], fetched[0])
@@ -243,7 +262,7 @@
             DummyFetchedPackage("bar", "1.0"),
             DummyFetchedPackage("bar", "1.1"),
         ]
-        source = self.useFixture(AptSource(available_packages))
+        source = self.useFixture(AptSourceFixture(available_packages))
         fetcher = self.get_fetcher([source])
         fetched = fetcher.fetch_packages(["bar"])
         self.assertEqual(available_packages[1], fetched[0])
@@ -251,8 +270,27 @@
     def test_fetch_packages_fetches_newest_from_multiple_sources(self):
         old_source_packages = [DummyFetchedPackage("bar", "1.0")]
         new_source_packages = [DummyFetchedPackage("bar", "1.1")]
-        old_source = self.useFixture(AptSource(old_source_packages))
-        new_source = self.useFixture(AptSource(new_source_packages))
+        old_source = self.useFixture(AptSourceFixture(old_source_packages))
+        new_source = self.useFixture(AptSourceFixture(new_source_packages))
         fetcher = self.get_fetcher([old_source, new_source])
         fetched = fetcher.fetch_packages(["bar"])
         self.assertEqual(new_source_packages[0], fetched[0])
+
+    def test_fetch_package_records_correct_architecture(self):
+        available_package = DummyFetchedPackage(
+            "foo", "1.0", architecture="nonexistant")
+        source = self.useFixture(AptSourceFixture([available_package]))
+        fetcher = self.get_fetcher([source], architecture="nonexistant")
+        self.assertEqual(
+            "nonexistant", fetcher.fetch_packages(["foo"])[0].architecture)
+
+    def test_fetch_package_fetches_from_correct_architecture(self):
+        wanted_package = DummyFetchedPackage(
+            "foo", "1.0", architecture="arch1")
+        unwanted_package = DummyFetchedPackage(
+            "foo", "1.1", architecture="arch2")
+        source = self.useFixture(
+            AptSourceFixture([wanted_package, unwanted_package]))
+        fetcher = self.get_fetcher([source], architecture="arch1")
+        self.assertEqual(
+            wanted_package, fetcher.fetch_packages(["foo"])[0])