← Back to branch summary

~mvo/software-center/trivial-renaming

« back to all changes in this revision

Viewing changes to tests/gtk3/test_appdetailsview.py

  • Committer: Natalia B. Bidart
  • Date: 2012-05-30 18:39:55 UTC
  • mto: This revision was merged to the branch mainline in revision 3030.
  • Revision ID: natalia.bidart@canonical.com-20120530183955-zbnjczayktmmg5tv
- Initial test cleanup:
  - Renamed test/ dir to tests/.
  - Isolated test code into tests/ directory, including moving all the
    get_test_window_foo from the gtk3 production modules to
    tests/gtk3/windows.py module.
  - Removed all the calls to Gtk.main() in gtk3 tests since that blocks the
    execution of the suite.
  - Pep8 and pyflakes fixes in the files already modified in this branch.
  - Minor bug fix in the softwarecenter/log.py module when trying to create a
    log dir with proper perms.

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"),
146
152
        do_events()
147
153
 
148
154
    def test_reviews_page(self):
149
 
        win = get_test_window_appdetails()
150
 
        view = win.get_data("view")
151
155
        # show s-c and click on more review
152
156
        app = Application("", "software-center")
153
 
        view.show_app(app)
 
157
        self.view.show_app(app)
154
158
        self.assertEqual(view._reviews_server_page, 1)
155
 
        view._on_more_reviews_clicked(None)
 
159
        self.view._on_more_reviews_clicked(None)
156
160
        self.assertEqual(view._reviews_server_page, 2)
157
161
        # show different app, ensure page is reset
158
162
        app = Application("", "apt")
159
 
        view.show_app(app)
 
163
        self.view.show_app(app)
160
164
        self.assertEqual(view._reviews_server_page, 1)
161
165
 
162
166
    def test_human_readable_name_in_view(self):
236
240
 
237
241
    @patch('softwarecenter.backend.spawn_helper.SpawnHelper.run')
238
242
    def test_submit_new_review_disables_button(self, mock_run):
 
243
        app = Application("", "2vcard")
 
244
        self.view.show_app(app)
239
245
        button = self.view.reviews.new_review
240
246
        self.assertTrue(button.is_sensitive())
241
247
 
250
256
        self.view._submit_reviews_done_callback(None, 0)
251
257
 
252
258
        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
 
259
 
 
260
 
 
261
class MultipleVersionsTestCase(BaseViewTestCase):
275
262
 
276
263
    def test_multiple_versions_automatic_button(self):
277
264
        # normal app
278
265
        self.view.show_app(self.app_mock)
279
266
        self.assertFalse(self.view.pkg_statusbar.combo_multiple_versions.get_visible())
280
267
        # switch to not-automatic app with different description
281
 
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [ 
 
268
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
282
269
            ("5.0", "precise"),
283
270
            ("12.0", "precise-backports"),
284
271
            ]
290
277
    def test_combo_multiple_versions(self):
291
278
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
292
279
            ("5.0",  "precise"),
293
 
            ("12.0", "precise-backports") 
 
280
            ("12.0", "precise-backports")
294
281
            ]
295
282
        # ensure that the right method is called
296
283
        self.app_mock.details.force_not_automatic_archive_suite = Mock()
305
292
    def test_installed_multiple_version_default(self):
306
293
        self.app_mock.details.get_not_automatic_archive_versions = lambda: [
307
294
            ("5.0",  "precise"),
308
 
            ("12.0", "precise-backports") 
 
295
            ("12.0", "precise-backports")
309
296
            ]
310
297
        self.app_mock.details.pkg_state = PkgStates.INSTALLED
311
298
        self.app_mock.details.version = "12.0"
332
319
        #self.assertEqual(call_args, (("precise",), {}))
333
320
        # ensure the button changes
334
321
        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
 
322
 
 
323
 
 
324
class HardwareRequirementsTestCase(BaseViewTestCase):
357
325
 
358
326
    def test_show_hardware_requirements(self):
