← Back to branch summary

~mvo/software-center/qml

« back to all changes in this revision

Viewing changes to test/test_gui.py

  • Committer: Michael Vogt
  • Date: 2011-10-05 13:08:09 UTC
  • mfrom: (1887.1.603 software-center)
  • Revision ID: michael.vogt@ubuntu.com-20111005130809-0tin9nr00f0uw65b
merged from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_gui.py
1
 
#!/usr/bin/python
2
 
 
3
 
import apt
4
 
import glib
5
 
import gtk
6
 
import logging
7
 
from mock import Mock
8
 
import os
9
 
import subprocess
10
 
import sys
11
 
import time
12
 
import unittest
13
 
 
14
 
sys.path.insert(0, "..")
15
 
 
16
 
from softwarecenter.app import SoftwareCenterApp
17
 
from softwarecenter.paths import XAPIAN_BASE_PATH
18
 
from softwarecenter.ui.gtk.appview import AppStore
19
 
from softwarecenter.ui.gtk.availablepane import AvailablePane
20
 
from softwarecenter.db.application import Application
21
 
from softwarecenter.ui.gtk.catview_gtk import get_category_by_name
22
 
from softwarecenter.backend import get_install_backend
23
 
 
24
 
# needed for the install test
25
 
if os.getuid() == 0:
26
 
    subprocess.call(["dpkg", "-r", "4g8"])
27
 
 
28
 
# we make app global as its relatively expensive to create
29
 
# and in setUp it would be created and destroyed for each
30
 
# test
31
 
apt.apt_pkg.config.set("Dir::log::history", "/tmp")
32
 
#apt.apt_pkg.config.set("Dir::state::lists", "/tmp")
33
 
mock_options = Mock()
34
 
mock_options.enable_lp = False
35
 
mock_options.enable_buy = True
36
 
mock_options.disable_apt_xapian_index = False
37
 
app = SoftwareCenterApp("../data", XAPIAN_BASE_PATH, mock_options)
38
 
app.window_main.show_all()
39
 
 
40
 
class TestGUI(unittest.TestCase):
41
 
 
42
 
    def setUp(self):
43
 
        self.app = app
44
 
        self._p()
45
 
    
46
 
    def test_supported_only(self):
47
 
        """ test if clicking on the "supported only" menuitems
48
 
            really makes the the amount of items smaller
49
 
        """
50
 
        self._reset_ui()
51
 
        items_all = self.app.label_status.get_text()
52
 
        self.app.menuitem_view_supported_only.activate()
53
 
        items_supported = self.app.label_status.get_text()
54
 
        self.assertNotEqual(items_all, items_supported)
55
 
        len_all = int(items_all.split()[0])
56
 
        len_supported = int(items_supported.split()[0])
57
 
        self.assertTrue(len_all > len_supported)
58
 
 
59
 
    def test_categories_and_back_forward(self):
60
 
        self._reset_ui()
61
 
 
62
 
        # find games, ensure its there and select it
63
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
64
 
                         AvailablePane.PAGE_CATEGORY)
65
 
        cat = get_category_by_name(self.app.available_pane.cat_view.categories,
66
 
                                   "Games")
67
 
        self.assertNotEqual(cat, None)
68
 
        self.app.available_pane.cat_view.emit("category-selected", cat)
69
 
        self._p()
70
 
        # we have a subcategory, ensure we really see it
71
 
        cat = get_category_by_name(self.app.available_pane.subcategories_view.categories,
72
 
                                   "Simulation")
73
 
        self.assertNotEqual(cat, None)
74
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
75
 
                         AvailablePane.PAGE_SUBCATEGORY)
76
 
        # click on the subcategory and ensure we get a list
77
 
        self.app.available_pane.subcategories_view.emit("category-selected", cat)
78
 
        self._p()
79
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
80
 
                         AvailablePane.PAGE_APPLIST)
81
 
        # now the details
82
 
        treeview = self.app.available_pane.app_view
83
 
        model = treeview.get_model()
84
 
        treeview.row_activated(model.get_path(model.get_iter_root()),
85
 
                               treeview.get_column(0))
