Merge lp:~mvo/software-center/support-multiple-exhibit-images into lp:software-center

[Michael Vogt]

This branch adds support for multiple images in the exhibit banners.
This is to fix #920542. It also does a bit of drive-by cleanup in the
testscases by extracting the exhibits testcase into its own file.

[lp:~mvo/software-center/support-multiple-exhibit-images]

3203. By Michael Vogt on 2012-09-24

add some debug code

[Gary Lasker (gary-lasker)]

Thanks, Michael!

review: Approve

=== modified file 'softwarecenter/ui/gtk3/views/lobbyview.py'
--- softwarecenter/ui/gtk3/views/lobbyview.py	2012-09-20 01:09:57 +0000
+++ softwarecenter/ui/gtk3/views/lobbyview.py	2012-09-24 15:24:22 +0000
@@ -150,6 +150,9 @@
                                 exhibit.package_names.split(','))
                 if available:
                     result.append(exhibit)
+                else:
+                    LOG.warn("skipping exhibit for: '%r' not available" % (
+                            exhibit.package_names))
 
         # its ok if result is empty, since set_exhibits() will ignore
         # empty lists

=== modified file 'softwarecenter/ui/gtk3/widgets/exhibits.py'
--- softwarecenter/ui/gtk3/widgets/exhibits.py	2012-09-12 14:08:18 +0000
+++ softwarecenter/ui/gtk3/widgets/exhibits.py	2012-09-24 15:24:22 +0000
@@ -86,10 +86,10 @@
             "webservice-office-zoho")
         self.title_translated = _("Our star apps")
         self.published = True
-        self.banner_url = "file:%s" % (os.path.abspath(os.path.join(
-            softwarecenter.paths.datadir, "default_banner/fallback.png")))
+        self.banner_urls = ["file:%s" % (os.path.abspath(os.path.join(
+            softwarecenter.paths.datadir, "default_banner/fallback.png")))]
         self.html = EXHIBIT_HTML % {
-            'banner_url': self.banner_url,
+            'banner_url': self.banner_urls[0],
             'title': _("Our star apps"),
             'subtitle': _("Come and explore our favourites"),
         }
@@ -121,47 +121,66 @@
         self.show_all()
         self.loader = SimpleFileDownloader()
         self.loader.connect("file-download-complete",
-                            self.on_download_complete)
+                            self._on_one_download_complete)
         self.loader.connect("error",
-                            self.on_download_error)
+                            self._on_download_error)
         self.exhibit = None
-        self.view.connect("notify::load-status", self._on_load_status)
-
-    def _on_load_status(self, view, prop):
+        self._downloaded_banner_images = []
+        self.view.connect(
+            "notify::load-status", self._on_internal_renderer_load_status)
+
+    def set_exhibit(self, exhibit):
+        LOG.debug("set_exhibit: '%s'" % exhibit)
+        self._downloaded_banner_images = []
+        self.exhibit = exhibit
+        self._download_next_banner_image()
+
+    def _on_download_error(self, loader, exception, error):
+        LOG.warn("download failed: '%s', '%s'" % (exception, error))
+
+    def _on_one_download_complete(self, loader, path):
+        LOG.debug("downloading of '%s' finished" % path)
+        self._downloaded_banner_images.append(path)
+        if len(self._downloaded_banner_images) < len(self.exhibit.banner_urls):
+            self._download_next_banner_image()
+        self._on_all_banner_images_downloaded()
+
+    def _on_all_banner_images_downloaded(self):
+        LOG.debug("downloading of all banner images finished")
+        html = self.exhibit.html
+        cache_dir = os.path.join(
+            softwarecenter.paths.SOFTWARE_CENTER_CACHE_DIR,
+            "download-cache")
+        for url, local_file in zip(self.exhibit.banner_urls,
+                              self._downloaded_banner_images):
+            # no need to mangle local urls
+            if url.startswith("file"):
+                continue
+            scheme, netloc, server_path, para, query, frag = urlparse(url)
+            image_name = os.path.basename(local_file)
+            # replace the server side path with the local image name, this
+            # assumes that the image always comes from the same server as
+            # the html
+            html = html.replace(server_path, image_name)
+        self.exhibit.html = html
+        LOG.debug("mangled html: '%s'" % html)
+        self.view.load_string(html, "text/html", "UTF-8",
+                              "file:%s/" % cache_dir)
+
+    def _download_next_banner_image(self):
+        LOG.debug("_download_next_banner_image")
+        self.loader.download_file(
+            self.exhibit.banner_urls[len(self._downloaded_banner_images)],
+            use_cache=True,
+            simple_quoting_for_webkit=True)
+
+    def _on_internal_renderer_load_status(self, view, prop):
+        """Called when the rendering of the html banner is done"""
         if view.get_property("load-status") == WebKit.LoadStatus.FINISHED:
             # this needs to run with a timeout because otherwise the
             # status is emited before the offscreen image is finihsed
             GObject.timeout_add(100, lambda: self.emit("render-finished"))
 
