← Back to branch summary

~ubuntu-branches/ubuntu/quantal/software-center/quantal-updates

« back to all changes in this revision

Viewing changes to test/gtk3/test_catview.py

  • Committer: Package Import Robot
  • Author(s): Michael Vogt, Robert Roth, Sebastian Heinlein, Robert Ancell, Michael Vogt
  • Date: 2012-06-01 19:54:38 UTC
  • mfrom: (192.1.1 precise-proposed)
  • Revision ID: package-import@ubuntu.com-20120601195438-wvbelmfgll4h1kuq
Tags: 5.3.0
https://launchpad.net/bugs/872760
https://launchpad.net/bugs/927426
https://launchpad.net/bugs/747172
[ Robert Roth ]
* lp:~evfool/software-center/lp872760:
  - Updated the category name for the RasterGraphics subcategory 
    from Painting & Editing to Painting (LP: #872760)
* lp:~evfool/software-center/lp927426:
  - Changed the reference to store to Software Center, as requested in 
    bug LP: #927426
* lp:~evfool/software-center/specs-update:
  - Moved the recommended applications section after the package details
  - Moved the addon status bar after the addons list
  - Aligned the star ratings widget vertically with the titles
  - Added some vertical padding before the star ratings widget to look 
     bette
* lp:~evfool/software-center/history-enhancements:
  - display text-sized icons in history, not double-sized ones
  - use padding between the icon and the package name
  - right-align the time of the history action
  - display the action +time (installed/updated/removed) if the 
    filter is all changes, otherwise only display the time
  - removed markup from the translatable string, to avoid translation
    mistakes with markup

[ Sebastian Heinlein ]
* lp:~glatzor/software-center/remove-workaround-747172:
  - remove old workaround that should be no longer needed (LP: #747172)
    
[ Robert Ancell ]
* lp:~robert-ancell/software-center/no-lpi:
  - Drop Launchpad integration

[ Michael Vogt ]
* lp:~mvo/software-center/piston-generic-helper-offline-mode:
  - add support for offline mode to the generic helper just like
    for piston_get_reviews_helper.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/gtk3/test_catview.py
 
1
import unittest
 
2
 
1
3
from gi.repository import Gtk
2
 
import time
3
 
import unittest
4
4
from mock import patch, Mock
5
5
 
6
6
from testutils import setup_test_env
7
7
setup_test_env()
8
8
 
 
9
import softwarecenter.distro
 
10
import softwarecenter.paths
 
11
 
 
12
from softwarecenter.db.database import StoreDatabase
9
13
from softwarecenter.enums import SortMethods
10
 
from softwarecenter.testutils import (get_test_db,
11
 
                                      make_recommender_agent_recommend_me_dict)
12
 
 
13
 
class TestCatView(unittest.TestCase):
 
14
from softwarecenter.testutils import (
 
15
    do_events_with_sleep,
 
16
    do_events,
 
17
    FakedCache,
 
18
    get_test_db,
 
19
    make_recommender_agent_recommend_me_dict,
 
20
    ObjectWithSignals,
 
21
)
 
22
from softwarecenter.ui.gtk3.views import catview_gtk
 
23
from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
 
24
from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
 
25
from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
 
26
 
 
27
 
 
28
class CatViewBaseTestCase(unittest.TestCase):
 
29
 
 
30
    @classmethod
 
31
    def setUpClass(cls):
 
32
        cls.db = get_test_db()
14
33
 
15
34
    def setUp(self):
16
 
        self.db = get_test_db()
 
35
        self._cat = None
 
36
        self.win = get_test_window_catview(self.db)
 
37
        self.addCleanup(self.win.destroy)
 
38
        self.notebook = self.win.get_child()
 
39
        self.lobby = self.win.get_data("lobby")
 
40
        self.subcat_view = self.win.get_data("subcat")
 
41
        self.rec_panel = self.lobby.recommended_for_you_panel
17
42
 
18
43
    def _on_category_selected(self, subcatview, category):
19
 
        #print "**************", subcatview, category
20
44
        self._cat = category
21
 
    
22
 
    def test_subcatview_top_rated(self):
23
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
24
 
        # get the widgets we need
25
 
        win = get_test_window_catview()
26
 
        lobby = win.get_data("lobby")
27
 
 
 
45
 
 
46
 
 
47
class TopAndWhatsNewTestCase(CatViewBaseTestCase):
 
48
 
 
49
    def test_top_rated(self):
28
50
        # simulate review-stats refresh
29
 
        lobby._update_top_rated_content = Mock()
30
 
        lobby.reviews_loader.emit("refresh-review-stats-finished", [])
31
 
        self.assertTrue(lobby._update_top_rated_content.called)
 
51
        self.lobby._update_top_rated_content = Mock()
 
52
        self.lobby.reviews_loader.emit("refresh-review-stats-finished", [])
 
53
        self.assertTrue(self.lobby._update_top_rated_content.called)
32
54
 
33
55
        # test clicking top_rated
34
 
        lobby.connect("category-selected", self._on_category_selected)
35
 
        lobby.top_rated_frame.more.clicked()
36
 
        self._p()
 
56
        self.lobby.connect("category-selected", self._on_category_selected)
 
57
        self.lobby.top_rated_frame.more.clicked()
 
58
        do_events()
37
59
        self.assertNotEqual(self._cat, None)
38
60
        self.assertEqual(self._cat.name, "Top Rated")
39
61
        self.assertEqual(self._cat.sortmode, SortMethods.BY_TOP_RATED)
40
 
        win.destroy()
41
 
 
42
 
    def test_subcatview_new(self):
43
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
44
 
        # get the widgets we need
45
 
        win = get_test_window_catview()
46
 
        lobby = win.get_data("lobby")
47
 
 
 
62
 
 
63
    def test_new(self):
48
64
        # test db reopen triggers whats-new update
49
 
        lobby._update_whats_new_content = Mock()
50
 
        lobby.db.emit("reopen")
51
 
        self.assertTrue(lobby._update_whats_new_content.called)
 
65
        self.lobby._update_whats_new_content = Mock()
 
66
        self.lobby.db.emit("reopen")
 
67
        self.assertTrue(self.lobby._update_whats_new_content.called)
52
68
 
53
69
        # test clicking new
54
 
        lobby.connect("category-selected", self._on_category_selected)
55
 
        lobby.whats_new_frame.more.clicked()
56
 
        self._p()
 
70
        self.lobby.connect("category-selected", self._on_category_selected)
 
71
        self.lobby.whats_new_frame.more.clicked()
 
72
        do_events()
57
73
        self.assertNotEqual(self._cat, None)
58
74
        # encoding is utf-8 (since r2218, see category.py)
59
75
        self.assertEqual(self._cat.name, 'What\xe2\x80\x99s New')
60
76
        self.assertEqual(self._cat.sortmode, SortMethods.BY_CATALOGED_TIME)
61
 
        win.destroy()
62
77
 
63
 
    def test_subcatview_new_no_sort_info_yet(self):
 
78
    def test_new_no_sort_info_yet(self):
64
79
        # ensure that we don't show a empty "whats new" category
65
80
        # see LP: #865985
66
81
        from softwarecenter.testutils import get_test_db
68
83
        cache = db._aptcache
69
84
        # simulate a fresh install with no catalogedtime info
70
85
        del db._axi_values["catalogedtime"]
71
 
        
 
86
 
72
87
        from softwarecenter.testutils import get_test_gtk3_icon_cache
73
88
        icons = get_test_gtk3_icon_cache()
74
89
 
76
91
        apps_filter = AppFilter(db, cache)
77
92
 
78
93
        from softwarecenter.distro import get_distro
79
 
        import softwarecenter.paths
80
 
        from softwarecenter.paths import APP_INSTALL_PATH
81
94
        from softwarecenter.ui.gtk3.views.catview_gtk import LobbyViewGtk
82
 
        view = LobbyViewGtk(softwarecenter.paths.datadir, APP_INSTALL_PATH,
 
95
        view = LobbyViewGtk(softwarecenter.paths.datadir,
 
96
                            softwarecenter.paths.APP_INSTALL_PATH,
83
97
                            cache, db, icons, get_distro(), apps_filter)
84
98
        view.show()
85
99
 
86
100
        # gui
87
101
        win = Gtk.Window()
 
102
        self.addCleanup(win.destroy)
88
103
        win.set_size_request(800, 400)
89
104
 
90
105
        scroll = Gtk.ScrolledWindow()
93
108
        win.add(scroll)
94
109
        win.show()
95
110
        # test visibility
96
 
        self._p()
 
111
        do_events()
97
112
        self.assertFalse(view.whats_new_frame.get_property("visible"))
98
 
        self._p()
99
 
        win.destroy()
100
 
 
101
 
    def test_subcatview_recommended_for_you_opt_in_display(self):
102
 
    
103
 
        # patch the recommender UUID value to insure that we are not opted-in for this test
104
 
        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
105
 
        self.addCleanup(get_recommender_opted_in_patcher.stop)
106
 
        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
107
 
        mock_get_recommender_opted_in.return_value = False
108
 
        
109
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
110
 
        # get the widgets we need
111
 
        win = get_test_window_catview()
112
 
        lobby = win.get_data("lobby")
113
 
        rec_panel = lobby.recommended_for_you_panel
114
 
        self._p()
115
 
        from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
116
 
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == FramedHeaderBox.CONTENT)
117
 
        self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
118
 
        win.destroy()
119
 
        
120
 
    # patch out the agent query method to avoid making the actual server call
121
 
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
122
 
           '.post_submit_profile')
123
 
    def test_subcatview_recommended_for_you_spinner_display(self, mock_query):
124
 
    
125
 
        # patch the recommender UUID value to insure that we are not opted-in for this test
126
 
        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
127
 
        self.addCleanup(get_recommender_opted_in_patcher.stop)
128
 
        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
129
 
        mock_get_recommender_opted_in.return_value = False
130
 
        
131
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
132
 
        # get the widgets we need
133
 
        win = get_test_window_catview()
134
 
        lobby = win.get_data("lobby")
135
 
        rec_panel = lobby.recommended_for_you_panel
136
 
        self._p()
137
 
        # click the opt-in button to initiate the process, this will show the spinner
138
 
        rec_panel.opt_in_button.emit('clicked')
139
 
        self._p()
140
 
        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
141
 
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.SPINNER_PAGE)
142
 
        self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