86
 
        self._p()
87
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
88
 
                         AvailablePane.PAGE_APP_DETAILS)
89
 
 
90
 
        # NOW test the back-foward
91
 
        self.app.available_pane.back_forward.emit("left-clicked", None)
92
 
        self._p()
93
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
94
 
                         AvailablePane.PAGE_APPLIST)
95
 
        self.app.available_pane.back_forward.emit("right-clicked", None)
96
 
        self._p()
97
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
98
 
                         AvailablePane.PAGE_APP_DETAILS)
99
 
        # and more back/forward
100
 
        for i in range(10):
101
 
            self.app.available_pane.back_forward.emit("left-clicked", None)
102
 
        self._p()
103
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
104
 
                         AvailablePane.PAGE_CATEGORY)
105
 
        self.app.available_pane.back_forward.emit("right-clicked", None)
106
 
        self._p()
107
 
        time.sleep(0.5)
108
 
        self._p()
109
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
110
 
                         AvailablePane.PAGE_SUBCATEGORY)
111
 
 
112
 
    def test_select_featured_and_back_forward(self):
113
 
        self._reset_ui()
114
 
 
115
 
        app = Application("Cheese","cheese")
116
 
        self.app.available_pane.cat_view.emit("application-activated", app)
117
 
        self._p()
118
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
119
 
                         AvailablePane.PAGE_APP_DETAILS)
120
 
        self.app.available_pane.back_forward.emit("left-clicked", None)
121
 
        self._p()
122
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
123
 
                         AvailablePane.PAGE_CATEGORY)
124
 
        self.app.available_pane.back_forward.emit("right-clicked", None)
125
 
        self._p()
126
 
        self.assertEqual(self.app.available_pane.notebook.get_current_page(),
127
 
                         AvailablePane.PAGE_APP_DETAILS)
128
 
 
129
 
 
130
 
    def test_search_suggestions(self):
131
 
        self._reset_ui()
132
 
        # correct search
133
 
        self._run_search("apt")
134
 
        self.assertFalse(self.app.available_pane.label_app_list_header.flags() & gtk.VISIBLE)
135
 
        # mispelled
136
 
        self._run_search("aptz")
137
 
        self.assertTrue(self.app.available_pane.label_app_list_header.flags() & gtk.VISIBLE)
138
 
        
139
 
 
140
 
    def test_install_the_4g8_package(self):
141
 
        self._reset_ui()
142
 
 
143
 
        # assert we find the right package
144
 
        model = self._run_search("4g8")
145
 
        treeview = self.app.available_pane.app_view
146
 
        self.assertFirstPkgInModel(model, "4g8")
147
 
        treeview.row_activated(model.get_path(model.get_iter_root()),
148
 
                               treeview.get_column(0))
149
 
        self._p()
150
 
        self.assertEqual(
151
 
            self.app.available_pane.app_details_view.pkg_statusbar.button.get_label(),
152
 
            "Install")
153
 
        self._p()
154
 
        # install only when runnig as root, as we require polkit promtps
155
 
        # otherwise
156
 
        # FIXME: provide InstallBackendSimulate()
157
 
        if os.getuid() == 0:
158
 
            backend = get_install_backend()
159
 
            backend.connect("transaction-finished", 
160
 
                            self._on_transaction_finished)
161
 
            self._install_done = False
162
 
            # now simulate a click, the UI will block until the glib timeout 
163
 
            # from the previous line hits
164
 
            self.app.available_pane.app_details_view.pkgstatus_bar.button.clicked()
165
 
            self._p()
166
 
            self.assertEqual(self.app.available_pane.app_details_view.pkgstatus_bar.label.get_text(),
167
 
                             "Installing...")
168
 
            self.assertFalse(self.app.available_pane.app_details_view.pkgstatus_bar.button.get_property("visible"))
169
 
            glib.timeout_add_seconds(2, self._test_for_progress)
170
 
            while not self._install_done:
171
 
                while gtk.events_pending():
172
 
                    gtk.main_iteration()