-    def on_download_error(self, loader, exception, error):
-        LOG.warn("download failed: '%s', '%s'" % (exception, error))
-
-    def on_download_complete(self, loader, path):
-        image_name = os.path.basename(path)
-        cache_dir = os.path.dirname(path)
-        if hasattr(self.exhibit, "html") and self.exhibit.html:
-            html = self.exhibit.html
-        else:
-            html = EXHIBIT_HTML % {
-                'banner_url': self.exhibit.banner_url,
-                'title': self.exhibit.title_translated,
-                'subtitle': "",
-            }
-        # replace the server side path with the local image name, this
-        # assumes that the image always comes from the same server as
-        # the html
-        scheme, netloc, server_path, para, query, frag = urlparse(
-            self.exhibit.banner_url)
-        html = html.replace(server_path, image_name)
-        self.view.load_string(html, "text/html", "UTF-8",
-                              "file:%s/" % cache_dir)
-
-    def set_exhibit(self, exhibit):
-        self.exhibit = exhibit
-        self.loader.download_file(exhibit.banner_url,
-                                  use_cache=True,
-                                  simple_quoting_for_webkit=True)
-
 
 class ExhibitButton(Gtk.Button):
 

=== modified file 'tests/gtk3/test_catview.py'
--- tests/gtk3/test_catview.py	2012-09-18 06:38:40 +0000
+++ tests/gtk3/test_catview.py	2012-09-24 15:24:22 +0000
@@ -6,11 +6,9 @@
 from tests.utils import (
     do_events,
     do_events_with_sleep,
-    FakedCache,
     get_test_db,
     get_test_gtk3_icon_cache,
     make_recommender_agent_recommend_me_dict,
-    ObjectWithSignals,
     setup_test_env,
 )
 setup_test_env()
@@ -19,7 +17,6 @@
 import softwarecenter.paths
 
 from softwarecenter.db.appfilter import AppFilter
-from softwarecenter.db.database import StoreDatabase
 from softwarecenter.enums import (SortMethods,
                                   TransactionTypes,
                                   RecommenderFeedbackActions)
@@ -35,10 +32,10 @@
     def setUpClass(cls):
         cls.db = get_test_db()
 
-    def setUp(self):
+    def setUp(self, selected_category=None):
         self._cat = None
         self._app = None
-        self.win = get_test_window_catview(self.db)
+        self.win = get_test_window_catview(self.db, selected_category)
         self.addCleanup(self.win.destroy)
         self.notebook = self.win.get_child()
         self.lobby = self.win.get_data("lobby")
@@ -122,19 +119,12 @@
     @patch('softwarecenter.ui.gtk3.widgets.recommendations.RecommenderAgent'
            '.post_submit_profile')
     def setUp(self, mock_query, mock_recommender_is_opted_in, mock_sso):
-        self._cat = None
-        self._app = None
         # patch the recommender to specify that we are not opted-in at
         # the start of each test
         mock_recommender_is_opted_in.return_value = False
         # we specify the "Internet" category because we do specific checks
         # in the following tests that depend on this being the category choice
