Merge lp:~jml/pkgme-devportal/backend-tests into lp:pkgme-devportal

[Jonathan Lange]

Refactor backend tests so there's less duplication.

This branch adds direct tests for the metadata backend, and then given that confidence, reconciles the tests for the PDF & binary backends to test the more direct methods. This results in less set up, fewer tests and faster tests.

More specifically:

 * Merge test_binary and test_binary_backend
 * Merge test_pdf and test_pdf_backend
 * Change PDF & binary backend tests to exercise the get_{depends,build_depends,etc.} methods of their backends, rather than get_info
 * Add tests for get_info, get_extra_files, and dump_json on MetadataBackend
 * Remove the extra_files tests from PDF & binary backend suites, since they don't differ in behaviour
 * Remove the package name tests from PDF & binary backend suites, since that's all handled by metadata backend
 * Change get_desktop_file to take the executable, and made get_extra_files call get_executable
 * Group the abstract methods in MetadataBackend
 * Combined the desktop tests with the core metadata backend tests
 * Extracted a base BackendTests class to reduce duplication
 * Removed the HasField matcher, since it's now unused

Future work:
 * Use composition instead of inheritance for the abstract backend methods
 * Move get_install_file and get_metadata into MetadataBackend

[James Westby (james-w)]

Hi,

Great work, I particularly like that this speeds up the tests.

I'm wondering if we want to lose a bit of that improvement for a couple
of tests that exercise the backend like pkgme will (by executing the scripts)?
They are simple, but I believe this change means they are untested?

There are the acceptance tests though, so maybe that is sufficient?

Thanks,

James

review: Approve

[Jonathan Lange (jml)]

On Thu, Jan 12, 2012 at 2:19 PM, James Westby <email address hidden> wrote:
> Review: Approve
>
> Hi,
>
> Great work, I particularly like that this speeds up the tests.
>
> I'm wondering if we want to lose a bit of that improvement for a couple
> of tests that exercise the backend like pkgme will (by executing the scripts)?
> They are simple, but I believe this change means they are untested?
>
> There are the acceptance tests though, so maybe that is sufficient?
>

I think the acceptance tests are sufficient here. Any tests we add
that exercise the backends via pkgme APIs are just duplicating the
acceptance tests and/or verifying that pkgme works or that we've
written our boilerplate scripts correctly.

jml

=== modified file 'devportalbinary/metadata.py'
--- devportalbinary/metadata.py	2012-01-10 15:23:27 +0000
+++ devportalbinary/metadata.py	2012-01-12 13:08:48 +0000
@@ -111,21 +111,6 @@
         """Get the build dependencies of the package."""
         raise NotImplementedError(self.get_build_depends)
 
-    def get_desktop_file(self, package_name, tagline=None, categories=None):
-        """Get the desktop file for the package.
-
-        :return: A ``Desktop``.
-        """
-        executable = self.get_executable(package_name)
-        info = {
-            PackageName.name: package_name,
-            ApplicationName.name: package_name.capitalize(),
-            Executable.name: executable,
-            TagLine.name: tagline,
-            Categories.name: categories,
-            }
-        return Desktop.from_info(DictInfo(info))
-
     def get_depends(self, metadata):
         """Get the dependencies for the package."""
         raise NotImplementedError(self.depends)
@@ -138,6 +123,21 @@
         """Return the path to the executable."""
         raise NotImplementedError(self.get_executable)
 
+    def get_desktop_file(self, package_name, executable, tagline=None,
+                         categories=None):
+        """Get the desktop file for the package.
+
+        :return: A ``Desktop``.
+        """
+        info = {
+            PackageName.name: package_name,
+            ApplicationName.name: package_name.capitalize(),
+            Executable.name: executable,
+            TagLine.name: tagline,
+            Categories.name: categories,
+            }
+        return Desktop.from_info(DictInfo(info))
+
     def get_extra_files(self, package_name, metadata):
         """Get the extra files for the package.
 
@@ -146,8 +146,10 @@
         desktop file.
         """
         install_file = get_install_file(package_name, self.path, True)