143
 
        win.destroy()
144
 
 
145
 
    # patch out the agent query method to avoid making the actual server call
146
 
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
147
 
           '.post_submit_profile')
148
 
    def test_subcatview_recommended_for_you_display_recommendations(self, mock_query):
149
 
    
150
 
        # patch the recommender UUID value to insure that we are not opted-in for this test
151
 
        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
152
 
        self.addCleanup(get_recommender_opted_in_patcher.stop)
153
 
        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
154
 
        mock_get_recommender_opted_in.return_value = False
155
 
        
156
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
157
 
        # get the widgets we need
158
 
        win = get_test_window_catview()
159
 
        lobby = win.get_data("lobby")
160
 
        rec_panel = lobby.recommended_for_you_panel
161
 
        self._p()
162
 
        # click the opt-in button to initiate the process, this will show the spinner
163
 
        rec_panel.opt_in_button.emit('clicked')
164
 
        self._p()
165
 
        rec_panel._update_recommended_for_you_content()
166
 
        self._p()
 
113
 
 
114
 
 
115
class RecommendationsTestCase(CatViewBaseTestCase):
 
116
    """The test suite for the recommendations ."""
 
117
 
 
118
    # FIXME: reenable
 
119
    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
 
120
    def disabled_test_recommended_for_you_opt_in_display(
 
121
                                        self, mock_get_recommender_opted_in):
 
