← Back to branch summary

~smspillaz/unity/untiy.less-paint-insanity

« back to all changes in this revision

Viewing changes to tests/autopilot/autopilot/tests/test_launcher.py

  • Committer: Daniel van Vugt
  • Date: 2012-03-14 06:24:18 UTC
  • mfrom: (2108 unity)
  • mto: This revision was merged to the branch mainline in revision 2146.
  • Revision ID: daniel.van.vugt@canonical.com-20120314062418-nprucpbr0m7qky5e
Merged latest lp:unity

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/autopilot/autopilot/tests/test_launcher.py
1
 
from testtools import TestCase
2
 
from testtools.matchers import Equals
3
 
 
4
 
from autopilot.emulators.unity import Launcher
5
 
from autopilot.glibrunner import GlibRunner
6
 
 
7
 
class LauncherTests(TestCase):
8
 
    run_test_with = GlibRunner
 
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 
2
# Copyright 2012 Canonical
 
3
# Authors: Thomi Richards,
 
4
#          Marco Trevisan (Treviño)
 
5
#
 
6
# This program is free software: you can redistribute it and/or modify it
 
7
# under the terms of the GNU General Public License version 3, as published
 
8
# by the Free Software Foundation.
 
9
 
 
10
import logging
 
11
from testtools.matchers import Equals, NotEquals, LessThan, GreaterThan
 
12
from time import sleep
 
13
 
 
14
from autopilot.tests import AutopilotTestCase
 
15
from autopilot.emulators.X11 import ScreenGeometry
 
16
 
 
17
logger = logging.getLogger(__name__)
 
18
 
 
19
def _make_scenarios():
 
20
    """Make scenarios for launcher test cases based on the number of configured
 
21
    monitors.
 
22
    """
 
23
    screen_geometry = ScreenGeometry()
 
24
    num_monitors = screen_geometry.get_num_monitors()
 
25
    if num_monitors == 1:
 
26
        return [('Single Monitor', {'launcher_num': 0})]
 
27
    else:
 
28
        return [('Monitor %d' % (i), {'launcher_num': i}) for i in range(num_monitors)]
 
29
 
 
30
 
 
31
class ScenariodLauncherTests(AutopilotTestCase):
 
32
    """A base class for all launcher tests that want to use scenarios to run on
 
33
    each launcher (for multi-monitor setups).
 
34
    """
 
35
 
 
36
    scenarios = _make_scenarios()
 
37
 
 
38
    def get_launcher(self):
 
39
        """Get the launcher for the current scenario."""
 
40
        return self.launcher.get_launcher_for_monitor(self.launcher_num)
 
41
 
 
42
    def setUp(self):
 
43
        super(ScenariodLauncherTests, self).setUp()
 
44
        self.set_unity_log_level("unity.launcher", "DEBUG")
 
45
 
 
46
 
 
47
class LauncherTests(ScenariodLauncherTests):
 
48
    """Test the launcher."""
9
49
 
10
50
    def setUp(self):
11
51
        super(LauncherTests, self).setUp()
12
 
        self.server = Launcher()
 
52
        sleep(1)
 
53
 
 
54
    def test_launcher_switcher_starts_at_index_zero(self):
 
55
        """Test that starting the Launcher switcher puts the keyboard focus on item 0."""
 
56
        sleep(.5)
 
57
        launcher_instance = self.get_launcher()
 
58
        launcher_instance.switcher_start()
 
59
        self.addCleanup(launcher_instance.switcher_end, True)
 
60
        sleep(.5)
 
61
 
 
62
        self.assertThat(self.launcher.key_nav_is_active, Equals(True))
 
63
        self.assertThat(self.launcher.key_nav_is_grabbed, Equals(False))
 
64
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
65
 
 
66
    def test_launcher_switcher_end_works(self):
 
67
        """Test that ending the launcher switcher actually works."""
 
68
        sleep(.5)
 
69
        launcher_instance = self.get_launcher()
 
70
        launcher_instance.switcher_start()
 
71
        sleep(.5)
 
72
        launcher_instance.switcher_end(cancel=True)
 
73
        sleep(.5)
 
74
        self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
75
 
 
76
    def test_launcher_switcher_escape_works(self):
 
77
        """Test that ending the launcher switcher actually works."""
 
78
        sleep(.5)
 
79
        launcher_instance = self.get_launcher()
 
80
        launcher_instance.switcher_start()
 
81
        self.addCleanup(launcher_instance.switcher_end, True)
 
82
        sleep(.25)
 
