← Back to branch summary

~mvo/software-center/memleak-fixes-lp1003466

« back to all changes in this revision

Viewing changes to test/gtk3/test_spinner.py

  • Committer: Michael Vogt
  • Date: 2012-05-22 12:38:02 UTC
  • mfrom: (2989.21.11 fix-965093)
  • Revision ID: michael.vogt@ubuntu.com-20120522123802-2bqdr6ujhp95k010
merged lp:~nataliabidart/software-center/fix-965093, many thanks!

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/gtk3/test_spinner.py
 
1
import os
 
2
import unittest
 
3
 
 
4
from gi.repository import Gtk
 
5
from mock import patch
 
6
 
 
7
from testutils import setup_test_env
 
8
setup_test_env()
 
9
 
 
10
from softwarecenter.ui.gtk3.widgets import spinner
 
11
 
 
12
 
 
13
class SpinnerNotebookTestCase(unittest.TestCase):
 
14
    """The test case for the SpinnerNotebook."""
 
15
 
 
16
    _fake_timeout_id = object()
 
17
 
 
18
    def setUp(self):
 
19
        # helpers to check the timeout's callbacks
 
20
        self._interval = None
 
21
        self._callback = None
 
22
 
 
23
        self.content = Gtk.Label('My test')
 
24
        self.content.show()
 
25
        self.addCleanup(self.content.hide)
 
26
        self.addCleanup(self.content.destroy)
 
27
 
 
28
        self.obj = spinner.SpinnerNotebook(self.content)
 
29
        self.addCleanup(self.obj.hide)
 
30
        self.addCleanup(self.obj.destroy)
 
31
        assert spinner.SOFTWARE_CENTER_DEBUG_TABS not in os.environ
 
32
 
 
33
        self.obj.show()
 
34
 
 
35
    def _fake_timeout_add(self, interval, callback):
 
36
        self._interval = interval
 
37
        self._callback = callback
 
38
        return self._fake_timeout_id
 
39
 
 
40
    def _fake_source_remove(self, event_id):
 
41
        if event_id is self._fake_timeout_id:
 
42
            self._fake_timeout_id = None
 
43
            return True
 
44
 
 
45
    def test_no_borders(self):
 
46
        """The notebook has no borders."""
 
47
        self.assertFalse(self.obj.get_show_border())
 
48
 
 
49
    def test_no_tabs(self):
 
50
        """The notebook has no visible tabs."""
 
51
        self.assertFalse(self.obj.get_show_tabs())
 
52
 
 
53
    def test_tabs_if_debug_set(self):
 
54
        """The notebook has visible tabs if debug is set."""
 
55
        with patch.object(spinner, 'SOFTWARE_CENTER_DEBUG_TABS', True):
 
56
            self.obj = spinner.SpinnerNotebook(self.content)
 
57
            self.assertTrue(self.obj.get_show_tabs())
 
58
 
 
59
    def test_has_two_pages(self):
 
60
        """The notebook has two pages."""
 
61
        self.assertEqual(self.obj.get_n_pages(), 2)
 
62
 
 
63
    def test_has_content(self):
 
64
        """The notebook has the given content."""
 
65
        self.assertEqual(self.obj.get_nth_page(self.obj.CONTENT_PAGE),
 
66
                         self.content)
 
67
 
 
68
    def test_has_spinner(self):
 
69
        """The notebook has the spinner view."""
 
70
        self.assertEqual(self.obj.get_nth_page(self.obj.SPINNER_PAGE),
 
71
                         self.obj.spinner_view)
 
72
        self.assertTrue(self.obj.spinner_view.get_visible())
 
73
 
 
74
    def test_show_content_by_default(self):
 
75
        """The content tab is shown by default."""
 
76
        self.assertEqual(self.obj.get_current_page(), self.obj.CONTENT_PAGE)
 
77
 
 
78
    def test_show_spinner(self):
 