122
        # patch the recommender UUID value to ensure that we are not opted-in
 
123
        # for this test
 
124
        mock_get_recommender_opted_in.return_value = False
 
125
 
 
126
        do_events_with_sleep()
 
127
        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
 
128
                         FramedHeaderBox.CONTENT)
 
129
        self.assertTrue(self.rec_panel.opt_in_vbox.get_property("visible"))
 
130
 
 
131
    # FIXME: reenable
 
132
    # patch out the agent query method to avoid making the actual server call
 
133
    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
 
134
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
 
135
           '.post_submit_profile')
 
136
    def disabled_test_recommended_for_you_spinner_display(
 
137
                             self, mock_query, mock_get_recommender_opted_in):
 
138
        # patch the recommender UUID value to insure that we are not opted-in
 
139
        # for this test
 
140
        mock_get_recommender_opted_in.return_value = False
 
141
 
 
142
        # click the opt-in button to initiate the process,
 
143
        # this will show the spinner
 
144
        self.rec_panel.opt_in_button.emit('clicked')
 
145
        do_events_with_sleep()
 
146
        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
 
147
                         SpinnerNotebook.SPINNER_PAGE)
 
148
        self.assertTrue(self.rec_panel.opt_in_vbox.get_property("visible"))
 
149
 
 
150
    # patch out the agent query method to avoid making the actual server call
 
