← Back to branch summary

~mvo/software-center/qml-banners2

« back to all changes in this revision

Viewing changes to test/gtk3/test_catview.py

  • Committer: Kiwinote
  • Date: 2012-03-15 22:36:31 UTC
  • mfrom: (2867 trunk)
  • mto: This revision was merged to the branch mainline in revision 2881.
  • Revision ID: kiwinote@gmail.com-20120315223631-lvea6t5sydpkkqni
merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/gtk3/test_catview.py
1
 
from gi.repository import Gtk, GObject
 
1
from gi.repository import Gtk
2
2
import time
3
3
import unittest
4
4
from mock import patch, Mock
97
97
        self.assertFalse(view.whats_new_frame.get_property("visible"))
98
98
        self._p()
99
99
        win.destroy()
100
 
        
 
100
 
101
101
    def test_subcatview_recommended_for_you_opt_in_display(self):
102
102
    
103
103
        # patch the recommender UUID value to insure that we are not opted-in for this test
104
 
        get_recommender_uuid_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent._get_recommender_uuid')
105
 
        self.addCleanup(get_recommender_uuid_patcher.stop)
106
 
        mock_get_recommender_uuid = get_recommender_uuid_patcher.start()
107
 
        mock_get_recommender_uuid.return_value = ""
 
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
108
        
109
109
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
110
110
        # get the widgets we need
123
123
    def test_subcatview_recommended_for_you_spinner_display(self, mock_query):
124
124
    
125
125
        # patch the recommender UUID value to insure that we are not opted-in for this test
126
 
        get_recommender_uuid_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent._get_recommender_uuid')
127
 
        self.addCleanup(get_recommender_uuid_patcher.stop)
128
 
        mock_get_recommender_uuid = get_recommender_uuid_patcher.start()
129
 
        mock_get_recommender_uuid.return_value = ""
 
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
130
        
131
131
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
132
132
        # get the widgets we need
137
137
        # click the opt-in button to initiate the process, this will show the spinner
138
138
        rec_panel.opt_in_button.emit('clicked')
139
139
        self._p()
140
 
        from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
141
 
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == FramedHeaderBox.SPINNER)
 
140
        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
 
141
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.SPINNER_PAGE)
142
142
        self.assertTrue(rec_panel.opt_in_vbox.get_property("visible"))
143
 
        # now pretent that we got data and ensure its displayed
144
 
        rec_panel._update_recommended_for_you_content()
145
 
        rec_panel.recommended_for_you_cat._recommend_me_result(
146
 
            None, make_recommender_agent_recommend_me_dict())
147
 
        self._p()
148
 
        self.assertTrue(rec_panel.recommended_for_you_content.get_property("visible"))
149
 
        self.assertFalse(rec_panel.opt_in_vbox.get_property("visible"))
150
 
        # exit after brief timeout
151
 
        TIMEOUT=100
152
 
        GObject.timeout_add(TIMEOUT, lambda: win.destroy())
153
 
        Gtk.main()
 
143
        win.destroy()
154
144
 
155
145
    # patch out the agent query method to avoid making the actual server call
156
146
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
158
148
    def test_subcatview_recommended_for_you_display_recommendations(self, mock_query):
159
149
    
160
150
        # patch the recommender UUID value to insure that we are not opted-in for this test
161
 
        get_recommender_uuid_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent._get_recommender_uuid')
162
 
        self.addCleanup(get_recommender_uuid_patcher.stop)
163
 
        mock_get_recommender_uuid = get_recommender_uuid_patcher.start()
164
 
        mock_get_recommender_uuid.return_value = ""
 
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
165
155
        
166
156
        from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
167
157
        # get the widgets we need
180
170
                                make_recommender_agent_recommend_me_dict())
181
171
        self.assertNotEqual(
182
172
                lobby.recommended_for_you_panel.recommended_for_you_cat.get_documents(self.db), [])
183
 
        from softwarecenter.ui.gtk3.widgets.containers import FramedHeaderBox
184
 
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == FramedHeaderBox.CONTENT)
 
173
        from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
 
174
        self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
185
175
        self._p()
186
176
        # test clicking recommended_for_you More button
187
177
        lobby.connect("category-selected", self._on_category_selected)
190
180
        self.assertNotEqual(self._cat, None)
191
181
        self.assertEqual(self._cat.name, "Recommended For You")
192
182
        win.destroy()
 
183
        
 
184
    # patch out the agent query method to avoid making the actual server call
 
185
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
 
186
           '.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()
 
193
        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()
 
198
        # 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
        
 
207
    # patch out the agent query method to avoid making the actual server call
 
208
    @patch('softwarecenter.backend.recagent.RecommenderAgent'
 
209
           '.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()
 
216
        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()
 
221
        # 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()
 
228
        rec_cat_panel._update_recommended_for_you_content()
 
229
        self._p()
 
230
        # we fake the callback from the agent here
 
231
        rec_cat_panel.recommended_for_you_cat._recommend_me_result(
 
232
                                None,
 
233
                                make_recommender_agent_recommend_me_dict())
 
234
        result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(self.db)
 
235
        self.assertNotEqual(result_docs, [])
 
236
        # check that we are getting the correct number of results, corresponding
 
237
        # to the following Internet items:
 
238
        #   Mangler, Midori, Midori Private Browsing, Psi
 
239
        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)
 
242
        # 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()
 
247
        # test clicking recommended_for_you More button
 
248
        subcat_view.connect("category-selected", self._on_category_selected)
 
249
        rec_cat_panel.more.clicked()
 
250
        self._p()
 
251
        self.assertNotEqual(self._cat, None)
 
252
        self.assertEqual(self._cat.name, "Recommended For You in Internet")
 
253
        win.destroy()
193
254
 
194
255
    def _p(self):
195
256
        for i in range(5):