← Back to branch summary

~nataliabidart/software-center/birth-of-a-website.1

« back to all changes in this revision

Viewing changes to tests/gtk3/test_appdetailsview.py

  • Committer: Michael Vogt
  • Date: 2012-06-11 15:58:19 UTC
  • mfrom: (3020.1.9 the-organizer)
  • Revision ID: michael.vogt@ubuntu.com-20120611155819-rfz96g7s7bysskrt
merged lp:~nataliabidart/software-center/the-organizer

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/gtk3/test_appdetailsview.py
1
 
#!/usr/bin/python
2
 
 
3
1
import unittest
4
2
 
5
 
from gi.repository import Gtk, GObject
6
3
from gettext import gettext as _
7
4
 
8
 
from testutils import setup_test_env
 
5
from tests.utils import (
 
6
    do_events,
 
7
    get_mock_app_from_real_app,
 
8
    get_test_db,
 
9
    make_recommend_app_data,
 
10
    setup_test_env,
 
11
)
9
12
setup_test_env()
10
13
 
11
14
from mock import Mock, patch
12
15
 
13
16
from softwarecenter.db.application import Application
14
 
from softwarecenter.testutils import get_mock_app_from_real_app, do_events, make_recommend_app_data
 
17
from softwarecenter.enums import PkgStates
15
18
from softwarecenter.ui.gtk3.widgets.labels import HardwareRequirementsBox
16
 
from softwarecenter.ui.gtk3.views.appdetailsview import get_test_window_appdetails
17
 
from softwarecenter.enums import PkgStates
18
19
from softwarecenter.region import REGION_WARNING_STRING
19
 
 
20
 
from test.test_database import make_purchased_app_details
21
 
 
22
 
 
23
 
 
24
 
# window destory timeout
25
 
TIMEOUT=100
26
 
 
27
 
class TestAppdetailsView(unittest.TestCase):
 
20
from tests.gtk3.windows import get_test_window_appdetails
 
21
from tests.test_database import make_purchased_app_details
 
22
 
 
23
 
 
24
class BaseViewTestCase(unittest.TestCase):
 
25
 
 
26
    db = get_test_db()
 
27
    app_name = "software-center"
 
28
    pkg_state = PkgStates.UNINSTALLED
28
29
 
29
30
    def setUp(self):
30
31
        self.win = get_test_window_appdetails()
 
32
        self.addCleanup(self.win.destroy)
31
33
        self.view = self.win.get_data("view")
32
34
 
33
 
    def tearDown(self):
34
 
        GObject.timeout_add(TIMEOUT, lambda: self.win.destroy())
35
 
        Gtk.main()
 
35
        app = Application("", self.app_name)
 
36
        self.app_mock = get_mock_app_from_real_app(app)
 
37
        self.app_mock.details.pkg_state = self.pkg_state
 
38
 
 
39
 
 
40
class TestAppdetailsView(BaseViewTestCase):
36
41
 
37
42
    def test_videoplayer(self):
38
43
        # show app with no video
50
55
        self.view.show_app(mock)
51
56
        do_events()
52
57
        self.assertTrue(self.view.videoplayer.get_property("visible"))
53
 
    
 
58
 
54
59
    def test_page_pkgstates(self):
55
 
        # show app 
 
60
        # show app
56
61
        app = Application("", "abiword")
57
62
        self.view.show_app(app)
58
63
        do_events()
59
 
        
 
64
 
60
65
        # check that the action bar is given initial focus in the view
61
66
        self.assertTrue(self.view.pkg_statusbar.button.is_focus())
62
67
 
74
79
        # the states and what labels we expect in the pkgstatusbar
75
80
        # first string is status text, second is button text
76
81
        pkg_states_to_labels = {
77
 
            PkgStates.INSTALLED : ("Purchased on 2011-11-20", "Remove"),
78
 
            PkgStates.UNINSTALLED : ('Free', 'Install'),
79
 
            PkgStates.NEEDS_PURCHASE : ('US$ 1.00', u'Buy\u2026'),
80
 
            PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED : ('Purchased on 2011-11-20', 'Install'),
 
82
            PkgStates.INSTALLED: ("Purchased on 2011-11-20", "Remove"),
 
83
            PkgStates.UNINSTALLED: ('Free', 'Install'),
 
84
            PkgStates.NEEDS_PURCHASE: ('US$ 1.00', u'Buy\u2026'),
 
85
            PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED:
 
86
                ('Purchased on 2011-11-20', 'Install'),
81
87
        }