151
    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
 
152
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
 
153
           '.post_submit_profile')
 
154
    def test_recommended_for_you_display_recommendations(self,
 
155
                                   mock_query, mock_get_recommender_opted_in):
 
156
        # patch the recommender UUID value to insure that we are not opted-in
 
157
        # for this test
 
158
        mock_get_recommender_opted_in.return_value = False
 
159
 
 
160
        # click the opt-in button to initiate the process,
 
161
        # this will show the spinner
 
162
        self.rec_panel.opt_in_button.emit('clicked')
 
163
        do_events()
 
164
        self.rec_panel._update_recommended_for_you_content()
 
165
        do_events()
167
166
        # we fake the callback from the agent here
168
 
        lobby.recommended_for_you_panel.recommended_for_you_cat._recommend_me_result(
169
 
                                None,
170
 
                                make_recommender_agent_recommend_me_dict())
171
 
        self.assertNotEqual(
172
 
                lobby.recommended_for_you_panel.recommended_for_you_cat.get_documents(self.db), [])
173
 
        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
174
 
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
175
 
        self._p()
 
167
        for_you = self.lobby.recommended_for_you_panel.recommended_for_you_cat
 
168
        for_you._recommend_me_result(None,
 
169
            make_recommender_agent_recommend_me_dict())
 
170
        self.assertNotEqual(for_you.get_documents(self.db), [])
 
171
        self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
 
172
                         SpinnerNotebook.CONTENT_PAGE)
 
173
        do_events()
176
174
        # test clicking recommended_for_you More button
177
 
        lobby.connect("category-selected", self._on_category_selected)
178
 
        lobby.recommended_for_you_panel.more.clicked()
179
 
        self._p()
 
175
        self.lobby.connect("category-selected", self._on_category_selected)
 
176
        self.lobby.recommended_for_you_panel.more.clicked()
 
177
        # this is delayed for some reason so we need to sleep here
 
178
        do_events_with_sleep()
180
179
        self.assertNotEqual(self._cat, None)
181
180
        self.assertEqual(self._cat.name, "Recommended For You")
182
 
        win.destroy()
183
 
        
 
181
 
184
182
    # patch out the agent query method to avoid making the actual server call
 
183
    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
185
184
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
186
185
           '.query_recommend_me')
187
 
    def test_subcatview_recommended_for_you_display_recommendations_not_opted_in(self, mock_query):
188
 
    
189
 
        # patch the recommender UUID value to insure that we are not opted-in for this test
190
 
        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
191
 
        self.addCleanup(get_recommender_opted_in_patcher.stop)
192
 
        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
 
186
    def test_recommended_for_you_display_recommendations_not_opted_in(self,
 
187
            mock_query, mock_get_recommender_opted_in):
 
188
        # patch the recommender UUID value to insure that we are not opted-in
 
189
        # for this test
193
190
        mock_get_recommender_opted_in.return_value = False
194
 
        
195
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
196
 
        # get the widgets we need
197
 
        win = get_test_window_catview()
 
191
 
198
192
        # we want to work in the "subcat" view
