Merge lp:~nataliabidart/software-center/fix-986563 into lp:software-center/5.2

[Natalia Bidart]

- Filtered out those exhibits that do not their packages available in the db.

Some of the changes in this diff were needed to avoid some nasty exception while running the test suite (for example the changes of how get_distro is imported).

[lp:~nataliabidart/software-center/fix-986563]

3027. By Natalia Bidart on 2012-05-21

Attaching bug #986563.

[Michael Vogt (mvo)]

Thanks for your branch.

This is again a beauty to read and I much appreciate the effort that goes beyond the immediate fix and that
helps making the code and tests better. The ExhibitsTestCase code is a excellent example on a good and
clean test, very nice.

Some questions/comments:
 - what do you think about moving "_pkg_available()" out into a more generic place like db/utils.py ?
 - _filter_and_set_exhibits() should probably have a small comment that its ok if result list is empty and that empty list is set via set_exhibits() as the exhibit banner will ignore empty lists

Why is
281 + if self.top_rated is None:
282 + return
needed? Is that for the tests when the spawn helper stuff is disabled?

This looks like its not really needed for the pkg:
735 + pkg.banner_url = ''
736 + pkg.title_translated = ''
or am I misreading this?

One thing that is maybe nice to test is a list with a existing and a non-existing pkgname.

But none of the above is a showstopper and I'm happy to approve it.

While looking at the test_catview.py I noticed quite a bit of older code that wasn't ideal so I took the
liberty to do some cleanup in lp:~mvo/software-center/test-catview-cleanup that is based on your branch.
I will propose this for merging.

review: Approve

[Natalia Bidart (nataliabidart)]

> This is again a beauty to read and I much appreciate the effort that goes
> beyond the immediate fix and that
> helps making the code and tests better. The ExhibitsTestCase code is a
> excellent example on a good and
> clean test, very nice.

:-)

> Some questions/comments:
> - what do you think about moving "_pkg_available()" out into a more generic
> place like db/utils.py ?

(09:42:04 AM) nessita: mvo: is there any better/simpler way of knowing if a given pkg is available, without creating an Application? Like, can the StoreDatabase know that?

(otherwise we need to pass the db to the helper and that sounds, at least to me, a bit dirty)

> - _filter_and_set_exhibits() should probably have a small comment that its ok
> if result list is empty and that empty list is set via set_exhibits() as the
> exhibit banner will ignore empty lists

Added.

> Why is
> 281 + if self.top_rated is None:
> 282 + return
> needed? Is that for the tests when the spawn helper stuff is disabled?

When running the catview tests, I was having tracebacks about this, apparently
_update_top_rated_content was being called before the top_rated attribute was set, so I added that workaround.

> This looks like its not really needed for the pkg:
> 735 + pkg.banner_url = ''
> 736 + pkg.title_translated = ''
> or am I misreading this?

This is needed since the _HtmlRenderer in exhibits.py is calling the following fragment:

    144 html = EXHIBIT_HTML % {
    145 'banner_url': self.exhibit.banner_url,
    146 'title': self.exhibit.title_translated,
    147 'subtitle': "",
    148 }

and since I'm passing a Mock, I need to mimic those attributes.

> One thing that is maybe nice to test is a list with a existing and a non-
> existing pkgname.

Adding a test, sounds great.

> While looking at the test_catview.py I noticed quite a bit of older code that
> wasn't ideal so I took the
> liberty to do some cleanup in lp:~mvo/software-center/test-catview-cleanup
> that is based on your branch.
> I will propose this for merging.

Sounds even better!

[lp:~nataliabidart/software-center/fix-986563]

3028. By Natalia Bidart on 2012-05-22

Merged 5.2 in.

3029. By Natalia Bidart on 2012-05-22

Adding tweaks from the review.

[Michael Vogt (mvo)]

Thanks for this update and for addressing the review points so quickly!

On Tue, May 22, 2012 at 12:57:20PM -0000, Natalia Bidart wrote:
> > - what do you think about moving "_pkg_available()" out into a more generic
> > place like db/utils.py ?
>
> (09:42:04 AM) nessita: mvo: is there any better/simpler way of knowing if a given pkg is available, without creating an Application? Like, can the StoreDatabase know that?
>
> (otherwise we need to pass the db to the helper and that sounds, at least to me, a bit dirty)

I think putting it into the DB is the ideal way forward, its fine to
land it as it is IMO, we can create a seperate branch that moves it
into the DB.

> > Why is
> > 281 + if self.top_rated is None:
> > 282 + return
> > needed? Is that for the tests when the spawn helper stuff is disabled?
>
> When running the catview tests, I was having tracebacks about this, apparently
> _update_top_rated_content was being called before the top_rated attribute was set, so I added that workaround.