83
        self.assertThat(self.launcher.key_nav_is_active, Equals(True))
 
84
        sleep(.25)
 
85
        self.keyboard.press_and_release("Escape")
 
86
        sleep(.25)
 
87
        self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
88
 
 
89
    def test_launcher_switcher_next_works(self):
 
90
        """Moving to the next launcher item while switcher is activated must work."""
 
91
        sleep(.5)
 
92
        launcher_instance = self.get_launcher()
 
93
        launcher_instance.switcher_start()
 
94
        self.addCleanup(launcher_instance.switcher_end, True)
 
95
        sleep(.5)
 
96
 
 
97
        launcher_instance.switcher_next()
 
98
        sleep(.5)
 
99
        self.assertThat(self.launcher.key_nav_selection, Equals(1))
 
100
 
 
101
    def test_launcher_switcher_prev_works(self):
 
102
        """Moving to the previous launcher item while switcher is activated must work."""
 
103
        sleep(.5)
 
104
        launcher_instance = self.get_launcher()
 
105
        launcher_instance.switcher_start()
 
106
        self.addCleanup(launcher_instance.switcher_end, True)
 
107
        sleep(.25)
 
108
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
109
 
 
110
        launcher_instance.switcher_prev()
 
111
        sleep(.25)
 
112
        self.assertThat(self.launcher.key_nav_selection, NotEquals(0))
 
113
 
 
114
    def test_launcher_switcher_down_works(self):
 
115
        """Pressing the down arrow key while switcher is activated must work."""
 
116
        sleep(.5)
 
117
        launcher_instance = self.get_launcher()
 
118
        launcher_instance.switcher_start()
 
119
        self.addCleanup(launcher_instance.switcher_end, True)
 
120
        sleep(.25)
 
121
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
122
 
 
123
        launcher_instance.switcher_down()
 
124
        sleep(.25)
 
125
        self.assertThat(self.launcher.key_nav_selection, Equals(1))
 
126
 
 
127
    def test_launcher_switcher_up_works(self):
 
128
        """Pressing the up arrow key while switcher is activated must work."""
 
129
        sleep(.5)
 
130
        launcher_instance = self.get_launcher()
 
131
        launcher_instance.switcher_start()
 
132
        self.addCleanup(launcher_instance.switcher_end, True)
 
133
        sleep(.25)
 
134
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
135
 
 
136
        launcher_instance.switcher_up()
 
137
        sleep(.25)
 
138
        self.assertThat(self.launcher.key_nav_selection, NotEquals(0))
 
139
 
 
140
    def test_launcher_switcher_next_doesnt_show_shortcuts(self):
 
141
        """Moving forward in launcher switcher must not show launcher shortcuts."""
 
142
        sleep(.5)
 
143
        launcher_instance = self.get_launcher()
 
144
        launcher_instance.switcher_start()
 
145
        self.addCleanup(launcher_instance.switcher_end, True)
 
146
        sleep(.5)
 
147
        launcher_instance.switcher_next()
 
148
        sleep(2)
 
149
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(False))
 
150
 
 
151
    def test_launcher_switcher_prev_doesnt_show_shortcuts(self):
 
152
        """Moving backward in launcher switcher must not show launcher shortcuts."""
 
153
        sleep(.5)
 
154
        launcher_instance = self.get_launcher()
 
155
        launcher_instance.switcher_start()
 
156
        self.addCleanup(launcher_instance.switcher_end, True)
 
157
        sleep(.5)
 
158
        launcher_instance.switcher_next()
 
159
        sleep(2)
 
160
        launcher_instance.switcher_prev()
 
161
        sleep(2)
 
162
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(False))
 
163
 
 
164
 
 
165
    def test_launcher_switcher_cycling_forward(self):
 
166
        """Launcher Switcher must loop through icons when cycling forwards"""
 
167
        sleep(.5)
 
168
        launcher_instance = self.get_launcher()
 
169
        launcher_instance.switcher_start()
 
170
        self.addCleanup(launcher_instance.switcher_end, True)
 
171
        sleep(.5)
 
172
 
 
173
        prev_icon = 0
 
174
        num_icons = self.launcher.model.num_launcher_icons()
 
175
        logger.info("This launcher has %d icons", num_icons)
 
176
        for icon in range(1, num_icons):
 
177
            launcher_instance.switcher_next()
 
178
            sleep(.25)
 
179
            # FIXME We can't directly check for selection/icon number equalty
 
180
            # since the launcher model also contains "hidden" icons that aren't
 
181
            # shown, so the selection index can increment by more than 1.
 