199
 
        notebook = win.get_child()
200
 
        notebook.next_page()
201
 
        
202
 
        subcat_view = win.get_data("subcat")
203
 
        self._p()
204
 
        self.assertFalse(subcat_view.recommended_for_you_in_cat.get_property("visible"))
205
 
        win.destroy()
206
 
        
 
193
        self.notebook.next_page()
 
194
 
 
195
        do_events()
 
196
        visible = self.subcat_view.recommended_for_you_in_cat.get_property(
 
197
            "visible")
 
198
        self.assertFalse(visible)
 
199
 
207
200
    # patch out the agent query method to avoid making the actual server call
 
201
    @patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
208
202
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
209
203
           '.query_recommend_me')
210
 
    def test_subcatview_recommended_for_you_display_recommendations_opted_in(self, mock_query):
211
 
    
212
 
        # patch the recommender UUID value to insure that we are not opted-in for this test
213
 
        get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
214
 
        self.addCleanup(get_recommender_opted_in_patcher.stop)
215
 
        mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
 
204
    def test_recommended_for_you_display_recommendations_opted_in(
 
205
        self, mock_query, mock_get_recommender_opted_in):
 
206
        # patch the recommender UUID value to insure that we are not opted-in
 
207
        # for this test
216
208
        mock_get_recommender_opted_in.return_value = True
217
 
        
218
 
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
219
 
        # get the widgets we need
220
 
        win = get_test_window_catview()
 
209
 
221
210
        # we want to work in the "subcat" view
222
 
        notebook = win.get_child()
223
 
        notebook.next_page()
224
 
        
225
 
        subcat_view = win.get_data("subcat")
226
 
        rec_cat_panel = subcat_view.recommended_for_you_in_cat
227
 
        self._p()
 
211
        self.notebook.next_page()
 
212
 
 
213
        rec_cat_panel = self.subcat_view.recommended_for_you_in_cat
228
214
        rec_cat_panel._update_recommended_for_you_content()
229
 
        self._p()
 
215
        do_events()
230
216
        # we fake the callback from the agent here
231
217
        rec_cat_panel.recommended_for_you_cat._recommend_me_result(
232
218
                                None,
233
219
                                make_recommender_agent_recommend_me_dict())
234
 
        result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(self.db)
 
220
        result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(
 
221
            self.db)
235
222
        self.assertNotEqual(result_docs, [])
236
 
        # check that we are getting the correct number of results, corresponding
237
 
        # to the following Internet items:
 
223
        # check that we are getting the correct number of results,
 
224
        # corresponding to the following Internet items:
238
225
        #   Mangler, Midori, Midori Private Browsing, Psi
239
226
        self.assertTrue(len(result_docs) == 4)
240
 
        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
241
 
        self.assertTrue(rec_cat_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
 
227
        self.assertEqual(rec_cat_panel.spinner_notebook.get_current_page(),
 
228
                         SpinnerNotebook.CONTENT_PAGE)
242
229
        # check that the tiles themselves are visible
243
 
        self._p()
244
 
        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property("visible"))
245
 
        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children()[0].title.get_property("visible"))
246
 
        self._p()
 
230
        do_events()
 
231
        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property(
 
232
            "visible"))
 
233
        self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children(
 
234
            )[0].title.get_property("visible"))
 
235
        do_events()
247
236
        # test clicking recommended_for_you More button
248
 
        subcat_view.connect("category-selected", self._on_category_selected)
 
237
        self.subcat_view.connect(
 
238
            "category-selected", self._on_category_selected)
249
239
        rec_cat_panel.more.clicked()
250
 
        self._p()
 
240
        # this is delayed for some reason so we need to sleep here
 
241
        do_events_with_sleep()
251
242
        self.assertNotEqual(self._cat, None)
252
243
        self.assertEqual(self._cat.name, "Recommended For You in Internet")
253
 
        win.destroy()
254
 
 
255
 
    def _p(self):
256
 
        for i in range(5):
257
 
            time.sleep(0.1)
258
 
            while Gtk.events_pending():
259
 
                Gtk.main_iteration()
260
 
 
 