Looking at the code I think this happens because "self.build(desktopdir)"
is called in LobbyViewGtk after the db reopen signal is connected and
the refresh-review-stats signal too. So hopefully its enough to move
"self.build(desktopdir)" up before the signal connection, could you
please check if that fixes the crash?

> > This looks like its not really needed for the pkg:
> > 735 + pkg.banner_url = ''
> > 736 + pkg.title_translated = ''
> > or am I misreading this?
>
> This is needed since the _HtmlRenderer in exhibits.py is calling the following fragment:
>
> 144 html = EXHIBIT_HTML % {
> 145 'banner_url': self.exhibit.banner_url,
> 146 'title': self.exhibit.title_translated,
> 147 'subtitle': "",
> 148 }
>
> and since I'm passing a Mock, I need to mimic those attributes.

Right, what I'm puzzled about is that those are parts of the "pkg"
Mock in line 735 not the "exhibit" Mock.

Thanks!
 Michael

[lp:~nataliabidart/software-center/fix-986563]

3030. By Natalia Bidart on 2012-05-22

Moving the package availability calculation to StoreDatabase.

3031. By Natalia Bidart on 2012-05-22

More cleanup after review comments.

[Natalia Bidart (nataliabidart)]

> > > Why is
> > > 281 + if self.top_rated is None:
> > > 282 + return
> > > needed? Is that for the tests when the spawn helper stuff is disabled?
> >
> > When running the catview tests, I was having tracebacks about this,
> apparently
> > _update_top_rated_content was being called before the top_rated attribute
> was set, so I added that workaround.
>
> Looking at the code I think this happens because "self.build(desktopdir)"
> is called in LobbyViewGtk after the db reopen signal is connected and
> the refresh-review-stats signal too. So hopefully its enough to move
> "self.build(desktopdir)" up before the signal connection, could you
> please check if that fixes the crash?

It does! Pushing that.

> > > This looks like its not really needed for the pkg:
> > > 735 + pkg.banner_url = ''
> > > 736 + pkg.title_translated = ''
> > > or am I misreading this?
> >
> > This is needed since the _HtmlRenderer in exhibits.py is calling the
> following fragment:
> >
> > 144 html = EXHIBIT_HTML % {
> > 145 'banner_url': self.exhibit.banner_url,
> > 146 'title': self.exhibit.title_translated,
> > 147 'subtitle': "",
> > 148 }
> >
> > and since I'm passing a Mock, I need to mimic those attributes.
>
> Right, what I'm puzzled about is that those are parts of the "pkg"
> Mock in line 735 not the "exhibit" Mock.

Ah, good point. I debugged a bit more and found out, like you predicted, that setting that to the pkd was indeed unnecessary (the output confused me before due to the exceptions being printed out-of-order, perhaps there are threads involved?). I removed it.

[lp:~nataliabidart/software-center/fix-986563]

3032. By Natalia Bidart on 2012-05-22

PyFlakes fixes.

[Michael Vogt (mvo)]

Thanks for this update and for moving the code into the DB, even nicer now. I will merge this now and it will be part of the next SRU.

review: Approve

[Michael Vogt (mvo)]

One thought for later that I just had was that it would be nice to have the code react to the db-reopen signal and refilter the exhibits again to update once there are new apps from e.g. the software-center-agent.

[Michael Vogt (mvo)]

I just noticed one regression that is a bit of a client/server interaction issue.

For the Ubuntu books exhibit the server sends:
        "package_names": "ubuntu-unleashed-2012,ubuntu-unleashed-2011,ubuntu-practical-guide,ubuntu-server-book,official-ubuntu-book\r\n",

note the \r\n at the end, so we need to either fix the server or do a strip() in the packagename.

[Michael Vogt (mvo)]

I filed bug #1004417 about this.

=== modified file 'softwarecenter/backend/channel.py'
--- softwarecenter/backend/channel.py	2012-03-19 14:20:55 +0000
+++ softwarecenter/backend/channel.py	2012-05-22 14:21:21 +0000
@@ -22,7 +22,7 @@
 
 from gettext import gettext as _
 