182
            self.assertThat(prev_icon, LessThan(self.launcher.key_nav_selection))
 
183
            prev_icon = self.launcher.key_nav_selection
 
184
 
 
185
        sleep(.5)
 
186
        launcher_instance.switcher_next()
 
187
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
188
 
 
189
    def test_launcher_switcher_cycling_backward(self):
 
190
        """Launcher Switcher must loop through icons when cycling backwards"""
 
191
        sleep(.5)
 
192
        launcher_instance = self.get_launcher()
 
193
        launcher_instance.switcher_start()
 
194
        self.addCleanup(launcher_instance.switcher_end, True)
 
195
        sleep(.5)
 
196
 
 
197
        launcher_instance.switcher_prev()
 
198
        # FIXME We can't directly check for self.launcher.num_launcher_icons - 1
 
199
        self.assertThat(self.launcher.key_nav_selection, GreaterThan(1))
 
200
 
 
201
    def test_launcher_keyboard_reveal_works(self):
 
202
        """Revealing launcher with keyboard must work."""
 
203
        launcher_instance = self.get_launcher()
 
204
        launcher_instance.keyboard_reveal_launcher()
 
205
        self.addCleanup(launcher_instance.keyboard_unreveal_launcher)
 
206
        sleep(0.5)
 
207
        self.assertThat(launcher_instance.is_showing(), Equals(True))
 
208
 
 
209
    def test_launcher_keyboard_reveal_shows_shortcut_hints(self):
 
210
        """Launcher icons must show shortcut hints after revealing with keyboard."""
 
211
        launcher_instance = self.get_launcher()
 
212
        launcher_instance.move_mouse_to_right_of_launcher()
 
213
        launcher_instance.keyboard_reveal_launcher()
 
214
        self.addCleanup(launcher_instance.keyboard_unreveal_launcher)
 
215
        sleep(1)
 
216
 
 
217
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(True))
 
218
 
 
219
    def test_launcher_switcher_keeps_shorcuts(self):
 
220
        """Initiating launcher switcher after showing shortcuts must not hide shortcuts"""
 
221
        sleep(.5)
 
222
        launcher_instance = self.get_launcher()
 
223
        launcher_instance.move_mouse_to_right_of_launcher()
 
224
        launcher_instance.keyboard_reveal_launcher()
 
225
        self.addCleanup(launcher_instance.keyboard_unreveal_launcher)
 
226
        sleep(1)
 
227
 
 
228
        launcher_instance.switcher_start()
 
229
        self.addCleanup(launcher_instance.switcher_end, True)
 
230
        sleep(.5)
 
231
 
 
232
        self.assertThat(self.launcher.key_nav_is_active, Equals(True))
 
233
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(True))
 
234
 
 
235
    def test_launcher_switcher_next_and_prev_keep_shortcuts(self):
 
236
        """Launcher switcher next and prev actions must keep shortcuts after they've been shown."""
 
237
        sleep(.5)
 
238
        launcher_instance = self.get_launcher()
 
239
        launcher_instance.move_mouse_to_right_of_launcher()
 
240
        launcher_instance.keyboard_reveal_launcher()
 
241
        self.addCleanup(launcher_instance.keyboard_unreveal_launcher)
 
242
        sleep(1)
 
243
 
 
244
        launcher_instance.switcher_start()
 
245
        self.addCleanup(launcher_instance.switcher_end, True)
 
246
        sleep(.5)
 
247
 
 
248
        launcher_instance.switcher_next()
 
249
        sleep(.5)
 
250
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(True))
 
251
 
 
252
        launcher_instance.switcher_prev()
 
253
        sleep(.5)
 
254
        self.assertThat(launcher_instance.are_shortcuts_showing(), Equals(True))
 
255
 
 
256
    def test_launcher_switcher_using_shorcuts(self):
 
257
        """Using some other shortcut while switcher is active must cancel switcher."""
 
258
        sleep(.5)
 
259
 
 
260
        launcher_instance = self.get_launcher()
 
261
        launcher_instance.move_mouse_to_right_of_launcher()
 
262
        launcher_instance.keyboard_reveal_launcher()
 
263
        self.addCleanup(launcher_instance.keyboard_unreveal_launcher)
 
264
        sleep(1)
 
265
        launcher_instance.switcher_start()
 
266
        self.addCleanup(launcher_instance.switcher_end, True)
 
267
        sleep(.5)
 
268
 
 
269
        self.keyboard.press_and_release("s")
 
270
        sleep(.25)
 
271
        self.keyboard.press_and_release("Escape")
 
