Merge lp:~alexlauni/unity/unity.ap-switcher-emu into lp:unity

[Alex Launi]

Port autopilot switcher emulator to new-style API.

Refactors autopilot switcher emulator, and updates tests to match.

[Thomi Richards (thomir)]

Hi,

A few things:

== switcher.py ==

1) Diff has several bits of trailing whitespace:

116 + @property
170 +
310 +
330 +

2) Your docstrings need to be PEP257 compliant. Specifically:

"""One line docstrings look like this."""

"""Multi-line docstrings start with a single sentence.

Then a newline, followed by one or more sentences. Multi-line
docstrings end with a blank line before the closing quotes as
well, like this.

"""

3) The docstring for 'Switcher.property' should be changes, as should the implementation. Currently it will sometimes return a typle of items, and sometimes return a single item. I suggest the following:

    @property
    def mode(self):
        """Returns a tuple of SwitcherMode items that describe the mode the switcher is in.

        For example, to check whether the switcher is in details mode:

        >>> SwitcherMode.DETAIL in self.switcher.mode
        ... True

        """
        if not self.visible:
            return tuple()
        if self.controller.model.detail_selection and not self.controller.model.only_detail_on_viewport:
            return (SwitcherMode.DETAIL, SwitcherMode.ALL)
        elif self.controller.model.detail_selection:
            return (SwitcherMode.DETAIL,)
        elif not self.controller.model.only_detail_on_viewport:
            return (SwitcherMode.ALL,)
        else:
            return (SwitcherMode.NORMAL,)

== test_switcher.py ==

1) Unused import: NotEquals

2) PEP8 compliance: need 2 blank lines between module-level blocks. So 2 blank lines between the end of one class and the start of the next, and between the end of the import block and the start of the first class.

3) Docstring issues here similar to the switcher.py file.

4) Lots of trailing whitespace in this file!

5) Should probably use Eventually in the first few tests of SwitcherTests class, for example:

    def test_witcher_starts_in_normal_mode(self):
        """Switcher must start in normal (i.e.- not details) mode.

        """
        self.start_app("Character Map")
        sleep(1)

        self.switcher.initiate()
        self.addCleanup(self.switcher.terminate)
        self.assertThat(self.switcher.mode, Eventually(Equals(SwitcherMode.NORMAL)))

6) Is the alt+Tab timeout value an introspectable property? If not, can we make it one? THen we can replace this:

370 + def set_timeout_setting(self, value):
371 + self.set_unity_option("alt_tab_timeout", value)
372 + sleep(1)

With this:

370 + def set_timeout_setting(self, value):
371 + self.set_unity_option("alt_tab_timeout", value)
372 + self.switcher.alt_tab_timeout.wait_for(value)

Otherwise, looks good - all switcher tests pass for me locally.

review: Needs Fixing

[lp:~alexlauni/unity/unity.ap-switcher-emu]

2321. By Alex Launi on 2012-04-26

update from merge comments

2322. By Alex Launi on 2012-04-26

merge thomi's whitespace fixes

[Thomi Richards (thomir)]

review: Approve

=== modified file 'tests/autopilot/autopilot/emulators/unity/switcher.py'
--- tests/autopilot/autopilot/emulators/unity/switcher.py	2012-04-16 01:03:10 +0000
+++ tests/autopilot/autopilot/emulators/unity/switcher.py	2012-04-26 20:14:23 +0000
@@ -8,10 +8,9 @@
 #
 
 import logging
-from time import sleep
 
-from autopilot.emulators.unity import get_state_by_path, make_introspection_object
-from autopilot.emulators.X11 import Keyboard, Mouse
+from autopilot.emulators.unity import UnityIntrospectionObject
+from autopilot.emulators.X11 import Mouse
 from autopilot.keybindings import KeybindingsHelper
 
 # even though we don't use these directly, we need to make sure they've been
@@ -21,63 +20,80 @@
 
 logger = logging.getLogger(__name__)
 
-
-# TODO: THis class needs to be ported to the new-style emulator classes.
-# See launcher.py or dash.py for reference.
+class SwitcherMode():
+    """Define the possible modes the switcher can be in"""
+    NORMAL = 0
+    ALL = 1
+    DETAIL = 2
+
+
 class Switcher(KeybindingsHelper):