+        executable = self.get_executable(package_name)
         desktop_file = self.get_desktop_file(
             package_name,
+            executable,
             tagline=metadata.get(self.TAGLINE, ''),
             categories=metadata.get(self.CATEGORIES, ''))
         return {
@@ -200,5 +202,3 @@
     def want(self):
         """How relevant this backend is."""
         raise NotImplementedError(self.want)
-
-

=== modified file 'devportalbinary/testing.py'
--- devportalbinary/testing.py	2012-01-10 12:31:05 +0000
+++ devportalbinary/testing.py	2012-01-12 13:08:48 +0000
@@ -1,3 +1,6 @@
+# Copyright 2011-2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
 import json
 import os
 
@@ -6,6 +9,7 @@
     Fixture,
     TempDir,
     )
+from testtools import TestCase
 
 from pkgme.testing import TempdirFixture
 
@@ -80,3 +84,27 @@
 def get_test_data_file_path(dirname, filename):
     """Get the path to a file in the test data."""
     return os.path.join(get_test_data_dir_path(dirname), filename)
+
+
+class BackendTests(TestCase):
+
+    BACKEND = None
+
+    def make_metadata(self, package_name=None, description=None, tagline=None,
+                      categories=None):
+        if package_name is None:
+            package_name = self.getUniqueString('package-name')
+        metadata = {MetadataBackend.PACKAGE_NAME: package_name}
+        if tagline is None:
+            tagline = self.getUniqueString('tagline')
+        metadata[MetadataBackend.TAGLINE] = tagline
+        if description is not None:
+            metadata[MetadataBackend.DESCRIPTION] = description
+        if categories is not None:
+            metadata[MetadataBackend.CATEGORIES] = categories
+        return metadata
+
+    def make_backend(self, path=None):
+        if path is None:
+            path = self.useFixture(TempdirFixture()).path
+        return self.BACKEND(path)

=== modified file 'devportalbinary/tests/test_binary.py'
--- devportalbinary/tests/test_binary.py	2012-01-10 13:18:19 +0000
+++ devportalbinary/tests/test_binary.py	2012-01-12 13:08:48 +0000
@@ -2,6 +2,7 @@
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 import os
+import shutil
 
 from testtools import TestCase
 from testtools.matchers import StartsWith
@@ -21,10 +22,15 @@
     NoBinariesFound,
     UnknownDependency,
     )
+from devportalbinary.metadata import (
+    MetadataBackend,
+    )
 from devportalbinary.testing import (
+    BackendTests,
     DatabaseFixture,
     get_test_data_dir_path,
     get_test_data_file_path,
+    MetadataFixture,
     )
 
 
@@ -34,20 +40,6 @@
         self.assertRaises(NoBinariesFound, needed_libraries_from_objdump, [])
 
 
-class BackendTests(TestCase):
-
-    def test_executable_is_best_guess(self):
-        package_name = self.getUniqueString()
-        tempdir = self.useFixture(TempdirFixture())
-        tempdir.mkdir('whatever')
-        tempdir.touch('whatever/not-the-best', 0755)
-        tempdir.touch('the-best', 0755)
-        backend = BinaryBackend(tempdir.path)
-        self.assertEqual(
-            '/opt/%s/the-best' % (package_name,),
-            backend.get_executable(package_name))
-
-
 class FindExecutableTests(TestCase):
 
     def test_only_one_file_and_it_is_executable(self):
@@ -223,3 +215,66 @@
         e = self.assertRaises(UnknownDependency,
                 guess_dependencies, get_test_data_dir_path('hello'))
         self.assertEqual('Can\'t find dependency for "libc.so.6".', str(e))