272
        sleep(.25)
 
273
 
 
274
        self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
275
 
 
276
    def test_launcher_keynav_initiate_works(self):
 
277
        """Tests we can initiate keyboard navigation on the launcher."""
 
278
        launcher_instance = self.get_launcher()
 
279
        sleep(.5)
 
280
        launcher_instance.key_nav_start()
 
281
        self.addCleanup(launcher_instance.key_nav_end, True)
 
282
        sleep(.5)
 
283
 
 
284
        self.assertThat(self.launcher.key_nav_is_active, Equals(True))
 
285
        self.assertThat(self.launcher.key_nav_is_grabbed, Equals(True))
 
286
 
 
287
    def test_launcher_keynav_end_works(self):
 
288
        """Test that we can exit keynav mode."""
 
289
        launcher_instance = self.get_launcher()
 
290
        sleep(.5)
 
291
        launcher_instance.key_nav_start()
 
292
        sleep(.5)
 
293
        launcher_instance.key_nav_end(cancel=True)
 
294
        self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
295
        self.assertThat(self.launcher.key_nav_is_grabbed, Equals(False))
 
296
 
 
297
    def test_launcher_keynav_starts_at_index_zero(self):
 
298
        """Test keynav mode starts at index 0."""
 
299
        launcher_instance = self.get_launcher()
 
300
        sleep(.5)
 
301
        launcher_instance.key_nav_start()
 
302
        self.addCleanup(launcher_instance.key_nav_end, True)
 
303
        sleep(.5)
 
304
 
 
305
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
306
 
 
307
    def test_launcher_keynav_forward_works(self):
 
308
        """Must be able to move forwards while in keynav mode."""
 
309
        launcher_instance = self.get_launcher()
 
310
        sleep(.5)
 
311
        launcher_instance.key_nav_start()
 
312
        self.addCleanup(launcher_instance.key_nav_end, True)
 
313
        sleep(.5)
 
314
        launcher_instance.key_nav_next()
 
315
        sleep(.5)
 
316
        self.assertThat(self.launcher.key_nav_selection, Equals(1))
 
317
 
 
318
    def test_launcher_keynav_prev_works(self):
 
319
        """Must be able to move backwards while in keynav mode."""
 
320
        launcher_instance = self.get_launcher()
 
321
        sleep(.5)
 
322
        launcher_instance.key_nav_start()
 
323
        self.addCleanup(launcher_instance.key_nav_end, True)
 
324
        sleep(.5)
 
325
        launcher_instance.key_nav_next()
 
326
        sleep(.5)
 
327
        launcher_instance.key_nav_prev()
 
328
        sleep(.5)
 
329
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
330
 
 
331
    def test_launcher_keynav_cycling_forward(self):
 
332
        """Launcher keynav must loop through icons when cycling forwards"""
 
333
        launcher_instance = self.get_launcher()
 
334
        sleep(.5)
 
335
        launcher_instance.key_nav_start()
 
336
        self.addCleanup(launcher_instance.key_nav_end, True)
 
337
        sleep(.25)
 
338
 
 
339
        prev_icon = 0
 
340
        for icon in range(1, self.launcher.model.num_launcher_icons()):
 
341
            launcher_instance.key_nav_next()
 
342
            sleep(.25)
 
343
            # FIXME We can't directly check for selection/icon number equalty
 
344
            # since the launcher model also contains "hidden" icons that aren't
 
345
            # shown, so the selection index can increment by more than 1.
 
346
            self.assertThat(prev_icon, LessThan(self.launcher.key_nav_selection))
 
347
            prev_icon = self.launcher.key_nav_selection
 
348
 
 
349
        sleep(.5)
 
350
        launcher_instance.key_nav_next()
 
351
        self.assertThat(self.launcher.key_nav_selection, Equals(0))
 
352
 
 
353
    def test_launcher_keynav_cycling_backward(self):
 
354
        """Launcher keynav must loop through icons when cycling backwards"""
 
355
        launcher_instance = self.get_launcher()
 
356
        sleep(.5)
 
357
        launcher_instance.key_nav_start()
 
358
        self.addCleanup(launcher_instance.key_nav_end, True)
 
359
        sleep(.25)
 
360
 
 
361
        launcher_instance.key_nav_prev()
 
362
        # FIXME We can't directly check for self.launcher.num_launcher_icons - 1
 
363
        self.assertThat(self.launcher.key_nav_selection, GreaterThan(1))
 
364
 
 
365
    def test_launcher_keynav_can_open_quicklist(self):
 