-    """Interact with the Unity switcher."""
+    """A class for interacting with the switcher.
+
+    Abstracts out switcher implementation, and makes the necessary functionality available
+    to consumer code.
+
+    """
 
     def __init__(self):
         super(Switcher, self).__init__()
-        self._keyboard = Keyboard()
         self._mouse = Mouse()
-
-    def initiate(self):
-        """Start the switcher with alt+tab."""
-        logger.debug("Initiating switcher with Alt+Tab")
-        self.keybinding_hold("switcher/reveal_normal")
-        self.keybinding_tap("switcher/reveal_normal")
-        sleep(1)
-
-    def initiate_detail_mode(self):
-        """Start detail mode with alt+`"""
-        logger.debug("Initiating switcher detail mode with Alt+`")
-        self.keybinding_hold("switcher/reveal_details")
-        self.keybinding_tap("switcher/reveal_details")
-        sleep(1)
-
-    def initiate_all_mode(self):
-        """Start switcher in 'all workspaces' mode.
-
-        Shows apps from all workspaces, instead of just the current workspace.
-        """
-        logger.debug("Initiating switcher in 'all workspaces' mode.")
-        self.keybinding_hold("switcher/reveal_all")
-        self.keybinding_tap("switcher/reveal_all")
-        sleep(1)
-
-    def initiate_right_arrow(self):
-        """Impropperly attempt to start switcher."""
-        logger.debug("Initiating switcher with Alt+Right (should not work)")
-        self.keybinding_hold("switcher/reveal_impropper")
-        self.keybinding_tap("switcher/right")
-        sleep(1)
-
-    def terminate(self):
-        """Stop switcher without activating the selected icon."""
-        logger.debug("Terminating switcher.")
-        self.keybinding("switcher/cancel")
-        self.keybinding_release("switcher/reveal_normal")
-
-    def cancel(self):
-        """Stop switcher without activating the selected icon and releasing the keys."""
-        logger.debug("Cancelling switcher.")
-        self.keybinding("switcher/cancel")
-
-    def stop(self):
-        """Stop switcher and activate the selected icon."""
-        logger.debug("Stopping switcher")
-        self.keybinding_release("switcher/reveal_normal")
+        controllers = SwitcherController.get_all_instances()
+        assert(len(controllers) == 1)
+        self.controller = controllers[0]
+
+    @property
+    def visible(self):
+        """Is the switcher currently visible
+
+        """
+        return self.controller.visible
+
+    @property
+    def icons(self):
+        """The set of icons in the switcher model
+
+        """
+        return self.controller.model.icons
+
+    @property
+    def current_icon(self):
+        """The currently selected switcher icon"""
+        return self.icons[self.selection_index]
+
+    @property
+    def selection_index(self):
+        """The index of the currently selected icon"""
+        return self.controller.model.selection_index
+
+    @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:
+            return SwitcherMode.DETAIL, SwitcherMode.ALL
+        elif self.controller.model.detail_selection:
+            return SwitcherMode.DETAIL
+        elif not self.controller.model.only_detail_on_viewport:
+            return SwitcherMode.ALL
+        else:
+            return SwitcherMode.NORMAL
+
+    def initiate(self, mode=SwitcherMode.NORMAL):
+        """Initiates the switcher in designated mode. Defaults to NORMAL"""
+        if mode == SwitcherMode.NORMAL:
+            logger.debug("Initiating switcher with Alt+Tab")
+            self.keybinding_hold_part_then_tap("switcher/reveal_normal")
+            self.visible.wait_for(True)
+        elif mode == SwitcherMode.DETAIL:
+            logger.debug("Initiating switcher detail mode with Alt+`")
+            self.keybinding_hold_part_then_tap("switcher/reveal_details")
+            self.controller.model.detail_selection.wait_for(True)
+        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)
 
     def next_icon(self):
         """Move to the next icon."""
@@ -89,14 +105,37 @@
         logger.debug("Selecting previous item in switcher.")
         self.keybinding("switcher/prev")
 
-    def next_icon_mouse(self):
-        """Move to the next icon using the mouse scroll wheel"""
+    def cancel(self):
+        """Stop switcher without activating the selected icon and releasing the keys.
+
+        NOTE: Does not release Alt.
+
+        """
+        logger.debug("Cancelling switcher.")
+        self.keybinding("switcher/cancel")
+        self.controller.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)
+
+    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)
+
+    def next_via_mouse(self):
+        """Move to the next icon using the mouse scroll wheel."""
         logger.debug("Selecting next item in switcher with mouse scroll wheel.")
         self._mouse.press(6)
         self._mouse.release(6)
 
