diff options
24 files changed, 907 insertions, 905 deletions
diff --git a/tests/autopilot/unity/emulators/dash.py b/tests/autopilot/unity/emulators/dash.py index eaf4d472a..ee6c404b3 100644 --- a/tests/autopilot/unity/emulators/dash.py +++ b/tests/autopilot/unity/emulators/dash.py @@ -20,20 +20,23 @@ import dbus logger = logging.getLogger(__name__) -class Dash(KeybindingsHelper): - """ - An emulator class that makes it easier to interact with the unity dash. - """ +class DashController(UnityIntrospectionObject, KeybindingsHelper): + """The main dash controller object.""" + + def get_dash_view(self): + """Get the dash view that's attached to this controller.""" + return self.get_children_by_type(DashView)[0] - def __init__(self): - super(Dash, self).__init__() - controllers = DashController.get_all_instances() - assert(len(controllers) == 1) - self.controller = controllers[0] + def hide_dash_via_dbus(self): + """ Emulate a DBus call for dash hiding """ + dash_object = dbus.SessionBus().get_object('com.canonical.Unity', + '/com/canonical/Unity/Dash') + dash_iface = dbus.Interface(dash_object, 'com.canonical.Unity.Dash') + dash_iface.HideDash() @property def view(self): - return self.controller.get_dash_view() + return self.get_dash_view() def toggle_reveal(self): """ @@ -63,21 +66,6 @@ class Dash(KeybindingsHelper): self.visible.wait_for(False) @property - def visible(self): - """Returns if the dash is currently visible""" - return self.controller.visible - - @property - def monitor(self): - """The monitor where the dash is""" - return self.controller.monitor - - @property - def ideal_monitor(self): - """The ideal monitor for the dash to appear on""" - return self.controller.ideal_monitor - - @property def search_string(self): return self.searchbar.search_string @@ -157,21 +145,6 @@ class Dash(KeybindingsHelper): return (self.view.x, self.view.y, self.view.width, self.view.height) -class DashController(UnityIntrospectionObject): - """The main dash controller object.""" - - def get_dash_view(self): - """Get the dash view that's attached to this controller.""" - return self.get_children_by_type(DashView)[0] - - def hide_dash_via_dbus(self): - """ Emulate a DBus call for dash hiding """ - dash_object = dbus.SessionBus().get_object('com.canonical.Unity', - '/com/canonical/Unity/Dash') - dash_iface = dbus.Interface(dash_object, 'com.canonical.Unity.Dash') - dash_iface.HideDash() - - class DashView(UnityIntrospectionObject): """The dash view.""" diff --git a/tests/autopilot/unity/emulators/hud.py b/tests/autopilot/unity/emulators/hud.py index b43fb8c46..fa3fa8e1e 100644 --- a/tests/autopilot/unity/emulators/hud.py +++ b/tests/autopilot/unity/emulators/hud.py @@ -19,16 +19,17 @@ from unity.emulators.dash import SearchBar from unity.emulators.icons import HudEmbeddedIcon, HudLauncherIcon -class Hud(KeybindingsHelper): - """An emulator class that makes it easier to iteract with unity hud.""" - - def __init__(self): - super (Hud, self).__init__() - controllers = HudController.get_all_instances() - assert(len(controllers) == 1) - self.controller = controllers[0] +class HudController(UnityIntrospectionObject, KeybindingsHelper): + """Proxy object for the Unity Hud Controller.""" + + def __init__(self, *args, **kwargs): + super(HudController, self).__init__(*args, **kwargs) self.keyboard = Keyboard() + def get_hud_view(self): + views = self.get_children_by_type(HudView) + return views[0] if views else None + def ensure_hidden(self): """Hides the hud if it's not already hidden.""" if self.visible: @@ -77,17 +78,12 @@ class Hud(KeybindingsHelper): @property def view(self): """Returns the HudView.""" - return self.controller.get_hud_view() - - @property - def visible(self): - """Is the Hud visible?""" - return self.controller.visible + return self.get_hud_view() @property def searchbar(self): """Returns the searchbar attached to the hud.""" - return self.controller.get_hud_view().searchbar + return self.get_hud_view().searchbar @property def search_string(self): @@ -96,24 +92,19 @@ class Hud(KeybindingsHelper): @property def is_locked_launcher(self): - return self.controller.locked_to_launcher + return self.locked_to_launcher @property def monitor(self): - return self.controller.hud_monitor - - @property - def ideal_monitor(self): - """The target monitor for the Hud to appear on.""" - return self.controller.ideal_monitor + return self.hud_monitor @property def geometry(self): - return (self.controller.x, self.controller.y, self.controller.width, self.controller.height) + return (self.x, self.y, self.width, self.height) @property def selected_button(self): - view = self.controller.get_hud_view() + view = self.get_hud_view() if view: return view.selected_button else: @@ -134,7 +125,7 @@ class Hud(KeybindingsHelper): @property def num_buttons(self): - view = self.controller.get_hud_view() + view = self.get_hud_view() if view: return view.num_buttons else: @@ -158,13 +149,6 @@ class HudView(UnityIntrospectionObject): return (self.x, self.y, self.width, self.height) -class HudController(UnityIntrospectionObject): - """Proxy object for the Unity Hud Controller.""" - - def get_hud_view(self): - views = self.get_children_by_type(HudView) - return views[0] if views else None - class HudButton(UnityIntrospectionObject): """Proxy object for the hud buttons.""" diff --git a/tests/autopilot/unity/emulators/switcher.py b/tests/autopilot/unity/emulators/switcher.py index d675ecafb..367b7a194 100644 --- a/tests/autopilot/unity/emulators/switcher.py +++ b/tests/autopilot/unity/emulators/switcher.py @@ -29,7 +29,13 @@ class SwitcherMode(): DETAIL = 2 -class Switcher(KeybindingsHelper): +class SwitcherDirection(): + """Directions the switcher can switch in.""" + FORWARDS = 0 + BACKWARDS = 1 + + +class SwitcherController(UnityIntrospectionObject, KeybindingsHelper): """A class for interacting with the switcher. Abstracts out switcher implementation, and makes the necessary functionality available @@ -37,29 +43,37 @@ class Switcher(KeybindingsHelper): """ - DIRECTION_FORWARDS = 0 - DIRECTION_BACKWARDS = 1 - - def __init__(self): - super(Switcher, self).__init__() + def __init__(self, *args, **kwargs): + super(SwitcherController, self).__init__(*args, **kwargs) self._mouse = Mouse() - controllers = SwitcherController.get_all_instances() - assert(len(controllers) == 1) - self.controller = controllers[0] + + def get_switcher_view(self): + views = self.get_children_by_type(SwitcherView) + return views[0] if views else None + + @property + def view(self): + """Returns the SwitcherView.""" + return self.get_switcher_view() @property - def visible(self): - """Is the switcher currently visible + def model(self): + models = self.get_children_by_type(SwitcherModel) + return models[0] if models else None - """ - return self.controller.visible + # @property + # def visible(self): + # """Is the switcher currently visible + + # """ + # return self.visible @property def icons(self): """The set of icons in the switcher model """ - return self.controller.model.icons + return self.model.icons @property def current_icon(self): @@ -69,28 +83,28 @@ class Switcher(KeybindingsHelper): @property def selection_index(self): """The index of the currently selected icon""" - return self.controller.model.selection_index + return self.model.selection_index @property def label(self): """The current switcher label""" - return self.controller.view.label + return self.view.label @property def label_visible(self): """The switcher label visibility""" - return self.controller.view.label_visible + return self.view.label_visible @property def mode(self): """Returns the SwitcherMode that the switcher is currently in.""" if not self.visible: return None - if self.controller.model.detail_selection and not self.controller.model.only_detail_on_viewport: + if self.model.detail_selection and not self.model.only_detail_on_viewport: return SwitcherMode.DETAIL, SwitcherMode.ALL - elif self.controller.model.detail_selection: + elif self.model.detail_selection: return SwitcherMode.DETAIL - elif not self.controller.model.only_detail_on_viewport: + elif not self.model.only_detail_on_viewport: return SwitcherMode.ALL else: return SwitcherMode.NORMAL @@ -108,7 +122,7 @@ class Switcher(KeybindingsHelper): elif mode == SwitcherMode.ALL: logger.debug("Initiating switcher in 'all workspaces' mode. Ctrl+Alt+Tab") self.keybinding_hold_part_then_tap("switcher/reveal_all") - self.controller.model.only_detail_on_viewport.wait_for(False) + self.model.only_detail_on_viewport.wait_for(False) def next_icon(self): """Move to the next icon.""" @@ -123,12 +137,12 @@ class Switcher(KeybindingsHelper): def select_icon(self, direction, **kwargs): """Select an icon in the switcher. - direction must be one of Switcher.DIRECTION_FORWARDS or Switcher.DIRECTION_BACKWARDS. + direction must be one of SwitcherDirection.FORWARDS or SwitcherDirection.BACKWARDS. The keyword arguments are used to select an icon. For example, you might do this to select the 'Show Desktop' icon: - >>> self.switcher.select_icon(Switcher.DIRECTION_BACKWARDS, tooltip_text="Show Desktop") + >>> self.switcher.select_icon(SwitcherDirection.BACKWARDS, tooltip_text="Show Desktop") The switcher must be initiated already, and must be in normal mode when this method is called, or a RuntimeError will be raised. @@ -139,10 +153,10 @@ class Switcher(KeybindingsHelper): if self.mode == SwitcherMode.DETAIL: raise RuntimeError("Switcher must be initiated in normal mode before calling this method.") - if direction not in (self.DIRECTION_BACKWARDS, self.DIRECTION_FORWARDS): - raise ValueError("direction must be one of Switcher.DIRECTION_BACKWARDS, Switcher.DIRECTION_FORWARDS") + if direction not in (SwitcherDirection.BACKWARDS, SwitcherDirection.FORWARDS): + raise ValueError("direction must be one of SwitcherDirection.BACKWARDS, SwitcherDirection.FORWARDS") - for i in self.controller.model.icons: + for i in self.model.icons: current_icon = self.current_icon passed=True for key,val in kwargs.iteritems(): @@ -150,9 +164,9 @@ class Switcher(KeybindingsHelper): passed=False if passed: return - if direction == self.DIRECTION_FORWARDS: + if direction == SwitcherDirection.FORWARDS: self.next_icon() - elif direction == self.DIRECTION_BACKWARDS: + elif direction == SwitcherDirection.BACKWARDS: self.previous_icon() raise ValueError("No icon found in switcher model that matches: %r" % kwargs) @@ -164,20 +178,20 @@ class Switcher(KeybindingsHelper): """ logger.debug("Cancelling switcher.") self.keybinding("switcher/cancel") - self.controller.visible.wait_for(False) + self.visible.wait_for(False) def terminate(self): """Stop switcher without activating the selected icon.""" logger.debug("Terminating switcher.") self.keybinding("switcher/cancel") self.keybinding_release("switcher/reveal_normal") - self.controller.visible.wait_for(False) + self.visible.wait_for(False) def select(self): """Stop switcher and activate the selected icon.""" logger.debug("Stopping switcher") self.keybinding_release("switcher/reveal_normal") - self.controller.visible.wait_for(False) + self.visible.wait_for(False) def next_via_mouse(self): """Move to the next icon using the mouse scroll wheel.""" @@ -194,24 +208,24 @@ class Switcher(KeybindingsHelper): @property def detail_selection_index(self): """The index of the currently selected detail""" - return self.controller.model.detail_selection_index + return self.model.detail_selection_index @property def detail_current_count(self): """The number of shown details""" - return self.controller.model.detail_current_count + return self.model.detail_current_count def show_details(self): """Show detail mode.""" logger.debug("Showing details view.") self.keybinding("switcher/detail_start") - self.controller.model.detail_selection.wait_for(True) + self.model.detail_selection.wait_for(True) def hide_details(self): """Hide detail mode.""" logger.debug("Hiding details view.") self.keybinding("switcher/detail_stop") - self.controller.model.detail_selection.wait_for(False) + self.model.detail_selection.wait_for(False) def next_detail(self): """Move to next detail in the switcher.""" @@ -224,18 +238,6 @@ class Switcher(KeybindingsHelper): self.keybinding("switcher/detail_prev") -class SwitcherController(UnityIntrospectionObject): - """An emulator class for interacting with the switcher controller.""" - - @property - def view(self): - return self.get_children_by_type(SwitcherView)[0] - - @property - def model(self): - return self.get_children_by_type(SwitcherModel)[0] - - class SwitcherView(UnityIntrospectionObject): """An emulator class for interacting with with SwitcherView.""" @@ -246,4 +248,3 @@ class SwitcherModel(UnityIntrospectionObject): @property def icons(self): return self.get_children_by_type(SimpleLauncherIcon) - diff --git a/tests/autopilot/unity/emulators/unity.py b/tests/autopilot/unity/emulators/unity.py index 6f0a31be9..22fdde19b 100644 --- a/tests/autopilot/unity/emulators/unity.py +++ b/tests/autopilot/unity/emulators/unity.py @@ -11,6 +11,17 @@ from __future__ import absolute_import from dbus import Interface, SessionBus +from unity.emulators import UnityIntrospectionObject +from unity.emulators.dash import DashController +from unity.emulators.hud import HudController +from unity.emulators.launcher import LauncherController +from unity.emulators.panel import PanelController +from unity.emulators.screen import Screen +from unity.emulators.shortcut_hint import ShortcutController +from unity.emulators.switcher import SwitcherController +from unity.emulators.window_manager import WindowManager + + # acquire the debugging dbus object UNITY_BUS_NAME = 'com.canonical.Unity' DEBUG_PATH = '/com/canonical/Unity/Debug' @@ -59,3 +70,37 @@ def log_unity_message(severity, message): """ get_dbus_logging_interface().LogMessage(severity, message) + +class Unity(UnityIntrospectionObject): + + @property + def screen(self): + return self.get_children_by_type(Screen)[0] + + @property + def dash(self): + return self.get_children_by_type(DashController)[0] + + @property + def hud(self): + return self.get_children_by_type(HudController)[0] + + @property + def launcher(self): + return self.get_children_by_type(LauncherController)[0] + + @property + def panels(self): + return self.get_children_by_type(PanelController)[0] + + @property + def switcher(self): + return self.get_children_by_type(SwitcherController)[0] + + @property + def shortcut_hint(self): + return self.get_children_by_type(ShortcutController)[0] + + @property + def window_manager(self): + return self.get_children_by_type(WindowManager)[0] diff --git a/tests/autopilot/unity/tests/__init__.py b/tests/autopilot/unity/tests/__init__.py index 164f8dba7..4d9cc64eb 100644 --- a/tests/autopilot/unity/tests/__init__.py +++ b/tests/autopilot/unity/tests/__init__.py @@ -95,7 +95,7 @@ class UnityTestCase(AutopilotTestCase): well_behaved = False reasons.append("The test left the dash open.") log.warning("Test left the dash open, closing it...") - self.dash.ensure_hidden() + self.unity.dash.ensure_hidden() # ... or the hud? if not self.well_behaved(self.hud, visible=False): well_behaved = False diff --git a/tests/autopilot/unity/tests/launcher/test_icon_behavior.py b/tests/autopilot/unity/tests/launcher/test_icon_behavior.py index d8ebdff93..56e231b57 100644 --- a/tests/autopilot/unity/tests/launcher/test_icon_behavior.py +++ b/tests/autopilot/unity/tests/launcher/test_icon_behavior.py @@ -45,7 +45,7 @@ class LauncherIconsTests(LauncherTestCase): self.addCleanup(self.call_gsettings_cmd, 'set', 'com.canonical.Unity.Launcher', 'favorites', old_fav) self.call_gsettings_cmd('set', 'com.canonical.Unity.Launcher', 'favorites', new_fav) - icon = self.launcher.model.get_children_by_type(ExpoLauncherIcon)[0] + icon = self.unity.launcher.model.get_children_by_type(ExpoLauncherIcon)[0] self.assertThat(icon, NotEquals(None)) self.assertThat(icon.visible, Eventually(Equals(True))) @@ -53,7 +53,7 @@ class LauncherIconsTests(LauncherTestCase): def ensure_calculator_in_launcher_and_not_running(self): calc = self.start_app("Calculator") - calc_icon = self.launcher.model.get_icon(desktop_id=calc.desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file) self.addCleanup(self.launcher_instance.unlock_from_launcher, calc_icon) self.launcher_instance.lock_to_launcher(calc_icon) self.close_all_app("Calculator") @@ -67,21 +67,21 @@ class LauncherIconsTests(LauncherTestCase): def test_bfb_tooltip_disappear_when_dash_is_opened(self): """Tests that the bfb tooltip disappear when the dash is opened.""" - bfb = self.launcher.model.get_bfb_icon() + bfb = self.unity.launcher.model.get_bfb_icon() self.mouse.move(bfb.center_x, bfb.center_y) self.assertThat(bfb.get_tooltip().active, Eventually(Equals(True))) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False))) def test_bfb_tooltip_is_disabled_when_dash_is_open(self): """Tests the that bfb tooltip is disabled when the dash is open.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) - bfb = self.launcher.model.get_bfb_icon() + bfb = self.unity.launcher.model.get_bfb_icon() self.mouse.move(bfb.center_x, bfb.center_y) # Tooltips are lazy-created in Unity, so if the BFB tooltip has never @@ -94,8 +94,8 @@ class LauncherIconsTests(LauncherTestCase): def test_shift_click_opens_new_application_instance(self): """Shift+Clicking MUST open a new instance of an already-running application.""" app = self.start_app("Calculator") - icon = self.launcher.model.get_icon(desktop_id=app.desktop_file) - launcher_instance = self.launcher.get_launcher_for_monitor(0) + icon = self.unity.launcher.model.get_icon(desktop_id=app.desktop_file) + launcher_instance = self.unity.launcher.get_launcher_for_monitor(0) self.keyboard.press("Shift") self.addCleanup(self.keyboard.release, "Shift") @@ -114,9 +114,9 @@ class LauncherIconsTests(LauncherTestCase): self.assertVisibleWindowStack([char_win2, calc_win, char_win1]) - char_icon = self.launcher.model.get_icon( + char_icon = self.unity.launcher.model.get_icon( desktop_id=char_win2.application.desktop_file) - calc_icon = self.launcher.model.get_icon( + calc_icon = self.unity.launcher.model.get_icon( desktop_id=calc_win.application.desktop_file) self.launcher_instance.click_launcher_icon(calc_icon) @@ -160,12 +160,12 @@ class LauncherIconsTests(LauncherTestCase): self.assertVisibleWindowStack([char_win2, char_win1]) self.assertProperty(char_win2, is_focused=True) - char_icon = self.launcher.model.get_icon(desktop_id=char_app.desktop_file) + char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file) self.addCleanup(self.keybinding, "spread/cancel") self.launcher_instance.click_launcher_icon(char_icon) - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) - self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active_for_group, Eventually(Equals(True))) def test_while_in_scale_mode_the_dash_will_still_open(self): """If scale is initiated through the laucher pressing super must close @@ -178,28 +178,28 @@ class LauncherIconsTests(LauncherTestCase): self.assertVisibleWindowStack([char_win2, char_win1]) self.assertProperty(char_win2, is_focused=True) - char_icon = self.launcher.model.get_icon(desktop_id=char_app.desktop_file) + char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file) self.launcher_instance.click_launcher_icon(char_icon) - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) - self.assertThat(self.dash.visible, Eventually(Equals(True))) - self.assertThat(self.window_manager.scale_active, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(False))) def test_icon_shows_on_quick_application_reopen(self): """Icons must stay on launcher when an application is quickly closed/reopened.""" calc = self.start_app("Calculator") desktop_file = calc.desktop_file - calc_icon = self.launcher.model.get_icon(desktop_id=desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file) self.assertThat(calc_icon.visible, Eventually(Equals(True))) self.close_all_app("Calculator") calc = self.start_app("Calculator") sleep(2) - calc_icon = self.launcher.model.get_icon(desktop_id=desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file) self.assertThat(calc_icon, NotEquals(None)) self.assertThat(calc_icon.visible, Eventually(Equals(True))) @@ -212,15 +212,15 @@ class LauncherIconsTests(LauncherTestCase): self.skipTest("This test requires enabled workspaces.") self.keybinding("expo/start") - self.assertThat(self.window_manager.expo_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.expo_active, Eventually(Equals(True))) self.addCleanup(self.keybinding, "expo/cancel") - bfb = self.launcher.model.get_bfb_icon() + bfb = self.unity.launcher.model.get_bfb_icon() self.mouse.move(bfb.center_x, bfb.center_y) self.mouse.click(button=3) self.assertThat(self.launcher_instance.quicklist_open, Eventually(Equals(True))) - self.assertThat(self.window_manager.expo_active, Eventually(Equals(False))) + self.assertThat(self.unity.window_manager.expo_active, Eventually(Equals(False))) def test_expo_launcher_icon_initiates_expo(self): """Clicking on the expo launcher icon must start the expo.""" @@ -231,7 +231,7 @@ class LauncherIconsTests(LauncherTestCase): self.addCleanup(self.keybinding, "expo/cancel") self.launcher_instance.click_launcher_icon(expo) - self.assertThat(self.window_manager.expo_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.expo_active, Eventually(Equals(True))) def test_expo_launcher_icon_terminates_expo(self): """Clicking on the expo launcher icon when expo is active must close it.""" @@ -239,13 +239,13 @@ class LauncherIconsTests(LauncherTestCase): self.skipTest("This test requires enabled workspaces.") self.keybinding("expo/start") - self.assertThat(self.window_manager.expo_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.expo_active, Eventually(Equals(True))) self.addCleanup(self.keybinding, "expo/cancel") expo = self.ensure_expo_launcher_icon() self.launcher_instance.click_launcher_icon(expo) - self.assertThat(self.window_manager.expo_active, Eventually(Equals(False))) + self.assertThat(self.unity.window_manager.expo_active, Eventually(Equals(False))) def test_unminimize_initially_minimized_windows(self): """Make sure initially minimized windows can be unminimized.""" @@ -255,7 +255,7 @@ class LauncherIconsTests(LauncherTestCase): } window = self.launch_test_window(window_spec) - icon = self.launcher.model.get_icon(desktop_id=window.application.desktop_file) + icon = self.unity.launcher.model.get_icon(desktop_id=window.application.desktop_file) self.launcher_instance.click_launcher_icon(icon) self.assertThat(lambda: window.x_win.get_wm_state()['state'], Eventually(Equals(Xutil.NormalState))) @@ -268,7 +268,7 @@ class LauncherIconsTests(LauncherTestCase): } window = self.launch_test_window(window_spec) - icon = self.launcher.model.get_icon(desktop_id=window.application.desktop_file) + icon = self.unity.launcher.model.get_icon(desktop_id=window.application.desktop_file) self.launcher_instance.click_launcher_icon(icon) self.assertThat(lambda: window.x_win.get_wm_state()['state'], Eventually(Equals(Xutil.NormalState))) @@ -291,7 +291,7 @@ class LauncherDragIconsBehavior(LauncherTestCase): # Normally we'd use get_icon(desktop_id="...") but we're expecting it to # not exist, and we don't want to wait for 10 seconds, so we do this # the old fashioned way. - get_icon_fn = lambda: self.launcher.model.get_children_by_type( + get_icon_fn = lambda: self.unity.launcher.model.get_children_by_type( ApplicationLauncherIcon, desktop_id="gcalctool.desktop") calc_icon = get_icon_fn() if calc_icon: @@ -304,15 +304,15 @@ class LauncherDragIconsBehavior(LauncherTestCase): self.ensure_calc_icon_not_in_launcher() calc = self.start_app("Calculator") - calc_icon = self.launcher.model.get_icon(desktop_id=calc.desktop_file) - bfb_icon = self.launcher.model.get_bfb_icon() + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file) + bfb_icon = self.unity.launcher.model.get_bfb_icon() self.launcher_instance.drag_icon_to_position( calc_icon, IconDragType.AFTER, bfb_icon, self.drag_type) - moved_icon = self.launcher.model.\ + moved_icon = self.unity.launcher.model.\ get_launcher_icons_for_monitor(self.launcher_monitor)[1] self.assertThat(moved_icon.id, Equals(calc_icon.id)) @@ -321,9 +321,9 @@ class LauncherDragIconsBehavior(LauncherTestCase): self.ensure_calc_icon_not_in_launcher() calc = self.start_app("Calculator") - calc_icon = self.launcher.model.get_icon(desktop_id=calc.desktop_file) - bfb_icon = self.launcher.model.get_bfb_icon() - trash_icon = self.launcher.model.get_trash_icon() + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file) + bfb_icon = self.unity.launcher.model.get_bfb_icon() + trash_icon = self.unity.launcher.model.get_trash_icon() # Move a known icon to the top as it needs to be more than 2 icon # spaces away for this test to actually do anything @@ -341,7 +341,7 @@ class LauncherDragIconsBehavior(LauncherTestCase): self.drag_type) # Must be the last bamf icon - not necessarily the third-from-end icon. - refresh_fn = lambda: self.launcher.model.get_launcher_icons()[-2].id + refresh_fn = lambda: self.unity.launcher.model.get_launcher_icons()[-2].id self.assertThat(refresh_fn, Eventually(Equals(calc_icon.id)), - "Launcher icons are: %r" % self.launcher.model.get_launcher_icons()) + "Launcher icons are: %r" % self.unity.launcher.model.get_launcher_icons()) diff --git a/tests/autopilot/unity/tests/launcher/test_keynav.py b/tests/autopilot/unity/tests/launcher/test_keynav.py index 69b0e5ac7..f9f79d90a 100644 --- a/tests/autopilot/unity/tests/launcher/test_keynav.py +++ b/tests/autopilot/unity/tests/launcher/test_keynav.py @@ -33,21 +33,21 @@ class LauncherKeyNavTests(LauncherTestCase): def safe_quit_keynav(self): """Quit the keynav mode if it's engaged.""" - if self.launcher.key_nav_is_active: + if self.unity.launcher.key_nav_is_active: self.launcher_instance.key_nav_cancel() def test_launcher_keynav_initiate(self): """Tests we can initiate keyboard navigation on the launcher.""" self.start_keynav_with_cleanup_cancel() - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(True))) - self.assertThat(self.launcher.key_nav_is_grabbed, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_grabbed, Eventually(Equals(True))) def test_launcher_keynav_cancel(self): """Test that we can exit keynav mode.""" self.launcher_instance.key_nav_start() self.launcher_instance.key_nav_cancel() - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) - self.assertThat(self.launcher.key_nav_is_grabbed, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_grabbed, Eventually(Equals(False))) def test_launcher_keynav_cancel_resume_focus(self): """Test that ending the launcher keynav resume the focus.""" @@ -63,7 +63,7 @@ class LauncherKeyNavTests(LauncherTestCase): def test_launcher_keynav_starts_at_index_zero(self): """Test keynav mode starts at index 0.""" self.start_keynav_with_cleanup_cancel() - self.assertThat(self.launcher.key_nav_selection, Eventually(Equals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0))) def test_launcher_keynav_forward(self): """Must be able to move forwards while in keynav mode.""" @@ -75,37 +75,37 @@ class LauncherKeyNavTests(LauncherTestCase): # make sure that the index has increased. This opens us to the # possibility that the launcher really is skipping forward more than one # icon at a time, but we can't do much about that. - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(0))) def test_launcher_keynav_prev_works(self): """Must be able to move backwards while in keynav mode.""" self.start_keynav_with_cleanup_cancel() self.launcher_instance.key_nav_next() - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(0))) self.launcher_instance.key_nav_prev() - self.assertThat(self.launcher.key_nav_selection, Eventually(Equals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0))) def test_launcher_keynav_cycling_forward(self): """Launcher keynav must loop through icons when cycling forwards""" self.start_keynav_with_cleanup_cancel() prev_icon = 0 - for icon in range(1, self.launcher.model.num_launcher_icons()): + for icon in range(1, self.unity.launcher.model.num_launcher_icons()): self.launcher_instance.key_nav_next() # FIXME We can't directly check for selection/icon number equalty # since the launcher model also contains "hidden" icons that aren't # shown, so the selection index can increment by more than 1. - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(prev_icon))) - prev_icon = self.launcher.key_nav_selection + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(prev_icon))) + prev_icon = self.unity.launcher.key_nav_selection self.launcher_instance.key_nav_next() - self.assertThat(self.launcher.key_nav_selection, Eventually(Equals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0))) def test_launcher_keynav_cycling_backward(self): """Launcher keynav must loop through icons when cycling backwards""" self.start_keynav_with_cleanup_cancel() self.launcher_instance.key_nav_prev() - # FIXME We can't directly check for self.launcher.num_launcher_icons - 1 - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(1))) + # FIXME We can't directly check for self.unity.launcher.num_launcher_icons - 1 + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(1))) def test_launcher_keynav_can_open_and_close_quicklist(self): """Tests that we can open and close a quicklist from keynav mode.""" @@ -115,15 +115,15 @@ class LauncherKeyNavTests(LauncherTestCase): self.assertThat(self.launcher_instance.quicklist_open, Eventually(Equals(True))) self.launcher_instance.key_nav_exit_quicklist() self.assertThat(self.launcher_instance.quicklist_open, Eventually(Equals(False))) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(True))) - self.assertThat(self.launcher.key_nav_is_grabbed, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_grabbed, Eventually(Equals(True))) def test_launcher_keynav_mode_toggles(self): """Tests that keynav mode toggles with Alt+F1.""" # was initiated in setup. self.start_keynav_with_cleanup_cancel() self.keybinding("launcher/keynav") - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_activate_keep_focus(self): """Activating a running launcher icon must focus it.""" @@ -151,13 +151,12 @@ class LauncherKeyNavTests(LauncherTestCase): self.launcher_instance.key_nav_activate() self.addCleanup(self.keybinding, "expo/cancel") - self.assertThat(self.panels.get_active_panel().title, Eventually(Equals("Ubuntu Desktop"))) + self.assertThat(self.unity.panels.get_active_panel().title, Eventually(Equals("Ubuntu Desktop"))) def test_launcher_keynav_expo_exit_on_esc(self): """Esc should quit expo when entering it from KeyNav.""" if self.workspace.num_workspaces < 2: self.skipTest("This test requires enabled more than one workspace.") - self.start_keynav_with_cleanup_cancel() self.launcher_instance.keyboard_select_icon(tooltip_text="Workspace Switcher") @@ -171,39 +170,39 @@ class LauncherKeyNavTests(LauncherTestCase): self.start_keynav_with_cleanup_cancel() self.keybinding("switcher/reveal_normal") - self.addCleanup(self.switcher.terminate) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.addCleanup(self.unity.switcher.terminate) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_alt_grave_quits(self): """Tests that alt+` exits keynav mode.""" self.start_keynav_with_cleanup_cancel() # Can't use switcher emulat here since the switcher won't appear. self.keybinding("switcher/reveal_details") - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_cancel_doesnt_activate_icon(self): """This tests when canceling keynav the current icon doesnt activate.""" self.start_keynav_with_cleanup_cancel() self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_alt_f1_closes_dash(self): """Pressing Alt+F1 when the Dash is open must close the Dash and start keynav.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.start_keynav_with_cleanup_cancel() - self.assertThat(self.dash.visible, Equals(False)) - self.assertThat(self.launcher.key_nav_is_active, Equals(True)) + self.assertThat(self.unity.dash.visible, Equals(False)) + self.assertThat(self.unity.launcher.key_nav_is_active, Equals(True)) def test_alt_f1_closes_hud(self): """Pressing Alt+F1 when the HUD is open must close the HUD and start keynav.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.start_keynav_with_cleanup_cancel() - self.assertThat(self.hud.visible, Equals(False)) - self.assertThat(self.launcher.key_nav_is_active, Equals(True)) + self.assertThat(self.unity.hud.visible, Equals(False)) + self.assertThat(self.unity.launcher.key_nav_is_active, Equals(True)) def test_launcher_keynav_cancel_on_click_outside(self): """A single click outside of launcher must cancel keynav.""" @@ -212,36 +211,36 @@ class LauncherKeyNavTests(LauncherTestCase): self.launcher_instance.move_mouse_to_right_of_launcher() self.mouse.click() - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_cancel_on_click_icon(self): """A single click on a launcher icon must cancel keynav.""" calc_win = self.start_app_window('Calculator', locale = 'C') calc_app = calc_win.application - calc_icon = self.launcher.model.get_icon(desktop_id=calc_app.desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc_app.desktop_file) self.start_keynav_with_cleanup_cancel() self.launcher_instance.click_launcher_icon(calc_icon) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_cancel_on_quicklist_activate(self): """A single click on a quicklist item must cancel keynav.""" self.start_keynav_with_cleanup_cancel() self.launcher_instance.key_nav_enter_quicklist() - bfb_icon = self.launcher.model.get_bfb_icon() + bfb_icon = self.unity.launcher.model.get_bfb_icon() bfb_ql = bfb_icon.get_quicklist() bfb_ql.click_item(bfb_ql.selected_item) - self.addCleanup(self.dash.ensure_hidden) + self.addCleanup(self.unity.dash.ensure_hidden) - self.assertThat(self.dash.visible, Eventually(Equals(True))) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_keynav_changes_panel(self): """The panel title must change when in key nav mode.""" self.start_keynav_with_cleanup_cancel() - self.assertThat(self.panels.get_active_panel().title, Eventually(Equals("Search your computer and online sources"))) + self.assertThat(self.unity.panels.get_active_panel().title, Eventually(Equals("Search your computer and online sources"))) diff --git a/tests/autopilot/unity/tests/launcher/test_reveal.py b/tests/autopilot/unity/tests/launcher/test_reveal.py index 45976fa7b..d1bfb22b8 100644 --- a/tests/autopilot/unity/tests/launcher/test_reveal.py +++ b/tests/autopilot/unity/tests/launcher/test_reveal.py @@ -79,21 +79,21 @@ class LauncherRevealTests(LauncherTestCase): char_win2 = self.start_app_window("Character Map") char_app = char_win1.application - char_icon = self.launcher.model.get_icon(desktop_id=char_app.desktop_file) + char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file) self.launcher_instance.click_launcher_icon(char_icon, move_mouse_after=False) - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) self.launcher_instance.click_launcher_icon(char_icon, move_mouse_after=False) self.assertThat(self.launcher_instance.is_showing, Eventually(Equals(True))) - self.assertThat(self.window_manager.scale_active, Eventually(Equals(False))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(False))) def test_launcher_stays_open_after_icon_click(self): """Clicking on a launcher icon must not hide the launcher.""" char_win = self.start_app_window("Character Map") char_app = char_win.application - char_icon = self.launcher.model.get_icon(desktop_id=char_app.desktop_file) + char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file) self.launcher_instance.click_launcher_icon(char_icon, move_mouse_after=False) # Have to sleep to give the launcher time to hide (what the old behavior was) @@ -103,13 +103,13 @@ class LauncherRevealTests(LauncherTestCase): def test_new_icon_has_the_shortcut(self): """New icons should have an associated shortcut""" - if self.launcher.model.num_bamf_launcher_icons() >= 10: + if self.unity.launcher.model.num_bamf_launcher_icons() >= 10: self.skip("There are already more than 9 icons in the launcher") desktop_file = self.KNOWN_APPS['Calculator']['desktop-file'] - if self.launcher.model.get_icon(desktop_id=desktop_file) != None: + if self.unity.launcher.model.get_icon(desktop_id=desktop_file) != None: self.skip("Calculator icon is already on the launcher.") self.start_app('Calculator') - icon = self.launcher.model.get_icon(desktop_id=desktop_file) + icon = self.unity.launcher.model.get_icon(desktop_id=desktop_file) self.assertThat(icon.shortcut, GreaterThan(0)) diff --git a/tests/autopilot/unity/tests/launcher/test_shortcut.py b/tests/autopilot/unity/tests/launcher/test_shortcut.py index 9cb3093ff..28d661395 100644 --- a/tests/autopilot/unity/tests/launcher/test_shortcut.py +++ b/tests/autopilot/unity/tests/launcher/test_shortcut.py @@ -37,7 +37,7 @@ class LauncherShortcutTests(LauncherTestCase): self.launcher_instance.switcher_start() self.addCleanup(self.launcher_instance.switcher_cancel) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(True))) self.assertThat(self.launcher_instance.shortcuts_shown, Eventually(Equals(True))) def test_launcher_switcher_next_keeps_shortcuts(self): diff --git a/tests/autopilot/unity/tests/launcher/test_switcher.py b/tests/autopilot/unity/tests/launcher/test_switcher.py index 786826f12..ad3d3c590 100644 --- a/tests/autopilot/unity/tests/launcher/test_switcher.py +++ b/tests/autopilot/unity/tests/launcher/test_switcher.py @@ -36,14 +36,14 @@ class LauncherSwitcherTests(LauncherTestCase): def safe_quit_switcher(self): """Quit the keynav mode if it's engaged.""" - if self.launcher.key_nav_is_active: + if self.unity.launcher.key_nav_is_active: self.launcher_instance.switcher_cancel() def test_launcher_switcher_cancel(self): """Test that ending the launcher switcher actually works.""" self.launcher_instance.switcher_start() self.launcher_instance.switcher_cancel() - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) def test_launcher_switcher_cancel_resume_focus(self): """Test that ending the launcher switcher resume the focus.""" @@ -63,9 +63,9 @@ class LauncherSwitcherTests(LauncherTestCase): """Test that starting the Launcher switcher puts the keyboard focus on item 0.""" self.start_switcher_with_cleanup_cancel() - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(True))) - self.assertThat(self.launcher.key_nav_is_grabbed, Eventually(Equals(False))) - self.assertThat(self.launcher.key_nav_selection, Eventually(Equals(0))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(True))) + self.assertThat(self.unity.launcher.key_nav_is_grabbed, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0))) def test_launcher_switcher_next(self): """Moving to the next launcher item while switcher is activated must work.""" @@ -77,13 +77,13 @@ class LauncherSwitcherTests(LauncherTestCase): # make sure that the index has increased. This opens us to the # possibility that the launcher really is skipping forward more than one # icon at a time, but we can't do much about that. - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(0))) def test_launcher_switcher_prev(self): """Moving to the previous launcher item while switcher is activated must work.""" self.start_switcher_with_cleanup_cancel() self.launcher_instance.switcher_prev() - self.assertThat(self.launcher.key_nav_selection, Eventually(NotEquals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(NotEquals(0))) def test_launcher_switcher_down(self): """Pressing the down arrow key while switcher is activated must work.""" @@ -95,13 +95,13 @@ class LauncherSwitcherTests(LauncherTestCase): # make sure that the index has increased. This opens us to the # possibility that the launcher really is skipping forward more than one # icon at a time, but we can't do much about that. - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(0))) def test_launcher_switcher_up(self): """Pressing the up arrow key while switcher is activated must work.""" self.start_switcher_with_cleanup_cancel() self.launcher_instance.switcher_up() - self.assertThat(self.launcher.key_nav_selection, Eventually(NotEquals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(NotEquals(0))) def test_launcher_switcher_next_doesnt_show_shortcuts(self): """Moving forward in launcher switcher must not show launcher shortcuts.""" @@ -123,25 +123,25 @@ class LauncherSwitcherTests(LauncherTestCase): """Launcher Switcher must loop through icons when cycling forwards""" self.start_switcher_with_cleanup_cancel() prev_icon = 0 - num_icons = self.launcher.model.num_launcher_icons() + num_icons = self.unity.launcher.model.num_launcher_icons() logger.info("This launcher has %d icons", num_icons) for icon in range(1, num_icons): self.launcher_instance.switcher_next() # FIXME We can't directly check for selection/icon number equalty # since the launcher model also contains "hidden" icons that aren't # shown, so the selection index can increment by more than 1. - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(prev_icon))) - prev_icon = self.launcher.key_nav_selection + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(prev_icon))) + prev_icon = self.unity.launcher.key_nav_selection self.launcher_instance.switcher_next() - self.assertThat(self.launcher.key_nav_selection, Eventually(Equals(0))) + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(Equals(0))) def test_launcher_switcher_cycling_backward(self): """Launcher Switcher must loop through icons when cycling backwards""" self.start_switcher_with_cleanup_cancel() self.launcher_instance.switcher_prev() - # FIXME We can't directly check for self.launcher.num_launcher_icons - 1 - self.assertThat(self.launcher.key_nav_selection, Eventually(GreaterThan(1))) + # FIXME We can't directly check for self.unity.launcher.num_launcher_icons - 1 + self.assertThat(self.unity.launcher.key_nav_selection, Eventually(GreaterThan(1))) def test_launcher_switcher_activate_keep_focus(self): """Activating a running launcher icon should focus the application.""" @@ -165,4 +165,4 @@ class LauncherSwitcherTests(LauncherTestCase): sleep(.25) self.keyboard.press_and_release("Escape") sleep(.25) - self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False))) + self.assertThat(self.unity.launcher.key_nav_is_active, Eventually(Equals(False))) diff --git a/tests/autopilot/unity/tests/launcher/test_visual.py b/tests/autopilot/unity/tests/launcher/test_visual.py index 6b1fd7805..620e2e596 100644 --- a/tests/autopilot/unity/tests/launcher/test_visual.py +++ b/tests/autopilot/unity/tests/launcher/test_visual.py @@ -28,9 +28,9 @@ class LauncherVisualTests(LauncherTestCase): Tests fix for bug #913569. """ - bfb = self.launcher.model.get_bfb_icon() + bfb = self.unity.launcher.model.get_bfb_icon() self.mouse.move(bfb.center_x, bfb.center_y) - self.dash.ensure_visible() + self.unity.dash.ensure_visible() sleep(1) # We can't use 'launcher_instance.switcher_start()' since it moves the mouse. self.keybinding_hold_part_then_tap("launcher/switcher") @@ -38,15 +38,15 @@ class LauncherVisualTests(LauncherTestCase): self.addCleanup(self.keybinding, "launcher/switcher/exit") self.keybinding_tap("launcher/switcher/next") - for icon in self.launcher.model.get_launcher_icons(): + for icon in self.unity.launcher.model.get_launcher_icons(): self.assertThat(icon.desaturated, Eventually(Equals(False))) def test_opening_dash_desaturates_icons(self): """Opening the dash must desaturate all the launcher icons.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) - for icon in self.launcher.model.get_launcher_icons(): + for icon in self.unity.launcher.model.get_launcher_icons(): if isinstance(icon, BFBLauncherIcon): self.assertThat(icon.desaturated, Eventually(Equals(False))) else: @@ -58,19 +58,19 @@ class LauncherVisualTests(LauncherTestCase): x,y,w,h = launcher_instance.geometry self.mouse.move(x + w/2, y + h/2) sleep(.5) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) - for icon in self.launcher.model.get_launcher_icons(): + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) + for icon in self.unity.launcher.model.get_launcher_icons(): self.assertThat(icon.desaturated, Eventually(Equals(False))) def test_mouse_over_with_dash_open_desaturates_icons(self): """Moving mouse over launcher with dash open must saturate icons.""" launcher_instance = self.get_launcher() - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) sleep(.5) x,y,w,h = launcher_instance.geometry self.mouse.move(x + w/2, y + h/2) sleep(.5) - for icon in self.launcher.model.get_launcher_icons(): + for icon in self.unity.launcher.model.get_launcher_icons(): self.assertThat(icon.desaturated, Eventually(Equals(False))) diff --git a/tests/autopilot/unity/tests/test_command_lens.py b/tests/autopilot/unity/tests/test_command_lens.py index 13db7a2da..403e16062 100644 --- a/tests/autopilot/unity/tests/test_command_lens.py +++ b/tests/autopilot/unity/tests/test_command_lens.py @@ -24,38 +24,38 @@ class CommandLensSearchTests(UnityTestCase): gettext.install("unity-lens-applications") def tearDown(self): - self.dash.ensure_hidden() + self.unity.dash.ensure_hidden() super(CommandLensSearchTests, self).tearDown() def test_no_results(self): """An empty string should get no results.""" - self.dash.reveal_command_lens() - command_lens = self.dash.get_current_lens() + self.unity.dash.reveal_command_lens() + command_lens = self.unity.dash.get_current_lens() - if self.dash.search_string != "": + if self.unity.dash.search_string != "": self.keyboard.press_and_release("Delete") - self.assertThat(self.dash.search_string, Eventually(Equals(""))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(""))) results_category = command_lens.get_category_by_name(_("Results")) self.assertThat(results_category.is_visible, Eventually(Equals(False))) def test_results_category_appears(self): """Results category must appear when there are some results.""" - self.dash.reveal_command_lens() - command_lens = self.dash.get_current_lens() + self.unity.dash.reveal_command_lens() + command_lens = self.unity.dash.get_current_lens() # lots of apps start with 'a'... self.keyboard.type("a") - self.assertThat(self.dash.search_string, Eventually(Equals("a"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("a"))) results_category = command_lens.get_category_by_name(_("Results")) self.assertThat(results_category.is_visible, Eventually(Equals(True))) def test_result_category_actually_contains_results(self): """With a search string of 'a', the results category must contain some results.""" - self.dash.reveal_command_lens() - command_lens = self.dash.get_current_lens() + self.unity.dash.reveal_command_lens() + command_lens = self.unity.dash.get_current_lens() # lots of apps start with 'a'... self.keyboard.type("a") - self.assertThat(self.dash.search_string, Eventually(Equals("a"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("a"))) results_category = command_lens.get_category_by_name(_("Results")) results = results_category.get_results() self.assertTrue(results) @@ -66,7 +66,7 @@ class CommandLensSearchTests(UnityTestCase): self.close_all_app("Text Editor") sleep(1) - self.dash.reveal_command_lens() + self.unity.dash.reveal_command_lens() self.keyboard.type("g") sleep(1) self.keyboard.type("edit", 0.1) @@ -77,12 +77,12 @@ class CommandLensSearchTests(UnityTestCase): def test_ctrl_tab_switching(self): """Pressing Ctrl+Tab after launching command lens must switch to Home lens.""" - self.dash.reveal_command_lens() + self.unity.dash.reveal_command_lens() self.keybinding("dash/lens/next") - self.assertThat(self.dash.active_lens, Eventually(Equals("home.lens"))) + self.assertThat(self.unity.dash.active_lens, Eventually(Equals("home.lens"))) def test_ctrl_shift_tab_switching(self): """Pressing Ctrl+Shift+Tab after launching command lens must switch to Video lens.""" - self.dash.reveal_command_lens() + self.unity.dash.reveal_command_lens() self.keybinding("dash/lens/prev") - self.assertThat(self.dash.active_lens, Eventually(Equals("video.lens"))) + self.assertThat(self.unity.dash.active_lens, Eventually(Equals("video.lens"))) diff --git a/tests/autopilot/unity/tests/test_dash.py b/tests/autopilot/unity/tests/test_dash.py index 24923dec2..0109b0f3b 100644 --- a/tests/autopilot/unity/tests/test_dash.py +++ b/tests/autopilot/unity/tests/test_dash.py @@ -24,9 +24,9 @@ class DashTestCase(UnityTestCase): super(DashTestCase, self).setUp() self.set_unity_log_level("unity.shell.compiz", "DEBUG") self.set_unity_log_level("unity.launcher", "DEBUG") - self.dash.ensure_hidden() + self.unity.dash.ensure_hidden() # On shutdown, ensure hidden too. Also add a delay. Cleanup is LIFO. - self.addCleanup(self.dash.ensure_hidden) + self.addCleanup(self.unity.dash.ensure_hidden) self.addCleanup(sleep, 1) @@ -35,68 +35,68 @@ class DashRevealTests(DashTestCase): def test_dash_reveal(self): """Ensure we can show and hide the dash.""" - self.dash.ensure_visible() - self.dash.ensure_hidden() + self.unity.dash.ensure_visible() + self.unity.dash.ensure_hidden() def test_application_lens_shortcut(self): """Application lense must reveal when Super+a is pressed.""" - self.dash.reveal_application_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('applications.lens'))) + self.unity.dash.reveal_application_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('applications.lens'))) def test_music_lens_shortcut(self): """Music lense must reveal when Super+w is pressed.""" - self.dash.reveal_music_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('music.lens'))) + self.unity.dash.reveal_music_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('music.lens'))) def test_file_lens_shortcut(self): """File lense must reveal when Super+f is pressed.""" - self.dash.reveal_file_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('files.lens'))) + self.unity.dash.reveal_file_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('files.lens'))) def test_video_lens_shortcut(self): """Video lens must reveal when super+v is pressed.""" - self.dash.reveal_video_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('video.lens'))) + self.unity.dash.reveal_video_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('video.lens'))) def test_command_lens_shortcut(self): """Run Command lens must reveat on alt+F2.""" - self.dash.reveal_command_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('commands.lens'))) + self.unity.dash.reveal_command_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('commands.lens'))) def test_can_go_from_dash_to_command_lens(self): """Switch to command lens without closing the dash.""" - self.dash.ensure_visible() - self.dash.reveal_command_lens() - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.unity.dash.ensure_visible() + self.unity.dash.reveal_command_lens() + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_alt_f4_close_dash(self): """Dash must close on alt+F4.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.press_and_release("Alt+F4") - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_alt_f4_close_dash_with_capslock_on(self): """Dash must close on Alt+F4 even when the capslock is turned on.""" self.keyboard.press_and_release("Caps_Lock") self.addCleanup(self.keyboard.press_and_release, "Caps_Lock") - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.press_and_release("Alt+F4") - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_closes_mouse_down_outside(self): """Test that a mouse down outside of the dash closes the dash.""" - self.dash.ensure_visible() - current_monitor = self.dash.monitor + self.unity.dash.ensure_visible() + current_monitor = self.unity.dash.monitor - (x,y,w,h) = self.dash.geometry + (x,y,w,h) = self.unity.dash.geometry (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor) self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2) self.mouse.click() - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_closes_then_focuses_window_on_mouse_down(self): """If 2 windows are open with 1 maximized and the non-maxmized @@ -107,7 +107,7 @@ class DashRevealTests(DashTestCase): self.keybinding("window/maximize") self.start_app("Calculator") - self.dash.ensure_visible() + self.unity.dash.ensure_visible() #Click bottom right of the screen w = self.screen_geo.get_screen_width() @@ -117,6 +117,7 @@ class DashRevealTests(DashTestCase): self.assertProperty(char_win, is_active=True) + class DashRevealWithSpreadTests(DashTestCase): """Test the interaction of the Dash with the Spead/Scale @@ -134,49 +135,49 @@ class DashRevealWithSpreadTests(DashTestCase): def test_dash_closes_on_spread(self): """This test shows that when the spread is initiated, the dash closes.""" self.start_placeholder_app() - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.addCleanup(self.keybinding, "spread/cancel") self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_dash_opens_when_in_spread(self): """This test shows the dash opens when in spread mode.""" self.start_placeholder_app() self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) - self.dash.ensure_visible() - self.assertThat(self.dash.visible, Eventually(Equals(True))) + self.unity.dash.ensure_visible() + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) def test_command_lens_opens_when_in_spread(self): """This test shows the command lens opens when in spread mode.""" self.start_placeholder_app() self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) - self.dash.reveal_command_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('commands.lens'))) + self.unity.dash.reveal_command_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('commands.lens'))) def test_lens_opens_when_in_spread(self): """This test shows that any lens opens when in spread mode.""" self.start_placeholder_app() self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) - self.dash.reveal_application_lens() - self.assertThat(self.dash.active_lens, Eventually(Equals('applications.lens'))) + self.unity.dash.reveal_application_lens() + self.assertThat(self.unity.dash.active_lens, Eventually(Equals('applications.lens'))) class DashSearchInputTests(DashTestCase): """Test features involving input to the dash search""" def assertSearchText(self, text): - self.assertThat(self.dash.search_string, Eventually(Equals(text))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(text))) def test_search_keyboard_focus(self): """Dash must put keyboard focus on the search bar at all times.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("Hello") self.assertSearchText("Hello") @@ -192,28 +193,28 @@ class DashMultiKeyTests(DashSearchInputTests): def test_multi_key(self): """Pressing 'Multi_key' must not add any characters to the search.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.press_and_release('Multi_key') self.keyboard.type("o") self.assertSearchText("") def test_multi_key_o(self): """Pressing the sequences 'Multi_key' + '^' + 'o' must produce 'ô'.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.press_and_release('Multi_key') self.keyboard.type("^o") self.assertSearchText(u'\xf4') def test_multi_key_copyright(self): """Pressing the sequences 'Multi_key' + 'c' + 'o' must produce '©'.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.press_and_release('Multi_key') self.keyboard.type("oc") self.assertSearchText(u'\xa9') def test_multi_key_delete(self): """Pressing 'Multi_key' must not get stuck looking for a sequence.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.type("dd") self.keyboard.press_and_release('Multi_key') self.keyboard.press_and_release('BackSpace') @@ -226,21 +227,21 @@ class DashKeyNavTests(DashTestCase): def test_lensbar_gets_keyfocus(self): """Test that the lensbar gets key focus after using Down keypresses.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() # Make sure that the lens bar can get the focus - for i in range(self.dash.get_num_rows()): + for i in range(self.unity.dash.get_num_rows()): self.keyboard.press_and_release("Down") - lensbar = self.dash.view.get_lensbar() + lensbar = self.unity.dash.view.get_lensbar() self.assertThat(lensbar.focused_lens_icon, Eventually(NotEquals(''))) def test_lensbar_focus_changes(self): """Lensbar focused icon should change with Left and Right keypresses.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() - for i in range(self.dash.get_num_rows()): + for i in range(self.unity.dash.get_num_rows()): self.keyboard.press_and_release("Down") - lensbar = self.dash.view.get_lensbar() + lensbar = self.unity.dash.view.get_lensbar() current_focused_icon = lensbar.focused_lens_icon @@ -252,12 +253,12 @@ class DashKeyNavTests(DashTestCase): def test_lensbar_enter_activation(self): """Must be able to activate LensBar icons that have focus with an Enter keypress.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() - for i in range(self.dash.get_num_rows()): + for i in range(self.unity.dash.get_num_rows()): self.keyboard.press_and_release("Down") self.keyboard.press_and_release("Right") - lensbar = self.dash.view.get_lensbar() + lensbar = self.unity.dash.view.get_lensbar() focused_icon = lensbar.focused_lens_icon self.keyboard.press_and_release("Enter") @@ -269,12 +270,12 @@ class DashKeyNavTests(DashTestCase): def test_focus_returns_to_searchbar(self): """This test makes sure that the focus is returned to the searchbar of the newly activated lens.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() - for i in range(self.dash.get_num_rows()): + for i in range(self.unity.dash.get_num_rows()): self.keyboard.press_and_release("Down") self.keyboard.press_and_release("Right") - lensbar = self.dash.view.get_lensbar() + lensbar = self.unity.dash.view.get_lensbar() focused_icon = lensbar.focused_lens_icon self.keyboard.press_and_release("Enter") @@ -284,7 +285,7 @@ class DashKeyNavTests(DashTestCase): # Now we make sure if the newly activated lens searchbar have the focus. self.keyboard.type("HasFocus") - self.assertThat(self.dash.search_string, Eventually(Equals("HasFocus"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("HasFocus"))) def test_category_header_keynav(self): """ Tests that a category header gets focus when 'down' is pressed after the @@ -294,10 +295,10 @@ class DashKeyNavTests(DashTestCase): focused, not the first and from doing this it seems that it's common for a header other than the first to get focus. """ - self.dash.ensure_visible() + self.unity.dash.ensure_visible() # Make sure that a category have the focus. self.keyboard.press_and_release("Down") - lens = self.dash.get_current_lens() + lens = self.unity.dash.get_current_lens() category = lens.get_focused_category() self.assertIsNot(category, None) # Make sure that the category is highlighted. @@ -305,13 +306,13 @@ class DashKeyNavTests(DashTestCase): def test_control_tab_lens_cycle(self): """This test makes sure that Ctrl+Tab cycles lenses.""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.press('Control') self.keyboard.press_and_release('Tab') self.keyboard.release('Control') - lensbar = self.dash.view.get_lensbar() + lensbar = self.unity.dash.view.get_lensbar() self.assertEqual(lensbar.active_lens, u'applications.lens') self.keyboard.press('Control') @@ -324,8 +325,8 @@ class DashKeyNavTests(DashTestCase): def test_tab_cycle_category_headers(self): """ Makes sure that pressing tab cycles through the category headers""" - self.dash.ensure_visible() - lens = self.dash.get_current_lens() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() # Test that tab cycles through the categories. # + 1 is to cycle back to first header @@ -336,20 +337,20 @@ class DashKeyNavTests(DashTestCase): def test_tab_with_filter_bar(self): """ This test makes sure that Tab works well with the filter bara.""" - self.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_application_lens() + lens = self.unity.dash.get_current_lens() # Tabs to last category for i in range(lens.get_num_visible_categories()): self.keyboard.press_and_release('Tab') self.keyboard.press_and_release('Tab') - self.assertThat(self.dash.searchbar.expander_has_focus, Eventually(Equals(True))) + self.assertThat(self.unity.dash.searchbar.expander_has_focus, Eventually(Equals(True))) filter_bar = lens.get_filterbar() - if not self.dash.searchbar.showing_filters: + if not self.unity.dash.searchbar.showing_filters: self.keyboard.press_and_release('Enter') - self.assertThat(self.dash.searchbar.showing_filters, Eventually(Equals(True))) + self.assertThat(self.unity.dash.searchbar.showing_filters, Eventually(Equals(True))) self.addCleanup(filter_bar.ensure_collapsed) for i in range(filter_bar.get_num_filters()): @@ -366,8 +367,8 @@ class DashKeyNavTests(DashTestCase): """This test makes sure that bottom-up key navigation works well in the dash filter bar. """ - self.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_application_lens() + lens = self.unity.dash.get_current_lens() filter_bar = lens.get_filterbar() # Need to ensure the filter expander has focus, so if it's already @@ -399,21 +400,21 @@ class DashClipboardTests(DashTestCase): def test_ctrl_a(self): """ This test if ctrl+a selects all text """ - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("SelectAll") - self.assertThat(self.dash.search_string, Eventually(Equals("SelectAll"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("SelectAll"))) self.keyboard.press_and_release("Ctrl+a") self.keyboard.press_and_release("Delete") - self.assertThat(self.dash.search_string, Eventually(Equals(''))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(''))) def test_ctrl_c(self): """ This test if ctrl+c copies text into the clipboard """ - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("Copy") - self.assertThat(self.dash.search_string, Eventually(Equals("Copy"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("Copy"))) self.keyboard.press_and_release("Ctrl+a") self.keyboard.press_and_release("Ctrl+c") @@ -422,44 +423,44 @@ class DashClipboardTests(DashTestCase): def test_ctrl_x(self): """ This test if ctrl+x deletes all text and copys it """ - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("Cut") - self.assertThat(self.dash.search_string, Eventually(Equals("Cut"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("Cut"))) self.keyboard.press_and_release("Ctrl+a") self.keyboard.press_and_release("Ctrl+x") - self.assertThat(self.dash.search_string, Eventually(Equals(""))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(""))) self.assertThat(get_clipboard_contents, Eventually(Equals('Cut'))) def test_ctrl_c_v(self): """ This test if ctrl+c and ctrl+v copies and pastes text""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("CopyPaste") - self.assertThat(self.dash.search_string, Eventually(Equals("CopyPaste"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("CopyPaste"))) self.keyboard.press_and_release("Ctrl+a") self.keyboard.press_and_release("Ctrl+c") self.keyboard.press_and_release("Ctrl+v") self.keyboard.press_and_release("Ctrl+v") - self.assertThat(self.dash.search_string, Eventually(Equals('CopyPasteCopyPaste'))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals('CopyPasteCopyPaste'))) def test_ctrl_x_v(self): """ This test if ctrl+x and ctrl+v cuts and pastes text""" - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.keyboard.type("CutPaste") - self.assertThat(self.dash.search_string, Eventually(Equals("CutPaste"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("CutPaste"))) self.keyboard.press_and_release("Ctrl+a") self.keyboard.press_and_release("Ctrl+x") self.keyboard.press_and_release("Ctrl+v") self.keyboard.press_and_release("Ctrl+v") - self.assertThat(self.dash.search_string, Eventually(Equals('CutPasteCutPaste'))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals('CutPasteCutPaste'))) def test_middle_click_paste(self): """Tests if Middle mouse button pastes into searchbar""" @@ -469,28 +470,28 @@ class DashClipboardTests(DashTestCase): self.keyboard.type("ThirdButtonPaste") self.keyboard.press_and_release("Ctrl+a") - self.dash.ensure_visible() + self.unity.dash.ensure_visible() - self.mouse.move(self.dash.searchbar.x + self.dash.searchbar.width / 2, - self.dash.searchbar.y + self.dash.searchbar.height / 2) + self.mouse.move(self.unity.dash.searchbar.x + self.unity.dash.searchbar.width / 2, + self.unity.dash.searchbar.y + self.unity.dash.searchbar.height / 2) self.mouse.click(button=2) - self.assertThat(self.dash.search_string, Eventually(Equals('ThirdButtonPaste'))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals('ThirdButtonPaste'))) class DashKeyboardFocusTests(DashTestCase): """Tests that keyboard focus works.""" def assertSearchText(self, text): - self.assertThat(self.dash.search_string, Eventually(Equals(text))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(text))) def test_filterbar_expansion_leaves_kb_focus(self): """Expanding or collapsing the filterbar must keave keyboard focus in the search bar. """ - self.dash.reveal_application_lens() - filter_bar = self.dash.get_current_lens().get_filterbar() + self.unity.dash.reveal_application_lens() + filter_bar = self.unity.dash.get_current_lens().get_filterbar() filter_bar.ensure_collapsed() self.keyboard.type("hello") @@ -502,8 +503,8 @@ class DashKeyboardFocusTests(DashTestCase): def test_keep_focus_on_application_opens(self): """The Dash must keep key focus as well as stay open if an app gets opened from an external source. """ - self.dash.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.start_app_window("Calculator") sleep(1) @@ -517,33 +518,33 @@ class DashLensResultsTests(DashTestCase): def test_results_message_empty_search(self): """This tests a message is not shown when there is no text.""" - self.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_application_lens() + lens = self.unity.dash.get_current_lens() self.assertThat(lens.no_results_active, Eventually(Equals(False))) def test_results_message(self): """This test no mesage will be shown when results are there.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.type("Terminal") - self.assertThat(self.dash.search_string, Eventually(Equals("Terminal"))) - lens = self.dash.get_current_lens() + self.assertThat(self.unity.dash.search_string, Eventually(Equals("Terminal"))) + lens = self.unity.dash.get_current_lens() self.assertThat(lens.no_results_active, Eventually(Equals(False))) def test_no_results_message(self): """This test shows a message will appear in the lens.""" - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() self.keyboard.type("qwerlkjzvxc") - self.assertThat(self.dash.search_string, Eventually(Equals("qwerlkjzvxc"))) - lens = self.dash.get_current_lens() + self.assertThat(self.unity.dash.search_string, Eventually(Equals("qwerlkjzvxc"))) + lens = self.unity.dash.get_current_lens() self.assertThat(lens.no_results_active, Eventually(Equals(True))) def test_results_update_on_filter_changed(self): """This test makes sure the results change when filters change.""" gettext.install("unity-lens-applications") - self.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_application_lens() + lens = self.unity.dash.get_current_lens() self.keyboard.type(" ") - self.assertThat(self.dash.search_string, Eventually(Equals(" "))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(" "))) results_category = lens.get_category_by_name(_("Installed")) old_results = results_category.get_results() @@ -556,12 +557,12 @@ class DashLensResultsTests(DashTestCase): self.keyboard.press_and_release('Tab') self.keyboard.press_and_release('Tab') - self.assertThat(self.dash.searchbar.expander_has_focus, Eventually(Equals(True))) + self.assertThat(self.unity.dash.searchbar.expander_has_focus, Eventually(Equals(True))) filter_bar = lens.get_filterbar() - if not self.dash.searchbar.showing_filters: + if not self.unity.dash.searchbar.showing_filters: self.keyboard.press_and_release('Enter') - self.assertThat(self.dash.searchbar.showing_filters, Eventually(Equals(True))) + self.assertThat(self.unity.dash.searchbar.showing_filters, Eventually(Equals(True))) if add_cleanup: self.addCleanup(filter_bar.ensure_collapsed) @@ -593,9 +594,9 @@ class DashVisualTests(DashTestCase): def test_closing_dash_hides_current_lens(self): """When exiting from the dash the current lens must set it self to not visible.""" - self.dash.ensure_visible() - lens = self.dash.get_current_lens() - self.dash.ensure_hidden() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() + self.unity.dash.ensure_hidden() self.assertThat(lens.visible, Eventually(Equals(False))) @@ -604,20 +605,20 @@ class DashVisualTests(DashTestCase): has a non-default width. """ self.set_unity_option('icon_size', 60) - self.dash.ensure_visible() + self.unity.dash.ensure_visible() - monitor = self.dash.monitor - launcher = self.launcher.get_launcher_for_monitor(monitor) + monitor = self.unity.dash.monitor + launcher = self.unity.launcher.get_launcher_for_monitor(monitor) - self.assertThat(self.dash.geometry[0], Eventually(Equals(launcher.geometry[0] + launcher.geometry[2] - 1))) + self.assertThat(self.unity.dash.geometry[0], Eventually(Equals(launcher.geometry[0] + launcher.geometry[2] - 1))) def test_see_more_result_alignment(self): """The see more results label should be baseline aligned with the category name label. """ - self.dash.reveal_application_lens() + self.unity.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + lens = self.unity.dash.get_current_lens() groups = lens.get_groups() for group in groups: @@ -632,8 +633,8 @@ class DashLensBarTests(DashTestCase): def setUp(self): super(DashLensBarTests, self).setUp() - self.dash.ensure_visible() - self.lensbar = self.dash.view.get_lensbar() + self.unity.dash.ensure_visible() + self.lensbar = self.unity.dash.view.get_lensbar() def test_click_inside_highlight(self): """Lens selection should work when clicking in @@ -653,37 +654,37 @@ class DashBorderTests(DashTestCase): """ def setUp(self): super(DashBorderTests, self).setUp() - self.dash.ensure_visible() + self.unity.dash.ensure_visible() def test_click_right_border(self): """Clicking on the right dash border should do nothing, *NOT* close the dash. """ - if (self.dash.view.form_factor != "desktop"): + if (self.unity.dash.view.form_factor != "desktop"): self.skip("Not in desktop form-factor.") - x = self.dash.view.x + self.dash.view.width + self.dash.view.right_border_width / 2 - y = self.dash.view.y + self.dash.view.height / 2 + x = self.unity.dash.view.x + self.unity.dash.view.width + self.unity.dash.view.right_border_width / 2 + y = self.unity.dash.view.y + self.unity.dash.view.height / 2 self.mouse.move(x, y) self.mouse.click() - self.assertThat(self.dash.visible, Eventually(Equals(True))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) def test_click_bottom_border(self): """Clicking on the bottom dash border should do nothing, *NOT* close the dash. """ - if (self.dash.view.form_factor != "desktop"): + if (self.unity.dash.view.form_factor != "desktop"): self.skip("Not in desktop form-factor.") - x = self.dash.view.x + self.dash.view.width / 2 - y = self.dash.view.y + self.dash.view.height + self.dash.view.bottom_border_height / 2 + x = self.unity.dash.view.x + self.unity.dash.view.width / 2 + y = self.unity.dash.view.y + self.unity.dash.view.height + self.unity.dash.view.bottom_border_height / 2 self.mouse.move(x, y) self.mouse.click() - self.assertThat(self.dash.visible, Eventually(Equals(True))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) class CategoryHeaderTests(DashTestCase): @@ -694,13 +695,13 @@ class CategoryHeaderTests(DashTestCase): the view. """ gettext.install("unity-lens-applications", unicode=True) - lens = self.dash.reveal_application_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_application_lens() + self.addCleanup(self.unity.dash.ensure_hidden) category = lens.get_category_by_name(_("Installed")) is_expanded = category.is_expanded - self.mouse.move(self.dash.view.x + self.dash.view.width / 2, + self.mouse.move(self.unity.dash.view.x + self.unity.dash.view.width / 2, category.header_y + category.header_height / 2) self.mouse.click() @@ -720,19 +721,19 @@ class PreviewInvocationTests(DashTestCase): """ gettext.install("unity-lens-applications", unicode=True) - lens = self.dash.reveal_application_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_application_lens() + self.addCleanup(self.unity.dash.ensure_hidden) category = lens.get_category_by_name(_("More suggestions")) results = category.get_results() result = results[0] # result.preview handles finding xy co-ords and right mouse-click result.preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_files_lens_preview_open_close(self): """Right-clicking on a files lens result must show its @@ -748,8 +749,8 @@ class PreviewInvocationTests(DashTestCase): self.addCleanup(self.close_all_app, 'Text Editor') self.assertProperty(gedit_win, is_focused=True) - lens = self.dash.reveal_file_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_file_lens() + self.addCleanup(self.unity.dash.ensure_hidden) category = lens.get_category_by_name(_("Recent")) refresh_results_fn = lambda: len(category.get_results()) @@ -758,18 +759,18 @@ class PreviewInvocationTests(DashTestCase): result = results[0] # result.preview handles finding xy co-ords and right mouse-click result.preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_music_lens_preview_open_close(self): """Right-clicking on a music lens result must show its preview. """ - lens = self.dash.reveal_music_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_music_lens() + self.addCleanup(self.unity.dash.ensure_hidden) category = lens.get_category_by_name("Songs") # Incase there was no music ever played we skip the test instead @@ -782,11 +783,11 @@ class PreviewInvocationTests(DashTestCase): result = results[0] # result.preview handles finding xy co-ords and right mouse-click result.preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_video_lens_preview_open_close(self): """Right-clicking on a video lens result must show its @@ -805,8 +806,8 @@ class PreviewInvocationTests(DashTestCase): self.skipTest("This lens is probably empty") return category - lens = self.dash.reveal_video_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_video_lens() + self.addCleanup(self.unity.dash.ensure_hidden) self.assertThat(lambda: get_category(lens), Eventually(NotEquals(None))) category = get_category(lens) @@ -816,26 +817,26 @@ class PreviewInvocationTests(DashTestCase): result = results[0] # result.preview handles finding xy co-ords and right mouse-click result.preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_preview_key(self): """Pressing menu key on a selected dash result must show its preview. """ gettext.install("unity-lens-applications", unicode=True) - lens = self.dash.reveal_application_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_application_lens() + self.addCleanup(self.unity.dash.ensure_hidden) category = lens.get_category_by_name(_("More suggestions")) results = category.get_results() result = results[0] # result.preview_key() handles finding xy co-ords and key press result.preview_key() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) class PreviewNavigateTests(DashTestCase): @@ -845,8 +846,8 @@ class PreviewNavigateTests(DashTestCase): super(PreviewNavigateTests, self).setUp() gettext.install("unity-lens-applications", unicode=True) - lens = self.dash.reveal_application_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_application_lens() + self.addCleanup(self.unity.dash.ensure_hidden) results_category = lens.get_category_by_name(_("More suggestions")) # wait for results (we need 4 results to perorm the multi-navigation tests) @@ -856,9 +857,10 @@ class PreviewNavigateTests(DashTestCase): result = results[2] # 2 so we can navigate left result.preview() - self.assertThat(self.dash.view.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.view.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.view.get_preview_container, Eventually(NotEquals(None))) - self.preview_container = self.dash.view.get_preview_container() + self.preview_container = self.unity.dash.view.get_preview_container() def test_navigate_left(self): """Tests that left navigation works with previews.""" @@ -882,7 +884,7 @@ class PreviewNavigateTests(DashTestCase): # Test close preview after navigate self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_navigate_left_multi(self): """Tests that multiple left navigation works with previews.""" @@ -927,7 +929,7 @@ class PreviewNavigateTests(DashTestCase): # Test close preview after navigate self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_navigate_right_multi(self): """Tests that multiple right navigation works with previews.""" @@ -959,7 +961,7 @@ class PreviewNavigateTests(DashTestCase): self.keyboard.press_and_release("Escape") - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) class PreviewClickCancelTests(DashTestCase): @@ -967,8 +969,8 @@ class PreviewClickCancelTests(DashTestCase): def setUp(self): super(PreviewClickCancelTests, self).setUp() - lens = self.dash.reveal_application_lens() - self.addCleanup(self.dash.ensure_hidden) + lens = self.unity.dash.reveal_application_lens() + self.addCleanup(self.unity.dash.ensure_hidden) # Only testing an application preview for this test. self.keyboard.type("Software Updater") results_category = lens.get_category_by_name(_("Installed")) @@ -976,9 +978,9 @@ class PreviewClickCancelTests(DashTestCase): result = results[0] result.preview() - self.assertThat(self.dash.view.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.view.preview_displaying, Eventually(Equals(True))) - self.preview_container = self.dash.view.get_preview_container() + self.preview_container = self.unity.dash.view.get_preview_container() def test_left_click_on_preview_icon_cancel_preview(self): """Left click on preview icon must close preview.""" @@ -989,7 +991,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=1) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_middle_click_on_preview_icon_cancel_preview(self): """Middle click on preview icon must close preview.""" @@ -1000,7 +1002,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=2) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_right_click_on_preview_icon_cancel_preview(self): """Right click on preview icon must close preview.""" @@ -1011,7 +1013,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=3) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_left_click_on_preview_image_cancel_preview(self): """Left click on preview image must cancel the preview.""" @@ -1022,7 +1024,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=1) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_middle_click_on_preview_image_cancel_preview(self): """Middle click on preview image must cancel the preview.""" @@ -1033,7 +1035,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=2) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_right_click_on_preview_image_cancel_preview(self): """Right click on preview image must cancel the preview.""" @@ -1044,7 +1046,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=3) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_left_click_on_preview_text_cancel_preview(self): """Left click on some preview text must cancel the preview.""" @@ -1055,7 +1057,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=1) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_middle_click_on_preview_text_cancel_preview(self): """Middle click on some preview text must cancel the preview.""" @@ -1066,7 +1068,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=2) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_right_click_on_preview_text_cancel_preview(self): """Right click on some preview text must cancel the preview.""" @@ -1077,7 +1079,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=3) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_left_click_on_preview_ratings_widget_cancel_preview(self): """Left click on the ratings widget must cancel the preview.""" @@ -1088,7 +1090,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=1) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_middle_click_on_preview_ratings_widget_cancel_preview(self): """Middle click on the ratings widget must cancel the preview.""" @@ -1099,7 +1101,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=2) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_right_click_on_preview_ratings_widget_cancel_preview(self): """Right click on the ratings widget must cancel the preview.""" @@ -1110,7 +1112,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=3) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_left_click_on_preview_info_hint_cancel_preview(self): """Left click on the info hint must cancel the preview.""" @@ -1121,7 +1123,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=1) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_middle_click_on_preview_info_hint_cancel_preview(self): """Middle click on the info hint must cancel the preview.""" @@ -1132,7 +1134,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=2) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) def test_right_click_on_preview_info_hint_cancel_preview(self): """Right click on the info hint must cancel the preview.""" @@ -1143,7 +1145,7 @@ class PreviewClickCancelTests(DashTestCase): self.mouse.move(tx, ty) self.mouse.click(button=3) - self.assertThat(self.dash.preview_displaying, Eventually(Equals(False))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False))) class DashDBusIfaceTests(DashTestCase): @@ -1151,10 +1153,10 @@ class DashDBusIfaceTests(DashTestCase): def test_dash_hide(self): """Ensure we can hide the dash via HideDash() dbus method.""" - self.dash.ensure_visible() - self.dash.controller.hide_dash_via_dbus() - self.assertThat(self.dash.visible, Eventually(Equals(False))) - self.dash.ensure_hidden() + self.unity.dash.ensure_visible() + self.unity.dash.hide_dash_via_dbus() + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) + self.unity.dash.ensure_hidden() class DashCrossMonitorsTests(DashTestCase): @@ -1169,27 +1171,27 @@ class DashCrossMonitorsTests(DashTestCase): """If the dash is opened, then the mouse is moved to another monitor and the keyboard is used. The Dash must not move to that monitor. """ - current_monitor = self.dash.ideal_monitor + current_monitor = self.unity.dash.ideal_monitor - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.screen_geo.move_mouse_to_monitor((current_monitor + 1) % self.screen_geo.get_num_monitors()) self.keyboard.type("abc") - self.assertThat(self.dash.ideal_monitor, Eventually(Equals(current_monitor))) + self.assertThat(self.unity.dash.ideal_monitor, Eventually(Equals(current_monitor))) def test_dash_close_on_cross_monitor_click(self): """Dash must close when clicking on a window in a different screen.""" - self.addCleanup(self.dash.ensure_hidden) + self.addCleanup(self.unity.dash.ensure_hidden) for monitor in range(self.screen_geo.get_num_monitors()-1): self.screen_geo.move_mouse_to_monitor(monitor) - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.screen_geo.move_mouse_to_monitor(monitor+1) sleep(.5) self.mouse.click() - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) diff --git a/tests/autopilot/unity/tests/test_home_lens.py b/tests/autopilot/unity/tests/test_home_lens.py index 65de6875c..38539a3d6 100644 --- a/tests/autopilot/unity/tests/test_home_lens.py +++ b/tests/autopilot/unity/tests/test_home_lens.py @@ -22,22 +22,22 @@ class HomeLensSearchTests(UnityTestCase): super(HomeLensSearchTests, self).setUp() def tearDown(self): - self.dash.ensure_hidden() + self.unity.dash.ensure_hidden() super(HomeLensSearchTests, self).tearDown() def test_quick_run_app(self): """Hitting enter runs an application even though a search might not have fully finished yet. - + """ if self.app_is_running("Text Editor"): self.close_all_app("Text Editor") sleep(1) kb = self.keyboard - self.dash.ensure_visible() + self.unity.dash.ensure_visible() kb.type("g") - self.assertThat(self.dash.search_string, Eventually(Equals("g"))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals("g"))) kb.type("edit", 0.1) kb.press_and_release("Enter", 0.1) self.addCleanup(self.close_all_app, "Text Editor") diff --git a/tests/autopilot/unity/tests/test_hud.py b/tests/autopilot/unity/tests/test_hud.py index 0e85e7f6f..97938b9d9 100644 --- a/tests/autopilot/unity/tests/test_hud.py +++ b/tests/autopilot/unity/tests/test_hud.py @@ -47,12 +47,12 @@ class HudTestsBase(UnityTestCase): super(HudTestsBase, self).setUp() def tearDown(self): - self.hud.ensure_hidden() + self.unity.hud.ensure_hidden() super(HudTestsBase, self).tearDown() def get_num_active_launcher_icons(self): num_active = 0 - for icon in self.launcher.model.get_launcher_icons(): + for icon in self.unity.launcher.model.get_launcher_icons(): if icon.active and icon.visible: num_active += 1 return num_active @@ -77,56 +77,56 @@ class HudBehaviorTests(HudTestsBase): self.screen_geo.move_mouse_to_monitor(self.hud_monitor) def test_no_initial_values(self): - self.hud.ensure_visible() - self.assertThat(self.hud.num_buttons, Equals(0)) - self.assertThat(self.hud.selected_button, Equals(0)) + self.unity.hud.ensure_visible() + self.assertThat(self.unity.hud.num_buttons, Equals(0)) + self.assertThat(self.unity.hud.selected_button, Equals(0)) def test_check_a_values(self): - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type('a') - self.assertThat(self.hud.search_string, Eventually(Equals('a'))) - self.assertThat(self.hud.num_buttons, Eventually(Equals(5))) - self.assertThat(self.hud.selected_button, Eventually(Equals(1))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals('a'))) + self.assertThat(self.unity.hud.num_buttons, Eventually(Equals(5))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(1))) def test_up_down_arrows(self): - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type('a') - self.assertThat(self.hud.search_string, Eventually(Equals('a'))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals('a'))) self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(2))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(2))) self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(3))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(3))) self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(4))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(4))) self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(5))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(5))) # Down again stays on 5. self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(5))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(5))) self.keyboard.press_and_release('Up') - self.assertThat(self.hud.selected_button, Eventually(Equals(4))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(4))) self.keyboard.press_and_release('Up') - self.assertThat(self.hud.selected_button, Eventually(Equals(3))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(3))) self.keyboard.press_and_release('Up') - self.assertThat(self.hud.selected_button, Eventually(Equals(2))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(2))) self.keyboard.press_and_release('Up') - self.assertThat(self.hud.selected_button, Eventually(Equals(1))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(1))) # Up again stays on 1. self.keyboard.press_and_release('Up') - self.assertThat(self.hud.selected_button, Eventually(Equals(1))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(1))) def test_no_reset_selected_button(self): """Hud must not change selected button when results update over time.""" # TODO - this test doesn't test anything. Onmy system the results never update. # ideally we'd send artificial results to the hud from the test. - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type('is') - self.assertThat(self.hud.search_string, Eventually(Equals('is'))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals('is'))) self.keyboard.press_and_release('Down') - self.assertThat(self.hud.selected_button, Eventually(Equals(2))) + self.assertThat(self.unity.hud.selected_button, Eventually(Equals(2))) # long sleep to let the service send updated results sleep(10) - self.assertThat(self.hud.selected_button, Equals(2)) + self.assertThat(self.unity.hud.selected_button, Equals(2)) def test_slow_tap_not_reveal_hud(self): """A slow tap must not reveal the HUD.""" @@ -134,7 +134,7 @@ class HudBehaviorTests(HudTestsBase): # need a long sleep to ensure that we test after the hud controller has # seen the keypress. sleep(5) - self.assertThat(self.hud.visible, Equals(False)) + self.assertThat(self.unity.hud.visible, Equals(False)) def test_alt_f4_doesnt_show_hud(self): self.start_app('Calculator') @@ -142,7 +142,7 @@ class HudBehaviorTests(HudTestsBase): # Do a very fast Alt+F4 self.keyboard.press_and_release("Alt+F4", 0.05) sleep(1) - self.assertFalse(self.hud.visible) + self.assertFalse(self.unity.hud.visible) def test_reveal_hud_with_no_apps(self): """Hud must show even with no visible applications. @@ -151,11 +151,11 @@ class HudBehaviorTests(HudTestsBase): """ self.start_placeholder_app() - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) - self.hud.ensure_visible() - self.hud.ensure_hidden() + self.unity.hud.ensure_visible() + self.unity.hud.ensure_hidden() def test_restore_focus(self): """Ensures that once the hud is dismissed, the same application @@ -166,14 +166,14 @@ class HudBehaviorTests(HudTestsBase): # first ensure that the application has started and is focused self.assertEqual(calc.is_active, True) - self.hud.ensure_visible() - self.hud.ensure_hidden() + self.unity.hud.ensure_visible() + self.unity.hud.ensure_hidden() # again ensure that the application we started is focused self.assertEqual(calc.is_active, True) - self.hud.ensure_visible() - self.hud.ensure_hidden() + self.unity.hud.ensure_visible() + self.unity.hud.ensure_hidden() # why do we do this: ??? self.keyboard.press_and_release('Return') sleep(1) @@ -193,14 +193,14 @@ class HudBehaviorTests(HudTestsBase): self.keyboard.type(" ") self.keyboard.type("1") - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("undo") - hud_query_check = lambda: self.hud.selected_hud_button.label_no_formatting + hud_query_check = lambda: self.unity.hud.selected_hud_button.label_no_formatting self.assertThat(hud_query_check, Eventually(Equals("Edit > Undo"))) self.keyboard.press_and_release('Return') - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) self.assertProperty(gedit_win, is_focused=True) self.keyboard.press_and_release("Ctrl+s") @@ -211,18 +211,18 @@ class HudBehaviorTests(HudTestsBase): def test_hud_to_dash_has_key_focus(self): """When switching from the hud to the dash you don't lose key focus.""" - self.hud.ensure_visible() - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.hud.ensure_visible() + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.keyboard.type('focus1') - self.assertThat(self.dash.search_string, Eventually(Equals('focus1'))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals('focus1'))) def test_dash_to_hud_has_key_focus(self): """When switching from the dash to the hud you don't lose key focus.""" - self.dash.ensure_visible() - self.hud.ensure_visible() + self.unity.dash.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type('focus2') - self.assertThat(self.hud.search_string, Eventually(Equals('focus2'))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals('focus2'))) def test_hud_closes_on_workspace_switch(self): """This test shows that when you switch to another workspace the hud closes.""" @@ -230,19 +230,19 @@ class HudBehaviorTests(HudTestsBase): self.skipTest("This test requires enabled more than one workspace.") initial_workspace = self.workspace.current_workspace self.addCleanup(self.workspace.switch_to, initial_workspace) - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_on_spread(self): """This test shows that when the spread is initiated, the hud closes.""" # Need at least one application open for the spread to work. self.start_app_window("Calculator") - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.addCleanup(self.keybinding, "spread/cancel") self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_click_outside_geo_shrunk(self): """ @@ -250,86 +250,86 @@ class HudBehaviorTests(HudTestsBase): Shurnk is when the hud has no results and is much smaller then normal. """ - self.hud.ensure_visible() - (x,y,w,h) = self.hud.view.geometry + self.unity.hud.ensure_visible() + (x,y,w,h) = self.unity.hud.view.geometry self.mouse.move(w/2, h-50) self.mouse.click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_click_outside_geo(self): """Clicking outside of the hud will make it close.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("Test") - (x,y,w,h) = self.hud.view.geometry + (x,y,w,h) = self.unity.hud.view.geometry self.mouse.move(w/2, h+50) self.mouse.click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_click_after_text_removed(self): """Clicking outside of the hud after a search text has been entered and then removed from the searchbox will make it close.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("Test") self.keyboard.press_and_release("Escape") - (x,y,w,h) = self.hud.view.geometry + (x,y,w,h) = self.unity.hud.view.geometry self.mouse.move(w/2, h+50) self.mouse.click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_alt_f4_close_hud(self): """Hud must close on alt+F4.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.press_and_release("Alt+F4") - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_alt_f4_close_hud_with_capslock_on(self): """Hud must close on Alt+F4 even when the capslock is turned on.""" self.keyboard.press_and_release("Caps_Lock") self.addCleanup(self.keyboard.press_and_release, "Caps_Lock") - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.press_and_release("Alt+F4") - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_app_activate_on_enter(self): """Hud must close after activating a search item with Enter.""" self.start_app('Text Editor', locale='C') self.addCleanup(self.close_all_app, "Text Editor") - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("File > Quit") - self.assertThat(self.hud.search_string, Eventually(Equals("File > Quit"))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals("File > Quit"))) self.keyboard.press_and_release("Enter") self.assertFalse(self.app_is_running("Text Editor")) - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_on_escape(self): """Hud must close on escape after searchbox is cleared""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("ThisText") self.keyboard.press_and_release("Escape") self.keyboard.press_and_release("Escape") - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_hud_closes_on_escape_shrunk(self): """Hud must close when escape key is pressed""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.press_and_release("Escape") - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_alt_arrow_keys_not_eaten(self): """Tests that Alt+ArrowKey events are correctly passed to the @@ -368,62 +368,62 @@ class HudBehaviorTests(HudTestsBase): change the selected button from 1 to 5. """ - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("a") - (x,y,w,h) = self.hud.view.geometry + (x,y,w,h) = self.unity.hud.view.geometry # Specify a slower rate so that HUD can register the mouse movement properly self.mouse.move(w/2, 0, rate=5) - self.assertThat(self.hud.view.selected_button, Eventually(Equals(1))) + self.assertThat(self.unity.hud.view.selected_button, Eventually(Equals(1))) self.mouse.move(w/2, h, rate=5) - self.assertThat(self.hud.view.selected_button, Eventually(Equals(5))) + self.assertThat(self.unity.hud.view.selected_button, Eventually(Equals(5))) def test_keyboard_steals_focus_from_mouse(self): """This tests moves the mouse from the top of the screen to the bottom, then it presses the keyboard up 5 times, this must change the selected button from 5 to 1. """ - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.keyboard.type("a") - (x,y,w,h) = self.hud.view.geometry + (x,y,w,h) = self.unity.hud.view.geometry self.mouse.move(w/2, 0) self.mouse.move(w/2, h) - self.assertThat(self.hud.view.selected_button, Eventually(Equals(5))) + self.assertThat(self.unity.hud.view.selected_button, Eventually(Equals(5))) for i in range(5): self.keyboard.press_and_release('Up') - self.assertThat(self.hud.view.selected_button, Eventually(Equals(1))) + self.assertThat(self.unity.hud.view.selected_button, Eventually(Equals(1))) def test_keep_focus_on_application_opens(self): """The Hud must keep key focus as well as stay open if an app gets opened from an external source. """ - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.start_app_window("Calculator") sleep(1) self.keyboard.type("HasFocus") - self.assertThat(self.hud.search_string, Eventually(Equals("HasFocus"))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals("HasFocus"))) def test_closes_mouse_down_outside(self): """Test that a mouse down outside of the hud closes the hud.""" - self.hud.ensure_visible() - current_monitor = self.hud.monitor + self.unity.hud.ensure_visible() + current_monitor = self.unity.hud.monitor - (x,y,w,h) = self.hud.geometry + (x,y,w,h) = self.unity.hud.geometry (screen_x,screen_y,screen_w,screen_h) = self.screen_geo.get_monitor_geometry(current_monitor) self.mouse.move(x + w + (screen_w-((screen_x-x)+w))/2, y + h + (screen_h-((screen_y-y)+h))/2) self.mouse.click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_closes_then_focuses_window_on_mouse_down(self): """If 2 windows are open with 1 maximized and the non-maxmized @@ -435,7 +435,7 @@ class HudBehaviorTests(HudTestsBase): self.keybinding("window/maximize") self.start_app("Calculator") - self.hud.ensure_visible() + self.unity.hud.ensure_visible() #Click bottom right of the screen w = self.screen_geo.get_screen_width() @@ -454,8 +454,8 @@ class HudBehaviorTests(HudTestsBase): self.keybinding("switcher/reveal_normal") self.assertProperty(char_win, is_active=True) - self.hud.ensure_visible() - self.hud.ensure_hidden() + self.unity.hud.ensure_visible() + self.unity.hud.ensure_hidden() self.assertProperty(char_win, is_active=True) @@ -481,7 +481,7 @@ class HudLauncherInteractionsTests(HudTestsBase): apps as active. """ - launcher = self.launcher.get_launcher_for_monitor(self.hud_monitor) + launcher = self.unity.launcher.get_launcher_for_monitor(self.hud_monitor) # We need an app to switch to: self.start_app('Character Map') @@ -495,11 +495,11 @@ class HudLauncherInteractionsTests(HudTestsBase): # reveal and hide hud several times over: for i in range(3): - self.hud.ensure_visible() - self.hud.ensure_hidden() + self.unity.hud.ensure_visible() + self.unity.hud.ensure_hidden() # click application icons for running apps in the launcher: - icon = self.launcher.model.get_icon(desktop_id="gucharmap.desktop") + icon = self.unity.launcher.model.get_icon(desktop_id="gucharmap.desktop") launcher.click_launcher_icon(icon) # see how many apps are marked as being active: @@ -509,10 +509,10 @@ class HudLauncherInteractionsTests(HudTestsBase): def test_hud_does_not_change_launcher_status(self): """Opening the HUD must not change the launcher visibility.""" - launcher = self.launcher.get_launcher_for_monitor(self.hud_monitor) + launcher = self.unity.launcher.get_launcher_for_monitor(self.hud_monitor) launcher_shows_pre = launcher.is_showing - self.hud.ensure_visible() + self.unity.hud.ensure_visible() launcher_shows_post = launcher.is_showing self.assertThat(launcher_shows_pre, Equals(launcher_shows_post)) @@ -533,14 +533,14 @@ class HudLockedLauncherInteractionsTests(HudTestsBase): def test_hud_launcher_icon_hides_bfb(self): """BFB icon must be hidden when the HUD launcher icon is shown.""" - hud_icon = self.hud.get_launcher_icon() - bfb_icon = self.launcher.model.get_bfb_icon() + hud_icon = self.unity.hud.get_launcher_icon() + bfb_icon = self.unity.launcher.model.get_bfb_icon() self.assertThat(bfb_icon.visible, Eventually(Equals(True))) self.assertTrue(bfb_icon.is_on_monitor(self.hud_monitor)) self.assertThat(hud_icon.visible, Eventually(Equals(False))) - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.assertThat(hud_icon.visible, Eventually(Equals(True))) self.assertTrue(hud_icon.is_on_monitor(self.hud_monitor)) @@ -550,9 +550,9 @@ class HudLockedLauncherInteractionsTests(HudTestsBase): def test_hud_desaturates_launcher_icons(self): """Launcher icons must desaturate when the HUD is opened.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() - for icon in self.launcher.model.get_launcher_icons_for_monitor(self.hud_monitor): + for icon in self.unity.launcher.model.get_launcher_icons_for_monitor(self.hud_monitor): if isinstance(icon, HudLauncherIcon): self.assertThat(icon.desaturated, Eventually(Equals(False))) else: @@ -561,13 +561,13 @@ class HudLockedLauncherInteractionsTests(HudTestsBase): def test_hud_launcher_icon_click_hides_hud(self): """Clicking the Hud Icon should hide the HUD""" - hud_icon = self.hud.get_launcher_icon() - self.hud.ensure_visible() + hud_icon = self.unity.hud.get_launcher_icon() + self.unity.hud.ensure_visible() - launcher = self.launcher.get_launcher_for_monitor(self.hud_monitor) + launcher = self.unity.launcher.get_launcher_for_monitor(self.hud_monitor) launcher.click_launcher_icon(hud_icon) - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) self.assertThat(hud_icon.visible, Eventually(Equals(False))) @@ -591,22 +591,22 @@ class HudVisualTests(HudTestsBase): sleep(0.5) def test_initially_hidden(self): - self.assertFalse(self.hud.visible) + self.assertFalse(self.unity.hud.visible) def test_hud_is_on_right_monitor(self): """HUD must be drawn on the monitor where the mouse is.""" - self.hud.ensure_visible() - self.assertThat(self.hud.monitor, Eventually(Equals(self.hud_monitor))) - self.assertTrue(self.screen_geo.is_rect_on_monitor(self.hud.monitor, self.hud.geometry)) + self.unity.hud.ensure_visible() + self.assertThat(self.unity.hud.monitor, Eventually(Equals(self.hud_monitor))) + self.assertTrue(self.screen_geo.is_rect_on_monitor(self.unity.hud.monitor, self.unity.hud.geometry)) def test_hud_geometries(self): """Tests the HUD geometries for the given monitor and status.""" - self.hud.ensure_visible() + self.unity.hud.ensure_visible() monitor_geo = self.screen_geo.get_monitor_geometry(self.hud_monitor) monitor_x = monitor_geo[0] monitor_w = monitor_geo[2] - hud_x = self.hud.geometry[0] - hud_w = self.hud.geometry[2] + hud_x = self.unity.hud.geometry[0] + hud_w = self.unity.hud.geometry[2] if self.hud_locked: self.assertThat(hud_x, GreaterThan(monitor_x)) @@ -618,16 +618,16 @@ class HudVisualTests(HudTestsBase): def test_hud_is_locked_to_launcher(self): """Tests if the HUD is locked to launcher as we expect or not.""" - self.hud.ensure_visible() - self.assertThat(self.hud.is_locked_launcher, Eventually(Equals(self.hud_locked))) + self.unity.hud.ensure_visible() + self.assertThat(self.unity.hud.is_locked_launcher, Eventually(Equals(self.hud_locked))) def test_hud_icon_is_shown(self): """Tests that the correct HUD icon is shown.""" - self.hud.ensure_visible() - hud_launcher_icon = self.hud.get_launcher_icon() - hud_embedded_icon = self.hud.get_embedded_icon() + self.unity.hud.ensure_visible() + hud_launcher_icon = self.unity.hud.get_launcher_icon() + hud_embedded_icon = self.unity.hud.get_embedded_icon() - if self.hud.is_locked_launcher: + if self.unity.hud.is_locked_launcher: self.assertThat(hud_launcher_icon.visible, Eventually(Equals(True))) self.assertTrue(hud_launcher_icon.is_on_monitor(self.hud_monitor)) self.assertTrue(hud_launcher_icon.active) @@ -645,18 +645,18 @@ class HudVisualTests(HudTestsBase): self.close_all_app("Calculator") calc = self.start_app("Calculator") self.assertTrue(calc.is_active) - self.hud.ensure_visible() + self.unity.hud.ensure_visible() - self.assertThat(self.hud.icon.icon_name, Eventually(Equals(calc.icon))) + self.assertThat(self.unity.hud.icon.icon_name, Eventually(Equals(calc.icon))) def test_hud_icon_shows_the_ubuntu_emblem_on_empty_desktop(self): """When in 'show desktop' mode the hud icon must be the BFB icon.""" self.start_placeholder_app() - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) - self.hud.ensure_visible() + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) + self.unity.hud.ensure_visible() - self.assertThat(self.hud.icon.icon_name, Eventually(EndsWith("launcher_bfb.png"))) + self.assertThat(self.unity.hud.icon.icon_name, Eventually(EndsWith("launcher_bfb.png"))) def test_switch_dash_hud_does_not_break_the_focused_application_emblem(self): """Switching from Dash to HUD must still show the correct HUD icon.""" @@ -664,10 +664,10 @@ class HudVisualTests(HudTestsBase): calc = self.start_app("Calculator") self.assertTrue(calc.is_active) - self.dash.ensure_visible() - self.hud.ensure_visible() + self.unity.dash.ensure_visible() + self.unity.hud.ensure_visible() - self.assertThat(self.hud.icon.icon_name, Eventually(Equals(calc.icon))) + self.assertThat(self.unity.hud.icon.icon_name, Eventually(Equals(calc.icon))) def test_switch_hud_dash_does_not_break_the_focused_application_emblem(self): """Switching from HUD to Dash and back must still show the correct HUD icon.""" @@ -675,10 +675,10 @@ class HudVisualTests(HudTestsBase): calc = self.start_app("Calculator") self.assertTrue(calc.is_active) - self.hud.ensure_visible() - self.dash.ensure_visible() - self.hud.ensure_visible() - self.assertThat(self.hud.icon.icon_name, Eventually(Equals(calc.icon))) + self.unity.hud.ensure_visible() + self.unity.dash.ensure_visible() + self.unity.hud.ensure_visible() + self.assertThat(self.unity.hud.icon.icon_name, Eventually(Equals(calc.icon))) def test_dash_hud_only_uses_icon_from_current_desktop(self): """ @@ -691,16 +691,16 @@ class HudVisualTests(HudTestsBase): self.start_placeholder_app() initial_workspace = self.workspace.current_workspace self.addCleanup(self.workspace.switch_to, initial_workspace) - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) calc = self.start_app("Calculator") self.assertTrue(calc.is_active) self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) - self.dash.ensure_visible() - self.hud.ensure_visible() + self.unity.dash.ensure_visible() + self.unity.hud.ensure_visible() - self.assertThat(self.hud.icon.icon_name, Eventually(EndsWith("launcher_bfb.png"))) + self.assertThat(self.unity.hud.icon.icon_name, Eventually(EndsWith("launcher_bfb.png"))) class HudAlternativeKeybindingTests(HudTestsBase): @@ -710,14 +710,14 @@ class HudAlternativeKeybindingTests(HudTestsBase): self.set_unity_option("show_hud", "<Super>h") # Don't use reveal_hud, but be explicit in the keybindings. self.keyboard.press_and_release("Super+h") - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) def test_ctrl_alt_h(self): """Test hud reveal on <Contrl><Alt>h.""" self.set_unity_option("show_hud", "<Control><Alt>h") # Don't use reveal_hud, but be explicit in the keybindings. self.keyboard.press_and_release("Ctrl+Alt+h") - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) class HudCrossMonitorsTests(HudTestsBase): @@ -733,27 +733,27 @@ class HudCrossMonitorsTests(HudTestsBase): the keyboard is used. The hud must not move to that monitor. """ - current_monitor = self.hud.ideal_monitor + current_monitor = self.unity.hud.ideal_monitor - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.screen_geo.move_mouse_to_monitor((current_monitor + 1) % self.screen_geo.get_num_monitors()) self.keyboard.type("abc") - self.assertThat(self.hud.ideal_monitor, Eventually(Equals(current_monitor))) + self.assertThat(self.unity.hud.ideal_monitor, Eventually(Equals(current_monitor))) def test_hud_close_on_cross_monitor_click(self): """Hud must close when clicking on a window in a different screen.""" - self.addCleanup(self.hud.ensure_hidden) + self.addCleanup(self.unity.hud.ensure_hidden) for monitor in range(self.screen_geo.get_num_monitors()-1): self.screen_geo.move_mouse_to_monitor(monitor) - self.hud.ensure_visible() + self.unity.hud.ensure_visible() self.screen_geo.move_mouse_to_monitor(monitor+1) sleep(.5) self.mouse.click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) diff --git a/tests/autopilot/unity/tests/test_ibus.py b/tests/autopilot/unity/tests/test_ibus.py index 400807f97..eeb57707d 100644 --- a/tests/autopilot/unity/tests/test_ibus.py +++ b/tests/autopilot/unity/tests/test_ibus.py @@ -20,8 +20,6 @@ from autopilot.emulators.ibus import ( from autopilot.matchers import Eventually from autopilot.testcase import multiply_scenarios from testtools.matchers import Equals, NotEquals -from unity.emulators.dash import Dash -from unity.emulators.hud import Hud from unity.tests import UnityTestCase @@ -94,13 +92,13 @@ class IBusWidgetScenariodTests(IBusTests): # Use lambdas here so we don't require DBus service at module import time. scenarios = [ - ('dash', {'widget': lambda: Dash()}), - ('hud', {'widget': lambda: Hud()}) + ('dash', {'widget': 'dash'}), + ('hud', {'widget': 'hud'}) ] def do_ibus_test(self): """Do the basic IBus test on self.widget using self.input and self.result.""" - widget = self.widget() + widget = getattr(self.unity, self.widget) widget.ensure_visible() self.addCleanup(widget.ensure_hidden) self.activate_ibus(widget.searchbar) @@ -195,26 +193,26 @@ class IBusTestsPinyinIgnore(IBusTests): self.activate_input_engine_or_skip(self.engine_name) def test_ignore_key_events_on_dash(self): - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) - self.activate_ibus(self.dash.searchbar) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) + self.activate_ibus(self.unity.dash.searchbar) self.keyboard.type("cipan") self.keyboard.press_and_release("Tab") self.keyboard.type(" ") - self.deactivate_ibus(self.dash.searchbar) - self.assertThat(self.dash.search_string, Eventually(NotEquals(" "))) + self.deactivate_ibus(self.unity.dash.searchbar) + self.assertThat(self.unity.dash.search_string, Eventually(NotEquals(" "))) def test_ignore_key_events_on_hud(self): - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.keyboard.type("a") - self.activate_ibus(self.hud.searchbar) + self.activate_ibus(self.unity.hud.searchbar) self.keyboard.type("riqi") - old_selected = self.hud.selected_button + old_selected = self.unity.hud.selected_button self.keyboard.press_and_release("Down") - new_selected = self.hud.selected_button - self.deactivate_ibus(self.hud.searchbar) + new_selected = self.unity.hud.selected_button + self.deactivate_ibus(self.unity.hud.searchbar) self.assertEqual(old_selected, new_selected) @@ -230,26 +228,26 @@ class IBusTestsAnthyIgnore(IBusTests): self.activate_input_engine_or_skip(self.engine_name) def test_ignore_key_events_on_dash(self): - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) - self.activate_ibus(self.dash.searchbar) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) + self.activate_ibus(self.unity.dash.searchbar) self.keyboard.type("shisutemu ") self.keyboard.press_and_release("Tab") self.keyboard.press_and_release("Ctrl+j") - self.deactivate_ibus(self.dash.searchbar) - dash_search_string = self.dash.search_string + self.deactivate_ibus(self.unity.dash.searchbar) + dash_search_string = self.unity.dash.search_string self.assertNotEqual("", dash_search_string) def test_ignore_key_events_on_hud(self): - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.keyboard.type("a") - self.activate_ibus(self.hud.searchbar) + self.activate_ibus(self.unity.hud.searchbar) self.keyboard.type("hiduke") - old_selected = self.hud.selected_button + old_selected = self.unity.hud.selected_button self.keyboard.press_and_release("Down") - new_selected = self.hud.selected_button - self.deactivate_ibus(self.hud.searchbar) + new_selected = self.unity.hud.selected_button + self.deactivate_ibus(self.unity.hud.searchbar) self.assertEqual(old_selected, new_selected) diff --git a/tests/autopilot/unity/tests/test_panel.py b/tests/autopilot/unity/tests/test_panel.py index 2c6b12f54..a8aeb1f98 100644 --- a/tests/autopilot/unity/tests/test_panel.py +++ b/tests/autopilot/unity/tests/test_panel.py @@ -43,7 +43,7 @@ class PanelTestsBase(UnityTestCase): def setUp(self): super(PanelTestsBase, self).setUp() - self.panel = self.panels.get_panel_for_monitor(self.panel_monitor) + self.panel = self.unity.panels.get_panel_for_monitor(self.panel_monitor) self.panel.move_mouse_below_the_panel() self.addCleanup(self.panel.move_mouse_below_the_panel) @@ -156,8 +156,8 @@ class PanelTitleTests(PanelTestsBase): """With no windows shown, the panel must display the default title.""" gettext.install("unity", unicode=True) self.start_placeholder_app() - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) self.assertThat(self.panel.desktop_is_active, Eventually(Equals(True))) self.assertThat(self.panel.title, Equals(_("Ubuntu Desktop"))) @@ -200,8 +200,8 @@ class PanelTitleTests(PanelTestsBase): text_win = self.open_new_application_window("Text Editor", maximized=True) self.open_new_application_window("Calculator", maximized=False) - icon = self.launcher.model.get_icon(desktop_id=text_win.application.desktop_file) - launcher = self.launcher.get_launcher_for_monitor(self.panel_monitor) + icon = self.unity.launcher.model.get_icon(desktop_id=text_win.application.desktop_file) + launcher = self.unity.launcher.get_launcher_for_monitor(self.panel_monitor) launcher.click_launcher_icon(icon) self.assertProperty(text_win, is_focused=True) @@ -224,9 +224,9 @@ class PanelTitleTests(PanelTestsBase): text_win = self.open_new_application_window("Text Editor") current_title = self.panel.title - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) - self.switcher.next_icon() + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) + self.unity.switcher.next_icon() self.assertThat(self.panel.title, Eventually(Equals(current_title))) @@ -245,8 +245,8 @@ class PanelWindowButtonsTests(PanelTestsBase): def test_window_buttons_dont_show_on_empty_desktop(self): """Tests that the window buttons are not shown on clean desktop.""" self.start_placeholder_app() - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False))) @@ -292,8 +292,8 @@ class PanelWindowButtonsTests(PanelTestsBase): def test_window_buttons_show_with_dash(self): """Window buttons must be shown when the dash is open.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(True))) self.assertWinButtonsInOverlayMode(True) @@ -303,29 +303,29 @@ class PanelWindowButtonsTests(PanelTestsBase): buttons must still work in the dash.""" self.set_unity_option("icon_size", 25) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) - desired_max = not self.dash.view.dash_maximized + desired_max = not self.unity.dash.view.dash_maximized if desired_max: self.panel.window_buttons.maximize.mouse_click() else: self.panel.window_buttons.unmaximize.mouse_click() - self.assertThat(self.dash.view.dash_maximized, Eventually(Equals(desired_max))) + self.assertThat(self.unity.dash.view.dash_maximized, Eventually(Equals(desired_max))) def test_window_buttons_show_with_hud(self): """Window buttons must be shown when the HUD is open.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(True))) self.assertWinButtonsInOverlayMode(True) def test_window_buttons_update_visual_state(self): """Window button must update its state in response to mouse events.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) button = self.panel.window_buttons.close self.assertThat(button.visual_state, Eventually(Equals("normal"))) @@ -341,8 +341,8 @@ class PanelWindowButtonsTests(PanelTestsBase): """Window buttons must ignore clicks when the mouse released outside their area. """ - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) button = self.panel.window_buttons.close button.mouse_move_to() @@ -352,7 +352,7 @@ class PanelWindowButtonsTests(PanelTestsBase): self.mouse.release() self.assertThat(button.visual_state, Eventually(Equals("normal"))) - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) def test_window_buttons_close_button_works_for_window(self): """Close window button must actually closes a window.""" @@ -441,43 +441,43 @@ class PanelWindowButtonsTests(PanelTestsBase): def test_window_buttons_close_button_works_for_hud(self): """Tests that the window 'Close' actually closes the HUD.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.panel.window_buttons.close.mouse_click() - self.assertThat(self.hud.visible, Eventually(Equals(False))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(False))) def test_minimize_button_disabled_for_hud(self): """Minimize button must be disabled for the HUD.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.assertThat(self.panel.window_buttons.minimize.enabled, Eventually(Equals(False))) def test_minimize_button_does_nothing_for_hud(self): """Minimize button must not affect the Hud.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.panel.window_buttons.minimize.mouse_click() - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) def test_maximize_button_disabled_for_hud(self): """Maximize button must be disabled for the HUD.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.assertThat(self.panel.window_buttons.maximize.enabled, Eventually(Equals(False))) def test_maximize_button_does_nothing_for_hud(self): """Maximize button must not affect the Hud.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.panel.window_buttons.maximize.mouse_click() - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) def test_hud_maximize_button_does_not_change_dash_form_factor(self): """Clicking on the 'Maximize' button of the HUD must not change the dash @@ -485,39 +485,39 @@ class PanelWindowButtonsTests(PanelTestsBase): See bug #939054 """ - inital_form_factor = self.dash.view.form_factor - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + inital_form_factor = self.unity.dash.view.form_factor + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.panel.window_buttons.maximize.mouse_click() # long sleep here to make sure that any change that might happen will # have already happened. sleep(5) - self.assertThat(self.dash.view.form_factor, Equals(inital_form_factor)) + self.assertThat(self.unity.dash.view.form_factor, Equals(inital_form_factor)) def test_window_buttons_close_button_works_for_dash(self): """Tests that the window 'Close' actually closes the Dash.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.panel.window_buttons.close.mouse_click() - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_minimize_button_disabled_for_dash(self): """Tests that the 'Minimize' button is disabled for the dash.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.assertThat(self.panel.window_buttons.minimize.enabled, Eventually(Equals(False))) def test_minimize_button_does_nothing_for_dash(self): """Tests that the 'Minimize' button is disabled for the dash.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.panel.window_buttons.minimize.mouse_click() sleep(5) - self.assertThat(self.dash.visible, Eventually(Equals(True))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) def test_window_buttons_maximization_buttons_works_for_dash(self): """'Maximize' and 'Restore' buttons (when both enabled) must work as expected.""" @@ -529,14 +529,14 @@ class PanelWindowButtonsTests(PanelTestsBase): # this test out and make it suck less. # # For your sanity I have annotated it with comments. - self.dash.ensure_visible() + self.unity.dash.ensure_visible() self.addCleanup(self.panel.window_buttons.close.mouse_click) unmaximize = self.panel.window_buttons.unmaximize maximize = self.panel.window_buttons.maximize # "netbook" means "dash is maximised" - dash_maximised = (self.dash.view.form_factor == "netbook") + dash_maximised = (self.unity.dash.view.form_factor == "netbook") # this if statement will trigger only when we're on very small screens, # where it doesn't make sense to have the dash anything other than @@ -545,7 +545,7 @@ class PanelWindowButtonsTests(PanelTestsBase): unmaximize.mouse_click() # nice long sleep to make sure that any changes have time to process. sleep(5) - self.assertThat(self.dash.view.form_factor, Equals("netbook")) + self.assertThat(self.unity.dash.view.form_factor, Equals("netbook")) else: # we are able to resize the dash. # maximise and unmaximise (restore) buttons are shown in the same place @@ -571,9 +571,9 @@ class PanelWindowButtonsTests(PanelTestsBase): self.assertThat(active_button.visible, Eventually(Equals(False))) if dash_maximised: - self.assertThat(self.dash.view.form_factor, Eventually(Equals("desktop"))) + self.assertThat(self.unity.dash.view.form_factor, Eventually(Equals("desktop"))) else: - self.assertThat(self.dash.view.form_factor, Eventually(Equals("netbook"))) + self.assertThat(self.unity.dash.view.form_factor, Eventually(Equals("netbook"))) self.addCleanup(active_button.mouse_click) inactive_button.mouse_click() @@ -582,9 +582,9 @@ class PanelWindowButtonsTests(PanelTestsBase): self.assertThat(inactive_button.visible, Eventually(Equals(False))) if dash_maximised: - self.assertThat(self.dash.view.form_factor, Eventually(Equals("netbook"))) + self.assertThat(self.unity.dash.view.form_factor, Eventually(Equals("netbook"))) else: - self.assertThat(self.dash.view.form_factor, Eventually(Equals("desktop"))) + self.assertThat(self.unity.dash.view.form_factor, Eventually(Equals("desktop"))) def test_minimize_button_disabled_for_non_minimizable_windows(self): """Minimize button must be disabled for windows that don't support minimization.""" @@ -645,14 +645,14 @@ class PanelWindowButtonsTests(PanelTestsBase): you must still be able to type into the Hud. """ - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.keyboard.type("Hello") self.panel.window_buttons.minimize.mouse_click() self.keyboard.type("World") - self.assertThat(self.hud.search_string, Eventually(Equals("HelloWorld"))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals("HelloWorld"))) def test_double_click_unmaximize_window(self): """Double clicking the grab area must unmaximize a maximized window.""" @@ -915,8 +915,8 @@ class PanelMenuTests(PanelTestsBase): def test_menus_dont_show_with_dash(self): """Tests that menus are not showing when opening the dash.""" self.open_new_application_window("Text Editor", maximized=True) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.assertThat(self.panel.menus_shown, Eventually(Equals(False))) @@ -924,8 +924,8 @@ class PanelMenuTests(PanelTestsBase): def test_menus_dont_show_with_hud(self): """Tests that menus are not showing when opening the HUD.""" self.open_new_application_window("Text Editor", maximized=True) - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.assertThat(self.panel.menus_shown, Eventually(Equals(False))) @@ -985,13 +985,13 @@ class PanelIndicatorEntryTests(PanelTestsBase): """When the dash is open and a click is on an indicator the dash must close and the indicator must open. """ - self.dash.ensure_visible() + self.unity.dash.ensure_visible() indicator = self.panel.indicators.get_indicator_by_name_hint("indicator-session") self.mouse_open_indicator(indicator) self.assertThat(indicator.active, Eventually(Equals(True))) - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) class PanelKeyNavigationTests(PanelTestsBase): @@ -1130,15 +1130,15 @@ class PanelGrabAreaTests(PanelTestsBase): def test_panels_dont_steal_keynav_foucs_from_hud(self): """On a mouse click event on the panel you must still be able to type into the Hud.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.keyboard.type("Hello") self.move_mouse_over_grab_area() self.mouse.click() self.keyboard.type("World") - self.assertThat(self.hud.search_string, Eventually(Equals("HelloWorld"))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals("HelloWorld"))) class PanelCrossMonitorsTests(PanelTestsBase): @@ -1159,10 +1159,10 @@ class PanelCrossMonitorsTests(PanelTestsBase): self.screen_geo.drag_window_to_monitor(calc_win, monitor) if prev_monitor: - prev_panel = self.panels.get_panel_for_monitor(prev_monitor) + prev_panel = self.unity.panels.get_panel_for_monitor(prev_monitor) self.assertThat(prev_panel.active, Eventually(Equals(False))) - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) self.assertThat(panel.active, Eventually(Equals(True))) self.assertThat(panel.title, Eventually(Equals(calc_win.application.name))) @@ -1176,7 +1176,7 @@ class PanelCrossMonitorsTests(PanelTestsBase): self.sleep_menu_settle_period() for monitor in range(0, self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) panel.move_mouse_over_window_buttons() self.sleep_menu_settle_period() @@ -1190,13 +1190,13 @@ class PanelCrossMonitorsTests(PanelTestsBase): """Window buttons must not show on the panels other than the one where the dash is opened. """ - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) for monitor in range(0, self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) - if self.dash.monitor == monitor: + if self.unity.dash.monitor == monitor: self.assertThat(panel.window_buttons_shown, Eventually(Equals(True))) else: self.assertThat(panel.window_buttons_shown, Eventually(Equals(False))) @@ -1205,13 +1205,13 @@ class PanelCrossMonitorsTests(PanelTestsBase): """Window buttons must not show on the panels other than the one where the hud is opened. """ - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) for monitor in range(0, self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) - if self.hud.monitor == monitor: + if self.unity.hud.monitor == monitor: self.assertThat(panel.window_buttons_shown, Eventually(Equals(True))) else: self.assertThat(panel.window_buttons_shown, Eventually(Equals(False))) @@ -1225,7 +1225,7 @@ class PanelCrossMonitorsTests(PanelTestsBase): text_win = self.open_new_application_window("Text Editor", maximized=True) for monitor in range(self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) if monitor != text_win.monitor: panel.window_buttons.close.mouse_move_to() @@ -1241,7 +1241,7 @@ class PanelCrossMonitorsTests(PanelTestsBase): text_win = self.open_new_application_window("Text Editor", maximized=True) for monitor in range(self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) if monitor != text_win.monitor: panel.window_buttons.minimize.mouse_click() @@ -1256,7 +1256,7 @@ class PanelCrossMonitorsTests(PanelTestsBase): text_win = self.open_new_application_window("Text Editor", maximized=True) for monitor in range(0, self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) if monitor != text_win.monitor: panel.window_buttons.unmaximize.mouse_click() @@ -1265,12 +1265,12 @@ class PanelCrossMonitorsTests(PanelTestsBase): def test_hovering_indicators_on_multiple_monitors(self): """Opening an indicator entry and then hovering others entries must open them.""" text_win = self.open_new_application_window("Text Editor") - panel = self.panels.get_panel_for_monitor(text_win.monitor) + panel = self.unity.panels.get_panel_for_monitor(text_win.monitor) indicator = panel.indicators.get_indicator_by_name_hint("indicator-session") self.mouse_open_indicator(indicator) for monitor in range(0, self.screen_geo.get_num_monitors()): - panel = self.panels.get_panel_for_monitor(monitor) + panel = self.unity.panels.get_panel_for_monitor(monitor) entries = panel.get_indicator_entries(include_hidden_menus=True) self.assertThat(len(entries), GreaterThan(0)) diff --git a/tests/autopilot/unity/tests/test_quicklist.py b/tests/autopilot/unity/tests/test_quicklist.py index 2ca1271a7..bf6224a76 100644 --- a/tests/autopilot/unity/tests/test_quicklist.py +++ b/tests/autopilot/unity/tests/test_quicklist.py @@ -32,7 +32,7 @@ class QuicklistActionTests(UnityTestCase): Returns the quicklist that was opened. """ - launcher = self.launcher.get_launcher_for_monitor(0) + launcher = self.unity.launcher.get_launcher_for_monitor(0) launcher.click_launcher_icon(launcher_icon, button=3) self.addCleanup(self.keyboard.press_and_release, "Escape") self.assertThat(launcher_icon.get_quicklist, Eventually(NotEquals(None))) @@ -47,7 +47,7 @@ class QuicklistActionTests(UnityTestCase): desktop_file = os.path.join('/usr/share/applications', desktop_id) de = DesktopEntry(desktop_file) # get the launcher icon from the launcher: - launcher_icon = self.launcher.model.get_icon(desktop_id=desktop_id) + launcher_icon = self.unity.launcher.model.get_icon(desktop_id=desktop_id) self.assertThat(launcher_icon, NotEquals(None)) # open the icon quicklist, and get all the text labels: @@ -78,9 +78,9 @@ class QuicklistActionTests(UnityTestCase): self.assertVisibleWindowStack([char_win2, calc_win, char_win1]) - char_icon = self.launcher.model.get_icon( + char_icon = self.unity.launcher.model.get_icon( desktop_id=char_win1.application.desktop_file) - calc_icon = self.launcher.model.get_icon( + calc_icon = self.unity.launcher.model.get_icon( desktop_id=calc_win.application.desktop_file) calc_ql = self.open_quicklist_for_icon(calc_icon) @@ -106,15 +106,15 @@ class QuicklistActionTests(UnityTestCase): self.assertVisibleWindowStack([char_win2, char_win1]) self.assertProperty(char_win2, is_focused=True) - char_icon = self.launcher.model.get_icon(desktop_id=char_app.desktop_file) + char_icon = self.unity.launcher.model.get_icon(desktop_id=char_app.desktop_file) char_ql = self.open_quicklist_for_icon(char_icon) app_item = char_ql.get_quicklist_application_item(char_app.name) self.addCleanup(self.keybinding, "spread/cancel") app_item.mouse_click() - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) - self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active_for_group, Eventually(Equals(True))) def test_quicklist_item_triggered_closes_dash(self): """When any quicklist item is triggered it must close the dash.""" @@ -122,38 +122,38 @@ class QuicklistActionTests(UnityTestCase): calc_win = self.start_app_window("Calculator") self.assertProperty(calc_win, is_focused=True) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) - calc_icon = self.launcher.model.get_icon( + calc_icon = self.unity.launcher.model.get_icon( desktop_id=calc_win.application.desktop_file) self.open_quicklist_for_icon(calc_icon) self.keyboard.press_and_release("Down") self.keyboard.press_and_release("Enter") - self.assertThat(self.dash.visible, Eventually(Equals(False))) + self.assertThat(self.unity.dash.visible, Eventually(Equals(False))) def test_quicklist_closes_when_hud_opens(self): """When a quicklist is open you must still be able to open the Hud.""" calc = self.start_app("Calculator") - calc_icon = self.launcher.model.get_icon(desktop_id=calc.desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file) self.open_quicklist_for_icon(calc_icon) - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) - self.assertThat(self.hud.visible, Eventually(Equals(True))) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) + self.assertThat(self.unity.hud.visible, Eventually(Equals(True))) def test_quicklist_closes_when_dash_opens(self): """When the quicklist is open you must still be able to open the dash.""" calc = self.start_app("Calculator") - calc_icon = self.launcher.model.get_icon(desktop_id=calc.desktop_file) + calc_icon = self.unity.launcher.model.get_icon(desktop_id=calc.desktop_file) self.open_quicklist_for_icon(calc_icon) - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) - self.assertThat(self.dash.visible, Eventually(Equals(True))) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) + self.assertThat(self.unity.dash.visible, Eventually(Equals(True))) def test_right_click_opens_quicklist_if_already_open(self): """A right click to another icon in the launcher must @@ -165,9 +165,9 @@ class QuicklistActionTests(UnityTestCase): calc_win = self.start_app_window("Calculator") mahj_win = self.start_app_window("Mahjongg") - calc_icon = self.launcher.model.get_icon( + calc_icon = self.unity.launcher.model.get_icon( desktop_id=calc_win.application.desktop_file) - mahj_icon = self.launcher.model.get_icon( + mahj_icon = self.unity.launcher.model.get_icon( desktop_id=mahj_win.application.desktop_file) calc_ql = self.open_quicklist_for_icon(calc_icon) @@ -184,7 +184,7 @@ class QuicklistActionTests(UnityTestCase): calc_win = self.start_app_window("Calculator") - calc_icon = self.launcher.model.get_icon( + calc_icon = self.unity.launcher.model.get_icon( desktop_id=calc_win.application.desktop_file) calc_ql = self.open_quicklist_for_icon(calc_icon) @@ -201,7 +201,7 @@ class QuicklistKeyNavigationTests(UnityTestCase): super(QuicklistKeyNavigationTests, self).setUp() desktop_file = self.KNOWN_APPS["Text Editor"]["desktop-file"] - icon_refresh_fn = lambda : self.launcher.model.get_icon( + icon_refresh_fn = lambda : self.unity.launcher.model.get_icon( desktop_id=desktop_file) self.assertThat(icon_refresh_fn, Eventually(Equals(None))) @@ -210,7 +210,7 @@ class QuicklistKeyNavigationTests(UnityTestCase): self.assertThat(icon_refresh_fn, Eventually(NotEquals(None))) self.ql_launcher_icon = icon_refresh_fn() - self.ql_launcher = self.launcher.get_launcher_for_monitor(0) + self.ql_launcher = self.unity.launcher.get_launcher_for_monitor(0) def open_quicklist_with_mouse(self): """Opens a quicklist with the mouse.""" diff --git a/tests/autopilot/unity/tests/test_shopping_lens.py b/tests/autopilot/unity/tests/test_shopping_lens.py index 94d42a771..b808abb2a 100644 --- a/tests/autopilot/unity/tests/test_shopping_lens.py +++ b/tests/autopilot/unity/tests/test_shopping_lens.py @@ -29,13 +29,13 @@ class ShoppingLensTests(UnityTestCase): gettext.install("unity-lens-shopping") def tearDown(self): - self.dash.ensure_hidden() + self.unity.dash.ensure_hidden() super(ShoppingLensTests, self).tearDown() def test_no_results_in_home_lens_if_empty_search(self): """Test that the home lens contains no results if the search bar is empty.""" - self.dash.ensure_visible() - lens = self.dash.get_current_lens() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() results_category = lens.get_category_by_name(_("More suggestions")) refresh_results_fn = lambda: len(results_category.get_results()) @@ -43,8 +43,8 @@ class ShoppingLensTests(UnityTestCase): def test_home_lens_has_shopping_results(self): """Test that the home lens contains results.""" - self.dash.ensure_visible() - lens = self.dash.get_current_lens() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() self.keyboard.type("playstation") results_category = lens.get_category_by_name(_("More suggestions")) @@ -54,8 +54,8 @@ class ShoppingLensTests(UnityTestCase): def test_application_lens_has_shopping_results(self): """Test that the application lens contains results.""" - self.dash.reveal_application_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_application_lens() + lens = self.unity.dash.get_current_lens() self.keyboard.type("Text Editor") results_category = lens.get_category_by_name(_("More suggestions")) @@ -65,8 +65,8 @@ class ShoppingLensTests(UnityTestCase): def test_music_lens_has_shopping_results(self): """Test that the music lens contains results.""" - self.dash.reveal_music_lens() - lens = self.dash.get_current_lens() + self.unity.dash.reveal_music_lens() + lens = self.unity.dash.get_current_lens() self.keyboard.type("megadeth") results_category = lens.get_category_by_name(_("More suggestions")) @@ -76,8 +76,8 @@ class ShoppingLensTests(UnityTestCase): def test_preview_works_with_shopping_lens(self): """This test shows the dash preview works with shopping lens results.""" - self.dash.ensure_visible() - lens = self.dash.get_current_lens() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() self.keyboard.type("playstation") results_category = lens.get_category_by_name(_("More suggestions")) @@ -88,14 +88,14 @@ class ShoppingLensTests(UnityTestCase): results = results_category.get_results() results[0].preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) def test_shopping_lens_preview_navigate_right(self): """This test shows that shopping lens results can open previews, then move to the next shopping result. """ - self.dash.ensure_visible() - lens = self.dash.get_current_lens() + self.unity.dash.ensure_visible() + lens = self.unity.dash.get_current_lens() self.keyboard.type("playstation") results_category = lens.get_category_by_name(_("More suggestions")) @@ -106,8 +106,8 @@ class ShoppingLensTests(UnityTestCase): results = results_category.get_results() results[0].preview() - self.assertThat(self.dash.preview_displaying, Eventually(Equals(True))) - self.preview_container = self.dash.view.get_preview_container() + self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True))) + self.preview_container = self.unity.dash.view.get_preview_container() start_index = self.preview_container.relative_nav_index self.preview_container.navigate_right() diff --git a/tests/autopilot/unity/tests/test_shortcut_hint.py b/tests/autopilot/unity/tests/test_shortcut_hint.py index 951de4d58..e92561858 100644 --- a/tests/autopilot/unity/tests/test_shortcut_hint.py +++ b/tests/autopilot/unity/tests/test_shortcut_hint.py @@ -25,7 +25,7 @@ class BaseShortcutHintTests(UnityTestCase): self.DEFAULT_WIDTH = 970; self.DEFAULT_HEIGHT = 680; - self.shortcut_hint = self.get_shortcut_controller() + #self.shortcut_hint = self.get_shortcut_controller() self.set_unity_option('shortcut_overlay', True) self.set_unity_log_level("unity.shell.compiz", "DEBUG") self.skip_if_monitor_too_small() @@ -36,23 +36,23 @@ class BaseShortcutHintTests(UnityTestCase): monitor_geo = self.screen_geo.get_monitor_geometry(monitor) monitor_w = monitor_geo[2] monitor_h = monitor_geo[3] - launcher_width = self.launcher.get_launcher_for_monitor(monitor).geometry[2] - panel_height = self.panels.get_panel_for_monitor(monitor).geometry[3] + launcher_width = self.unity.launcher.get_launcher_for_monitor(monitor).geometry[2] + panel_height = self.unity.panels.get_panel_for_monitor(monitor).geometry[3] if ((monitor_w - launcher_width) <= self.DEFAULT_WIDTH or (monitor_h - panel_height) <= self.DEFAULT_HEIGHT): self.skipTest("This test requires a bigger screen, to show the ShortcutHint") - def get_shortcut_controller(self): - controllers = ShortcutController.get_all_instances() - self.assertThat(len(controllers), Equals(1)) - return controllers[0] + # def get_shortcut_controller(self): + # controllers = ShortcutController.get_all_instances() + # self.assertThat(len(controllers), Equals(1)) + # return controllers[0] def get_launcher(self): # We could parameterise this so all tests run on both monitors (if MM is # set up), but I think it's fine to just always use monitor primary monitor: monitor = self.screen_geo.get_primary_monitor() - return self.launcher.get_launcher_for_monitor(monitor) + return self.unity.launcher.get_launcher_for_monitor(monitor) class ShortcutHintTests(BaseShortcutHintTests): @@ -60,39 +60,39 @@ class ShortcutHintTests(BaseShortcutHintTests): def test_shortcut_hint_reveal(self): """Test that the shortcut hint is shown.""" - self.shortcut_hint.show() - self.addCleanup(self.shortcut_hint.ensure_hidden) - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(True))) + self.unity.shortcut_hint.show() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(True))) def test_shortcut_hint_reveal_timeout(self): """Shortcut hint must be shown after a sufficient timeout.""" - timeout = self.shortcut_hint.get_show_timeout() - self.shortcut_hint.show() - self.addCleanup(self.shortcut_hint.ensure_hidden) + timeout = self.unity.shortcut_hint.get_show_timeout() + self.unity.shortcut_hint.show() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) sleep(timeout/2.0) - self.assertThat(self.shortcut_hint.visible, Equals(False)) + self.assertThat(self.unity.shortcut_hint.visible, Equals(False)) # This should happen after 3/4 of 'timeout': - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(True))) + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(True))) def test_shortcut_hint_unreveal(self): """Shortcut hint must hide when keys are released.""" - self.shortcut_hint.ensure_visible() - self.shortcut_hint.hide() - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(False))) + self.unity.shortcut_hint.ensure_visible() + self.unity.shortcut_hint.hide() + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(False))) def test_shortcut_hint_cancel(self): """Shortcut hint must hide when cancelled.""" - self.shortcut_hint.ensure_visible() - self.shortcut_hint.cancel() - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(False))) + self.unity.shortcut_hint.ensure_visible() + self.unity.shortcut_hint.cancel() + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(False))) def test_shortcut_hint_no_blur(self): """""" - self.shortcut_hint.ensure_visible() - self.addCleanup(self.shortcut_hint.ensure_hidden) + self.unity.shortcut_hint.ensure_visible() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) - self.assertThat(self.shortcut_hint.get_shortcut_view().bg_texture_is_valid, Eventually(Equals(True))) + self.assertThat(self.unity.shortcut_hint.get_shortcut_view().bg_texture_is_valid, Eventually(Equals(True))) class ShortcutHintInteractionsTests(BaseShortcutHintTests): @@ -100,39 +100,39 @@ class ShortcutHintInteractionsTests(BaseShortcutHintTests): def test_shortcut_hint_hide_using_unity_shortcuts(self): """Unity shortcuts (like expo) must hide the shortcut hint.""" - self.shortcut_hint.ensure_visible() - self.addCleanup(self.shortcut_hint.ensure_hidden) + self.unity.shortcut_hint.ensure_visible() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) self.keybinding_tap("expo/start") self.addCleanup(self.keybinding, "expo/cancel") def test_shortcut_hint_hide_pressing_modifiers(self): """Pressing a modifer key must hide the shortcut hint.""" - self.shortcut_hint.ensure_visible() - self.addCleanup(self.shortcut_hint.ensure_hidden) + self.unity.shortcut_hint.ensure_visible() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) self.keyboard.press('Control') - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(False))) + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(False))) def test_launcher_switcher_next_doesnt_show_shortcut_hint(self): """Super+Tab switcher cycling forward must not show shortcut hint.""" - switcher_timeout = self.shortcut_hint.get_show_timeout() - self.shortcut_hint.show() - self.addCleanup(self.shortcut_hint.ensure_hidden) + switcher_timeout = self.unity.shortcut_hint.get_show_timeout() + self.unity.shortcut_hint.show() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) self.keybinding("launcher/switcher/next") self.keybinding("launcher/switcher/next") self.addCleanup(self.keyboard.press_and_release, "Escape") sleep(switcher_timeout * 2) - self.assertThat(self.shortcut_hint.visible, Equals(False)) + self.assertThat(self.unity.shortcut_hint.visible, Equals(False)) def test_launcher_switcher_prev_doesnt_show_shortcut_hint(self): """Super+Tab switcher cycling backwards must not show shortcut hint.""" - switcher_timeout = self.shortcut_hint.get_show_timeout() - self.shortcut_hint.show() - self.addCleanup(self.shortcut_hint.ensure_hidden) + switcher_timeout = self.unity.shortcut_hint.get_show_timeout() + self.unity.shortcut_hint.show() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) self.keybinding("launcher/switcher/next") self.addCleanup(self.keyboard.press_and_release, "Escape") @@ -140,7 +140,7 @@ class ShortcutHintInteractionsTests(BaseShortcutHintTests): self.keybinding("launcher/switcher/prev") sleep(switcher_timeout * 2) - self.assertThat(self.shortcut_hint.visible, Equals(False)) + self.assertThat(self.unity.shortcut_hint.visible, Equals(False)) def test_launcher_icons_hints_show_with_shortcut_hint(self): """When the shortcut hint is shown also the launcer's icons hints should @@ -148,10 +148,10 @@ class ShortcutHintInteractionsTests(BaseShortcutHintTests): """ launcher = self.get_launcher() - self.shortcut_hint.ensure_visible() - self.addCleanup(self.shortcut_hint.ensure_hidden) + self.unity.shortcut_hint.ensure_visible() + self.addCleanup(self.unity.shortcut_hint.ensure_hidden) - self.assertThat(self.shortcut_hint.visible, Equals(True)) + self.assertThat(self.unity.shortcut_hint.visible, Equals(True)) self.assertThat(launcher.shortcuts_shown, Equals(True)) def test_shortcut_hint_shows_with_launcher_icons_hints(self): @@ -164,4 +164,4 @@ class ShortcutHintInteractionsTests(BaseShortcutHintTests): self.addCleanup(launcher.keyboard_unreveal_launcher) self.assertThat(launcher.shortcuts_shown, Eventually(Equals(True))) - self.assertThat(self.shortcut_hint.visible, Eventually(Equals(True))) + self.assertThat(self.unity.shortcut_hint.visible, Eventually(Equals(True))) diff --git a/tests/autopilot/unity/tests/test_showdesktop.py b/tests/autopilot/unity/tests/test_showdesktop.py index e6469fb77..64f42595a 100644 --- a/tests/autopilot/unity/tests/test_showdesktop.py +++ b/tests/autopilot/unity/tests/test_showdesktop.py @@ -11,6 +11,7 @@ from __future__ import absolute_import from testtools import skip from time import sleep +from unity.emulators.switcher import SwitcherDirection from unity.tests import UnityTestCase @@ -35,8 +36,8 @@ class ShowDesktopTests(UnityTestCase): test_windows = self.launch_test_apps() # show desktop, verify all windows are hidden: - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) for win in test_windows: self.assertProperty(win, is_valid=True) @@ -47,15 +48,15 @@ class ShowDesktopTests(UnityTestCase): test_windows = self.launch_test_apps() # show desktop, verify all windows are hidden: - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) for win in test_windows: self.assertProperty(win, is_valid=True) self.assertProperty(win, is_hidden=True) # un-show desktop, verify all windows are shown: - self.window_manager.leave_show_desktop() + self.unity.window_manager.leave_show_desktop() for win in test_windows: self.assertProperty(win, is_valid=True) @@ -66,17 +67,17 @@ class ShowDesktopTests(UnityTestCase): charmap, calc = self.launch_test_apps() # show desktop, verify all windows are hidden: - self.window_manager.enter_show_desktop() - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.window_manager.enter_show_desktop() + self.addCleanup(self.unity.window_manager.leave_show_desktop) for win in (charmap, calc): self.assertProperty(win, is_valid=True) self.assertProperty(win, is_hidden=True) # We'll un-minimise the character map - find it's launcherIcon in the launcher: - charmap_icon = self.launcher.model.get_icon(desktop_id="gucharmap.desktop") + charmap_icon = self.unity.launcher.model.get_icon(desktop_id="gucharmap.desktop") if charmap_icon: - self.launcher.get_launcher_for_monitor(0).click_launcher_icon(charmap_icon) + self.unity.launcher.get_launcher_for_monitor(0).click_launcher_icon(charmap_icon) else: self.fail("Could not find launcher icon in launcher.") @@ -84,7 +85,7 @@ class ShowDesktopTests(UnityTestCase): self.assertProperty(calc, is_hidden=True) # hide desktop - now all windows should be visible: - self.window_manager.leave_show_desktop() + self.unity.window_manager.leave_show_desktop() for win in (charmap, calc): self.assertProperty(win, is_hidden=False) @@ -95,9 +96,9 @@ class ShowDesktopTests(UnityTestCase): test_windows = self.launch_test_apps() # show desktop, verify all windows are hidden: - self.switcher.initiate() - self.switcher.select_icon(self.switcher.DIRECTION_BACKWARDS, tooltip_text="Show Desktop") - self.addCleanup(self.window_manager.leave_show_desktop) + self.unity.switcher.initiate() + self.unity.switcher.select_icon(SwitcherDirection.BACKWARDS, tooltip_text="Show Desktop") + self.addCleanup(self.unity.window_manager.leave_show_desktop) self.switcher.select() for win in test_windows: diff --git a/tests/autopilot/unity/tests/test_spread.py b/tests/autopilot/unity/tests/test_spread.py index 9636b6de6..99d545de3 100644 --- a/tests/autopilot/unity/tests/test_spread.py +++ b/tests/autopilot/unity/tests/test_spread.py @@ -38,21 +38,21 @@ class SpreadTests(UnityTestCase): """Initiate the Spread for all windows""" self.addCleanup(self.keybinding, "spread/cancel") self.keybinding("spread/start") - self.assertThat(self.window_manager.scale_active, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True))) def initiate_spread_for_application(self, desktop_id): """Initiate the Spread for windows of the given app""" - icon = self.launcher.model.get_icon(desktop_id=desktop_id) + icon = self.unity.launcher.model.get_icon(desktop_id=desktop_id) self.assertThat(icon, NotEquals(None)) - launcher = self.launcher.get_launcher_for_monitor(self.screen_geo.get_primary_monitor()) + launcher = self.unity.launcher.get_launcher_for_monitor(self.screen_geo.get_primary_monitor()) self.addCleanup(self.keybinding, "spread/cancel") launcher.click_launcher_icon(icon) - self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True))) + self.assertThat(self.unity.window_manager.scale_active_for_group, Eventually(Equals(True))) def assertWindowIsNotScaled(self, xid): """Assert that a window is not scaled""" - refresh_fn = lambda: xid in [w.xid for w in self.screen.scaled_windows] + refresh_fn = lambda: xid in [w.xid for w in self.unity.screen.scaled_windows] self.assertThat(refresh_fn, Eventually(Equals(False))) def assertWindowIsClosed(self, xid): @@ -68,8 +68,8 @@ class SpreadTests(UnityTestCase): [win1, win2] = self.start_test_application_windows("Calculator") self.initiate_spread_for_application(win1.application.desktop_file) - self.assertThat(lambda: len(self.screen.scaled_windows), Eventually(Equals(2))) - self.assertThat(lambda: (win1.x_id and win2.x_id) in [w.xid for w in self.screen.scaled_windows], + self.assertThat(lambda: len(self.unity.screen.scaled_windows), Eventually(Equals(2))) + self.assertThat(lambda: (win1.x_id and win2.x_id) in [w.xid for w in self.unity.screen.scaled_windows], Eventually(Equals(True))) def test_scaled_window_is_focused_on_click(self): @@ -80,7 +80,7 @@ class SpreadTests(UnityTestCase): not_focused = [w for w in windows if not w.is_focused][0] target_xid = not_focused.x_id - [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid] + [target_win] = [w for w in self.unity.screen.scaled_windows if w.xid == target_xid] (x, y, w, h) = target_win.geometry self.mouse.move(x + w / 2, y + h / 2) @@ -95,7 +95,7 @@ class SpreadTests(UnityTestCase): self.initiate_spread_for_application(win.application.desktop_file) target_xid = win.x_id - [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid] + [target_win] = [w for w in self.unity.screen.scaled_windows if w.xid == target_xid] (x, y, w, h) = target_win.geometry self.mouse.move(x + w / 2, y + h / 2) @@ -111,7 +111,7 @@ class SpreadTests(UnityTestCase): self.initiate_spread_for_screen() target_xid = win.x_id - [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid] + [target_win] = [w for w in self.unity.screen.scaled_windows if w.xid == target_xid] (x, y, w, h) = target_win.scale_close_geometry self.mouse.move(x + w / 2, y + h / 2) diff --git a/tests/autopilot/unity/tests/test_switcher.py b/tests/autopilot/unity/tests/test_switcher.py index 7347052b3..e86db7b1e 100644 --- a/tests/autopilot/unity/tests/test_switcher.py +++ b/tests/autopilot/unity/tests/test_switcher.py @@ -14,7 +14,7 @@ import logging from testtools.matchers import Equals, Contains, Not from time import sleep -from unity.emulators.switcher import Switcher, SwitcherMode +from unity.emulators.switcher import SwitcherDirection, SwitcherMode from unity.tests import UnityTestCase logger = logging.getLogger(__name__) @@ -34,7 +34,7 @@ class SwitcherTestCase(UnityTestCase): if type(state) is not bool: raise TypeError("'state' must be boolean, not %r" % type(state)) self.set_unity_option("disable_show_desktop", state) - self.assertThat(self.switcher.controller.show_desktop_disabled, Eventually(Equals(state))) + self.assertThat(self.unity.switcher.show_desktop_disabled, Eventually(Equals(state))) def set_timeout_setting(self, state): if type(state) is not bool: @@ -79,90 +79,90 @@ class SwitcherTests(SwitcherTestCase): """Switcher must start in normal (i.e.- not details) mode.""" self.start_app("Character Map") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) - self.assertProperty(self.switcher, mode=SwitcherMode.NORMAL) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) + self.assertProperty(self.unity.switcher, mode=SwitcherMode.NORMAL) def test_label_matches_application_name(self): """The switcher label must match the selected application name in normal mode.""" windows = self.start_applications() - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) for win in windows: app_name = win.application.name - self.switcher.select_icon(Switcher.DIRECTION_FORWARDS, tooltip_text=app_name) - self.assertThat(self.switcher.label_visible, Eventually(Equals(True))) - self.assertThat(self.switcher.label, Eventually(Equals(app_name))) + self.unity.switcher.select_icon(SwitcherDirection.FORWARDS, tooltip_text=app_name) + self.assertThat(self.unity.switcher.label_visible, Eventually(Equals(True))) + self.assertThat(self.unity.switcher.label, Eventually(Equals(app_name))) def test_application_window_is_fake_decorated(self): """When the switcher is in details mode must not show the focused window title.""" window = self.start_app_window("Text Editor") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - self.switcher.select_icon(Switcher.DIRECTION_BACKWARDS, tooltip_text=window.application.name) + self.unity.switcher.select_icon(SwitcherDirection.BACKWARDS, tooltip_text=window.application.name) - self.switcher.show_details() - self.assertThat(self.switcher.label_visible, Eventually(Equals(False))) - self.assertThat(self.screen.window(window.x_id).fake_decorated, Eventually(Equals(True))) + self.unity.switcher.show_details() + self.assertThat(self.unity.switcher.label_visible, Eventually(Equals(False))) + self.assertThat(self.unity.screen.window(window.x_id).fake_decorated, Eventually(Equals(True))) def test_application_window_is_fake_decorated_in_detail_mode(self): """Starting switcher in details mode must not show the focused window title.""" window = self.start_app_window("Text Editor") - self.switcher.initiate(SwitcherMode.DETAIL) - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate(SwitcherMode.DETAIL) + self.addCleanup(self.unity.switcher.terminate) - self.assertThat(self.switcher.label_visible, Eventually(Equals(False))) - self.assertThat(self.screen.window(window.x_id).fake_decorated, Eventually(Equals(True))) + self.assertThat(self.unity.switcher.label_visible, Eventually(Equals(False))) + self.assertThat(self.unity.screen.window(window.x_id).fake_decorated, Eventually(Equals(True))) def test_switcher_move_next(self): """Test that pressing the next icon binding moves to the next icon""" self.start_applications() - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - start = self.switcher.selection_index - self.switcher.next_icon() + start = self.unity.switcher.selection_index + self.unity.switcher.next_icon() # Allow for wrap-around to first icon in switcher - next_index = (start + 1) % len(self.switcher.icons) + next_index = (start + 1) % len(self.unity.switcher.icons) - self.assertThat(self.switcher.selection_index, Eventually(Equals(next_index))) + self.assertThat(self.unity.switcher.selection_index, Eventually(Equals(next_index))) def test_switcher_move_prev(self): """Test that pressing the previous icon binding moves to the previous icon""" self.start_applications() - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - start = self.switcher.selection_index - self.switcher.previous_icon() + start = self.unity.switcher.selection_index + self.unity.switcher.previous_icon() - self.assertThat(self.switcher.selection_index, Eventually(Equals(start - 1))) + self.assertThat(self.unity.switcher.selection_index, Eventually(Equals(start - 1))) def test_switcher_scroll_next(self): """Test that scrolling the mouse wheel down moves to the next icon""" self.start_applications() - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - start = self.switcher.selection_index - self.switcher.next_via_mouse() + start = self.unity.switcher.selection_index + self.unity.switcher.next_via_mouse() # Allow for wrap-around to first icon in switcher - next_index = (start + 1) % len(self.switcher.icons) + next_index = (start + 1) % len(self.unity.switcher.icons) - self.assertThat(self.switcher.selection_index, Eventually(Equals(next_index))) + self.assertThat(self.unity.switcher.selection_index, Eventually(Equals(next_index))) def test_switcher_scroll_prev(self): """Test that scrolling the mouse wheel up moves to the previous icon""" self.start_applications() - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - start = self.switcher.selection_index - self.switcher.previous_via_mouse() + start = self.unity.switcher.selection_index + self.unity.switcher.previous_via_mouse() - self.assertThat(self.switcher.selection_index, Eventually(Equals(start - 1))) + self.assertThat(self.unity.switcher.selection_index, Eventually(Equals(start - 1))) def test_switcher_arrow_key_does_not_init(self): """Ensure that Alt+Right does not initiate switcher. @@ -171,7 +171,7 @@ class SwitcherTests(SwitcherTestCase): """ self.keyboard.press_and_release('Alt+Right') - self.assertThat(self.switcher.visible, Equals(False)) + self.assertThat(self.unity.switcher.visible, Equals(False)) def test_lazy_switcher_initiate(self): """Inserting a long delay between the Alt press and the Tab tab must still @@ -182,22 +182,22 @@ class SwitcherTests(SwitcherTestCase): self.keybinding_hold("switcher/reveal_normal") self.addCleanup(self.keybinding_release, "switcher/reveal_normal") - self.assertThat(self.switcher.visible, Eventually(Equals(False))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(False))) sleep(5) self.keybinding_tap("switcher/reveal_normal") self.addCleanup(self.keybinding, "switcher/cancel") - self.assertThat(self.switcher.visible, Eventually(Equals(True))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(True))) def test_switcher_cancel(self): """Pressing the switcher cancel keystroke must cancel the switcher.""" self.start_app("Character Map") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - self.assertThat(self.switcher.visible, Eventually(Equals(True))) - self.switcher.cancel() - self.assertThat(self.switcher.visible, Eventually(Equals(False))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(True))) + self.unity.switcher.cancel() + self.assertThat(self.unity.switcher.visible, Eventually(Equals(False))) def test_lazy_switcher_cancel(self): """Must be able to cancel the switcher after a 'lazy' initiation.""" @@ -205,12 +205,12 @@ class SwitcherTests(SwitcherTestCase): self.keybinding_hold("switcher/reveal_normal") self.addCleanup(self.keybinding_release, "switcher/reveal_normal") - self.assertThat(self.switcher.visible, Eventually(Equals(False))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(False))) sleep(5) self.keybinding_tap("switcher/reveal_normal") - self.assertThat(self.switcher.visible, Eventually(Equals(True))) - self.switcher.cancel() - self.assertThat(self.switcher.visible, Eventually(Equals(False))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(True))) + self.unity.switcher.cancel() + self.assertThat(self.unity.switcher.visible, Eventually(Equals(False))) def test_switcher_appears_on_monitor_with_mouse(self): """Tests that the switches appears on the correct monitor. @@ -229,21 +229,20 @@ class SwitcherTests(SwitcherTestCase): for monitor in range(num_monitors): self.screen_geo.move_mouse_to_monitor(monitor) - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) - self.assertThat(self.switcher.controller.monitor, Eventually(Equals(monitor))) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) + self.assertThat(self.unity.switcher.monitor, Eventually(Equals(monitor))) - def test_alt_f4_closes_switcher(self): - """Tests that alt+f4 should close the switcher when active.""" + def test_switcher_alt_f4_is_disabled(self): + """Tests that alt+f4 does not work while switcher is active.""" win = self.start_app_window("Text Editor") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) - self.assertThat(self.switcher.visible, Eventually(Equals(True))) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(True))) self.keyboard.press_and_release("Alt+F4") - self.assertThat(self.switcher.visible, Eventually(Equals(False))) # Need the sleep to allow the window time to close, for jenkins! sleep(10) self.assertProperty(win, is_valid=True) @@ -317,11 +316,11 @@ class SwitcherDetailsTests(SwitcherTestCase): self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) self.start_applications("Character Map", "Character Map", "Mahjongg") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) # Wait longer than details mode. sleep(3) - self.assertProperty(self.switcher, mode=SwitcherMode.DETAIL) + self.assertProperty(self.unity.switcher, mode=SwitcherMode.DETAIL) def test_no_details_for_apps_on_different_workspace(self): """Tests that details mode does not initiates when there are multiple windows @@ -338,11 +337,11 @@ class SwitcherDetailsTests(SwitcherTestCase): self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) self.start_applications("Character Map", "Mahjongg") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) # Wait longer than details mode. sleep(3) - self.assertProperty(self.switcher, mode=SwitcherMode.NORMAL) + self.assertProperty(self.unity.switcher, mode=SwitcherMode.NORMAL) class SwitcherDetailsModeTests(SwitcherTestCase): @@ -368,12 +367,12 @@ class SwitcherDetailsModeTests(SwitcherTestCase): """ self.start_app_window("Character Map") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) self.keyboard.press_and_release(self.initiate_keycode) - self.assertProperty(self.switcher, mode=SwitcherMode.DETAIL) + self.assertProperty(self.unity.switcher, mode=SwitcherMode.DETAIL) def test_next_icon_from_last_detail_works(self): """Pressing next while showing last switcher item in details mode @@ -381,19 +380,19 @@ class SwitcherDetailsModeTests(SwitcherTestCase): """ self.start_app("Character Map") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) - while self.switcher.selection_index < len(self.switcher.icons) - 1: - self.switcher.next_icon() + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) + while self.unity.switcher.selection_index < len(self.unity.switcher.icons) - 1: + self.unity.switcher.next_icon() self.keyboard.press_and_release(self.initiate_keycode) sleep(0.5) # Make sure we're at the end of the details list for this icon - possible_details = self.switcher.detail_current_count - 1 - while self.switcher.detail_selection_index < possible_details: - self.switcher.next_detail() + possible_details = self.unity.switcher.detail_current_count - 1 + while self.unity.switcher.detail_selection_index < possible_details: + self.unity.switcher.next_detail() - self.switcher.next_icon() - self.assertThat(self.switcher.selection_index, Eventually(Equals(0))) + self.unity.switcher.next_icon() + self.assertThat(self.unity.switcher.selection_index, Eventually(Equals(0))) def test_detail_mode_selects_last_active_window(self): """The active selection in detail mode must be the last focused window. @@ -402,12 +401,12 @@ class SwitcherDetailsModeTests(SwitcherTestCase): char_win1, char_win2 = self.start_applications("Character Map", "Character Map") self.assertVisibleWindowStack([char_win2, char_win1]) - self.switcher.initiate() - while self.switcher.current_icon.tooltip_text != char_win2.application.name: - self.switcher.next_icon() + self.unity.switcher.initiate() + while self.unity.switcher.current_icon.tooltip_text != char_win2.application.name: + self.unity.switcher.next_icon() self.keyboard.press_and_release(self.initiate_keycode) sleep(0.5) - self.switcher.select() + self.unity.switcher.select() self.assertProperty(char_win1, is_focused=True) @@ -418,10 +417,10 @@ class SwitcherDetailsModeTests(SwitcherTestCase): char_win1, char_win2, char_win3 = self.start_applications("Character Map", "Character Map", "Character Map") self.assertVisibleWindowStack([char_win3, char_win2, char_win1]) - self.switcher.initiate(SwitcherMode.DETAIL) - self.switcher.next_detail() + self.unity.switcher.initiate(SwitcherMode.DETAIL) + self.unity.switcher.next_detail() - self.switcher.select() + self.unity.switcher.select() self.assertVisibleWindowStack([char_win1, char_win3, char_win2]) @@ -442,10 +441,10 @@ class SwitcherWorkspaceTests(SwitcherTestCase): self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) char_map = self.start_app("Character Map") - self.switcher.initiate() - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate() + self.addCleanup(self.unity.switcher.terminate) - get_icon_names = lambda: [i.tooltip_text for i in self.switcher.icons] + get_icon_names = lambda: [i.tooltip_text for i in self.unity.switcher.icons] self.assertThat(get_icon_names, Eventually(Contains(char_map.name))) self.assertThat(get_icon_names, Eventually(Not(Contains(calc.name)))) @@ -458,10 +457,10 @@ class SwitcherWorkspaceTests(SwitcherTestCase): self.workspace.switch_to((initial_workspace + 1) % self.workspace.num_workspaces) char_map = self.start_app("Character Map") - self.switcher.initiate(SwitcherMode.ALL) - self.addCleanup(self.switcher.terminate) + self.unity.switcher.initiate(SwitcherMode.ALL) + self.addCleanup(self.unity.switcher.terminate) - get_icon_names = lambda: [i.tooltip_text for i in self.switcher.icons] + get_icon_names = lambda: [i.tooltip_text for i in self.unity.switcher.icons] self.assertThat(get_icon_names, Eventually(Contains(calc.name))) self.assertThat(get_icon_names, Eventually(Contains(char_map.name))) @@ -487,10 +486,10 @@ class SwitcherWorkspaceTests(SwitcherTestCase): self.start_app("Calculator") - self.switcher.initiate() - while self.switcher.current_icon.tooltip_text != char_win2.application.name: - self.switcher.next_icon() - self.switcher.select() + self.unity.switcher.initiate() + while self.unity.switcher.current_icon.tooltip_text != char_win2.application.name: + self.unity.switcher.next_icon() + self.unity.switcher.select() self.assertProperty(char_win2, is_hidden=False) @@ -505,6 +504,6 @@ class SwitcherWorkspaceTests(SwitcherTestCase): self.addCleanup(self.keyboard.release, "Ctrl+Alt+Right") sleep(1) self.keybinding_hold_part_then_tap("switcher/reveal_normal") - self.addCleanup(self.switcher.terminate) + self.addCleanup(self.unity.switcher.terminate) - self.assertThat(self.switcher.visible, Eventually(Equals(False))) + self.assertThat(self.unity.switcher.visible, Eventually(Equals(False))) diff --git a/tests/autopilot/unity/tests/xim/test_gcin.py b/tests/autopilot/unity/tests/xim/test_gcin.py index 3a5adacbc..936b99f38 100644 --- a/tests/autopilot/unity/tests/xim/test_gcin.py +++ b/tests/autopilot/unity/tests/xim/test_gcin.py @@ -54,19 +54,19 @@ class GcinTestHangul(GcinTestCase): def test_dash_input(self): """Entering an input string through gcin will result in a Korean string result in the dash.""" - self.dash.ensure_visible() - self.addCleanup(self.dash.ensure_hidden) + self.unity.dash.ensure_visible() + self.addCleanup(self.unity.dash.ensure_hidden) self.enter_hangul_mode() self.keyboard.type(self.input) - self.assertThat(self.dash.search_string, Eventually(Equals(self.result))) + self.assertThat(self.unity.dash.search_string, Eventually(Equals(self.result))) def test_hud_input(self): """Entering an input string through gcin will result in a Korean string result in the hud.""" - self.hud.ensure_visible() - self.addCleanup(self.hud.ensure_hidden) + self.unity.hud.ensure_visible() + self.addCleanup(self.unity.hud.ensure_hidden) self.enter_hangul_mode() self.keyboard.type(self.input) - self.assertThat(self.hud.search_string, Eventually(Equals(self.result))) + self.assertThat(self.unity.hud.search_string, Eventually(Equals(self.result))) |