+
+
+class BinaryBackendTests(BackendTests):
+
+    BACKEND = BinaryBackend
+
+    def test_want_with_metadata(self):
+        # If we detect a binary, then we score 10. The way we determine if
+        # something is a binary is if it has a devportal-metadata.json in its
+        # top-level.
+        path = self.useFixture(MetadataFixture({})).path
+        backend = self.make_backend(path)
+        self.assertEqual(10, backend.want())
+
+    def test_want_without_metadata(self):
+        # If we do *not* detect a binary, then we score 0. The way we
+        # determine if something is a binary is if it has a
+        # devportal-metadata.json in its top-level.
+        backend = self.make_backend()
+        self.assertEqual(0, backend.want())
+
+    def test_description(self):
+        # The binary backend uses the package description that's in the
+        # metadata.
+        expected_description = self.getUniqueString()
+        backend = self.make_backend()
+        description = backend.get_description(
+            {MetadataBackend.DESCRIPTION: expected_description})
+        self.assertEqual(expected_description, description)
+
+    def test_no_description(self):
+        # If no description is provided in the metadata then the description
+        # in the package info is just an empty string.
+        backend = self.make_backend()
+        description = backend.get_description({})
+        self.assertEqual('', description)
+
+    def test_build_depends(self):
+        # Make sure there's a database.
+        backend = self.make_backend()
+        shutil.copy(
+            get_test_data_file_path('hello', 'hello'), backend.path)
+        db = self.useFixture(DatabaseFixture()).db
+        db.update_source_package('eglibc', [[('libc.so.6', 'libc6')]])
+        expected_deps = ', '.join(guess_dependencies(backend.path))
+        build_deps = backend.get_build_depends(None)
+        self.assertEqual(expected_deps, build_deps)
+
+    def test_depends(self):
+        backend = self.make_backend()
+        depends = backend.get_depends(None)
+        self.assertEqual('${shlibs:Depends}, ${misc:Depends}', depends)
+
+    def test_executable_is_best_guess(self):
+        package_name = self.getUniqueString()
+        tempdir = self.useFixture(TempdirFixture())
+        tempdir.mkdir('whatever')
+        tempdir.touch('whatever/not-the-best', 0755)
+        tempdir.touch('the-best', 0755)
+        backend = self.make_backend(tempdir.path)
+        self.assertEqual(
+            '/opt/%s/the-best' % (package_name,),
+            backend.get_executable(package_name))

