Merge lp:~jml/pkgme/more-info-in-api into lp:pkgme

[Jonathan Lange]

More information.

At the moment it's just me going crazy.

[lp:~jml/pkgme/more-info-in-api]

144. By Jonathan Lange on 2012-08-31

Just return the straight dict from get_eligible_backends.

145. By Jonathan Lange on 2012-08-31

Straight up data

146. By Jonathan Lange on 2012-08-31

Move the guts of some of the new methods out to be functions

147. By Jonathan Lange on 2012-08-31

Pull the main thing out of the class.

148. By Jonathan Lange on 2012-08-31

Move the guts of the __init__ file to main, where other very similar things
already live.

Make sure the test modules line up with the modules they are testing.

149. By Jonathan Lange on 2012-08-31

We weren't running these tests :(

150. By Jonathan Lange on 2012-08-31

Document the change

Unmerged revisions

150. By Jonathan Lange on 2012-08-31

Document the change

149. By Jonathan Lange on 2012-08-31

We weren't running these tests :(

148. By Jonathan Lange on 2012-08-31

Move the guts of the __init__ file to main, where other very similar things
already live.

Make sure the test modules line up with the modules they are testing.

=== modified file 'NEWS.txt'
--- NEWS.txt	2012-08-28 10:57:30 +0000
+++ NEWS.txt	2012-08-31 10:03:29 +0000
@@ -3,6 +3,17 @@
 NEWS for pkgme
 ==============
 
+
+NEXT
+====
+
+Changes
+-------
+
+ * ``BackendSelector.get_eligible_backends`` returns a list of dicts, rather
+   than a list of ``(score, backend)`` 2-tuples.  (Jonathan Lange)
+
+
 0.3.1 (2012-08-28)
 ==================
 

=== modified file 'pkgme/__init__.py'
--- pkgme/__init__.py	2012-08-29 16:18:20 +0000
+++ pkgme/__init__.py	2012-08-31 10:03:29 +0000
@@ -21,54 +21,11 @@
 __metaclass__ = type
 __all__ = [
     '__version__',
-    'get_packaging_info',
     'write_packaging',
-    'write_packaging_info',
     ]
 
 
 __version__ = '0.3.1'
 
 
-
-def get_packaging_info(path, distribution=None, allowed_backend_names=None):
-    """Get the packaging information for 'path'.
-
-    :param path: Path to the thing being packaged.
-    :param distribution: Name of the distribution being packaged for.
-    :param allowed_backend_names: List of allowed backend names.  If not,
-        provided, all backends are allowed.
-    :return: A ``ProjectInfo`` object.
-    """
-    # Do these imports in the function to reduce the side-effects of importing
-    # pkgme.   This avoids the need for setup.py of the tool being packaged
-    # from having to find all the imported dependencies when running the
-    # extension pkgme_info setup.py command.
-    from pkgme.backend import get_info_for
-    info = get_info_for(path, allowed_backend_names=allowed_backend_names)
-    if distribution:
-        from pkgme.info_elements import Distribution
-        from pkgme.project_info import DictInfo, FallbackInfo
-        info = FallbackInfo(DictInfo({Distribution.name: distribution}), info)
-    return info
-
-
-def write_packaging_info(path, info):
-    """Write packaging information for 'path'.
-
-    :param path: Path to write the packaging information to.
-    :param info: A ``ProjectInfo`` containing everything we need to package it.
-    """
-    # Do these imports in the function to reduce the side-effects of importing
-    # pkgme.   This avoids the need for setup.py of the tool being packaged
-    # from having to find all the imported dependencies when running the
-    # extension pkgme_info setup.py command.
-    from pkgme.package_files import default_package_file_group
-    from pkgme.write import Writer
-    files = default_package_file_group.get_files(info)
-    Writer().write(files, path)
-
-
-def write_packaging(path, distribution=None, allowed_backend_names=None):
-    info = get_packaging_info(path, distribution, allowed_backend_names)
-    write_packaging_info(path, info)
+from .bin.main import write_packaging