173
 
                time.sleep(0.1)
174
 
        self.app.available_pane.searchentry.delete_text(0, -1)
175
 
 
176
 
    def test_show_unavailable(self):
177
 
        # make sure that certain UI elements are hidden when showing
178
 
        # packages that are not available
179
 
        self.app.show_available_packages(["i-dont-exit"])
180
 
        self._p()
181
 
        self.assertFalse(self.app.available_pane.app_details_view.screenshot.get_property("visible"))
182
 
        self.assertFalse(self.app.available_pane.app_details_view.info_vb.get_property("visible"))
183
 
        self.assertEqual(self.app.available_pane.app_details_view.desc.description.order, [])
184
 
 
185
 
    def _monkey_sso_login(self):
186
 
        #print "monkey_sso_login"
187
 
        token = { "token": "the_token",
188
 
                  "consumer_key":"the_consumer_key" }
189
 
        self.app.sso.emit("login-successful", token)
190
 
 
191
 
    def _monkey_query_available_for_me(self, t, c):
192
 
        #print "_monkey_query_available_for_me(self, t, c)", t,c
193
 
        class MockApp():
194
 
            name = "FooApp"
195
 
            package_name = "foopkg"
196
 
            description = "foodescr\n long desc"
197
 
            price = "1.0"
198
 
        self.app.scagent.emit("available-for-me", [MockApp()])
199
 
 
200
 
    def test_previous_purchase(self):
201
 
        self._reset_ui()
202
 
        # monkey patch stuff
203
 
        self.app._create_dbus_sso_if_needed()
204
 
        self.app.sso.login = self._monkey_sso_login
205
 
        self.app._create_scagent_if_needed()
206
 
        self.app.scagent.query_available_for_me = self._monkey_query_available_for_me
207
 
        self.app.on_menuitem_reinstall_purchases_activate(None)
208
 
        self._p()
209
 
        # ensure we are at the right place and show the right stuff
210
 
        self.assertTrue(self.app.available_pane.get_visible())
211
 
        self.assertTrue(self.app.available_pane.get_visible())
212
 
        self.assertEqual(self.app.available_pane.navigation_bar.get_active().label, "Previous Purchases")
213
 
        model = self.app.available_pane.app_view.get_model()
214
 
        self.assertFirstPkgInModel(model, "foopkg")
215
 
 
216
 
    # helper stuff
217
 
    def _p(self):
218
 
        """ process gtk events """
219
 
        while gtk.events_pending():
220
 
            gtk.main_iteration()
221
 
        # for debugging the steps
222
 
        #print "press [ENTER]"
223
 
        #sys.stdin.readline()
224
 
            
225
 
    def _reset_ui(self):
226
 
        self.app.available_pane.navigation_bar.remove_all(animate=False)
227
 
        self._p()
228
 
        time.sleep(0.5)
229
 
        self._p()
230
 
 
231
 
    def assertFirstPkgInModel(self, model, needle):
232
 
        pkgname_from_row = model[0][AppStore.COL_PKGNAME]
233
 
        self.assertEqual(
234
 
            pkgname_from_row, needle, "excpeted row '%s' got '%s'" % (
235
 
                needle, pkgname_from_row))
236
 
 
237
 
    def _run_search(self, search_text):
238
 
        logging.info("_run_search", search_text)
239
 
        self.app.available_pane.searchentry.delete_text(0, -1)
240
 
        self.app.available_pane.searchentry.insert_text(search_text)
241
 
        self._p()
242
 
        time.sleep(1)
243
 
        self._p()
244
 
        return self.app.available_pane.app_view.get_model()
245
 
 
246
 
    def _test_for_progress(self):
247
 
        self.assertTrue(self.app.available_pane.app_details_view.pkgstatus_bar.progress.get_property("visible"))
248
 
        return False
249
 
 
250
 
    def _on_transaction_finished(self, *args, **kwargs):
251
 
        print "_on_transaction_finished", args
252
 
        self._install_done = True
253
 
 
254
 
if __name__ == "__main__":
255
 
    unittest.main()