=== removed file 'devportalbinary/tests/test_binary_backend.py'
--- devportalbinary/tests/test_binary_backend.py	2012-01-10 15:23:27 +0000
+++ devportalbinary/tests/test_binary_backend.py	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-# Copyright 2011 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-import shutil
-
-from fixtures import TempDir
-from testtools import TestCase
-from testtools.matchers import (
-    Equals,
-    Matcher,
-    )
-
-from pkgme.info_elements import (
-    BuildDepends,
-    Description,
-    Depends,
-    ExtraFiles,
-    PackageName,
-    )
-
-from devportalbinary.binary import (
-    BinaryBackend,
-    guess_dependencies,
-    MetadataBackend,
-    )
-from devportalbinary.metadata import  get_install_file
-from devportalbinary.testing import (
-    DatabaseFixture,
-    get_test_data_file_path,
-    MetadataFixture,
-    )
-
-
-class HasField(Matcher):
-    """Matches if 'info' has a field with the given value."""
-
-    def __init__(self, field, field_value):
-        super(HasField, self).__init__()
-        self.field = field
-        self.field_value = field_value
-
-    def match(self, info):
-        return Equals(self.field_value).match(info[self.field])
-
-
-class BinaryBackendTests(TestCase):
-
-    def make_metadata(self, package_name=None, description=None, tagline=None,
-                      categories=None):
-        if package_name is None:
-            package_name = self.getUniqueString('package-name')
-        metadata = {MetadataBackend.PACKAGE_NAME: package_name}
-        if description is not None:
-            metadata[MetadataBackend.DESCRIPTION] = description
-        if tagline is not None:
-            metadata[MetadataBackend.TAGLINE] = tagline
-        if categories is not None:
-            metadata[MetadataBackend.CATEGORIES] = categories
-        return metadata
-
-    def make_backend(self, path=None):
-        if path is None:
-            path = self.useFixture(TempDir()).path
-        backend = BinaryBackend(path)
-        shutil.copy(
-            get_test_data_file_path('hello', 'hello'), path)
-        db = self.useFixture(DatabaseFixture()).db
-        db.update_source_package('eglibc', [[('libc.so.6', 'libc6')]])
-        return backend
-
-    def test_want_with_metadata(self):
-        # If we detect a binary, then we score 10. The way we determine if
-        # something is a binary is if it has a devportal-metadata.json in its
-        # top-level.
-        path = self.useFixture(MetadataFixture({})).path
-        backend = self.make_backend(path)
-        self.assertEqual(10, backend.want())
-
-    def test_want_without_metadata(self):
-        # If we do *not* detect a binary, then we score 0. The way we
-        # determine if something is a binary is if it has a
-        # devportal-metadata.json in its top-level.
-        backend = self.make_backend()
-        self.assertEqual(0, backend.want())
-
-    def test_package_name(self):
-        # The binary backend gets the package name from the metadata file.
-        backend = self.make_backend()
-        metadata = self.make_metadata(package_name='foo')
-        info = backend.get_info(metadata)
-        self.assertThat(info, HasField(PackageName, 'foo'))
-
-    def test_description(self):
-        # The binary backend uses the package description that's in the
-        # metadata.
-        description = self.getUniqueString()
-        metadata = self.make_metadata(description=description)
-        backend = self.make_backend()
-        info = backend.get_info(metadata)
-        self.assertThat(info, HasField(Description, description))
-
-    def test_no_description(self):
-        # If no description is provided in the metadata then the description
-        # in the package info is just an empty string.
-        backend = self.make_backend()
-        metadata = self.make_metadata()
-        info = backend.get_info(metadata)
-        self.assertThat(info, HasField(Description, ''))
-
-    def test_build_depends(self):
-        # Make sure there's a database.
-        backend = self.make_backend()
-        info = backend.get_info(self.make_metadata())
-        deps = ', '.join(guess_dependencies(backend.path))
-        self.assertThat(info, HasField(BuildDepends, deps))
-
-    def test_depends(self):
-        backend = self.make_backend()
-        info = backend.get_info(self.make_metadata())
-        self.assertThat(info, HasField(Depends, BinaryBackend.DEPENDS))
-
-    def test_extra_files_install_file(self):
-        # We create an 'install' file that tells debhelper to just copy
-        # everything to opt.
-        package_name = self.getUniqueString()
-        metadata = self.make_metadata(package_name=package_name)
-        backend = self.make_backend()
-        info = backend.get_info(metadata)
-        install_file = info[ExtraFiles]['debian/install']
-        self.assertEqual(
-            get_install_file(package_name, backend.path, True),
-            install_file)
-
-    def test_extra_files_desktop_file(self):
-        # We create an 'desktop' file that launches the guessed binary
-        package_name = self.getUniqueString()
-        tagline = self.getUniqueString()
-        categories = self.getUniqueString()
-        metadata = self.make_metadata(
-            package_name=package_name,
-            tagline=tagline,
-            categories=categories,
-            )
-        backend = self.make_backend()
-        expected_desktop_file = backend.get_desktop_file(
-            package_name, tagline=tagline,
-            categories=categories).get_contents()
-        info = backend.get_info(metadata)
-        extra_files = info[ExtraFiles]
-        desktop = extra_files['debian/%s.desktop' % (package_name,)]
-        self.assertEqual(expected_desktop_file, desktop)

=== modified file 'devportalbinary/tests/test_metadata.py'
--- devportalbinary/tests/test_metadata.py	2012-01-10 13:18:19 +0000
+++ devportalbinary/tests/test_metadata.py	2012-01-12 13:08:48 +0000
@@ -1,8 +1,18 @@
 # Copyright 2011-2012 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
+import json
+from StringIO import StringIO
 import os
 
+from pkgme.info_elements import (
+    Architecture,
+    BuildDepends,
+    Description,
+    Depends,
+    ExtraFiles,
+    PackageName,
+    )
 from pkgme.package_files import DEBIAN_DIR
 from pkgme.testing import (
     AreDesktopValuesFor,
@@ -16,11 +26,14 @@
     MetadataBackend,
     )
 from devportalbinary.testing import (
+    BackendTests,
     MetadataFixture,
     )
 
 
-class MetadataTests(TestCase):
+class MetadataTests(BackendTests):
+
+    BACKEND = MetadataBackend
 
     def test_metadata_file(self):
         self.assertEqual('devportal-metadata.json', MetadataBackend.METADATA_FILE)
