Merge lp:~jml/pkgme/more-information into lp:pkgme

[Jonathan Lange]

Changes the --version option to dump more information about backends and where they come from, but only when the --debug option is also specified.

 * Extracts out a get_version_info function
 * Adds tests for it
 * Creates a StaticLoaderFixture so it's easier for tests to change which backends get loaded
 * Adds a describe() method to Backend and gives it an implementation for the base class and ExternalHelperBackend
 * Random docstring additions

[James Westby (james-w)]

review: Approve

=== modified file 'pkgme/backend.py'
--- pkgme/backend.py	2011-10-26 18:30:07 +0000
+++ pkgme/backend.py	2011-10-26 19:32:27 +0000
@@ -98,6 +98,9 @@
     def __init__(self, name):
         self.name = name
 
+    def describe(self):
+        return self.name
+
     def want(self, path):
         raise NotImplementedError(self.want)
 
@@ -113,6 +116,9 @@
         super(ExternalHelpersBackend, self).__init__(name)
         self.basepath = basepath
 
+    def describe(self):
+        return "%s (%s)" % (self.name, self.basepath)
+
     def want(self, path):
         try:
             out = run_script(self.basepath, self.WANT_SCRIPT_NAME, path)
@@ -143,6 +149,16 @@
 class StaticBackend(Backend):
 
     def __init__(self, name, score, info, expected_path=None):
+        """Create a StaticBackend.
+
+        :param name: The name of the backend.
+        :param score: A fixed score always returned in response to a 'want'
+            call. (But see expected_path).
+        :param info: A fixed dict of packaging information always returned in
+            response to a 'want' call. (But see expected_path).
+        :expected_path: If provided, then only return 'score' and 'info' if
+            the backend is being called for this path.
+        """
         super(StaticBackend, self).__init__(name)
         self.score = score
         self.info = info

=== modified file 'pkgme/bin/main.py'
--- pkgme/bin/main.py	2011-08-11 08:54:56 +0000
+++ pkgme/bin/main.py	2011-10-26 19:32:27 +0000
@@ -5,6 +5,10 @@
 import sys
 
 from pkgme import __version__, write_packaging
+from pkgme.backend import (
+    EXTERNAL_BACKEND_PATHS,
+    get_default_loader,
+    )
 from pkgme.debuild import build_source_package
 from pkgme.upload import (
     InvalidPPAName,
@@ -39,8 +43,7 @@
     parser = argparse.ArgumentParser(
         description='pkgme - A Debian packaging generation framework.')
     parser.add_argument(
-        '-v', '--version',
-        action='version', version='pkgme {0}'.format(__version__),
+        '-v', '--version', action='store_true',
         help='Print this version string and exit')
     parser.add_argument('-D', '--debug', action='store_true')
     parser.add_argument(
@@ -52,11 +55,28 @@
     return parser
 
 
+def get_version_info(debug=False):
+    version = 'pkgme %s' % (__version__,)
+    if debug:
+        ls = [version, '']
+        ls.append('Backend paths: %s' % ', '.join(map(repr, EXTERNAL_BACKEND_PATHS)))
+        ls.append("Available backends:")
+        loader = get_default_loader()
+        backends = loader.load()
+        for backend in backends:
+            ls.append(" %s" % backend.describe())
+        version = '\n'.join(ls)
+    return version
+
+
 def main(argv=None, target_dir=None, interactive=True):
     if argv is None:
         argv = sys.argv[1:]
     parser = make_arg_parser()
     options = parser.parse_args(args=argv)
+    if options.version:
+        print get_version_info(options.debug)
+        return 0
     if options.debug:
         trace.set_debug()
     if target_dir is None:

=== modified file 'pkgme/testing.py'
--- pkgme/testing.py	2011-07-29 17:07:54 +0000
+++ pkgme/testing.py	2011-10-26 19:32:27 +0000
@@ -14,6 +14,11 @@
     MismatchesAll,
     )
 
+from pkgme.backend import (
+    StaticLoader,
+    set_default_loader_factory,
+    reset_default_loader_factory,
+    )
 from pkgme.write import write_file
 
 
@@ -301,3 +306,22 @@
         find_error = require_command(command_name)
         if find_error is not None:
             self.skipTest("'%s' not executable: %s" % (command_name, find_error))
+
+
+class StaticLoaderFixture(Fixture):
+    """Change the default loader to one that only loads the given backends."""
+
+    def __init__(self, backends):
+        """Construct a ``StaticLoaderFixture``.
+
+        :param backends: A list of backends for the loader to load.
+        """
+        self.backends = backends
+
+    def setUp(self):
+        super(StaticLoaderFixture, self).setUp()
+        self.addCleanup(reset_default_loader_factory)
+        set_default_loader_factory(self.make_loader)
+
+    def make_loader(self):
+        return StaticLoader(self.backends)

=== modified file 'pkgme/tests/__init__.py'
--- pkgme/tests/__init__.py	2011-08-10 10:51:10 +0000
+++ pkgme/tests/__init__.py	2011-10-26 19:32:27 +0000
@@ -9,6 +9,7 @@
         'pkgme.tests.test_backend',
         'pkgme.tests.test_distutils_command',
         'pkgme.tests.test_info_elements',
+        'pkgme.tests.test_main',
         'pkgme.tests.test_package_files',
         'pkgme.tests.test_project_info',
         'pkgme.tests.test_python_backend',

=== modified file 'pkgme/tests/test_backend.py'
--- pkgme/tests/test_backend.py	2011-10-26 18:22:49 +0000
+++ pkgme/tests/test_backend.py	2011-10-26 19:32:27 +0000
@@ -5,6 +5,7 @@
 from testtools import TestCase
 
 from pkgme.backend import (
+    Backend,
     BackendSelector,
     EXTERNAL_BACKEND_PATHS,
     ExternalHelpersBackend,
@@ -14,8 +15,6 @@
     get_info_for,
     NoBackend,
     NoEligibleBackend,
-    reset_default_loader_factory,
-    set_default_loader_factory,
     StaticBackend,
     StaticLoader,
     )
@@ -25,10 +24,19 @@
     )
 from pkgme.testing import (
     ExecutableFileFixture,
+    StaticLoaderFixture,
     TempdirFixture,
     )
 
 