-        self.win = get_test_window_catview(self.db,
-                                           selected_category="Internet")
-        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")
+        super(RecommendationsTestCase, self).setUp(selected_category="Internet")
         self.rec_panel = self.lobby.recommended_for_you_panel
 
     def test_recommended_for_you_opt_in_display(self):
@@ -371,138 +361,6 @@
                                     mock_result)
         do_events()
 
-
-class ExhibitsTestCase(unittest.TestCase):
-    """The test suite for the exhibits carousel."""
-
-    def setUp(self):
-        self.cache = FakedCache()
-        self.db = StoreDatabase(cache=self.cache)
-        self.lobby = lobbyview.LobbyView(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], lobbyview.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(lobbyview, '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], lobbyview.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(lobbyview, '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(lobbyview, '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_with_url(self):
-        # available exhibit
-        exhibit = Mock()
-        exhibit.package_names = ''
-        exhibit.click_url = 'http://example.com'
-        exhibit.banner_url = 'banner'
-        exhibit.title_translated = ''
-
-        sca = ObjectWithSignals()
-        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
-                                              [exhibit])
-
-        with patch.object(lobbyview, 'SoftwareCenterAgent', lambda: sca):
-            # add the banners
-            self.lobby._append_banner_ads()
-            # fake click
-            alloc = self.lobby.exhibit_banner.get_allocation()
-            mock_event = Mock()
-            mock_event.x = alloc.x
-            mock_event.y = alloc.y
-            with patch.object(self.lobby.exhibit_banner, 'emit') as mock_emit:
-                self.lobby.exhibit_banner.on_button_press(None, mock_event)
-                self.lobby.exhibit_banner.on_button_release(None, mock_event)
-                mock_emit.assert_called()
-                signal_name = mock_emit.call_args[0][0]
-                call_exhibit = mock_emit.call_args[0][1]
-                self.assertEqual(signal_name, "show-exhibits-clicked")
-                self.assertEqual(call_exhibit.click_url, "http://example.com")
-
-    def test_exhibit_with_featured_exhibit(self):
-        """ regression test for bug #1023777 """
-        sca = ObjectWithSignals()
-        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
-                                              [lobbyview.FeaturedExhibit()])
-
-        with patch.object(lobbyview, 'SoftwareCenterAgent', lambda: sca):
-            # add the banners
-            self.lobby._append_banner_ads()
-            # fake click
-            alloc = self.lobby.exhibit_banner.get_allocation()
-            mock_event = Mock()
-            mock_event.x = alloc.x
-            mock_event.y = alloc.y
-            with patch.object(self.lobby, 'emit') as mock_emit:
-                self.lobby.exhibit_banner.on_button_press(None, mock_event)
-                self.lobby.exhibit_banner.on_button_release(None, mock_event)
-                mock_emit.assert_called()
-                signal_name = mock_emit.call_args[0][0]
-                call_category = mock_emit.call_args[0][1]
-                self.assertEqual(signal_name, "category-selected")
-                self.assertEqual(call_category.name, "Our star apps")
         
 if __name__ == "__main__":
     unittest.main()