@@ -76,6 +89,144 @@
         found_metadata = get_metadata(path=path)
         self.assertEqual(metadata, found_metadata)
 
+    def test_dump_json(self):
+        # dump_json loads metadata, passes it to get_info and then dumps
+        # whatever that returns.  This means that get_info(metadata) can be a
+        # relatively pure function, obsessed only with figuring out the right
+        # packaging information.
+        metadata = {'foo': 'bar'}
+        path = self.useFixture(MetadataFixture(metadata)).path
+        backend = MetadataBackend(path)
+        # get_info takes metadata and returns a dict mapping InfoElements to
+        # values.  We're using PackageName here arbitrarily.
+        backend.get_info = lambda metadata: {PackageName: metadata}
+        output_buffer = StringIO()
+        backend.dump_json(output_buffer)
+        # The resulting JSON maps the names of the InfoElements to values.
+        self.assertEqual(
+            {PackageName.name: metadata},
+            json.loads(output_buffer.getvalue()))
+
+    def test_get_extra_files_install_file(self):
+        # ExtraFiles includes an install file generated by get_install_file.
+        package_name = self.getUniqueString()
+        metadata = {MetadataBackend.PACKAGE_NAME: package_name}
+        backend = self.make_backend()
+        backend.get_executable = lambda x: x
+        extra_files = backend.get_extra_files(package_name, metadata)
+        install_file = extra_files['debian/install']
+        self.assertEqual(
+            get_install_file(package_name, backend.path, True),
+            install_file)
+
+    def test_extra_files_desktop_file(self):
+        # ExtraFiles includes a desktop file, named after the package, that is
+        # generated using get_desktop_file on the backend.
+        package_name = self.getUniqueString()
+        tagline = self.getUniqueString()
+        categories = self.getUniqueString()
+        metadata = self.make_metadata(
+            package_name=package_name,
+            tagline=tagline,
+            categories=categories,
+            )
+        backend = self.make_backend()
+        backend.get_executable = lambda x: 'executable:' + x
+        expected_desktop_file = backend.get_desktop_file(
+            package_name, backend.get_executable(package_name),
+            tagline=tagline, categories=categories).get_contents()
+        extra_files = backend.get_extra_files(package_name, metadata)
+        desktop = extra_files['debian/%s.desktop' % (package_name,)]
+        self.assertEqual(expected_desktop_file, desktop)
+
+    def test_get_info_with_architecture(self):
+        # get_info consults various methods on the backend class and uses
+        # those to figure out the info to return.
+        class Backend(MetadataBackend):
+            def get_architecture(self):
+                return 'architecture'
+            def get_build_depends(self, metadata):
+                return 'build_depends', metadata
+            def get_depends(self, metadata):
+                return 'depends', metadata
+            def get_description(self, metadata):
+                return 'description', metadata
+            def get_executable(self, package_name):
+                return 'executable:' + package_name
+
+        package_name = self.getUniqueString('package-name')
+        metadata = self.make_metadata(package_name=package_name)
+        backend = Backend(self.useFixture(TempdirFixture()).path)
+        info = backend.get_info(metadata)
+        self.assertEqual(
+            {Architecture: 'architecture',
+             BuildDepends: ('build_depends', metadata),
+             Depends: ('depends', metadata),
+             Description: ('description', metadata),
+             ExtraFiles: backend.get_extra_files(package_name, metadata),
+             PackageName: package_name}, info)
+
+    def test_get_info_without_architecture(self):
+        # get_info consults various methods on the backend class and uses
+        # those to figure out the info to return.  If get_architecture returns
+        # None, then it is excluded from the info.
+        class Backend(MetadataBackend):
+            def get_architecture(self):
+                return None
+            def get_build_depends(self, metadata):
+                return 'build_depends', metadata
+            def get_depends(self, metadata):
+                return 'depends', metadata
+            def get_description(self, metadata):
+                return 'description', metadata
+            def get_executable(self, package_name):
+                return 'executable:' + package_name
+
+        package_name = self.getUniqueString('package-name')
+        metadata = self.make_metadata(package_name=package_name)
+        backend = Backend(self.useFixture(TempdirFixture()).path)
+        info = backend.get_info(metadata)
+        self.assertEqual(
+            {BuildDepends: ('build_depends', metadata),
+             Depends: ('depends', metadata),
+             Description: ('description', metadata),
+             ExtraFiles: backend.get_extra_files(package_name, metadata),
+             PackageName: package_name}, info)
+
+    def test_app_name_is_capitalized_package_name(self):
+        # We don't have any information on the package name, so try to guess
+        # the application name.
+        backend = self.make_backend()
+        package_name = self.getUniqueString()
+        executable = self.getUniqueString()
+        desktop_file = backend.get_desktop_file(package_name, executable)
+        self.assertThat(
+            {'Name': package_name.capitalize()},
+            AreDesktopValuesFor(desktop_file))
+
+    def test_category_and_tagline_are_specified(self):
+        # We just pass the category and comment through.
+        package_name = self.getUniqueString()
+        executable = self.getUniqueString()
+        tagline = self.getUniqueString()
+        categories = self.getUniqueString()
+        backend = self.make_backend()
+        desktop_file = backend.get_desktop_file(
+            package_name, executable, tagline=tagline, categories=categories)
+        self.assertThat(
+            {'Comment': tagline, 'Categories': categories},
+            AreDesktopValuesFor(desktop_file))
+
+    def test_executable(self):
+        # The executable in the desktop file is just whatever get_desktop
+        # returns.
+        package_name = self.getUniqueString()
+        executable = self.getUniqueString()
+        backend = self.make_backend()
+        desktop_file = backend.get_desktop_file(package_name, executable)
+        self.assertThat(
+            {'Exec': executable}, AreDesktopValuesFor(desktop_file))
+
 
 class InstallFileTests(TestCase):
 
