Merge lp:~mvo/software-center/test-catview-cleanup into lp:software-center

[Michael Vogt]

This branch refactors the test_catview.py code:
- split the TestCases for the Recommender and the Top Rated/Whats New
- remove duplicated code in the tests by using setUp()/tearDown() more efficiently
- use the patch decorator more
- avoid re-creating the DB in each test via setUpClass, this could be optimized further by just having one global instance for the entire test

[lp:~mvo/software-center/test-catview-cleanup]

3034. By Michael Vogt on 2012-05-22

test/gtk3/test_catview.py: use addCleanup() instead of tearDown() as suggested by Natalia

3035. By Michael Vogt on 2012-05-22

merge 5.2 and resolve conflicts

Unmerged revisions

=== modified file 'softwarecenter/backend/channel.py'
--- softwarecenter/backend/channel.py	2012-03-19 14:20:55 +0000
+++ softwarecenter/backend/channel.py	2012-05-22 12:42:24 +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 12:42:24 +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/testutils.py'
--- softwarecenter/testutils.py	2012-04-16 16:41:29 +0000
+++ softwarecenter/testutils.py	2012-05-22 12:42:24 +0000
@@ -22,6 +22,8 @@
 import tempfile
 import time
 
+from collections import defaultdict
+
 from mock import Mock
 
 m_dbus = m_polkit = m_aptd = None
@@ -142,6 +144,12 @@
         main_loop.iteration()
 
 