82
88
        # this describes if a button is visible or invisible
83
89
        button_invisible = [ PkgStates.ERROR,
101
107
            if state in pkg_states_to_labels:
102
108
                label, button_label = pkg_states_to_labels[state]
103
109
                self.assertEqual(
104
 
                    self.view.pkg_statusbar.get_label(), 
 
110
                    self.view.pkg_statusbar.get_label(),
105
111
                    label.decode("utf-8"))
106
112
                self.assertEqual(
107
113
                    self.view.pkg_statusbar.get_button_label().decode("utf-8"),
117
123
                    "button visible error for state %s" % state)
118
124
            # regression test for #955005
119
125
            if state == PkgStates.NOT_FOUND:
120
 
                self.assertFalse(self.view.review_stats.get_property("visible"))
121
 
                self.assertFalse(self.view.reviews.get_property("visible"))
 
126
                self.assertFalse(self.view.review_stats.get_visible())
 
127
                self.assertFalse(self.view.reviews.get_visible())
122
128
 
123
129
    def test_app_icon_loading(self):
124
130
        # get icon
142
148
        self.view.show_app(app)
143
149
        self.view._add_where_is_it_commandline("apt")
144
150
        do_events()
145
 
        self.view._add_where_is_it_launcher("/usr/share/applications/ubuntu-software-center.desktop")
 
151
        self.view._add_where_is_it_launcher(
 
152
            "/usr/share/applications/ubuntu-software-center.desktop")
146
153
        do_events()
147
154
 
148
155
    def test_reviews_page(self):
149
 
        win = get_test_window_appdetails()
150
 
        view = win.get_data("view")
151
156
        # show s-c and click on more review
152
157
        app = Application("", "software-center")
153
 
        view.show_app(app)
154
 
        self.assertEqual(view._reviews_server_page, 1)
155
 
        view._on_more_reviews_clicked(None)
156
 
        self.assertEqual(view._reviews_server_page, 2)
 
158
        self.view.show_app(app)
 
159
        self.assertEqual(self.view._reviews_server_page, 1)
 
160
        self.view._on_more_reviews_clicked(None)
 
161
        self.assertEqual(self.view._reviews_server_page, 2)
157
162
        # show different app, ensure page is reset
158
163
        app = Application("", "apt")
159
 
        view.show_app(app)
160
 
        self.assertEqual(view._reviews_server_page, 1)
 
164
        self.view.show_app(app)
 
165
        self.assertEqual(self.view._reviews_server_page, 1)
161
166
 
162
167
    def test_human_readable_name_in_view(self):
163
168
        model = self.view.reviews.review_language.get_model()
236
241
 
237
242
    @patch('softwarecenter.backend.spawn_helper.SpawnHelper.run')
238
243
    def test_submit_new_review_disables_button(self, mock_run):
 
244
        app = Application("", "2vcard")
 
245
        self.view.show_app(app)
239
246
        button = self.view.reviews.new_review
240
247
        self.assertTrue(button.is_sensitive())
241
248
 
250
257
        self.view._submit_reviews_done_callback(None, 0)
251
258
 
252
259
        self.assertTrue(button.is_sensitive())
253
 
        
254
 
 
255
 
class MultipleVersionsTestCase(unittest.TestCase):
256
 
    
257
 
    @classmethod
258
 
    def setUpClass(cls):
259
 
        # Set these as class attributes as we don't modify either
260
 
        # during the tests.
261
 
        from softwarecenter.testutils import get_test_db
262
 
        cls.db = get_test_db()
263
 
        cls.win = get_test_window_appdetails()
264
 
        cls.view = cls.win.get_data("view")
265
 
 
266
 
    @classmethod
267
 
    def tearDownClass(cls):
268
 
        GObject.timeout_add(TIMEOUT, lambda: cls.win.destroy())
269
 
        Gtk.main()
270
 
 
271
 
    def setUp(self):
272
 
        app = Application("", "software-center")
273
 
        self.app_mock = get_mock_app_from_real_app(app)
274
 
        self.app_mock.details.pkg_state = PkgStates.UNINSTALLED
 
260
 
 
261
 
 
262
class MultipleVersionsTestCase(BaseViewTestCase):
275
263
 
276
264
    def test_multiple_versions_automatic_button(self):
277
265
        # normal app
278
266
        self.view.show_app(self.app_mock)
279
267
        self.assertFalse(self.view.pkg_statusbar.combo_multiple_versions.get_visible())
280
268
        # switch to not-automatic app with different description
281
 
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [ 
 
269
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
282
270
            ("5.0", "precise"),
283
271
            ("12.0", "precise-backports"),
284
272
            ]
290
278
    def test_combo_multiple_versions(self):
291
279
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
292
280
            ("5.0",  "precise"),
293
 
            ("12.0", "precise-backports") 
 
281
            ("12.0", "precise-backports")
294
282
            ]