@@ -135,44 +286,3 @@
             "some-file opt/package-name\n"
             "debian/package-name.desktop usr/share/applications\n",
             install_file)
-
-
-class DesktopFileTests(TestCase):
-
-    def make_backend(self, executable=None):
-        tempdir = self.useFixture(TempdirFixture())
-        backend = MetadataBackend(tempdir.path)
-        backend.get_executable = lambda package_name: executable
-        return backend
-
-    def test_app_name_is_capitalized_package_name(self):
-        # We don't have any information on the package name, so try to guess
-        # the application name.
-        backend = self.make_backend()
-        package_name = self.getUniqueString()
-        desktop_file = backend.get_desktop_file(package_name)
-        self.assertThat(
-            {'Name': package_name.capitalize()},
-            AreDesktopValuesFor(desktop_file))
-
-    def test_category_and_tagline_are_specified(self):
-        # We just pass the category and comment through.
-        package_name = self.getUniqueString()
-        tagline = self.getUniqueString()
-        categories = self.getUniqueString()
-        backend = self.make_backend()
-        desktop_file = backend.get_desktop_file(
-            package_name, tagline=tagline, categories=categories)
-        self.assertThat(
-            {'Comment': tagline, 'Categories': categories},
-            AreDesktopValuesFor(desktop_file))
-
-    def test_executable_from_get_executable(self):
-        # The executable in the desktop file is just whatever get_desktop
-        # returns.
-        package_name = self.getUniqueString()
-        executable = self.getUniqueString()
-        backend = self.make_backend(executable)
-        desktop_file = backend.get_desktop_file(package_name)
-        self.assertThat(
-            {'Exec': executable}, AreDesktopValuesFor(desktop_file))

=== removed file 'devportalbinary/tests/test_pdf.py'
--- devportalbinary/tests/test_pdf.py	2012-01-10 13:18:19 +0000
+++ devportalbinary/tests/test_pdf.py	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-# Copyright 2012 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-from testtools import TestCase
-
-from pkgme.testing import TempdirFixture
-
-from devportalbinary.pdf import PdfBackend
-
-
-class BackendTests(TestCase):
-
-    def test_executable_opens_pdf(self):
-        tempdir = self.useFixture(TempdirFixture())
-        tempdir.touch('foo.pdf')
-        package_name = self.getUniqueString()
-        backend = PdfBackend(tempdir.path)
-        executable = backend.get_executable(package_name)
-        self.assertEqual(
-            '/usr/bin/xdg-open /opt/%s/%s' % (package_name, 'foo.pdf'),
-            executable)