=== modified file 'pkgme/backend.py'
--- pkgme/backend.py	2012-08-24 13:48:10 +0000
+++ pkgme/backend.py	2012-08-31 10:03:29 +0000
@@ -1,4 +1,5 @@
 import json
+from operator import itemgetter
 import os
 import sys
 
@@ -265,23 +266,60 @@
 class NoEligibleBackend(PkgmeError):
     """Raised when pkgme cannot find an appropriate backend."""
 
-    def __init__(self, path, tried_backends,
-            disallowed_backends=None):
-        backend_names = []
-        for backend, reason in tried_backends:
-            if reason:
-                name = '%s (%s)' % (backend.name, reason)
-            else:
-                name = backend.name
-            backend_names.append(name)
-        backend_names = sorted(backend_names)
+    def __init__(self, path, tried_backends, disallowed_backends=None):
+        backend_names = sorted(map(self._describe_result, tried_backends))
         msg = ("No eligible backends for %s. Tried %s"
                 % (path, ', '.join(backend_names)))
-        if disallowed_backends is not None:
+        if disallowed_backends:
             msg += (". The following backends were disallowed by policy: %s."
-                % (', '.join(disallowed_backends)))
+                % (', '.join([b.name for b in disallowed_backends])))
         super(NoEligibleBackend, self).__init__(msg)
 
+    @staticmethod
+    def _describe_result(result):
+        name = result['backend'].name
+        reason = result.get('reason', None)
+        if reason:
+            name = '%s (%s)' % (name, reason)
+        return name
+
+
+def dichotomy(predicate, collection):
+    false, true = [], []
+    for x in collection:
+        if predicate(x):
+            true.append(x)
+        else:
+            false.append(x)
+    return false, true
+
+
+def _query_backend(path, backend):
+    score, reason = backend.want(path)
+    return {'score': score, 'backend': backend, 'reason': reason}
+
+
+def _query_backends(path, backends):
+    return (_query_backend(path, backend) for backend in backends)
+
+
+def _is_eligible(backend):
+    return backend['score'] > 0
+
+
+def query_backends(path, backends, allowed_backend_names=None):
+    if not backends:
+        raise NoBackend()
+    if allowed_backend_names is None:
+        disallowed, allowed = [], backends
+    else:
+        disallowed, allowed = dichotomy(
+            lambda b: b.name in allowed_backend_names, backends)
+    results = _query_backends(path, allowed)
+    ineligible, eligible = dichotomy(_is_eligible, results)
+    eligible.sort(key=itemgetter('score'), reverse=True)
+    return disallowed, ineligible, eligible
+
 
 class BackendSelector(object):
 
@@ -298,24 +336,6 @@
         self.backends = backends
         self.allowed_backend_names = allowed_backend_names
 
-    def _split_disallowed_backends(self, backends):
-        """Split backends into those allowed and those not.
-
-        :return: (disallowed, allowed), where ``disallowed`` is a list
-            of disallowed backend names and ``allowed`` is a list of
-            allowed backends.  If all backends are allowed then ``disallowed``
-            is None.
-        """
-        if self.allowed_backend_names is None:
-            return None, list(backends)
-        disallowed, allowed = [], []
-        for backend in backends:
-            if backend.name in self.allowed_backend_names:
-                allowed.append(backend)
-            else:
-                disallowed.append(backend.name)
-        return disallowed, allowed
-
     def get_eligible_backends(self, path):
         """Get the backends that could possibly work for ``path``.
 
@@ -324,30 +344,17 @@
         :return: ``[(score, backend), ...]``.  Will always be sorted with
             the highest score first, and then lexographically by backend name.
         """
-        if not self.backends:
-            raise NoBackend()
-        disallowed, backends = self._split_disallowed_backends(self.backends)
-        eligible = []
-        ineligible = []
-        for backend in backends:
-            score, reason = backend.want(path)
-            trace.debug('  %s scored %s' % (backend.name, score))
-            if score > 0:
-                eligible.append((score, backend))
-            else:
-                ineligible.append((backend, reason))
+        disallowed, ineligible, eligible = query_backends(
+            path, self.backends, self.allowed_backend_names)
         if not eligible:
-            # FIXME: some info about the problem. Bug 809423.
             raise NoEligibleBackend(
-                path, ineligible,
-                disallowed_backends=disallowed)
-        return sorted(
-            eligible, key=lambda (score, backend): (-score, backend.name))
+                path, ineligible, disallowed_backends=disallowed)
+        return eligible
 
     def get_info(self, path):
         trace.debug('Finding backend for %s' % (path,))
         eligble = self.get_eligible_backends(path)
-        backend = eligble[0][1]
+        backend = eligble[0]['backend']
         if len(eligble) > 1:
             trace.debug(
                 '%s eligble backends. Picked %s' % (len(eligble), backend.name))

=== modified file 'pkgme/bin/main.py'
--- pkgme/bin/main.py	2012-07-20 19:24:04 +0000
+++ pkgme/bin/main.py	2012-08-31 10:03:29 +0000
@@ -5,7 +5,6 @@
 import os
 import sys
 
-from pkgme import __version__, write_packaging
 from pkgme.backend import (
     EXTERNAL_BACKEND_PATHS,
     get_backend_selector,
@@ -21,6 +20,49 @@
 from pkgme import trace
 
 
+def get_packaging_info(path, distribution=None, allowed_backend_names=None):
+    """Get the packaging information for 'path'.
+
+    :param path: Path to the thing being packaged.
+    :param distribution: Name of the distribution being packaged for.
+    :param allowed_backend_names: List of allowed backend names.  If not,
+        provided, all backends are allowed.
+    :return: A ``ProjectInfo`` object.
+    """
+    # Do these imports in the function to reduce the side-effects of importing
+    # pkgme.   This avoids the need for setup.py of the tool being packaged
+    # from having to find all the imported dependencies when running the
+    # extension pkgme_info setup.py command.
+    from pkgme.backend import get_info_for
+    info = get_info_for(path, allowed_backend_names=allowed_backend_names)
+    if distribution:
+        from pkgme.info_elements import Distribution
+        from pkgme.project_info import DictInfo, FallbackInfo
+        info = FallbackInfo(DictInfo({Distribution.name: distribution}), info)
+    return info
+
+
+def write_packaging_info(path, info):
+    """Write packaging information for 'path'.
+
+    :param path: Path to write the packaging information to.
+    :param info: A ``ProjectInfo`` containing everything we need to package it.
+    """
+    # Do these imports in the function to reduce the side-effects of importing
+    # pkgme.   This avoids the need for setup.py of the tool being packaged
+    # from having to find all the imported dependencies when running the
+    # extension pkgme_info setup.py command.
+    from pkgme.package_files import default_package_file_group
+    from pkgme.write import Writer
+    files = default_package_file_group.get_files(info)
+    Writer().write(files, path)
+
+
+def write_packaging(path, distribution=None, allowed_backend_names=None):
+    info = get_packaging_info(path, distribution, allowed_backend_names)
+    write_packaging_info(path, info)
+
+
 def build_package(target_dir, interactive, ppa=None, sign=None):
     """Where the magic happens."""
     trace.debug("Building source package for %s" % (target_dir,))
@@ -64,6 +106,7 @@
 
 
 def get_version_info(debug=False):
+    from pkgme import __version__
     version = 'pkgme %s' % (__version__,)
     if debug:
         ls = [version, '']
@@ -81,7 +124,12 @@
     """Return a string listing eligible backends for ``target_dir``."""
     selector = get_backend_selector()
     backends = selector.get_eligible_backends(target_dir)
-    return ', '.join('%s (%s)' % (backend.name, score) for (score, backend) in backends)
+    return ', '.join('%s (%s)' % (r['backend'].name, r['score']) for r in backends)
+
+
+def _encode_backend(result):
+    result.update({'backend': result['backend'].name})
+    return result
 
 
 def get_all_info(target_dir, selector=None):
@@ -96,7 +144,7 @@
     if selector is None:
         selector = get_backend_selector()
     eligible = selector.get_eligible_backends(target_dir)
-    backend = eligible[0][1]
+    backend = eligible[0]['backend']
     # XXX: This ignores ExtraFiles and ExtraFilesFromPaths because they aren't
     # in get_elements().
     elements = default_package_file_group.get_elements()
@@ -104,7 +152,7 @@
     project_info = backend.get_info(target_dir)
     data = project_info.get_all(keys)
     data[u'selected_backend'] = backend.name
-    data[u'eligible_backends'] = [(score, b.name) for (score, b) in eligible]
+    data[u'eligible_backends'] = map(_encode_backend, eligible)
     return data
 
 

=== modified file 'pkgme/tests/__init__.py'
--- pkgme/tests/__init__.py	2011-11-23 16:26:39 +0000
+++ pkgme/tests/__init__.py	2012-08-31 10:03:29 +0000
@@ -7,6 +7,7 @@
 def test_suite():
     module_names = [
         'pkgme.tests.test_backend',
+        'pkgme.tests.test_debuild',
         'pkgme.tests.test_distutils_command',
         'pkgme.tests.test_info_elements',
         'pkgme.tests.test_main',
@@ -21,7 +22,6 @@
         'pkgme.tests.test_upload',
         'pkgme.tests.test_vala_backend',
         'pkgme.tests.test_write',
-        'pkgme.tests.test_write_packaging',
         ]
     loader = unittest.TestLoader()
     suite = loader.loadTestsFromNames(module_names)

=== modified file 'pkgme/tests/test_backend.py'
--- pkgme/tests/test_backend.py	2012-08-24 13:54:32 +0000
+++ pkgme/tests/test_backend.py	2012-08-31 10:03:29 +0000
@@ -368,7 +368,8 @@
         backends = [backend1, backend2]
         selector = BackendSelector(backends)
         self.assertEqual(
-            [(10, backend2), (5, backend1)],
+            [{'score': 10, 'backend': backend2, 'reason': None},
+             {'score': 5, 'backend': backend1, 'reason': None}],
             selector.get_eligible_backends(path))
 
     def test_order_by_name_after_score(self):
@@ -381,7 +382,9 @@
         backends = [backend1, backend2, backend3]
         selector = BackendSelector(backends)
         self.assertEqual(
-            [(10, backend2), (10, backend3), (5, backend1)],
+            [{'score': 10, 'backend': backend2, 'reason': None},
+             {'score': 10, 'backend': backend3, 'reason': None},
+             {'score': 5, 'backend': backend1, 'reason': None}],
             selector.get_eligible_backends(path))
 
     def test_ineligible_backends_excluded(self):
@@ -393,7 +396,8 @@
         backends = [backend1, backend2, backend3]
         selector = BackendSelector(backends)
         self.assertEqual(
-            [(10, backend2), (5, backend1)],
+            [{'score': 10, 'backend': backend2, 'reason': None},
+             {'score': 5, 'backend': backend1, 'reason': None}],
             selector.get_eligible_backends(path))
 
     def test_excludes_non_allowed_backend(self):
@@ -407,7 +411,8 @@
         selector = BackendSelector(backends,
                 allowed_backend_names=allowed_backend_names)
         self.assertEqual(
-            [(10, backend2)], selector.get_eligible_backends(path))
+            [{'score': 10, 'backend': backend2, 'reason': None}],
+            selector.get_eligible_backends(path))
 
 
 class ExternalHelpersBackendLoaderTests(TestCase, TestWithFixtures):