295
283
        # ensure that the right method is called
296
284
        self.app_mock.details.force_not_automatic_archive_suite = Mock()
305
293
    def test_installed_multiple_version_default(self):
306
294
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
307
295
            ("5.0",  "precise"),
308
 
            ("12.0", "precise-backports") 
 
296
            ("12.0", "precise-backports")
309
297
            ]
310
298
        self.app_mock.details.pkg_state = PkgStates.INSTALLED
311
299
        self.app_mock.details.version = "12.0"
332
320
        #self.assertEqual(call_args, (("precise",), {}))
333
321
        # ensure the button changes
334
322
        self.assertEqual(self.view.pkg_statusbar.button.get_label(), "Change")
335
 
        
336
 
 
337
 
class HardwareRequirementsTestCase(unittest.TestCase):
338
 
    
339
 
    @classmethod
340
 
    def setUpClass(cls):
341
 
        # Set these as class attributes as we don't modify either
342
 
        # during the tests.
343
 
        from softwarecenter.testutils import get_test_db
344
 
        cls.db = get_test_db()
345
 
        cls.win = get_test_window_appdetails()
346
 
        cls.view = cls.win.get_data("view")
347
 
 
348
 
    @classmethod
349
 
    def tearDownClass(cls):
350
 
        GObject.timeout_add(TIMEOUT, lambda: cls.win.destroy())
351
 
        Gtk.main()
352
 
 
353
 
    def setUp(self):
354
 
        app = Application("", "software-center")
355
 
        self.app_mock = get_mock_app_from_real_app(app)
356
 
        self.app_mock.details.pkg_state = PkgStates.UNINSTALLED
 
323
 
 
324
 
 
325
class HardwareRequirementsTestCase(BaseViewTestCase):
357
326
 
358
327
    def test_show_hardware_requirements(self):
359
 
        self.app_mock.details.hardware_requirements = { 
360
 
            'hardware::video:opengl' : 'yes',
361
 
            'hardware::gps' : 'no',
 
328
        self.app_mock.details.hardware_requirements = {
 
329
            'hardware::video:opengl': 'yes',
 
330
            'hardware::gps': 'no',
362
331
            }
363
332
        self.app_mock.details.hardware_requirements_satisfied = False
364
333
        self.view.show_app(self.app_mock)
378
347
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
379
348
        self.view.show_app(self.app_mock)
380
349
        self.assertEqual(
381
 
            self.view.pkg_statusbar.button.get_label(), 
 
350
            self.view.pkg_statusbar.button.get_label(),
382
351
            _(u"Buy Anyway\u2026").encode("utf-8"))
383
352
        # check if the warning bar is displayed
384
353
        self.assertTrue(self.view.pkg_warningbar.get_property("visible"))
401
370
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
402
371
        self.view.show_app(self.app_mock)
403
372
        self.assertEqual(
404
 
            self.view.pkg_statusbar.button.get_label(), 
 
373
            self.view.pkg_statusbar.button.get_label(),
405
374
            _(u'Buy\u2026').encode("utf-8"))
406
375
        # check if the warning bar is invisible
407
376
        self.assertFalse(self.view.pkg_warningbar.get_property("visible"))
408
377
 
409
 
class RegionRequirementsTestCase(unittest.TestCase):
410
 
    
411
 
    @classmethod
412
 
    def setUpClass(cls):
413
 
        # Set these as class attributes as we don't modify either
414
 
        # during the tests.
415
 
        from softwarecenter.testutils import get_test_db
416
 
        cls.db = get_test_db()
417
 
        cls.win = get_test_window_appdetails()
418
 
        cls.view = cls.win.get_data("view")
419
 
 
420
 
    @classmethod
421
 
    def tearDownClass(cls):
422
 
        GObject.timeout_add(TIMEOUT, lambda: cls.win.destroy())
423
 
        Gtk.main()
424
 
 
425
 
    def setUp(self):
426
 
        app = Application("", "software-center")
427
 
        self.app_mock = get_mock_app_from_real_app(app)
428
 
        self.app_mock.details.pkg_state = PkgStates.UNINSTALLED
 
378
 
 
379
class RegionRequirementsTestCase(BaseViewTestCase):
429
380
 
430
381
    def test_show_region_requirements(self):
431
382
        self.app_mock.details.region_requirements_satisfied = False
438
389
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
439
390
        self.view.show_app(self.app_mock)
440
391
        self.assertEqual(
441
 
            self.view.pkg_statusbar.button.get_label(), 
 
392
            self.view.pkg_statusbar.button.get_label(),
442
393
            _(u"Buy Anyway\u2026").encode("utf-8"))
443
394
        # check if the warning bar is displayed
444
395
        self.assertTrue(self.view.pkg_warningbar.get_property("visible"))
446
397
                         REGION_WARNING_STRING)