-from softwarecenter.distro import get_distro
+import softwarecenter.distro
 
 from softwarecenter.enums import (SortMethods,
                                   Icons,
@@ -34,7 +34,7 @@
 
 class ChannelsManager(object):
     def __init__(self, db, **kwargs):
-        self.distro = get_distro()
+        self.distro = softwarecenter.distro.get_distro()
         self.db = db
 
     # public
@@ -154,7 +154,7 @@
         self.installed_only = installed_only
         self._channel_sort_mode = channel_sort_mode
         # distro specific stuff
-        self.distro = get_distro()
+        self.distro = softwarecenter.distro.get_distro()
         # configure the channel
         self._channel_display_name = self._get_display_name_for_channel(
             channel_name, channel_origin, channel_component)
@@ -351,7 +351,7 @@
     return AptChannelsManager.channel_available(channelname)
 
 if __name__ == "__main__":
-    distro = get_distro()
+    distro = softwarecenter.distro.get_distro()
     channel = SoftwareChannel(distro.get_distro_channel_name(),
                               None, None)
     print(channel)

=== modified file 'softwarecenter/db/application.py'
--- softwarecenter/db/application.py	2012-05-11 13:48:04 +0000
+++ softwarecenter/db/application.py	2012-05-22 14:21:21 +0000
@@ -24,9 +24,10 @@
 import os
 import re
 
+import softwarecenter.distro
+
 from gettext import gettext as _
 from softwarecenter.backend.channel import is_channel_available
-from softwarecenter.distro import get_distro
 from softwarecenter.enums import PkgStates, XapianValues, Icons
 
 from softwarecenter.paths import (APP_INSTALL_CHANNELS_PATH,
@@ -177,7 +178,7 @@
         self._db = db
         self._db.connect("reopen", self._on_db_reopen)
         self._cache = self._db._aptcache
-        self._distro = get_distro()
+        self._distro = softwarecenter.distro.get_distro()
         self._history = None
         # import here (intead of global) to avoid dbus dependency
         # in update-software-center (that imports application, but
@@ -298,7 +299,7 @@
         # try apt first
         if self._pkg:
             for origin in self._pkg.candidate.origins:
-                if (origin.origin == get_distro().get_distro_channel_name() and
+                if (origin.origin == self._distro.get_distro_channel_name() and
                     origin.trusted and origin.component):
                     return origin.component
         # then xapian
@@ -639,7 +640,7 @@
             self.emit("screenshots-available", self._screenshot_list)
             return
         # download it
-        distro = get_distro()
+        distro = self._distro
         url = distro.SCREENSHOT_JSON_URL % self._app.pkgname
         try:
             f = Gio.File.new_for_uri(url)

=== modified file 'softwarecenter/db/database.py'
--- softwarecenter/db/database.py	2012-05-03 20:27:00 +0000
+++ softwarecenter/db/database.py	2012-05-22 14:21:21 +0000
@@ -493,9 +493,10 @@
         return popcon
 
     def get_xapian_document(self, appname, pkgname):
-        """ Get the machting xapian document for appname, pkgname
-
-        If no document is found, raise a IndexError
+        """Get the machting xapian document for appname, pkgname.
+
+        If no document is found, raise a IndexError.
+
         """
         #LOG.debug("get_xapian_document app='%s' pkg='%s'" % (appname,
         #    pkgname))
@@ -517,9 +518,23 @@
         raise IndexError("No app '%s' for '%s' in database" % (appname,
             pkgname))
 
+    def is_pkgname_known(self, pkgname):
+        """Check if 'pkgname' is known to this database.
+
+        Note that even if this function returns True, it may mean that the
+        package needs  to be purchased first or is available in a
+        not-yet-enabled source.
+
+        """
+        # check cache first, then our own database
+        return (pkgname in self._aptcache or
+                any(self.xapiandb.postlist("AP" + pkgname)))
+
     def is_appname_duplicated(self, appname):
-        """Check if the given appname is stored multiple times in the db
-           This can happen for generic names like "Terminal"
+        """Check if the given appname is stored multiple times in the db.
+
+        This can happen for generic names like "Terminal".
+
         """
         for (i, m) in enumerate(self.xapiandb.postlist("AA" + appname)):
             if i > 0:

=== modified file 'softwarecenter/testutils.py'
--- softwarecenter/testutils.py	2012-04-16 16:41:29 +0000
+++ softwarecenter/testutils.py	2012-05-22 14:21:21 +0000
@@ -22,6 +22,8 @@
 import tempfile
 import time
 
+from collections import defaultdict
+
 from mock import Mock
 
 m_dbus = m_polkit = m_aptd = None
@@ -314,3 +316,57 @@
             {u'rating': 1.5, u'package_name': u'tucan'}],
         u'app': u'pitivi'}
     return recommend_app_data
+
+
+class ObjectWithSignals(object):
+    """A faked object that you can connect to and emit signals."""
+
+    def __init__(self, *a, **kw):
+        super(ObjectWithSignals, self).__init__()
+        self._callbacks = defaultdict(list)
+
+    def connect(self, signal, callback):
+        """Connect a signal with a callback."""
+        self._callbacks[signal].append(callback)
+
+    def disconnect(self, signal, callback):
+        """Connect a signal with a callback."""
+        self._callbacks[signal].remove(callback)
+        if len(self._callbacks[signal]) == 0:
+            self._callbacks.pop(signal)
+
+    def disconnect_by_func(self, callback):
+        """Disconnect 'callback' from every signal."""
+        # do not use iteritems since we may change the dict inside the for
+        for signal, callbacks in self._callbacks.items():
+            if callback in callbacks:
+                self.disconnect(signal, callback)
+
+    def emit(self, signal, *args, **kwargs):
+        """Emit 'signal' passing *args, **kwargs to every callback."""
+        for callback in self._callbacks[signal]:
+            callback(*args, **kwargs)
+
+
+class FakedCache(ObjectWithSignals, dict):
+    """A faked cache."""
+
+    def __init__(self, *a, **kw):
+        super(FakedCache, self).__init__()
+        self.ready = False
+
+    def open(self):
+        """Open this cache."""
+        self.ready = True
+
+    def component_available(self, distro_codename, component):
+        """Return whether 'component' is available in 'distro_codename'."""
+
+    def get_addons(self, pkgname):
+        """Return (recommended, suggested) addons for 'pkgname'."""
+        return ([], [])
+
+    def get_total_size_on_install(self, pkgname, addons_to_install,
+                                  addons_to_remove, archive_suite):
+        """Return a fake (total_download_size, total_install_size) result."""
+        return (0, 0)

=== modified file 'softwarecenter/ui/gtk3/models/appstore2.py'
--- softwarecenter/ui/gtk3/models/appstore2.py	2012-05-22 12:19:51 +0000
+++ softwarecenter/ui/gtk3/models/appstore2.py	2012-05-22 14:21:21 +0000
@@ -115,9 +115,7 @@
         self.icons = icons
         self.icon_size = icon_size
 
-        # cache the 'missing icon' used in the treeview for apps without an
-        # icon
-        self._missing_icon = icons.load_icon(Icons.MISSING_APP, icon_size, 0)
+        self._missing_icon = None  # delay this until actually needed
         if global_icon_cache:
             self.icon_cache = _app_icon_cache
         else:
@@ -146,6 +144,14 @@
                 on_image_download_complete, pkgname)
             image_downloader.download_file(url, icon_file_path)
 