=== modified file 'pkgme/tests/test_main.py'
--- pkgme/tests/test_main.py	2011-10-26 19:25:00 +0000
+++ pkgme/tests/test_main.py	2012-08-31 10:03:29 +0000
@@ -1,12 +1,38 @@
+import os
+
+from fixtures import TempDir
 from testtools import TestCase
+from treeshape import HasFileTree
 
-from pkgme import __version__
+from pkgme import (
+    write_packaging,
+    __version__,
+    )
 from pkgme.backend import (
+    BackendSelector,
     EXTERNAL_BACKEND_PATHS,
     StaticBackend,
     )
-from pkgme.bin.main import get_version_info
-from pkgme.testing import StaticLoaderFixture
+from pkgme.bin.main import (
+    get_all_info,
+    get_packaging_info,
+    get_version_info,
+    write_packaging_info,
+    )
+from pkgme.info_elements import (
+    Architecture,
+    Description,
+    Maintainer,
+    PackageName,
+    Version,
+    )
+from pkgme.package_files import Control, DEBIAN_DIR
+from pkgme.project_info import DictInfo
+from pkgme.testing import (
+    ControlSourceStanzaHasField,
+    StaticLoaderFixture,
+    )
+
 
 class TestVersionInfo(TestCase):
 
@@ -28,3 +54,135 @@
             ', '.join(map(repr, EXTERNAL_BACKEND_PATHS)),
             expected_backends)
         self.assertEqual(expected, x)