359
 
        self.app_mock.details.hardware_requirements = { 
360
 
            'hardware::video:opengl' : 'yes',
361
 
            'hardware::gps' : 'no',
 
327
        self.app_mock.details.hardware_requirements = {
 
328
            'hardware::video:opengl': 'yes',
 
329
            'hardware::gps': 'no',
362
330
            }
363
331
        self.app_mock.details.hardware_requirements_satisfied = False
364
332
        self.view.show_app(self.app_mock)
378
346
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
379
347
        self.view.show_app(self.app_mock)
380
348
        self.assertEqual(
381
 
            self.view.pkg_statusbar.button.get_label(), 
 
349
            self.view.pkg_statusbar.button.get_label(),
382
350
            _(u"Buy Anyway\u2026").encode("utf-8"))
383
351
        # check if the warning bar is displayed
384
352
        self.assertTrue(self.view.pkg_warningbar.get_property("visible"))
401
369
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
402
370
        self.view.show_app(self.app_mock)
403
371
        self.assertEqual(
404
 
            self.view.pkg_statusbar.button.get_label(), 
 
372
            self.view.pkg_statusbar.button.get_label(),
405
373
            _(u'Buy\u2026').encode("utf-8"))
406
374
        # check if the warning bar is invisible
407
375
        self.assertFalse(self.view.pkg_warningbar.get_property("visible"))
408
376
 
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
 
377
 
 
378
class RegionRequirementsTestCase(BaseViewTestCase):
429
379
 
430
380
    def test_show_region_requirements(self):
431
381
        self.app_mock.details.region_requirements_satisfied = False
438
388
        self.app_mock.details.pkg_state = PkgStates.NEEDS_PURCHASE
439
389
        self.view.show_app(self.app_mock)
440
390
        self.assertEqual(
441
 
            self.view.pkg_statusbar.button.get_label(), 
 
391
            self.view.pkg_statusbar.button.get_label(),
442
392
            _(u"Buy Anyway\u2026").encode("utf-8"))
443
393
        # check if the warning bar is displayed
444
394
        self.assertTrue(self.view.pkg_warningbar.get_property("visible"))
446
396
                         REGION_WARNING_STRING)
447
397
 
448
398
 
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()
 
399
class PurchasedAppDetailsStatusBarTestCase(BaseViewTestCase):
463
400
 
464
401
    def _make_statusbar_view_for_state(self, state):
465
402
        app_details = make_purchased_app_details(db=self.db)
537
474
            self.assertEqual(
538
475
                [method_name],
539
476
                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
 
        
 
477
 
 
478
 
 
479
class AppRecommendationsTestCase(BaseViewTestCase):
 
480
 
 
481
    app_name = "pitivi"
 
482
 
562
483
    def on_query_done(self, recagent, data):
563
 
        print "query done, data: '%s'" % data
 
484
        # print "query done, data: '%s'" % data
564
485
        self.loop.quit()
565
 
        
 
486
 
566
487
    def on_query_error(self, recagent, error):
567
 
        print "query error received: ", error
 
488
        # print "query error received: ", error
568
489
        self.loop.quit()
569
490
        self.error = True
570
491
 
574
495
    def test_show_recommendations_for_app(self, mock_query):
575
496
        self.view.show_app(self.app_mock)
576
497
        do_events()
577
 
        self.view.recommended_for_app_panel._update_app_recommendations_content()
 
498
        panel = self.view.recommended_for_app_panel
 
499
        panel._update_app_recommendations_content()
578
500
        do_events()
579
501
        # we fake the callback from the agent here
580
 
        self.view.recommended_for_app_panel.app_recommendations_cat._recommend_app_result(
581
 
                                None,
 
502
        panel.app_recommendations_cat._recommend_app_result(None,
582
503
                                make_recommend_app_data())
583
504
        self.assertNotEqual(
584
 
                self.view.recommended_for_app_panel.app_recommendations_cat.get_documents(self.db), [])
 
505
                panel.app_recommendations_cat.get_documents(self.db), [])
585
506
 
586
507
 
587
508
if __name__ == "__main__":
588
 
    import logging
589
 
    logging.basicConfig(level=logging.DEBUG)
590
509
    unittest.main()