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

[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]

3035. By Michael Vogt on 2012-05-22

merge 5.2 and resolve conflicts

[Gary Lasker (gary-lasker)]

Very nice, thank you, mvo!

review: Approve

=== modified file 'softwarecenter/testutils.py'
--- softwarecenter/testutils.py	2012-05-21 21:33:20 +0000
+++ softwarecenter/testutils.py	2012-05-22 15:42:19 +0000
@@ -144,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

=== modified file 'softwarecenter/ui/gtk3/views/catview_gtk.py'
--- softwarecenter/ui/gtk3/views/catview_gtk.py	2012-05-22 14:36:03 +0000
+++ softwarecenter/ui/gtk3/views/catview_gtk.py	2012-05-22 15:42:19 +0000
@@ -728,21 +728,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_catview.py'
--- test/gtk3/test_catview.py	2012-05-22 14:18:49 +0000
+++ test/gtk3/test_catview.py	2012-05-22 15:42:19 +0000
@@ -1,4 +1,3 @@
-import time
 import unittest
 
 from gi.repository import Gtk
@@ -13,6 +12,8 @@
 from softwarecenter.db.database import StoreDatabase
 from softwarecenter.enums import SortMethods
 from softwarecenter.testutils import (
+    do_events_with_sleep,
+    do_events,
     FakedCache,
     get_test_db,
     make_recommender_agent_recommend_me_dict,
@@ -24,49 +25,51 @@
 from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
 
 
-class TestCatView(unittest.TestCase):
+class CatViewBaseTestCase(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.db = get_test_db()
 
     def setUp(self):
         self._cat = None
-        self.db = get_test_db()
+        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):
         self._cat = category
 
+
+class TopAndWhatsNewTestCase(CatViewBaseTestCase):
+
     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
-        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)
 
     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
-        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')
@@ -105,145 +108,109 @@
         win.add(scroll)
         win.show()
         # test visibility
-        self._p()
+        do_events()
         self.assertFalse(view.whats_new_frame.get_property("visible"))
-        self._p()
-
-    def test_recommended_for_you_opt_in_display(self):
+
+
+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
-        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
 
-        # 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()
-        self.assertEqual(rec_panel.spinner_notebook.get_current_page(),
+        do_events()
+        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
                          FramedHeaderBox.CONTENT)
-        self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
+        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):
+    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
-        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
 
-        # 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
-        rec_panel.opt_in_button.emit('clicked')
-        self._p()
-        self.assertEqual(rec_panel.spinner_notebook.get_current_page(),
+        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(rec_panel.opt_in_vbox.get_property("visible"))
+        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_query, mock_get_recommender_opted_in):
         # 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
 
-        # 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
-        rec_panel.opt_in_button.emit('clicked')
-        self._p()
-        rec_panel._update_recommended_for_you_content()
-        self._p()
+        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
-        for_you = lobby.recommended_for_you_panel.recommended_for_you_cat
+        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(rec_panel.spinner_notebook.get_current_page(),
+        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
                          SpinnerNotebook.CONTENT_PAGE)
-        self._p()
+        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")
 
     # 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_recommended_for_you_display_recommendations_not_opted_in(self,
-            mock_query):
+            mock_query, mock_get_recommender_opted_in):
         # 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
 
-        # 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()
+        self.notebook.next_page()
 
-        subcat_view = win.get_data("subcat")
-        self._p()
-        self.assertFalse(subcat_view.recommended_for_you_in_cat.get_property(
-            "visible"))
+        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_recommended_for_you_display_recommendations_opted_in(self, mock_query):
+    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
-        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
 
-        # 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()
+        self.notebook.next_page()
 
-        subcat_view = win.get_data("subcat")
-        rec_cat_panel = subcat_view.recommended_for_you_in_cat
-        self._p()
+        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,
@@ -258,25 +225,21 @@
         self.assertEqual(rec_cat_panel.spinner_notebook.get_current_page(),
                          SpinnerNotebook.CONTENT_PAGE)
         # check that the tiles themselves are 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"))
-        self._p()
+        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")
 
-    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."""