244
 
 
245
 
 
246
class ExhibitsTestCase(unittest.TestCase):
 
247
    """The test suite for the exhibits carousel."""
 
248
 
 
249
    def setUp(self):
 
250
        self.datadir = softwarecenter.paths.datadir
 
251
        self.desktopdir = softwarecenter.paths.APP_INSTALL_PATH
 
252
        self.cache = FakedCache()
 
253
        self.db = StoreDatabase(cache=self.cache)
 
254
        self.lobby = catview_gtk.LobbyViewGtk(datadir=self.datadir,
 
255
            desktopdir=self.desktopdir, cache=self.cache, db=self.db,
 
256
            icons=None, apps_filter=None)
 
257
        self.addCleanup(self.lobby.destroy)
 
258
 
 
259
    def _get_banner_from_lobby(self):
 
260
        return self.lobby.vbox.get_children()[-1].get_child()
 
261
 
 
262
    def test_featured_exhibit_by_default(self):
 
263
        """Show the featured exhibit before querying the remote service."""
 
264
        self.lobby._append_banner_ads()
 
265
 
 
266
        banner = self._get_banner_from_lobby()
 
267
        self.assertEqual(1, len(banner.exhibits))
 
268
        self.assertIsInstance(banner.exhibits[0], catview_gtk.FeaturedExhibit)
 
269
 
 
270
    def test_no_exhibit_if_not_available(self):
 
271
        """The exhibit should not be shown if the package is not available."""
 
272
        exhibit = Mock()
 
273
        exhibit.package_names = u'foobarbaz'
 
274
 
 
275
        sca = ObjectWithSignals()
 
276
        sca.query_exhibits = lambda: sca.emit('exhibits', sca, [exhibit])
 
277
 
 
278
        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
 
279
            self.lobby._append_banner_ads()
 
280
 
 
281
        banner = self._get_banner_from_lobby()
 
282
        self.assertEqual(1, len(banner.exhibits))
 
283
        self.assertIsInstance(banner.exhibits[0], catview_gtk.FeaturedExhibit)
 
284
 
 
285
    def test_exhibit_if_available(self):
 
286
        """The exhibit should be shown if the package is available."""
 
287
        exhibit = Mock()
 
288
        exhibit.package_names = u'foobarbaz'
 
289
        exhibit.banner_url = 'banner'
 
290
        exhibit.title_translated = ''
 
291
 
 
292
        self.cache[u'foobarbaz'] = Mock()
 
293
 
 
294
        sca = ObjectWithSignals()
 
295
        sca.query_exhibits = lambda: sca.emit('exhibits', sca, [exhibit])
 
296
 
 
297
        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
 
298
            self.lobby._append_banner_ads()
 
299
 
 
300
        banner = self._get_banner_from_lobby()
 
301
        self.assertEqual(1, len(banner.exhibits))
 
302
        self.assertIs(banner.exhibits[0], exhibit)
 
303
 
 
304
    def test_exhibit_if_mixed_availability(self):
 
305
        """The exhibit should be shown even if some are not available."""
 
306
        # available exhibit
 
307
        exhibit = Mock()
 
308
        exhibit.package_names = u'foobarbaz'
 
309
        exhibit.banner_url = 'banner'
 
310
        exhibit.title_translated = ''
 
311
 
 
312
        self.cache[u'foobarbaz'] = Mock()
 
313
 
 
314
        # not available exhibit
 
315
        other = Mock()
 
316
        other.package_names = u'not-there'
 
317
 
 
318
        sca = ObjectWithSignals()
 
319
        sca.query_exhibits = lambda: sca.emit('exhibits', sca,
 
320
                                              [exhibit, other])
 
321
 
 
322
        with patch.object(catview_gtk, 'SoftwareCenterAgent', lambda: sca):
 
323
            self.lobby._append_banner_ads()
 
324
 
 
325
        banner = self._get_banner_from_lobby()
 
326
        self.assertEqual(1, len(banner.exhibits))
 
327
        self.assertIs(banner.exhibits[0], exhibit)
261
328
 
262
329
 
263
330
if __name__ == "__main__":