=== added file 'tests/gtk3/test_exhibits.py'
--- tests/gtk3/test_exhibits.py	1970-01-01 00:00:00 +0000
+++ tests/gtk3/test_exhibits.py	2012-09-24 15:24:22 +0000
@@ -0,0 +1,182 @@
+import os
+import unittest
+
+from mock import patch, Mock
+
+from tests.utils import (
+    FakedCache,
+    ObjectWithSignals,
+    setup_test_env,
+)
+setup_test_env()
+
+
+from softwarecenter.db.database import StoreDatabase
+from softwarecenter.ui.gtk3.views import lobbyview
+from softwarecenter.ui.gtk3.widgets.exhibits import (
+    _HtmlRenderer,
+    )
+
+
+class ExhibitsTestCase(unittest.TestCase):
+    """The test suite for the exhibits carousel."""
+
+    def setUp(self):
+        self.cache = FakedCache()
+        self.db = StoreDatabase(cache=self.cache)
+        self.lobby = lobbyview.LobbyView(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], lobbyview.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(lobbyview, '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], lobbyview.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_urls = ['banner']
+        exhibit.title_translated = ''
+
+        self.cache[u'foobarbaz'] = Mock()
+
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca, [exhibit])
+
+        with patch.object(lobbyview, '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_urls = ['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(lobbyview, '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_with_url(self):
+        # available exhibit
+        exhibit = Mock()
+        exhibit.package_names = ''
+        exhibit.click_url = 'http://example.com'
+        exhibit.banner_urls = ['banner']
+        exhibit.title_translated = ''
+
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
+                                              [exhibit])
+
+        with patch.object(lobbyview, 'SoftwareCenterAgent', lambda: sca):
+            # add the banners
+            self.lobby._append_banner_ads()
+            # fake click
+            alloc = self.lobby.exhibit_banner.get_allocation()
+            mock_event = Mock()
+            mock_event.x = alloc.x
+            mock_event.y = alloc.y
+            with patch.object(self.lobby.exhibit_banner, 'emit') as mock_emit:
+                self.lobby.exhibit_banner.on_button_press(None, mock_event)
+                self.lobby.exhibit_banner.on_button_release(None, mock_event)
+                mock_emit.assert_called()
+                signal_name = mock_emit.call_args[0][0]
+                call_exhibit = mock_emit.call_args[0][1]
+                self.assertEqual(signal_name, "show-exhibits-clicked")
+                self.assertEqual(call_exhibit.click_url, "http://example.com")
+
+    def test_exhibit_with_featured_exhibit(self):
+        """ regression test for bug #1023777 """
+        sca = ObjectWithSignals()
+        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
+                                              [lobbyview.FeaturedExhibit()])
+
+        with patch.object(lobbyview, 'SoftwareCenterAgent', lambda: sca):
+            # add the banners
+            self.lobby._append_banner_ads()
+            # fake click
+            alloc = self.lobby.exhibit_banner.get_allocation()
+            mock_event = Mock()
+            mock_event.x = alloc.x
+            mock_event.y = alloc.y
+            with patch.object(self.lobby, 'emit') as mock_emit:
+                self.lobby.exhibit_banner.on_button_press(None, mock_event)
+                self.lobby.exhibit_banner.on_button_release(None, mock_event)
+                mock_emit.assert_called()
+                signal_name = mock_emit.call_args[0][0]
+                call_category = mock_emit.call_args[0][1]
+                self.assertEqual(signal_name, "category-selected")
+                self.assertEqual(call_category.name, "Our star apps")
+
+
+class HtmlRendererTestCase(unittest.TestCase):
+
+    def test_multiple_images(self):
+        downloader = ObjectWithSignals()
+        downloader.download_file = lambda *args, **kwargs: downloader.emit(
+            "file-download-complete", downloader, os.path.basename(args[0]))
+
+        with patch("softwarecenter.ui.gtk3.widgets.exhibits."
+                   "SimpleFileDownloader", lambda: downloader):
+            renderer = _HtmlRenderer()
+            mock_exhibit = Mock()
+            mock_exhibit.banner_urls = [
+                "http://example.com/path1/banner1.png",
+                "http://example.com/path2/banner2.png",
+                ]
+            mock_exhibit.html = "url('/path1/banner1.png')#"\
+                                "url('/path2/banner2.png')"
+
+            renderer.set_exhibit(mock_exhibit)
+            # assert the stuff we expected to get downloaded got downloaded
+            self.assertEqual(
+                renderer._downloaded_banner_images,
+                ["banner1.png", "banner2.png"])
+            # test that the path mangling worked
+            self.assertEqual(
+                mock_exhibit.html, "url('banner1.png')#url('banner2.png')")
+
+if __name__ == "__main__":
+    unittest.main()