+    @property
+    def missing_icon(self):
+        # cache the 'missing icon' used in treeviews for apps without an icon
+        if self._missing_icon is None:
+            self._missing_icon = self.icons.load_icon(Icons.MISSING_APP,
+                                                      self.icon_size, 0)
+        return self._missing_icon
+
     def update_availability(self, doc):
         doc.available = None
         doc.installed = None
@@ -228,10 +234,10 @@
                         self.get_pkgname(doc),
                         full_icon_file_name)
                     # display the missing icon while the real one downloads
-                    self.icon_cache[icon_name] = self._missing_icon
+                    self.icon_cache[icon_name] = self.missing_icon
         except GObject.GError as e:
             LOG.debug("get_icon returned '%s'" % e)
-        return self._missing_icon
+        return self.missing_icon
 
     def get_review_stats(self, doc):
         return self.review_loader.get_review_stats(self.get_application(doc))

=== modified file 'softwarecenter/ui/gtk3/views/catview_gtk.py'
--- softwarecenter/ui/gtk3/views/catview_gtk.py	2012-03-16 16:52:54 +0000
+++ softwarecenter/ui/gtk3/views/catview_gtk.py	2012-05-22 14:21:21 +0000
@@ -28,9 +28,11 @@
 
 import softwarecenter.paths
 from softwarecenter.db.application import Application
-from softwarecenter.enums import (NonAppVisibility,
-                                  SortMethods,
-                                  TOP_RATED_CAROUSEL_LIMIT)
+from softwarecenter.enums import (
+    NonAppVisibility,
+    SortMethods,
+    TOP_RATED_CAROUSEL_LIMIT,
+)
 from softwarecenter.utils import wait_for_apt_cache_ready
 from softwarecenter.ui.gtk3.models.appstore2 import AppPropertiesHelper
 from softwarecenter.ui.gtk3.widgets.viewport import Viewport
@@ -224,11 +226,15 @@
                  apps_filter, apps_limit=0):
         CategoriesViewGtk.__init__(self, datadir, desktopdir, cache, db, icons,
                                    apps_filter, apps_limit=0)
+        self.top_rated = None
+        self.exhibit_banner = None
 
         # sections
         self.departments = None
         self.appcount = None
 
+        self.build(desktopdir)
+
         # ensure that on db-reopen we refresh the whats-new titles
         self.db.connect("reopen", self._on_db_reopen)
 
@@ -237,9 +243,6 @@
         self.reviews_loader.connect(
             "refresh-review-stats-finished", self._on_refresh_review_stats)
 
-        self.build(desktopdir)
-        return
-
     def _on_db_reopen(self, db):
         self._update_whats_new_content()
 
@@ -270,7 +273,6 @@
 
         #self._append_video_clips()
         #self._append_top_of_the_pops
-        return
 
     #~ def _append_top_of_the_pops(self):
         #~ self.totp_hbox = Gtk.HBox(spacing=self.SPACING)
@@ -337,24 +339,34 @@
                            flags=['nonapps-visible'])
             self.emit("category-selected", cat)
 