79
        """The spinner is shown only after the timeout occurs."""
 
80
        assert self._interval is None
 
81
        assert self._callback is None
 
82
 
 
83
        with patch.object(spinner.GObject, 'timeout_add',
 
84
                          self._fake_timeout_add):
 
85
            self.obj.show_spinner()
 
86
 
 
87
        # this must hold before the callback is fired
 
88
        self.assertEqual(self.obj.get_current_page(), self.obj.CONTENT_PAGE)
 
89
        self.assertFalse(self.obj.spinner_view.spinner.get_property('active'))
 
90
        self.assertFalse(self.obj.spinner_view.spinner.get_visible())
 
91
        self.assertEqual(self._interval, 250)
 
92
        self.assertEqual(self._callback, self.obj._unmask_view_spinner)
 
93
 
 
94
        result = self._callback()  # fire the timeout
 
95
 
 
96
        # this must hold after the callback is fired
 
97
        self.assertFalse(result, 'The timeout callback should return False.')
 
98
        self.assertTrue(self.obj.spinner_view.spinner.get_property('active'))
 
99
        self.assertTrue(self.obj.spinner_view.spinner.get_visible())
 
100
        self.assertEqual(self.obj.get_current_page(), self.obj.SPINNER_PAGE)
 
101
 
 
102
    def test_show_spinner_with_msg(self):
 
103
        """The spinner is shown with the given message."""
 
104
        message = 'Something I want to show'
 
105
        with patch.object(spinner.GObject, 'timeout_add', lambda *a: None):
 
106
            self.obj.show_spinner(msg=message)
 
107
 
 
108
        self.assertEqual(self.obj.spinner_view.get_text(), message)
 
109
 
 
110
    def test_hide_spinner_before_timeout(self):
 
111
        """The spinner is hidden cancelling the timeout."""
 
112
        with patch.object(spinner.GObject, 'timeout_add',
 
113
                          self._fake_timeout_add):
 
114
            self.obj.show_spinner()
 
115
 
 
116
        with patch.object(spinner.GObject, 'source_remove',
 
117
                          self._fake_source_remove):
 
118
            self.obj.hide_spinner()
 
119
 
 
120
        # hide_spinner should call source_remove with the proper event id,
 
121
        # which in turn will set the _fake_timeout_id to None
 
122
        self.assertTrue(self._fake_timeout_id is None,
 
123
            'The timeout should be removed by calling GObject.source_remove')
 
124
        # the content page is shown
 
125
        self.assertEqual(self.obj.get_current_page(), self.obj.CONTENT_PAGE)
 
126
        # the spinner is stoppped and hidden
 
127
        self.assertFalse(self.obj.spinner_view.spinner.get_property('active'))
 
128
        self.assertFalse(self.obj.spinner_view.spinner.get_visible())
 
129
 
 
130
    def test_hide_spinner_after_timeout(self):
 
131
        """The spinner is hidden without cancelling the timeout."""
 
132
        with patch.object(spinner.GObject, 'timeout_add',
 
133
                          self._fake_timeout_add):
 
134
            self.obj.show_spinner()
 
135
 
 
136
        self._callback()  # fake the timeout being fired
 
137
 
 
138
        with patch.object(spinner.GObject, 'source_remove',
 
139
                          self._fake_source_remove):
 
140
            self.obj.hide_spinner()
 
141
 
 
142
        self.assertTrue(self._fake_timeout_id is not None,
 
143
            'GObject.source_remove should not be called if already fired.')
 
144
        # the content page is shown
 
145
        self.assertEqual(self.obj.get_current_page(), self.obj.CONTENT_PAGE)
 
146
        # the spinner is stoppped and hidden
 
147
        self.assertFalse(self.obj.spinner_view.spinner.get_property('active'))
 
148
        self.assertFalse(self.obj.spinner_view.spinner.get_visible())
 
149
 
 
150
 
 
151
if __name__ == "__main__":
 
152
    unittest.main()