447
398
 
448
399
 
449
 
class PurchasedAppDetailsStatusBarTestCase(unittest.TestCase):
450
 
 
451
 
    @classmethod
452
 
    def setUpClass(cls):
453
 
        # Set these as class attributes as we don't modify either
454
 
        # during the tests.
455
 
        from softwarecenter.testutils import get_test_db
456
 
        cls.db = get_test_db()
457
 
        cls.win = get_test_window_appdetails()
458
 
 
459
 
    @classmethod
460
 
    def tearDownClass(cls):
461
 
        GObject.timeout_add(TIMEOUT, lambda: cls.win.destroy())
462
 
        Gtk.main()
 
400
class PurchasedAppDetailsStatusBarTestCase(BaseViewTestCase):
463
401
 
464
402
    def _make_statusbar_view_for_state(self, state):
465
403
        app_details = make_purchased_app_details(db=self.db)
537
475
            self.assertEqual(
538
476
                [method_name],
539
477
                all_method_calls)
540
 
                
541
 
class AppRecommendationsTestCase(unittest.TestCase):
542
 
    
543
 
    @classmethod
544
 
    def setUpClass(cls):
545
 
        # Set these as class attributes as we don't modify either
546
 
        # during the tests.
547
 
        cls.win = get_test_window_appdetails()
548
 
        cls.view = cls.win.get_data("view")
549
 
        from softwarecenter.testutils import get_test_db
550
 
        cls.db = get_test_db()
551
 
 
552
 
    @classmethod
553
 
    def tearDownClass(cls):
554
 
        GObject.timeout_add(TIMEOUT, lambda: cls.win.destroy())
555
 
        Gtk.main()
556
 
 
557
 
    def setUp(self):
558
 
        app = Application("", "pitivi")
559
 
        self.app_mock = get_mock_app_from_real_app(app)
560
 
        self.app_mock.details.pkg_state = PkgStates.UNINSTALLED
561
 
        
 
478
 
 
479
 
 
480
class AppRecommendationsTestCase(BaseViewTestCase):
 
481
 
 
482
    app_name = "pitivi"
 
483
 
562
484
    def on_query_done(self, recagent, data):
563
 
        print "query done, data: '%s'" % data
 
485
        # print "query done, data: '%s'" % data
564
486
        self.loop.quit()
565
 
        
 
487
 
566
488
    def on_query_error(self, recagent, error):
567
 
        print "query error received: ", error
 
489
        # print "query error received: ", error
568
490
        self.loop.quit()
569
491
        self.error = True
570
492
 
574
496
    def test_show_recommendations_for_app(self, mock_query):
575
497
        self.view.show_app(self.app_mock)
576
498
        do_events()
577
 
        self.view.recommended_for_app_panel._update_app_recommendations_content()
 
499
        panel = self.view.recommended_for_app_panel
 
500
        panel._update_app_recommendations_content()
578
501
        do_events()
579
502
        # we fake the callback from the agent here
580
 
        self.view.recommended_for_app_panel.app_recommendations_cat._recommend_app_result(
581
 
                                None,
 
503
        panel.app_recommendations_cat._recommend_app_result(None,
582
504
                                make_recommend_app_data())
583
505
        self.assertNotEqual(
584
 
                self.view.recommended_for_app_panel.app_recommendations_cat.get_documents(self.db), [])
 
506
                panel.app_recommendations_cat.get_documents(self.db), [])
585
507
 
586
508
 
587
509
if __name__ == "__main__":
588
 
    import logging
589
 
    logging.basicConfig(level=logging.DEBUG)
590
510
    unittest.main()