366
        """Tests that we can open a quicklist from keynav mode."""
 
367
        launcher_instance = self.get_launcher()
 
368
        launcher_instance.move_mouse_to_right_of_launcher()
 
369
        sleep(.5)
 
370
        launcher_instance.key_nav_start()
 
371
        self.addCleanup(launcher_instance.key_nav_end, True)
 
372
        sleep(.5)
 
373
        launcher_instance.key_nav_next()
 
374
        sleep(.5)
 
375
        launcher_instance.key_nav_enter_quicklist()
 
376
        self.addCleanup(launcher_instance.key_nav_exit_quicklist)
 
377
        sleep(.5)
 
378
        self.assertThat(launcher_instance.is_quicklist_open(), Equals(True))
 
379
 
 
380
    def test_launcher_keynav_can_close_quicklist(self):
 
381
        """Tests that we can close a quicklist from keynav mode."""
 
382
        launcher_instance = self.get_launcher()
 
383
        launcher_instance.move_mouse_to_right_of_launcher()
 
384
        sleep(.5)
 
385
        launcher_instance.key_nav_start()
 
386
        self.addCleanup(launcher_instance.key_nav_end, True)
 
387
        sleep(.5)
 
388
        launcher_instance.key_nav_next()
 
389
        sleep(.5)
 
390
        launcher_instance.key_nav_enter_quicklist()
 
391
        sleep(.5)
 
392
        launcher_instance.key_nav_exit_quicklist()
 
393
 
 
394
        self.assertThat(launcher_instance.is_quicklist_open(), Equals(False))
 
395
        self.assertThat(self.launcher.key_nav_is_active, Equals(True))
 
396
        self.assertThat(self.launcher.key_nav_is_grabbed, Equals(True))
 
397
 
 
398
class LauncherRevealTests(ScenariodLauncherTests):
 
399
    """Test the launcher reveal bahavior when in autohide mode."""
 
400
 
 
401
    def setUp(self):
 
402
        super(LauncherRevealTests, self).setUp()
 
403
        self.set_unity_option('launcher_hide_mode', True)
 
404
        sleep(1)
13
405
 
14
406
    def test_reveal_on_mouse_to_edge(self):
15
 
        self.server.move_mouse_outside_of_boundry()
16
 
        self.server.move_mouse_to_reveal_pos()
17
 
        self.assertThat(self.server.is_showing(), Equals(True))
 
407
        """Tests reveal of launchers by mouse pressure."""
 
408
        launcher_instance = self.get_launcher()
 
409
        launcher_instance.move_mouse_to_right_of_launcher()
 
410
        launcher_instance.reveal_launcher()
 
411
        self.assertThat(launcher_instance.is_showing(), Equals(True))
 
412
 
 
413
    def test_reveal_with_mouse_under_launcher(self):
 
414
        """Tests that the launcher hides properly if the
 
415
        mouse is under the launcher when it is revealed.
 
416
 
 
417
        """
 
418
        launcher_instance = self.get_launcher()
 
419
 
 
420
        launcher_instance.move_mouse_over_launcher()
 
421
        # we can't use "launcher_instance.keyboard_reveal_launcher()"
 
422
        # since it moves the mouse out of the way, invalidating the test.
 
423
        self.keybinding_hold("launcher/reveal")
 
424
        sleep(1)
 
425
        self.keybinding_release("launcher/reveal")
 
426
        sleep(2)
 
427
        self.assertThat(launcher_instance.is_showing(), Equals(False))
 
428
 
 
429
    def test_reveal_does_not_hide_again(self):
 
430
        """Tests reveal of launchers by mouse pressure to ensure it doesn't
 
431
        automatically hide again.
 
432
 
 
433
        """
 
434
        launcher_instance = self.get_launcher()
 
435
 
 
436
        launcher_instance.move_mouse_to_right_of_launcher()
 
437
        launcher_instance.reveal_launcher()
 
438
        sleep(2)
 
439
        self.assertThat(launcher_instance.is_showing(), Equals(True))
 
440
 
 
441
    def test_launcher_does_not_reveal_with_mouse_down(self):
 
442
        """Launcher must not reveal if have mouse button 1 down."""
 
443
        launcher_instance = self.get_launcher()
 
444
        screens = ScreenGeometry()
 
445
 
 
446
        screens.move_mouse_to_monitor(launcher_instance.monitor)
 
447
        self.mouse.press(1)
 
448
        launcher_instance.reveal_launcher()
 
449
        self.assertThat(launcher_instance.is_showing(), Equals(False))
 
450
        self.mouse.release(1)