+
+
+class GetAllInfoTests(TestCase):
+
+    def test_eligible_backends(self):
+        info = DictInfo({})
+        backend1 = StaticBackend(self.getUniqueString(), 5, info)
+        backend2 = StaticBackend(self.getUniqueString(), 10, info)
+        selector = BackendSelector([backend1, backend2])
+        path = self.getUniqueString()
+        info = get_all_info(path, selector)
+        self.assertEqual(
+            [{'score': 10, 'backend': backend2.name, 'reason': None},
+             {'score': 5, 'backend': backend1.name, 'reason': None}],
+            info['eligible_backends'])
+
+    def test_selected_backend(self):
+        info = DictInfo({})
+        backend1 = StaticBackend(self.getUniqueString(), 5, info)
+        backend2 = StaticBackend(self.getUniqueString(), 10, info)
+        selector = BackendSelector([backend1, backend2])
+        path = self.getUniqueString()
+        info = get_all_info(path, selector)
+        self.assertEqual(backend2.name, info['selected_backend'])
+
+    def test_all_info(self):
+        info = {PackageName.name: self.getUniqueString()}
+        backend = StaticBackend(self.getUniqueString(), 5, DictInfo(info))
+        selector = BackendSelector([backend])
+        path = self.getUniqueString()
+        all_info = get_all_info(path, selector)
+        del all_info['eligible_backends']
+        del all_info['selected_backend']
+        self.assertEqual(info, all_info)
+
+
+def ControlHasSourceName(name):
+    control_path = os.path.join(DEBIAN_DIR, Control.filename)
+    return HasFileTree(
+        {control_path:
+             {'content': ControlSourceStanzaHasField("Source", name)}})
+
+
+class WritePackagingTests(TestCase):
+
+    def make_info(self, name):
+        info = DictInfo(
+            {
+                PackageName.name: name,
+                Maintainer.name: self.getUniqueString(),
+                Architecture.name: "all",
+                Description.name: self.getUniqueString(),
+                Version.name: "1",
+            })
+        return info
+
+    def test_write_packaging(self):
+        name = PackageName.clean(self.getUniqueString())
+        info = self.make_info(name)
+        tempdir = self.useFixture(TempDir()).path
+        backend = StaticBackend(
+            self.getUniqueString(), 10, info, expected_path=tempdir)
+        self.useFixture(StaticLoaderFixture([backend]))
+        write_packaging(tempdir)
+        self.assertThat(tempdir, ControlHasSourceName(name))
+
+    def test_write_packaging_passes_allowed_backend_names(self):
+        name = PackageName.clean(self.getUniqueString())
+        other_name = name + "WRONG"
+        info1 = self.make_info(name)
+        info2 = self.make_info(other_name)
+        tempdir = self.useFixture(TempDir()).path
+        backend1 = StaticBackend(
+            self.getUniqueString(), 10, info1, expected_path=tempdir)
+        backend2 = StaticBackend(
+            self.getUniqueString(), 20, info2)
+        self.useFixture(StaticLoaderFixture(
+            [backend1, backend2]))
+        write_packaging(tempdir, allowed_backend_names=[backend1.name])
+        self.assertThat(tempdir, ControlHasSourceName(name))
+
+
+class TestWritePackagingInformation(TestCase):
+
+    def test_writes_packaging(self):
+        path = self.useFixture(TempDir()).path
+        package_name = PackageName.clean(self.getUniqueString())
+        info = DictInfo(
+            {
+                PackageName.name: package_name,
+                Maintainer.name: self.getUniqueString(),
+                Architecture.name: "all",
+                Description.name: self.getUniqueString(),
+                Version.name: "1",
+            })
+        write_packaging_info(path, info)
+        self.assertThat(path, ControlHasSourceName(package_name))
+
+
+class TestGetPackagingInfo(TestCase):
+
+    def make_info(self):
+        return DictInfo(
+            {
+                PackageName.name: PackageName.clean(self.getUniqueString()),
+                Maintainer.name: self.getUniqueString(),
+                Architecture.name: "all",
+                Description.name: self.getUniqueString(),
+                Version.name: "1",
+            })
+
+    def test_get_packaging_info(self):
+        info = self.make_info()
+        tempdir = self.useFixture(TempDir()).path
+        backend = StaticBackend(
+            self.getUniqueString(), 10, info, expected_path=tempdir)
+        self.useFixture(StaticLoaderFixture([backend]))
+        found = get_packaging_info(tempdir)
+        self.assertEqual(found, info)
+
+    def test_allowed_backend_names(self):
+        info1 = self.make_info()
+        info2 = self.make_info()
+        tempdir = self.useFixture(TempDir()).path
+        backend1 = StaticBackend(
+            self.getUniqueString(), 10, info1, expected_path=tempdir)
+        backend2 = StaticBackend(
+            self.getUniqueString(), 20, info2)
+        self.useFixture(StaticLoaderFixture([backend1, backend2]))
+        found = get_packaging_info(
+            tempdir, allowed_backend_names=[backend1.name])
+        self.assertEqual(found, info1)