=== renamed file 'devportalbinary/tests/test_pdf_backend.py' => 'devportalbinary/tests/test_pdf.py'
--- devportalbinary/tests/test_pdf_backend.py	2012-01-10 12:50:21 +0000
+++ devportalbinary/tests/test_pdf.py	2012-01-12 13:08:48 +0000
@@ -1,40 +1,16 @@
-# Copyright 2011 Canonical Ltd.  This software is licensed under the
+# Copyright 2011-2012 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-from testtools import TestCase
-
-from pkgme.backend import ExternalHelpersBackend, get_backend_dir
-from pkgme.info_elements import (
-    Architecture,
-    BuildDepends,
-    Depends,
-    Description,
-    ExtraFiles,
-    PackageName,
-    )
 from pkgme.testing import TempdirFixture
 
 from devportalbinary.binary import MetadataBackend
 from devportalbinary.pdf import PdfBackend
-from devportalbinary.metadata import get_install_file
-from devportalbinary.testing import MetadataFixture
-
-
-BACKEND_NAME = 'pdf'
-
-backend_dir = get_backend_dir(__file__, BACKEND_NAME)
-
-
-class PdfBackendTests(TestCase):
-
-    def with_metadata(self, metadata=None):
-        if metadata is None:
-            metadata = {}
-        metadata.setdefault(
-            MetadataBackend.PACKAGE_NAME, self.getUniqueString('package_name'))
-        metadata.setdefault(
-            MetadataBackend.TAGLINE, self.getUniqueString('tagline'))
-        return self.useFixture(MetadataFixture(metadata))
+from devportalbinary.testing import BackendTests
+
+
+class PdfBackendTests(BackendTests):
+
+    BACKEND = PdfBackend
 
     def test_want_with_metadata(self):
         # If we detect the metadata file and a pdf, then we score 20.
@@ -42,23 +18,23 @@
         tempdir.touch(MetadataBackend.METADATA_FILE)
         filename = self.getUniqueString() + ".pdf"
         tempdir.touch(filename)
-        backend = ExternalHelpersBackend(BACKEND_NAME, backend_dir)
-        self.assertEqual(20, backend.want(tempdir.path))
+        backend = PdfBackend(tempdir.path)
+        self.assertEqual(20, backend.want())
 
     def test_want_with_just_metadata(self):
         # If we detect just the metadata file then we score 0.
         tempdir = self.useFixture(TempdirFixture())
         tempdir.touch(MetadataBackend.METADATA_FILE)
-        backend = ExternalHelpersBackend(BACKEND_NAME, backend_dir)
-        self.assertEqual(0, backend.want(tempdir.path))
+        backend = PdfBackend(tempdir.path)
+        self.assertEqual(0, backend.want())
 
     def test_want_with_just_pdf(self):
         # If we detect just a pdf file then we score 0.
         tempdir = self.useFixture(TempdirFixture())
         filename = self.getUniqueString() + ".pdf"
         tempdir.touch(filename)
-        backend = ExternalHelpersBackend(BACKEND_NAME, backend_dir)
-        self.assertEqual(0, backend.want(tempdir.path))
+        backend = PdfBackend(tempdir.path)
+        self.assertEqual(0, backend.want())
 
     def test_want_with_extra_files(self):
         # If we detect other files then we score 0. This is so that
@@ -70,8 +46,8 @@
         tempdir.touch(filename)
         other_filename = self.getUniqueString() + ".foo"
         tempdir.touch(other_filename)
-        backend = ExternalHelpersBackend(BACKEND_NAME, backend_dir)
-        self.assertEqual(0, backend.want(tempdir.path))
+        backend = PdfBackend(tempdir.path)
+        self.assertEqual(0, backend.want())
 
     def test_want_with_debian_dir(self):
         # If the other file is a debian dir then we score 20 still.
@@ -82,76 +58,41 @@
         tempdir.touch(filename)
         other_filename = "debian"
         tempdir.touch(other_filename)