+class TestBackend(TestCase):
+
+    def test_describe(self):
+        # The default describe() just returns the name.
+        backend = Backend(self.getUniqueString())
+        self.assertEqual(backend.name, backend.describe())
+
+
 class ExternalHelpersBackendTests(TestCase, TestWithFixtures):
 
     def make_want_script(self, script):
@@ -38,6 +46,12 @@
         self.useFixture(ExecutableFileFixture(script_path, script))
         return tempdir
 
+    def test_describe(self):
+        backend = ExternalHelpersBackend(
+            self.getUniqueString(), self.getUniqueString())
+        self.assertEqual(
+            "%s (%s)" % (backend.name, backend.basepath), backend.describe())
+
     def test_want_runs_script(self):
         script = "#!/bin/sh\necho 10\n"
         tempdir = self.make_want_script(script)
@@ -255,8 +269,5 @@
         path = self.getUniqueString()
         backend = StaticBackend(
             self.getUniqueString(), 10, info, expected_path=path)
-        def make_loader():
-            return StaticLoader([backend])
-        self.addCleanup(reset_default_loader_factory)
-        set_default_loader_factory(make_loader)
+        self.useFixture(StaticLoaderFixture([backend]))
         self.assertEqual(info, get_info_for(path))

=== added file 'pkgme/tests/test_main.py'
--- pkgme/tests/test_main.py	1970-01-01 00:00:00 +0000
+++ pkgme/tests/test_main.py	2011-10-26 19:32:27 +0000
@@ -0,0 +1,30 @@
+from testtools import TestCase
+
+from pkgme import __version__
+from pkgme.backend import (
+    EXTERNAL_BACKEND_PATHS,
+    StaticBackend,
+    )
+from pkgme.bin.main import get_version_info
+from pkgme.testing import StaticLoaderFixture
+
+class TestVersionInfo(TestCase):
+
+    def test_version_info(self):
+        x = get_version_info()
+        self.assertEqual("pkgme %s" % (__version__,), x)
+
+    def test_debug_version_info(self):
+        backends = [StaticBackend(self.getUniqueString(), 0, {})]
+        self.useFixture(StaticLoaderFixture(backends))
+        x = get_version_info(debug=True)
+        expected_backends = '\n'.join(" %s" % b.describe() for b in backends)
+        expected = """pkgme %s
+
+Backend paths: %s
+Available backends:
+%s""" % (
+            __version__,
+            ', '.join(map(repr, EXTERNAL_BACKEND_PATHS)),
+            expected_backends)
+        self.assertEqual(expected, x)

=== modified file 'pkgme/tests/test_write_packaging.py'
--- pkgme/tests/test_write_packaging.py	2011-06-15 18:53:17 +0000
+++ pkgme/tests/test_write_packaging.py	2011-10-26 19:32:27 +0000
@@ -1,15 +1,9 @@
 import os
 
-from fixtures import TestWithFixtures
 from testtools import TestCase
 
 from pkgme import write_packaging
-from pkgme.backend import (
-    reset_default_loader_factory,
-    set_default_loader_factory,
-    StaticBackend,
-    StaticLoader,
-    )
+from pkgme.backend import StaticBackend
 from pkgme.info_elements import (
     Architecture,
     Description,
@@ -21,11 +15,12 @@
 from pkgme.project_info import DictInfo
 from pkgme.testing import (
     ControlSourceStanzaHasField,
+    StaticLoaderFixture,
     TempdirFixture,
     )
 
 
-class WritePackagingTests(TestCase, TestWithFixtures):
+class WritePackagingTests(TestCase):
 
     def test_write_packaging(self):
         name = self.getUniqueString()
@@ -40,11 +35,7 @@
         tempdir = self.useFixture(TempdirFixture())
         backend = StaticBackend(
             self.getUniqueString(), 10, info, expected_path=tempdir.path)
-        loader = StaticLoader([backend])
-        def get_loader():
-            return loader
-        self.addCleanup(reset_default_loader_factory)
-        set_default_loader_factory(get_loader)
+        self.useFixture(StaticLoaderFixture([backend]))
         write_packaging(tempdir.path)
         control_path = os.path.join(
             tempdir.path, DEBIAN_DIR, Control.filename)