=== modified file 'pkgme/tests/test_script.py'
--- pkgme/tests/test_script.py	2012-08-06 13:26:01 +0000
+++ pkgme/tests/test_script.py	2012-08-31 10:03:29 +0000
@@ -14,18 +14,8 @@
     Not,
     )
 
-from pkgme.backend import (
-    BackendSelector,
-    StaticBackend,
-    )
 from pkgme.bin.main import get_all_info
-from pkgme.info_elements import (
-    PackageName,
-    )
-from pkgme.project_info import DictInfo
-from pkgme.testing import (
-    TempdirFixture,
-    )
+from pkgme.testing import TempdirFixture
 
 
 class ScriptTests(TestCase):
@@ -115,34 +105,3 @@
         sig_text = signature.readlines()
         signature.close()
         self.assertNotIn(sig_text, "-----BEGIN PGP SIGNATURE-----\n")
-
-class GetAllInfoTests(TestCase):
-
-    def test_eligible_backends(self):
-        info = DictInfo({})
-        backend1 = StaticBackend(self.getUniqueString(), 5, info)
-        backend2 = StaticBackend(self.getUniqueString(), 10, info)
-        selector = BackendSelector([backend1, backend2])
-        path = self.getUniqueString()
-        info = get_all_info(path, selector)
-        self.assertEqual(
-            [(10, backend2.name), (5, backend1.name)], info['eligible_backends'])
-
-    def test_selected_backend(self):
-        info = DictInfo({})
-        backend1 = StaticBackend(self.getUniqueString(), 5, info)
-        backend2 = StaticBackend(self.getUniqueString(), 10, info)
-        selector = BackendSelector([backend1, backend2])
-        path = self.getUniqueString()
-        info = get_all_info(path, selector)
-        self.assertEqual(backend2.name, info['selected_backend'])
-
-    def test_all_info(self):
-        info = {PackageName.name: self.getUniqueString()}
-        backend = StaticBackend(self.getUniqueString(), 5, DictInfo(info))
-        selector = BackendSelector([backend])
-        path = self.getUniqueString()
-        all_info = get_all_info(path, selector)
-        del all_info['eligible_backends']
-        del all_info['selected_backend']
-        self.assertEqual(info, all_info)