+def do_events_with_sleep(iterations=5, sleep=0.1):
+        for i in range(iterations):
+            do_events()
+            time.sleep(sleep)
+
+
 def get_mock_app_from_real_app(real_app):
     """ take a application and return a app where the details are a mock
         of the real details so they can easily be modified
@@ -314,3 +322,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-18 18:42:27 +0000
+++ softwarecenter/ui/gtk3/models/appstore2.py	2012-05-22 12:42:24 +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 12:42:24 +0000
@@ -28,9 +28,12 @@
 
 import softwarecenter.paths
 from softwarecenter.db.application import Application
-from softwarecenter.enums import (NonAppVisibility,
-                                  SortMethods,
-                                  TOP_RATED_CAROUSEL_LIMIT)
+from softwarecenter.enums import (
+    NonAppVisibility,
+    PkgStates,
+    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,6 +227,8 @@
                  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
@@ -337,24 +342,41 @@
                            flags=['nonapps-visible'])
             self.emit("category-selected", cat)
 
+    def _pkg_available(self, pkgname):
+        try:
+            state = Application("", pkgname).get_details(self.db).pkg_state
+        except:
+            available = False
+        else:
+            available = state not in (PkgStates.NOT_FOUND, PkgStates.ERROR)
+        return available
+
+    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._pkg_available(p) for p in
+                            exhibit.package_names.split(','))
+            if available:
+                result.append(exhibit)
+
+        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
@@ -382,6 +404,8 @@
     # FIXME: _update_{top_rated,whats_new,recommended_for_you}_content()
     #        duplicates a lot of code
     def _update_top_rated_content(self):
+        if self.top_rated is None:
+            return
         # remove any existing children from the grid widget
         self.top_rated.remove_all()
         # get top_rated category and docs
@@ -715,21 +739,24 @@
         #return
 
 
-def get_test_window_catview():
+def get_test_window_catview(db=None):
 
     def on_category_selected(view, cat):
         print "on_category_selected view: ", view
         print "on_category_selected cat: ", cat
 
-    from softwarecenter.db.pkginfo import get_pkg_info
-    cache = get_pkg_info()
-    cache.open()
+    if db is None:
+        from softwarecenter.db.pkginfo import get_pkg_info
+        cache = get_pkg_info()
+        cache.open()
 
-    from softwarecenter.db.database import StoreDatabase
-    xapian_base_path = "/var/cache/software-center"
-    pathname = os.path.join(xapian_base_path, "xapian")
-    db = StoreDatabase(pathname, cache)
-    db.open()
+        from softwarecenter.db.database import StoreDatabase
+        xapian_base_path = "/var/cache/software-center"
+        pathname = os.path.join(xapian_base_path, "xapian")
+        db = StoreDatabase(pathname, cache)
+        db.open()
+    else:
+        cache = db._aptcache
 
     import softwarecenter.paths
     datadir = softwarecenter.paths.datadir

=== 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 12:42:24 +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 12:42:24 +0000
@@ -1,66 +1,81 @@
+import unittest
+
 from gi.repository import Gtk
-import time
-import unittest
 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)
-
-class TestCatView(unittest.TestCase):
+from softwarecenter.testutils import (
+    do_events_with_sleep,
+    do_events,
+    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 CatViewBaseTestCase(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.db = get_test_db()
 
     def setUp(self):
-        self.db = get_test_db()
+        self._cat = None
+        self.win = get_test_window_catview(self.db)
+        self.addCleanup(self.win.destroy)
+        self.notebook = self.win.get_child()
+        self.lobby = self.win.get_data("lobby")
+        self.subcat_view = self.win.get_data("subcat")
+        self.rec_panel = self.lobby.recommended_for_you_panel
 
     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
-        # get the widgets we need
-        win = get_test_window_catview()
-        lobby = win.get_data("lobby")
-
+
+
+class TopAndWhatsNewTestCase(CatViewBaseTestCase):
+
+    def test_top_rated(self):
         # simulate review-stats refresh
-        lobby._update_top_rated_content = Mock()
-        lobby.reviews_loader.emit("refresh-review-stats-finished", [])
-        self.assertTrue(lobby._update_top_rated_content.called)
+        self.lobby._update_top_rated_content = Mock()
+        self.lobby.reviews_loader.emit("refresh-review-stats-finished", [])
+        self.assertTrue(self.lobby._update_top_rated_content.called)
 
         # test clicking top_rated
-        lobby.connect("category-selected", self._on_category_selected)
-        lobby.top_rated_frame.more.clicked()
-        self._p()
+        self.lobby.connect("category-selected", self._on_category_selected)
+        self.lobby.top_rated_frame.more.clicked()
+        do_events()
         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
-        # get the widgets we need
-        win = get_test_window_catview()
-        lobby = win.get_data("lobby")
-
+
+    def test_new(self):
         # test db reopen triggers whats-new update
-        lobby._update_whats_new_content = Mock()
-        lobby.db.emit("reopen")
-        self.assertTrue(lobby._update_whats_new_content.called)
+        self.lobby._update_whats_new_content = Mock()
+        self.lobby.db.emit("reopen")
+        self.assertTrue(self.lobby._update_whats_new_content.called)
 
         # test clicking new
-        lobby.connect("category-selected", self._on_category_selected)
-        lobby.whats_new_frame.more.clicked()
-        self._p()
+        self.lobby.connect("category-selected", self._on_category_selected)
+        self.lobby.whats_new_frame.more.clicked()
+        do_events()
         self.assertNotEqual(self._cat, None)
         # 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 +83,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,7 +91,6 @@
         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,
@@ -85,6 +99,7 @@
 
         # gui
         win = Gtk.Window()
+        self.addCleanup(win.destroy)
         win.set_size_request(800, 400)
 
         scroll = Gtk.ScrolledWindow()
@@ -93,171 +108,198 @@
         win.add(scroll)
         win.show()
         # test visibility
-        self._p()
+        do_events()
         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()
-        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()
-        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.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()
-        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()
-        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
-        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.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()
-        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()
-        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
-        rec_panel.opt_in_button.emit('clicked')
-        self._p()
-        rec_panel._update_recommended_for_you_content()
-        self._p()
+
+
+class RecommendationsTestCase(CatViewBaseTestCase):
+    """The test suite for the recommendations ."""
+
+    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+    def test_recommended_for_you_opt_in_display(
+                                        self, mock_get_recommender_opted_in):
+        # patch the recommender UUID value to ensure that we are not opted-in
+        # for this test
+        mock_get_recommender_opted_in.return_value = False
+
+        do_events()
+        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
+                         FramedHeaderBox.CONTENT)
+        self.assertTrue(self.rec_panel.opt_in_vbox.get_property("visible"))
+
+    # patch out the agent query method to avoid making the actual server call
+    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+    @patch('softwarecenter.backend.recagent.RecommenderAgent'
+           '.post_submit_profile')
+    def test_recommended_for_you_spinner_display(
+                             self, mock_query, mock_get_recommender_opted_in):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        mock_get_recommender_opted_in.return_value = False
+
+        # click the opt-in button to initiate the process,
+        # this will show the spinner
+        self.rec_panel.opt_in_button.emit('clicked')
+        do_events()
+        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
+                         SpinnerNotebook.SPINNER_PAGE)
+        self.assertTrue(self.rec_panel.opt_in_vbox.get_property("visible"))
+
+    # patch out the agent query method to avoid making the actual server call
+    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
+    @patch('softwarecenter.backend.recagent.RecommenderAgent'
+           '.post_submit_profile')
+    def test_recommended_for_you_display_recommendations(self,
+                                   mock_query, mock_get_recommender_opted_in):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
+        mock_get_recommender_opted_in.return_value = False
+
+        # click the opt-in button to initiate the process,
+        # this will show the spinner
+        self.rec_panel.opt_in_button.emit('clicked')
+        do_events()
+        self.rec_panel._update_recommended_for_you_content()
+        do_events()
         # 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)
-        self._p()
+        for_you = self.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(self.rec_panel.spinner_notebook.get_current_page(),
+                         SpinnerNotebook.CONTENT_PAGE)
+        do_events()
         # test clicking recommended_for_you More button
-        lobby.connect("category-selected", self._on_category_selected)
-        lobby.recommended_for_you_panel.more.clicked()
-        self._p()
+        self.lobby.connect("category-selected", self._on_category_selected)
+        self.lobby.recommended_for_you_panel.more.clicked()
+        # this is delayed for some reason so we need to sleep here
+        do_events_with_sleep()
         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.is_opted_in')
     @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, mock_get_recommender_opted_in):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
         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()
+
         # 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.notebook.next_page()
+
+        do_events()
+        visible = self.subcat_view.recommended_for_you_in_cat.get_property(
+            "visible")
+        self.assertFalse(visible)
+
     # patch out the agent query method to avoid making the actual server call
+    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
     @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, mock_get_recommender_opted_in):
+        # patch the recommender UUID value to insure that we are not opted-in
+        # for this test
         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()
+
         # 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()
+        self.notebook.next_page()
+
+        rec_cat_panel = self.subcat_view.recommended_for_you_in_cat
         rec_cat_panel._update_recommended_for_you_content()
-        self._p()
+        do_events()
         # we fake the callback from the agent here
         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._p()
+        do_events()
+        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"))
+        do_events()
         # test clicking recommended_for_you More button
-        subcat_view.connect("category-selected", self._on_category_selected)
+        self.subcat_view.connect(
+            "category-selected", self._on_category_selected)
         rec_cat_panel.more.clicked()
-        self._p()
+        # this is delayed for some reason so we need to sleep here
+        do_events_with_sleep()
         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):
-            time.sleep(0.1)
-            while Gtk.events_pending():
-                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 not available."""
+        exhibit = Mock()
+        exhibit.package_names = u'foobarbaz'
+        exhibit.banner_url = 'banner'
+
+        pkg = Mock()
+        pkg.banner_url = ''
+        pkg.title_translated = ''
+        self.cache[u'foobarbaz'] = pkg
+
+        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)
 
 
 if __name__ == "__main__":