+    def _filter_and_set_exhibits(self, sca_client, exhibit_list):
+        result = []
+        # filter out those exhibits that are not available in this run
+        for exhibit in exhibit_list:
+            available = all(self.db.is_pkgname_known(p) for p in
+                            exhibit.package_names.split(','))
+            if available:
+                result.append(exhibit)
+
+        # its ok if result is empty, since set_exhibits() will ignore
+        # empty lists
+        self.exhibit_banner.set_exhibits(result)
+
     def _append_banner_ads(self):
-        exhibit_banner = ExhibitBanner()
-        exhibit_banner.set_exhibits([FeaturedExhibit(),
-                                    ])
-        exhibit_banner.connect("show-exhibits-clicked", self._on_show_exhibits)
+        self.exhibit_banner = ExhibitBanner()
+        self.exhibit_banner.set_exhibits([FeaturedExhibit()])
+        self.exhibit_banner.connect(
+            "show-exhibits-clicked", self._on_show_exhibits)
 
         # query using the agent
         scagent = SoftwareCenterAgent()
-        scagent.connect(
-            "exhibits", lambda sca, l: exhibit_banner.set_exhibits(l))
+        scagent.connect("exhibits", self._filter_and_set_exhibits)
         scagent.query_exhibits()
 
         a = Gtk.Alignment()
         a.set_padding(0, StockEms.SMALL, 0, 0)
-        a.add(exhibit_banner)
-
+        a.add(self.exhibit_banner)
         self.vbox.pack_start(a, False, False, 0)
-        return
 
     def _append_departments(self):
         # set the departments section to use the label markup we have just

=== modified file 'test/gtk3/test_app.py'
--- test/gtk3/test_app.py	2012-05-16 15:52:07 +0000
+++ test/gtk3/test_app.py	2012-05-22 14:21:21 +0000
@@ -8,7 +8,7 @@
 
 from mock import Mock
 
-from testutils import get_mock_options, setup_test_env
+from testutils import FakedCache, get_mock_options, setup_test_env
 setup_test_env()
 
 import softwarecenter.paths
@@ -17,40 +17,6 @@
 from softwarecenter.ui.gtk3 import app
 
 
-class FakedCache(dict):
-    """A faked cache."""
-
-    def __init__(self, *a, **kw):
-        super(FakedCache, self).__init__()
-        self._callbacks = defaultdict(list)
-        self.ready = False
-
-    def open(self):
-        """Open this cache."""
-        self.ready = True
-
-    def connect(self, signal, callback):
-        """Connect a signal with a callback."""
-        self._callbacks[signal].append(callback)
-
-    def disconnect_by_func(self, callback):
-        """Disconnect 'callback' from every signal."""
-        for signal, cb in self._callbacks.iteritems():
-            if cb == callback:
-                self._callbacks[signal].remove(callback)
-            if len(self._callbacks[signal]) == 0:
-                self._callbacks.pop(signal)
-
-    def get_addons(self, pkgname):
-        """Return (recommended, suggested) addons for 'pkgname'."""
-        return ([],[])
-
-    def get_total_size_on_install(self,pkgname, addons_to_install,
-                                  addons_to_remove, archive_suite):
-        """Return a fake (total_download_size, total_install_size) result."""
-        return (0, 0)
-
-
 class ParsePackagesArgsTestCase(unittest.TestCase):
     """Test suite for the parse_packages_args helper."""
 
@@ -109,7 +75,7 @@
         fname = __file__
         assert os.path.exists(fname)
         self.assertRaises(DebFileOpenError, app.parse_packages_args, fname)
-        
+
 
 class ParsePackagesWithAptPrefixTestCase(ParsePackagesArgsTestCase):
 

=== modified file 'test/gtk3/test_catview.py'
--- test/gtk3/test_catview.py	2012-03-15 22:23:21 +0000
+++ test/gtk3/test_catview.py	2012-05-22 14:21:21 +0000
@@ -1,28 +1,42 @@
-from gi.repository import Gtk
 import time
 import unittest
+
+from gi.repository import Gtk
 from mock import patch, Mock
 
 from testutils import setup_test_env
 setup_test_env()
 
+import softwarecenter.distro
+import softwarecenter.paths
+
+from softwarecenter.db.database import StoreDatabase
 from softwarecenter.enums import SortMethods
-from softwarecenter.testutils import (get_test_db,
-                                      make_recommender_agent_recommend_me_dict)
+from softwarecenter.testutils import (
+    FakedCache,
+    get_test_db,
+    make_recommender_agent_recommend_me_dict,
+    ObjectWithSignals,
+)
+from softwarecenter.ui.gtk3.views import catview_gtk
+from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
+from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
+
 
 class TestCatView(unittest.TestCase):
 
     def setUp(self):
+        self._cat = None
         self.db = get_test_db()
 
     def _on_category_selected(self, subcatview, category):
-        #print "**************", subcatview, category
         self._cat = category