=== removed file 'pkgme/tests/test_write_packaging.py'
--- pkgme/tests/test_write_packaging.py	2012-08-29 16:07:33 +0000
+++ pkgme/tests/test_write_packaging.py	1970-01-01 00:00:00 +0000
@@ -1,123 +0,0 @@
-import os
-
-from fixtures import TempDir
-from testtools import TestCase
-from treeshape import HasFileTree
-
-from pkgme import (
-    get_packaging_info,
-    write_packaging,
-    write_packaging_info,
-    )
-from pkgme.backend import StaticBackend
-from pkgme.info_elements import (
-    Architecture,
-    Description,
-    Maintainer,
-    PackageName,
-    Version,
-    )
-from pkgme.package_files import Control, DEBIAN_DIR
-from pkgme.project_info import DictInfo
-from pkgme.testing import (
-    ControlSourceStanzaHasField,
-    StaticLoaderFixture,
-    )
-
-
-def ControlHasSourceName(name):
-    control_path = os.path.join(DEBIAN_DIR, Control.filename)
-    return HasFileTree(
-        {control_path:
-             {'content': ControlSourceStanzaHasField("Source", name)}})
-
-
-class WritePackagingTests(TestCase):
-
-    def make_info(self, name):
-        info = DictInfo(
-            {
-                PackageName.name: name,
-                Maintainer.name: self.getUniqueString(),
-                Architecture.name: "all",
-                Description.name: self.getUniqueString(),
-                Version.name: "1",
-            })
-        return info
-
-    def test_write_packaging(self):
-        name = PackageName.clean(self.getUniqueString())
-        info = self.make_info(name)
-        tempdir = self.useFixture(TempDir()).path
-        backend = StaticBackend(
-            self.getUniqueString(), 10, info, expected_path=tempdir)
-        self.useFixture(StaticLoaderFixture([backend]))
-        write_packaging(tempdir)
-        self.assertThat(tempdir, ControlHasSourceName(name))
-
-    def test_write_packaging_passes_allowed_backend_names(self):
-        name = PackageName.clean(self.getUniqueString())
-        other_name = name + "WRONG"
-        info1 = self.make_info(name)
-        info2 = self.make_info(other_name)
-        tempdir = self.useFixture(TempDir()).path
-        backend1 = StaticBackend(
-            self.getUniqueString(), 10, info1, expected_path=tempdir)
-        backend2 = StaticBackend(
-            self.getUniqueString(), 20, info2)
-        self.useFixture(StaticLoaderFixture(
-            [backend1, backend2]))
-        write_packaging(tempdir, allowed_backend_names=[backend1.name])
-        self.assertThat(tempdir, ControlHasSourceName(name))
-
-
-class TestWritePackagingInformation(TestCase):
-
-    def test_writes_packaging(self):
-        path = self.useFixture(TempDir()).path
-        package_name = PackageName.clean(self.getUniqueString())
-        info = DictInfo(
-            {
-                PackageName.name: package_name,
-                Maintainer.name: self.getUniqueString(),
-                Architecture.name: "all",
-                Description.name: self.getUniqueString(),
-                Version.name: "1",
-            })
-        write_packaging_info(path, info)
-        self.assertThat(path, ControlHasSourceName(package_name))
-
-
-class TestGetPackagingInfo(TestCase):
-
-    def make_info(self):
-        return DictInfo(
-            {
-                PackageName.name: PackageName.clean(self.getUniqueString()),
-                Maintainer.name: self.getUniqueString(),
-                Architecture.name: "all",
-                Description.name: self.getUniqueString(),
-                Version.name: "1",
-            })
-
-    def test_get_packaging_info(self):
-        info = self.make_info()
-        tempdir = self.useFixture(TempDir()).path
-        backend = StaticBackend(
-            self.getUniqueString(), 10, info, expected_path=tempdir)
-        self.useFixture(StaticLoaderFixture([backend]))
-        found = get_packaging_info(tempdir)
-        self.assertEqual(found, info)
-
-    def test_allowed_backend_names(self):
-        info1 = self.make_info()
-        info2 = self.make_info()
-        tempdir = self.useFixture(TempDir()).path
-        backend1 = StaticBackend(
-            self.getUniqueString(), 10, info1, expected_path=tempdir)
-        backend2 = StaticBackend(
-            self.getUniqueString(), 20, info2)
-        self.useFixture(StaticLoaderFixture([backend1, backend2]))
-        found = get_packaging_info(
-            tempdir, allowed_backend_names=[backend1.name])
-        self.assertEqual(found, info1)