-    def previous_icon_mouse(self):
-        """Move to the previous icon using the mouse scroll wheel"""
+    def previous_via_mouse(self):
+        """Move to the previous icon using the mouse scroll wheel."""
         logger.debug("Selecting previous item in switcher with mouse scroll wheel.")
         self._mouse.press(7)
         self._mouse.release(7)
@@ -105,11 +144,13 @@
         """Show detail mode."""
         logger.debug("Showing details view.")
         self.keybinding("switcher/detail_start")
+        self.controller.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)
 
     def next_detail(self):
         """Move to next detail in the switcher."""
@@ -121,65 +162,27 @@
         logger.debug("Selecting previous item in details mode.")
         self.keybinding("switcher/detail_prev")
 
-    def __get_icon(self, index):
-        return self.__get_model()['Children'][index][1][0]
-
-    @property
-    def current_icon(self):
-        """Get the currently-selected icon."""
-        if not self.get_is_visible:
-            return None
-        model = self.__get_model()
-        sel_idx = self.get_selection_index()
-        try:
-            return make_introspection_object(model['Children'][sel_idx])
-        except KeyError:
-            return None
-
-    def get_icon_name(self, index):
-        return self.__get_icon(index)['tooltip_text']
-
-    def get_icon_desktop_file(self, index):
-        try:
-            return self.__get_icon(index)['desktop_file']
-        except:
-            return None
-
-    def get_model_size(self):
-        return len(self.__get_model()['Children'])
-
-    def get_selection_index(self):
-        return int(self.__get_model()['selection-index'])
-
-    def get_last_selection_index(self):
-        return bool(self.__get_model()['last-selection-index'])
-
-    def get_is_visible(self):
-        return bool(self.__get_controller()['visible'])
-
-    def get_monitor(self):
-        return int(self.__get_controller()['monitor'])
-
-    def get_is_in_details_mode(self):
-        """Return True if the SwitcherView is in details mode."""
-        return bool(self.__get_model()['detail-selection'])
-
-    def get_switcher_icons(self):
-        """Get all icons in the switcher model.
-
-        The switcher needs to be initiated in order to get the model.
-
-        """
-        icons = []
-        model = get_state_by_path('//SwitcherModel')[0]
-        for child in model['Children']:
-            icon = make_introspection_object(child)
-            if icon:
-                icons.append(icon)
-        return icons
-
-    def __get_model(self):
-        return get_state_by_path('/Unity/SwitcherController/SwitcherModel')[0]
-
-    def __get_controller(self):
-        return get_state_by_path('/Unity/SwitcherController')[0]
+
+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."""
+
+
+class SwitcherModel(UnityIntrospectionObject):
+    """An emulator class for interacting with the SwitcherModel."""
+
+    @property
+    def icons(self):
+        return self.get_children_by_type(SimpleLauncherIcon)
+

=== modified file 'tests/autopilot/autopilot/tests/test_switcher.py'
--- tests/autopilot/autopilot/tests/test_switcher.py	2012-04-16 01:03:10 +0000
+++ tests/autopilot/autopilot/tests/test_switcher.py	2012-04-26 20:14:23 +0000
@@ -6,198 +6,172 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
-from testtools.matchers import Equals, NotEquals, Contains, Not
+import logging
+from testtools.matchers import Equals, Contains, Not
 from time import sleep
 
+from autopilot.matchers import Eventually
+#from autopilot.emulators.window import Window
+from autopilot.emulators.unity.switcher import SwitcherMode
 from autopilot.tests import AutopilotTestCase
 
-
-class SwitcherTests(AutopilotTestCase):
+logger = logging.getLogger(__name__)
+
+class SwitcherTestCase(AutopilotTestCase):
+    def set_timeout_setting(self, value):
+        self.set_unity_option("alt_tab_timeout", value)
+        sleep(1)
+
+
+class SwitcherTests(SwitcherTestCase):
     """Test the switcher."""
-
     def set_timeout_setting(self, value):
         self.set_unity_option("alt_tab_timeout", value)
+        sleep(1)
 
     def setUp(self):
         super(SwitcherTests, self).setUp()
-
+        self.set_timeout_setting(False)
         self.char_map = self.start_app('Character Map')
         self.calc = self.start_app('Calculator')
         self.mahjongg = self.start_app('Mahjongg')
 
     def tearDown(self):
         super(SwitcherTests, self).tearDown()
+
+    def test_nothing(self):
+        pass
+        #Window()
+
+    def test_witcher_starts_in_normal_mode(self):
+        """Switcher must start in normal (i.e.- not details) mode."""
+        self.start_app("Character Map")
         sleep(1)
 
+        self.switcher.initiate()
+        self.addCleanup(self.switcher.terminate)
+        self.assertThat(self.switcher.mode, Equals(SwitcherMode.NORMAL))
+
     def test_switcher_move_next(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Test that pressing the next icon binding moves to the next icon"""
         self.switcher.initiate()