-    
-    def test_subcatview_top_rated(self):
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
+    def test_top_rated(self):
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         lobby = win.get_data("lobby")
 
         # simulate review-stats refresh
@@ -37,12 +51,11 @@
         self.assertNotEqual(self._cat, None)
         self.assertEqual(self._cat.name, "Top Rated")
         self.assertEqual(self._cat.sortmode, SortMethods.BY_TOP_RATED)
-        win.destroy()
 
-    def test_subcatview_new(self):
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+    def test_new(self):
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         lobby = win.get_data("lobby")
 
         # test db reopen triggers whats-new update
@@ -58,9 +71,8 @@
         # encoding is utf-8 (since r2218, see category.py)
         self.assertEqual(self._cat.name, 'What\xe2\x80\x99s New')
         self.assertEqual(self._cat.sortmode, SortMethods.BY_CATALOGED_TIME)
-        win.destroy()
 
-    def test_subcatview_new_no_sort_info_yet(self):
+    def test_new_no_sort_info_yet(self):
         # ensure that we don't show a empty "whats new" category
         # see LP: #865985
         from softwarecenter.testutils import get_test_db
@@ -68,7 +80,7 @@
         cache = db._aptcache
         # simulate a fresh install with no catalogedtime info
         del db._axi_values["catalogedtime"]
-        
+
         from softwarecenter.testutils import get_test_gtk3_icon_cache
         icons = get_test_gtk3_icon_cache()
 
@@ -76,15 +88,15 @@
         apps_filter = AppFilter(db, cache)
 
         from softwarecenter.distro import get_distro
-        import softwarecenter.paths
-        from softwarecenter.paths import APP_INSTALL_PATH
         from softwarecenter.ui.gtk3.views.catview_gtk import LobbyViewGtk