-        backend = ExternalHelpersBackend(BACKEND_NAME, backend_dir)
-        self.assertEqual(20, backend.want(tempdir.path))
-
-    def test_package_name(self):
-        # The pdf backend gets the package name from the metadata file.
-        path = self.with_metadata({MetadataBackend.PACKAGE_NAME: 'foo'}).path
-        package_name = self.get_info_for(BACKEND_NAME, PackageName, path)
-        self.assertEqual("foo", package_name)
+        backend = PdfBackend(tempdir.path)
+        self.assertEqual(20, backend.want())
 
     def test_architecture(self):
         # The pdf backend set architecture to all
-        path = self.with_metadata().path
-        architecture = self.get_info_for(BACKEND_NAME, Architecture, path)
-        self.assertEqual("all", architecture)
-
-    def get_info_for(self, backend_name, info_element, path):
-        backend = ExternalHelpersBackend(backend_name, backend_dir)
-        info = backend.get_info(path)
-        return info.get_all([info_element.name])[info_element.name]
+        backend = self.make_backend()
+        architecture = backend.get_architecture()
+        self.assertEqual('all', architecture)
 
     def test_build_depends(self):
         # The pdf backend has simple build dependencies
-        path = self.with_metadata().path
-        build_depends = self.get_info_for(BACKEND_NAME, BuildDepends, path)
+        backend = self.make_backend()
+        build_depends = backend.get_build_depends(None)
         self.assertEqual('debhelper (>=7)', build_depends)
 
     def test_depends(self):
         # The pdf backend depends on xdg-utils
-        path = self.with_metadata().path
-        depends = self.get_info_for(BACKEND_NAME, Depends, path)
+        backend = self.make_backend()
+        depends = backend.get_depends(None)
         self.assertEqual('xdg-utils, ${misc:Depends}', depends)
 
     def test_description(self):
         # The pdf backend gets the description from the metadata file.
         expected_description = 'best pdf evar'
-        path = self.with_metadata(
-            {MetadataBackend.TAGLINE: expected_description}).path
-        description = self.get_info_for(BACKEND_NAME, Description, path)
+        metadata = {MetadataBackend.TAGLINE: expected_description}
+        backend = self.make_backend()
+        description = backend.get_description(metadata)
         self.assertEqual(expected_description, description)
 
-    def test_extra_files_install_file(self):
-        # We create an 'install' file that tells debhelper to copy
-        # the pdf to opt
+    def test_executable_opens_pdf(self):
+        tempdir = self.useFixture(TempdirFixture())
+        tempdir.touch('foo.pdf')
         package_name = self.getUniqueString()
-        tempdir = self.with_metadata(
-            {MetadataBackend.PACKAGE_NAME: package_name}).tempdir
-        extra_files = self.get_info_for(BACKEND_NAME, ExtraFiles, tempdir.path)
-        install_file = extra_files['debian/install']
+        backend = PdfBackend(tempdir.path)
+        executable = backend.get_executable(package_name)
         self.assertEqual(
-            get_install_file(package_name, tempdir.path, True),
-            install_file)
-
-    def test_extra_files_desktop_file(self):
-        # We create an 'desktop' file that uses xdg-open to open the
-        # pdf.
-        package_name = self.getUniqueString()
-        tagline = self.getUniqueString()
-        categories = self.getUniqueString()
-        metadata = {
-            MetadataBackend.PACKAGE_NAME: package_name,
-            MetadataBackend.TAGLINE: tagline,
-            MetadataBackend.CATEGORIES: categories,
-            }
-        tempdir = self.with_metadata(metadata).tempdir
-        # We need to create a pdf file in order to be able to generate a
-        # desktop.
-        tempdir.touch('foo.pdf')
-        expected_desktop_file = PdfBackend(tempdir.path).get_desktop_file(
-            package_name, tagline=tagline,
-            categories=categories).get_contents()
-        extra_files = self.get_info_for(BACKEND_NAME, ExtraFiles, tempdir.path)
-        desktop = extra_files['debian/%s.desktop' % (package_name,)]
-        self.assertEqual(expected_desktop_file, desktop)
+            '/usr/bin/xdg-open /opt/%s/%s' % (package_name, 'foo.pdf'),
+            executable)