-        sleep(.2)
+        self.addCleanup(self.switcher.terminate)
 
-        start = self.switcher.get_selection_index()
+        start = self.switcher.selection_index
         self.switcher.next_icon()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.switcher.terminate()
-
-        self.assertThat(start, NotEquals(0))
-        self.assertThat(end, Equals(start + 1))
+        self.assertThat(self.switcher.selection_index, Equals(start + 1))
 
     def test_switcher_move_prev(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Test that pressing the previous icon binding moves to the previous icon"""
         self.switcher.initiate()
-        sleep(.2)
+        self.addCleanup(self.switcher.terminate)
 
-        start = self.switcher.get_selection_index()
+        start = self.switcher.selection_index
         self.switcher.previous_icon()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.switcher.terminate()
-
-        self.assertThat(start, NotEquals(0))
-        self.assertThat(end, Equals(start - 1))
+        self.assertThat(self.switcher.selection_index, Equals(start - 1))
 
     def test_switcher_scroll_next(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Test that scrolling the mouse wheel down moves to the next icon"""
         self.switcher.initiate()
-        sleep(.2)
-
-        start = self.switcher.get_selection_index()
-        self.switcher.next_icon_mouse()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.assertThat(start, NotEquals(0))
-        self.assertThat(end, Equals(start + 1))
-
-        self.switcher.terminate()
+        self.addCleanup(self.switcher.terminate)
+
+        start = self.switcher.selection_index
+        self.switcher.next_via_mouse()
+
+        self.assertThat(self.switcher.selection_index, Equals(start + 1))
 
     def test_switcher_scroll_prev(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Test that scrolling the mouse wheel up moves to the previous icon"""
         self.switcher.initiate()
-        sleep(.2)
-
-        start = self.switcher.get_selection_index()
-        self.switcher.previous_icon_mouse()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.assertThat(start, NotEquals(0))
+        self.addCleanup(self.switcher.terminate)
+
+        start = self.switcher.selection_index
+        self.switcher.previous_via_mouse()
+
+        end = self.switcher.selection_index
         self.assertThat(end, Equals(start - 1))
 
         self.switcher.terminate()
 
     def test_switcher_scroll_next_ignores_fast_events(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Ensures that smoothing is working correctly for next icon scrolling.
+
+        Only the first event in a rapid fire string of events should be acted upon.
+        The rest ignored.
+
+        """
         self.switcher.initiate()
-        sleep(.2)
-
-        # Quickly repeatead events should be ignored (except the first)
-        start = self.switcher.get_selection_index()
-        self.switcher.next_icon_mouse()
-        self.switcher.next_icon_mouse()
-        self.switcher.next_icon_mouse()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.assertThat(start, NotEquals(0))
-        self.assertThat(end, Equals(start + 1))
-
-        self.switcher.terminate()
+        self.addCleanup(self.switcher.terminate)
+
+        # Quickly repeated events should be ignored (except the first)
+        start = self.switcher.selection_index
+        self.switcher.next_via_mouse()
+        self.switcher.next_via_mouse()
+        self.switcher.next_via_mouse()
+
+        self.assertThat(self.switcher.selection_index, Equals(start + 1))
 
     def test_switcher_scroll_prev_ignores_fast_events(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
+        """Ensures that smoothing is working correctly for previous icon scrolling.
+
+        Only the first event in a rapid fire string of events should be acted upon.
+        The rest ignored.
+
+        """
         self.switcher.initiate()
-        sleep(.2)
+        self.addCleanup(self.switcher.terminate)
 
         # Quickly repeatead events should be ignored (except the first)
-        start = self.switcher.get_selection_index()
-        self.switcher.previous_icon_mouse()
-        self.switcher.previous_icon_mouse()
-        self.switcher.previous_icon_mouse()
-        sleep(.2)
-
-        end = self.switcher.get_selection_index()
-        self.assertThat(end, Equals(start - 1))
-
-        self.switcher.terminate()
+        start = self.switcher.selection_index
+        self.switcher.previous_via_mouse()
+        self.switcher.previous_via_mouse()
+        self.switcher.previous_via_mouse()
+
+        self.assertThat(self.switcher.selection_index, Equals(start - 1))
 
     def test_switcher_arrow_key_does_not_init(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
-        self.switcher.initiate_right_arrow()
-        sleep(.2)
-
-        self.assertThat(self.switcher.get_is_visible(), Equals(False))
-        self.switcher.terminate()
-        self.set_timeout_setting(True)
+        """Ensure that Alt+Right does not initiate switcher.
+
+        Regression test for LP:??????
+
+        """
+        self.keyboard.press('Alt')
+        self.addCleanup(self.keyboard.release, 'Alt')
+        self.keyboard.press_and_release('Right')
+        self.assertThat(self.switcher.visible, Equals(False))
 
     def test_lazy_switcher_initiate(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
         self.keybinding_hold("switcher/reveal_normal")
         self.addCleanup(self.keybinding_release, "switcher/reveal_normal")
-        sleep(1)
-        self.assertThat(self.switcher.get_is_visible(), Equals(False))
+        self.assertThat(self.switcher.visible, Eventually(Equals(False)))
 
-        sleep(1)
         self.keybinding_tap("switcher/reveal_normal")
         self.addCleanup(self.keybinding, "switcher/cancel")
-        sleep(.5)
-        self.assertThat(self.switcher.get_is_visible(), Equals(True))
+        self.assertThat(self.switcher.visible, Eventually(Equals(True)))
 
     def test_switcher_cancel(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
         self.switcher.initiate()
         self.addCleanup(self.switcher.terminate)
-        sleep(.2)
-
-        self.assertThat(self.switcher.get_is_visible(), Equals(True))
-
+
+        self.assertThat(self.switcher.visible, Eventually(Equals(True)))
         self.switcher.cancel()
-        sleep(.2)
-
-        self.assertThat(self.switcher.get_is_visible(), Equals(False))
+        self.assertThat(self.switcher.visible, Eventually(Equals(False)))
 
     def test_lazy_switcher_cancel(self):
-        self.set_timeout_setting(False)
-        sleep(1)
-
         self.keybinding_hold("switcher/reveal_normal")
         self.addCleanup(self.keybinding_release, "switcher/reveal_normal")
-        sleep(1)
-        self.assertThat(self.switcher.get_is_visible(), Equals(False))
-
-        sleep(1)
+        self.assertThat(self.switcher.visible, Eventually(Equals(False)))
         self.keybinding_tap("switcher/reveal_normal")
-        self.addCleanup(self.keybinding, "switcher/cancel")
-        sleep(.5)
-        self.assertThat(self.switcher.get_is_visible(), Equals(True))
-
+        self.assertThat(self.switcher.visible, Eventually(Equals(True)))
         self.switcher.cancel()
-        sleep(.2)
-
-        self.assertThat(self.switcher.get_is_visible(), Equals(False))
+        self.assertThat(self.switcher.visible, Eventually(Equals(False)))
 
     def test_switcher_appears_on_monitor_with_focused_window(self):
+        """Tests that the switches appears on the correct monitor.
+
+        This is defined as the monitor with a focused window.
+
+        """
         num_monitors = self.screen_geo.get_num_monitors()
         if num_monitors == 1:
             self.skip("No point testing this on one monitor")
@@ -206,21 +180,24 @@
         for monitor in range(num_monitors):
             self.screen_geo.drag_window_to_monitor(calc_win, monitor)
             self.switcher.initiate()
-            sleep(1)
-            self.assertThat(self.switcher.get_monitor(), Equals(monitor))
-            self.switcher.terminate()
-
-
-class SwitcherWindowsManagementTests(AutopilotTestCase):
+            self.addCleanup(self.switcher.terminate)
+            self.assertThat(self.switcher.controller.monitor, Eventually(Equals(monitor)))
+
+
+class SwitcherWindowsManagementTests(SwitcherTestCase):
     """Test the switcher window management."""
 
     def test_switcher_raises_only_last_focused_window(self):
-        """Tests that when we do an alt+tab only the previously focused window
-        is raised.
+        """Tests that when we do an alt+tab only the previously focused window is raised.
+
         This is tests by opening 2 Calculators and a Mahjongg.
         Then we do a quick alt+tab twice.
         Then we close the currently focused window.
+
         """
+        #FIXME: Setup
+        # There are a lot of asserts in this test that are just making sure the env. is properly
+        # initialized.
         self.close_all_app("Mahjongg")
         self.close_all_app("Calculator")
 
@@ -243,37 +220,33 @@
         self.assertTrue(mah_win2.is_focused)
 
         self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+        #end setup?
 
         self.keybinding("switcher/reveal_normal")
         sleep(1)
-        self.assertTrue(calc_win.is_focused)
+        self.assertThat(calc_win.is_focused, Equals(True))
         self.assertVisibleWindowStack([calc_win, mah_win2, mah_win1])
 
         self.keybinding("switcher/reveal_normal")
         sleep(1)
-        self.assertTrue(mah_win2.is_focused)
+        self.assertThat(mah_win2.is_focused, Equals(True))
         self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
 
         self.keybinding("window/close")
         sleep(1)
-
-        self.assertTrue(calc_win.is_focused)
+        self.assertThat(calc_win.is_focused, Equals(True))
         self.assertVisibleWindowStack([calc_win, mah_win1])
 
 
-class SwitcherDetailsTests(AutopilotTestCase):
+class SwitcherDetailsTests(SwitcherTestCase):
     """Test the details mode for the switcher."""
-
-    def test_switcher_starts_in_normal_mode(self):
-        """Switcher must start in normal (i.e.- not details) mode."""
-        self.start_app("Character Map")
-        sleep(1)
-
-        self.switcher.initiate()
-        self.addCleanup(self.switcher.terminate)
-        self.assertThat(self.switcher.get_is_in_details_mode(), Equals(False))
+    def setUp(self):
+        super(SwitcherDetailsTests, self).setUp()
+        self.set_timeout_setting(True)
 
     def test_details_mode_on_delay(self):
+        """Test that details mode activates on a timeout."""
+        #FIXME: Setup
         self.close_all_app('Character Map')
         self.workspace.switch_to(1)
         self.start_app("Character Map")
@@ -285,17 +258,23 @@
         # the character map.
         self.start_app('Mahjongg')
         sleep(1)
+        # end setup
 
         self.switcher.initiate()
         self.addCleanup(self.switcher.terminate)
         # Wait longer than details mode.
         sleep(3)
-        self.assertTrue(self.switcher.get_is_in_details_mode())
+        self.assertThat(self.switcher.mode, Equals(SwitcherMode.DETAIL))
 
     def test_no_details_for_apps_on_different_workspace(self):
-        # Re bug: 933406
+        """Tests that details mode does not initiates when there are multiple windows
+
+        of an application spread across different workspaces.
+        Regression test for LP:933406.
+
+        """
+        #Fixme: setup
         self.close_all_app('Character Map')
-
         self.workspace.switch_to(1)
         self.start_app("Character Map")
         sleep(1)
@@ -306,15 +285,16 @@
         # the character map.
         self.start_app('Mahjongg')
         sleep(1)
+        # end setup
 
         self.switcher.initiate()
         self.addCleanup(self.switcher.terminate)
         # Wait longer than details mode.
         sleep(3)
-        self.assertFalse(self.switcher.get_is_in_details_mode())
-
-
-class SwitcherDetailsModeTests(AutopilotTestCase):
+        self.assertThat(self.switcher.mode, Equals(SwitcherMode.NORMAL))
+
+
+class SwitcherDetailsModeTests(SwitcherTestCase):
     """Tests for the details mode of the switcher.
 
     Tests for initiation with both grave (`) and Down arrow.
@@ -327,34 +307,38 @@
     ]
 
     def test_can_start_details_mode(self):
-        """Must be able to initiate details mode using selected scenario keycode."""
+        """Must be able to initiate details mode using selected scenario keycode.
+
+        """
         self.start_app("Character Map")
         self.switcher.initiate()
         self.addCleanup(self.switcher.terminate)
         self.keyboard.press_and_release(self.initiate_keycode)
-        self.assertThat(self.switcher.get_is_in_details_mode(), Equals(True))
-
-    def test_tab_from_last_detail_works(self):
-        """Pressing tab while showing last switcher item in details mode
+        self.assertThat(self.switcher.mode, Equals(SwitcherMode.DETAIL))
+
+    def test_next_icon_from_last_detail_works(self):
+        """Pressing next while showing last switcher item in details mode
+
         must select first item in the model in non-details mode.
 
         """
         self.start_app("Character Map")
         self.switcher.initiate()
         self.addCleanup(self.switcher.terminate)
-        while self.switcher.get_selection_index() < self.switcher.get_model_size() -1:
+        while self.switcher.selection_index < len(self.switcher.icons) -1:
             self.switcher.next_icon()
         self.keyboard.press_and_release(self.initiate_keycode)
         sleep(0.5)
         self.switcher.next_icon()
-        self.assertThat(self.switcher.get_selection_index(), Equals(0))
-
-
-class SwitcherWorkspaceTests(AutopilotTestCase):
+        self.assertThat(self.switcher.selection_index, Equals(0))
+
+
+class SwitcherWorkspaceTests(SwitcherTestCase):
     """Test Switcher behavior with respect to multiple workspaces."""
 
     def test_switcher_shows_current_workspace_only(self):
         """Switcher must show apps from the current workspace only."""
+        #FIXME: SETUP
         self.close_all_app('Calculator')
         self.close_all_app('Character Map')
 
@@ -364,11 +348,12 @@
         self.workspace.switch_to(2)
         char_map = self.start_app("Character Map")
         sleep(1)
+        # END SETUP
 
         self.switcher.initiate()
-        sleep(1)
-        icon_names = [i.tooltip_text for i in self.switcher.get_switcher_icons()]
-        self.switcher.terminate()
+        self.addCleanup(self.switcher.terminate)
+
+        icon_names = [i.tooltip_text for i in self.switcher.icons]
         self.assertThat(icon_names, Contains(char_map.name))
         self.assertThat(icon_names, Not(Contains(calc.name)))
 
@@ -377,23 +362,29 @@
         self.close_all_app('Calculator')
         self.close_all_app('Character Map')
 
+        #FIXME: this is setup
         self.workspace.switch_to(1)
         calc = self.start_app("Calculator")
         sleep(1)
         self.workspace.switch_to(2)
         char_map = self.start_app("Character Map")
         sleep(1)
-
-        self.switcher.initiate_all_mode()
-        sleep(1)
-        icon_names = [i.tooltip_text for i in self.switcher.get_switcher_icons()]
-        self.switcher.terminate()
+        # END SETUP
+
+        self.switcher.initiate(SwitcherMode.ALL)
+        self.addCleanup(self.switcher.terminate)
+
+        icon_names = [i.tooltip_text for i in self.switcher.icons]
         self.assertThat(icon_names, Contains(calc.name))
         self.assertThat(icon_names, Contains(char_map.name))
 
     def test_switcher_can_switch_to_minimised_window(self):
         """Switcher must be able to switch to a minimised window when there's
-        another instance of the same application on a different workspace."""
+
+        another instance of the same application on a different workspace.
+
+        """
+        #FIXME this is setup.
         # disable automatic gridding of the switcher after a timeout, since it makes
         # it harder to write the tests.
         self.set_unity_option("alt_tab_timeout", False)
@@ -411,14 +402,14 @@
 
         self.start_app("Calculator")
         sleep(1)
+        # END SETUP
 
         self.switcher.initiate()
-        sleep(1)
         while self.switcher.current_icon.tooltip_text != mahjongg.name:
+            logger.debug("%s -> %s" % (self.switcher.current_icon.tooltip_text, mahjongg.name))
             self.switcher.next_icon()
             sleep(1)
-        self.switcher.stop()
-        sleep(1)
+        self.switcher.select()
 
         #get mahjongg windows - there should be two:
         wins = mahjongg.get_windows()