-        view = LobbyViewGtk(softwarecenter.paths.datadir, APP_INSTALL_PATH,
+        view = LobbyViewGtk(softwarecenter.paths.datadir,
+                            softwarecenter.paths.APP_INSTALL_PATH,
                             cache, db, icons, get_distro(), apps_filter)
         view.show()
 
         # gui
         win = Gtk.Window()
+        self.addCleanup(win.destroy)
         win.set_size_request(800, 400)
 
         scroll = Gtk.ScrolledWindow()
@@ -96,82 +108,85 @@
         self._p()
         self.assertFalse(view.whats_new_frame.get_property("visible"))
         self._p()
-        win.destroy()
 
-    def test_subcatview_recommended_for_you_opt_in_display(self):
-    
-        # patch the recommender UUID value to insure that we are not opted-in for this test
-        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
-        self.addCleanup(get_recommender_opted_in_patcher.stop)
-        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
+    def test_recommended_for_you_opt_in_display(self):
+        # patch the recommender UUID value to ensure that we are not opted-in
+        # for this test
+        recommender_opted_in_patcher = patch(
+            'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+        self.addCleanup(recommender_opted_in_patcher.stop)
+        mock_get_recommender_opted_in = recommender_opted_in_patcher.start()
         mock_get_recommender_opted_in.return_value = False
-        
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
+
         lobby = win.get_data("lobby")
         rec_panel = lobby.recommended_for_you_panel
         self._p()
-        from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
-        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == FramedHeaderBox.CONTENT)
+        self.assertEqual(rec_panel.spinner_notebook.get_current_page(),
+                         FramedHeaderBox.CONTENT)
         self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
-        win.destroy()
-        
+
     # patch out the agent query method to avoid making the actual server call
     @patch('softwarecenter.backend.recagent.RecommenderAgent'
            '.post_submit_profile')
-    def test_subcatview_recommended_for_you_spinner_display(self, mock_query):
-    
-        # patch the recommender UUID value to insure that we are not opted-in for this test
-        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
-        self.addCleanup(get_recommender_opted_in_patcher.stop)
-        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
+    def test_recommended_for_you_spinner_display(self, mock_query):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        recommender_opted_in_patcher = patch(
+            'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+        self.addCleanup(recommender_opted_in_patcher.stop)
+        mock_get_recommender_opted_in = recommender_opted_in_patcher.start()
         mock_get_recommender_opted_in.return_value = False
-        
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         lobby = win.get_data("lobby")
         rec_panel = lobby.recommended_for_you_panel
         self._p()
-        # click the opt-in button to initiate the process, this will show the spinner
+        # click the opt-in button to initiate the process,
+        # this will show the spinner
         rec_panel.opt_in_button.emit('clicked')
         self._p()
-        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
-        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.SPINNER_PAGE)
+        self.assertEqual(rec_panel.spinner_notebook.get_current_page(),
+                         SpinnerNotebook.SPINNER_PAGE)
         self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
-        win.destroy()
 
     # patch out the agent query method to avoid making the actual server call
     @patch('softwarecenter.backend.recagent.RecommenderAgent'
            '.post_submit_profile')
-    def test_subcatview_recommended_for_you_display_recommendations(self, mock_query):
-    
-        # patch the recommender UUID value to insure that we are not opted-in for this test
-        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
-        self.addCleanup(get_recommender_opted_in_patcher.stop)
-        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
+    def test_recommended_for_you_display_recommendations(self,
+            mock_query):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        recommender_opted_in_patcher = patch(
+            'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+        self.addCleanup(recommender_opted_in_patcher.stop)
+        mock_get_recommender_opted_in = recommender_opted_in_patcher.start()
         mock_get_recommender_opted_in.return_value = False
-        
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         lobby = win.get_data("lobby")
         rec_panel = lobby.recommended_for_you_panel
         self._p()
-        # click the opt-in button to initiate the process, this will show the spinner
+        # click the opt-in button to initiate the process,
+        # this will show the spinner
         rec_panel.opt_in_button.emit('clicked')
         self._p()
         rec_panel._update_recommended_for_you_content()
         self._p()
         # we fake the callback from the agent here
-        lobby.recommended_for_you_panel.recommended_for_you_cat._recommend_me_result(
-                                None,
-                                make_recommender_agent_recommend_me_dict())
-        self.assertNotEqual(
-                lobby.recommended_for_you_panel.recommended_for_you_cat.get_documents(self.db), [])
-        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
-        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
+        for_you = lobby.recommended_for_you_panel.recommended_for_you_cat
+        for_you._recommend_me_result(None,
+            make_recommender_agent_recommend_me_dict())
+        self.assertNotEqual(for_you.get_documents(self.db), [])
+        self.assertEqual(rec_panel.spinner_notebook.get_current_page(),
+                         SpinnerNotebook.CONTENT_PAGE)
         self._p()
         # test clicking recommended_for_you More button
         lobby.connect("category-selected", self._on_category_selected)
@@ -179,49 +194,51 @@
         self._p()
         self.assertNotEqual(self._cat, None)
         self.assertEqual(self._cat.name, "Recommended For You")
-        win.destroy()
-        
+
     # patch out the agent query method to avoid making the actual server call
     @patch('softwarecenter.backend.recagent.RecommenderAgent'
            '.query_recommend_me')
-    def test_subcatview_recommended_for_you_display_recommendations_not_opted_in(self, mock_query):
-    
-        # patch the recommender UUID value to insure that we are not opted-in for this test
-        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
-        self.addCleanup(get_recommender_opted_in_patcher.stop)
-        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
+    def test_recommended_for_you_display_recommendations_not_opted_in(self,
+            mock_query):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        recommender_opted_in_patcher = patch(
+            'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+        self.addCleanup(recommender_opted_in_patcher.stop)
+        mock_get_recommender_opted_in = recommender_opted_in_patcher.start()
         mock_get_recommender_opted_in.return_value = False
-        
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         # we want to work in the "subcat" view
         notebook = win.get_child()
         notebook.next_page()
-        
+
         subcat_view = win.get_data("subcat")
         self._p()
-        self.assertFalse(subcat_view.recommended_for_you_in_cat.get_property("visible"))
-        win.destroy()
-        
+        self.assertFalse(subcat_view.recommended_for_you_in_cat.get_property(
+            "visible"))
+
     # patch out the agent query method to avoid making the actual server call
     @patch('softwarecenter.backend.recagent.RecommenderAgent'
            '.query_recommend_me')
-    def test_subcatview_recommended_for_you_display_recommendations_opted_in(self, mock_query):
-    
-        # patch the recommender UUID value to insure that we are not opted-in for this test
-        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
-        self.addCleanup(get_recommender_opted_in_patcher.stop)
-        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
+    def test_recommended_for_you_display_recommendations_opted_in(self, mock_query):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        recommender_opted_in_patcher = patch(
+            'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+        self.addCleanup(recommender_opted_in_patcher.stop)
+        mock_get_recommender_opted_in = recommender_opted_in_patcher.start()
         mock_get_recommender_opted_in.return_value = True
-        
-        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
+
         # get the widgets we need
         win = get_test_window_catview()
+        self.addCleanup(win.destroy)
         # we want to work in the "subcat" view
         notebook = win.get_child()
         notebook.next_page()
-        
+
         subcat_view = win.get_data("subcat")
         rec_cat_panel = subcat_view.recommended_for_you_in_cat
         self._p()
@@ -231,18 +248,21 @@
         rec_cat_panel.recommended_for_you_cat._recommend_me_result(
                                 None,
                                 make_recommender_agent_recommend_me_dict())
-        result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(self.db)
+        result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(
+            self.db)
         self.assertNotEqual(result_docs, [])
-        # check that we are getting the correct number of results, corresponding
-        # to the following Internet items:
+        # check that we are getting the correct number of results,
+        # corresponding to the following Internet items:
         #   Mangler, Midori, Midori Private Browsing, Psi
         self.assertTrue(len(result_docs) == 4)
-        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
-        self.assertTrue(rec_cat_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
+        self.assertEqual(rec_cat_panel.spinner_notebook.get_current_page(),
+                         SpinnerNotebook.CONTENT_PAGE)
         # check that the tiles themselves are visible
         self._p()
-        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property("visible"))
-        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children()[0].title.get_property("visible"))
+        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property(
+            "visible"))
+        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children(
+            )[0].title.get_property("visible"))
         self._p()
         # test clicking recommended_for_you More button
         subcat_view.connect("category-selected", self._on_category_selected)
@@ -250,7 +270,6 @@
         self._p()
         self.assertNotEqual(self._cat, None)
         self.assertEqual(self._cat.name, "Recommended For You in Internet")
-        win.destroy()
 
     def _p(self):
         for i in range(5):
@@ -259,6 +278,89 @@
                 Gtk.main_iteration()
 
 
+class ExhibitsTestCase(unittest.TestCase):
+    """The test suite for the exhibits carousel."""
+
+    def setUp(self):
+        self.datadir = softwarecenter.paths.datadir
+        self.desktopdir = softwarecenter.paths.APP_INSTALL_PATH
+        self.cache = FakedCache()
+        self.db = StoreDatabase(cache=self.cache)
+        self.lobby = catview_gtk.LobbyViewGtk(datadir=self.datadir,
+            desktopdir=self.desktopdir, cache=self.cache, db=self.db,
+            icons=None, apps_filter=None)
+        self.addCleanup(self.lobby.destroy)
+
+    def _get_banner_from_lobby(self):
+        return self.lobby.vbox.get_children()[-1].get_child()
+
+    def test_featured_exhibit_by_default(self):
+        """Show the featured exhibit before querying the remote service."""
+        self.lobby._append_banner_ads()
+
+        banner = self._get_banner_from_lobby()
+        self.assertEqual(1, len(banner.exhibits))
+        self.assertIsInstance(banner.exhibits[0], catview_gtk.FeaturedExhibit)
+
+    def test_no_exhibit_if_not_available(self):
+        """The exhibit should not be shown if the package is not available."""
+        exhibit = Mock()
+        exhibit.package_names = u'foobarbaz'
+
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca, [exhibit])
+
+        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
+            self.lobby._append_banner_ads()
+
+        banner = self._get_banner_from_lobby()
+        self.assertEqual(1, len(banner.exhibits))
+        self.assertIsInstance(banner.exhibits[0], catview_gtk.FeaturedExhibit)
+
+    def test_exhibit_if_available(self):
+        """The exhibit should be shown if the package is available."""
+        exhibit = Mock()
+        exhibit.package_names = u'foobarbaz'
+        exhibit.banner_url = 'banner'
+        exhibit.title_translated = ''
+
+        self.cache[u'foobarbaz'] = Mock()
+
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca, [exhibit])
+
+        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
+            self.lobby._append_banner_ads()
+
+        banner = self._get_banner_from_lobby()
+        self.assertEqual(1, len(banner.exhibits))
+        self.assertIs(banner.exhibits[0], exhibit)
+
+    def test_exhibit_if_mixed_availability(self):
+        """The exhibit should be shown even if some are not available."""
+        # available exhibit
+        exhibit = Mock()
+        exhibit.package_names = u'foobarbaz'
+        exhibit.banner_url = 'banner'
+        exhibit.title_translated = ''
+
+        self.cache[u'foobarbaz'] = Mock()
+
+        # not available exhibit
+        other = Mock()
+        other.package_names = u'not-there'
+
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
+                                              [exhibit, other])
+
+        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
+            self.lobby._append_banner_ads()
+
+        banner = self._get_banner_from_lobby()
+        self.assertEqual(1, len(banner.exhibits))
+        self.assertIs(banner.exhibits[0], exhibit)
+
 
 if __name__ == "__main__":
     #import logging

=== modified file 'test/test_database.py'
--- test/test_database.py	2012-04-16 17:44:04 +0000
+++ test/test_database.py	2012-05-22 14:21:21 +0000
@@ -424,7 +424,7 @@
         self.assertTrue(len(details.tags) > 2)
 
     def test_app_enquire(self):
-        db = StoreDatabase("/var/cache/software-center/xapian", self.cache)
+        db = StoreDatabase(cache=self.cache)
         db.open()
         # test the AppEnquire engine
         enquirer = AppEnquire(self.cache, db)
@@ -433,6 +433,12 @@
         self.assertTrue(len(enquirer.get_docids()) > 0)
         # FIXME: test more of the interface
 
+    def test_is_pkgname_known(self):
+        db = StoreDatabase(cache=self.cache)
+        db.open()
+        self.assertTrue(db.is_pkgname_known("apt"))
+        self.assertFalse(db.is_pkgname_known("i+am-not-a-pkg"))
+
 
 class UtilsTestCase(unittest.TestCase):