Back to index

unity  6.0.0
Public Member Functions | Public Attributes | Static Public Attributes
unity.tests.launcher.test_icon_behavior.LauncherIconsTests Class Reference
Inheritance diagram for unity.tests.launcher.test_icon_behavior.LauncherIconsTests:
Inheritance graph
[legend]
Collaboration diagram for unity.tests.launcher.test_icon_behavior.LauncherIconsTests:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def setUp
def test_bfb_tooltip_disappear_when_dash_is_opened
def test_bfb_tooltip_is_disabled_when_dash_is_open
def test_shift_click_opens_new_application_instance
def test_launcher_activate_last_focused_window
def test_clicking_icon_twice_initiates_spread
def test_icon_shows_on_quick_application_reopen
def get_launcher
def check_test_behavior
def dash
def hud
def launcher
def panels
def switcher
def window_manager
def workspace
def set_unity_log_level
def assertNumberWinsIsEventually

Public Attributes

 screen_geo
 launcher_instance

Static Public Attributes

tuple scenarios = _make_scenarios()

Detailed Description

Test the launcher icons interactions

Definition at line 24 of file test_icon_behavior.py.


Member Function Documentation

def unity.tests.UnityTestCase.assertNumberWinsIsEventually (   self,
  app,
  num 
) [inherited]
Asserts that 'app' eventually has 'num' wins. Waits up to 10 seconds.

Definition at line 196 of file __init__.py.

00196 
00197     def assertNumberWinsIsEventually(self, app, num):
00198         """Asserts that 'app' eventually has 'num' wins. Waits up to 10 seconds."""
00199 
00200         self.assertThat(lambda: len(app.get_windows()), Eventually(Equals(num)))

Here is the caller graph for this function:

Fail the test if it did something naughty.

This includes leaving the dash or the hud open, changing the current
workspace, or leaving the system in show_desktop mode.

Definition at line 56 of file __init__.py.

00056 
00057     def check_test_behavior(self):
00058         """Fail the test if it did something naughty.
00059 
00060         This includes leaving the dash or the hud open, changing the current
00061         workspace, or leaving the system in show_desktop mode.
00062 
00063         """
00064         well_behaved = True
00065         reasons = []
00066         log.info("Checking system state for badly behaving test...")
00067 
00068         # Have we switched workspace?
00069         if self.workspace.current_workspace != self._initial_workspace_num:
00070             well_behaved = False
00071             reasons.append("The test changed the active workspace from %d to %d." \
00072                 % (self._initial_workspace_num, self.workspace.current_workspace))
00073             log.warning("Test changed the active workspace, changing it back...")
00074             self.workspace.switch_to(self._initial_workspace_num)
00075         # Have we left the dash open?
00076         if self.dash.visible:
00077             well_behaved = False
00078             reasons.append("The test left the dash open.")
00079             log.warning("Test left the dash open, closing it...")
00080             self.dash.ensure_hidden()
00081         # ... or the hud?
00082         if self.hud.visible:
00083             well_behaved = False
00084             reasons.append("The test left the hud open.")
00085             log.warning("Test left the hud open, closing it...")
00086             self.hud.ensure_hidden()
00087         # Are we in show desktop mode?
00088         if self.window_manager.showdesktop_active:
00089             well_behaved = False
00090             reasons.append("The test left the system in show_desktop mode.")
00091             log.warning("Test left the system in show desktop mode, exiting it...")
00092             self.window_manager.leave_show_desktop()
00093         for launcher in self.launcher.get_launchers():
00094             if launcher.in_keynav_mode:
00095                 well_behaved = False
00096                 reasons.append("The test left the launcher keynav mode enabled.")
00097                 log.warning("Test left the launcher in keynav mode, exiting it...")
00098                 launcher.key_nav_cancel()
00099             if launcher.in_switcher_mode:
00100                 well_behaved = False
00101                 reasons.append("The test left the launcher in switcher mode.")
00102                 log.warning("Test left the launcher in switcher mode, exiting it...")
00103                 launcher.switcher_cancel()
00104 
00105         if not well_behaved:
00106             self.fail("/n".join(reasons))
00107         else:
00108             log.info("Test was well behaved.")

def unity.tests.UnityTestCase.dash (   self) [inherited]

Definition at line 110 of file __init__.py.

00110 
00111     def dash(self):
00112         if not getattr(self, '__dash', None):
00113             self.__dash = Dash()
00114         return self.__dash

Get the launcher for the current scenario.

Definition at line 57 of file __init__.py.

00057 
00058     def get_launcher(self):
00059         """Get the launcher for the current scenario."""
00060         return self.launcher.get_launcher_for_monitor(self.launcher_monitor)

Here is the caller graph for this function:

def unity.tests.UnityTestCase.hud (   self) [inherited]

Definition at line 116 of file __init__.py.

00116 
00117     def hud(self):
00118         if not getattr(self, '__hud', None):
00119             self.__hud = Hud();
00120         return self.__hud

def unity.tests.UnityTestCase.launcher (   self) [inherited]

Definition at line 122 of file __init__.py.

00122 
00123     def launcher(self):
00124         if not getattr(self, '__launcher', None):
00125             self.__launcher = self._get_launcher_controller()
00126         return self.__launcher

def unity.tests.UnityTestCase.panels (   self) [inherited]

Definition at line 128 of file __init__.py.

00128 
00129     def panels(self):
00130         if not getattr(self, '__panels', None):
00131             self.__panels = self._get_panel_controller()
00132         return self.__panels

def unity.tests.UnityTestCase.set_unity_log_level (   self,
  component,
  level 
) [inherited]
Set the unity log level for 'component' to 'level'.

Valid levels are: TRACE, DEBUG, INFO, WARNING and ERROR.

Components are dotted unity component names. The empty string specifies
the root logging component.

Definition at line 183 of file __init__.py.

00183 
00184     def set_unity_log_level(self, component, level):
00185         """Set the unity log level for 'component' to 'level'.
00186 
00187         Valid levels are: TRACE, DEBUG, INFO, WARNING and ERROR.
00188 
00189         Components are dotted unity component names. The empty string specifies
00190         the root logging component.
00191         """
00192         valid_levels = ('TRACE', 'DEBUG', 'INFO', 'WARN', 'WARNING', 'ERROR')
00193         if level not in valid_levels:
00194             raise ValueError("Log level '%s' must be one of: %r" % (level, valid_levels))
00195         set_log_severity(component, level)

Here is the call graph for this function:

Here is the caller graph for this function:

Reimplemented from unity.tests.launcher.LauncherTestCase.

Definition at line 27 of file test_icon_behavior.py.

00027 
00028     def setUp(self):
00029         super(LauncherIconsTests, self).setUp()
00030         self.set_unity_option('launcher_hide_mode', 0)

def unity.tests.UnityTestCase.switcher (   self) [inherited]

Definition at line 134 of file __init__.py.

00134 
00135     def switcher(self):
00136         if not getattr(self, '__switcher', None):
00137             self.__switcher = Switcher()
00138         return self.__switcher

Tests that the bfb tooltip disappear when the dash is opened.

Definition at line 31 of file test_icon_behavior.py.

00031 
00032     def test_bfb_tooltip_disappear_when_dash_is_opened(self):
00033          """Tests that the bfb tooltip disappear when the dash is opened."""
00034          bfb = self.launcher.model.get_bfb_icon()
00035          self.mouse.move(bfb.center_x, bfb.center_y)
00036 
00037          self.dash.ensure_visible()
00038          self.addCleanup(self.dash.ensure_hidden)
00039 
00040          self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False)))

Tests the that bfb tooltip is disabled when the dash is open.

Definition at line 41 of file test_icon_behavior.py.

00041 
00042     def test_bfb_tooltip_is_disabled_when_dash_is_open(self):
00043          """Tests the that bfb tooltip is disabled when the dash is open."""
00044          self.dash.ensure_visible()
00045          self.addCleanup(self.dash.ensure_hidden)
00046 
00047          bfb = self.launcher.model.get_bfb_icon()
00048          self.mouse.move(bfb.center_x, bfb.center_y)
00049 
00050          self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False)))

This tests shows that when you click on a launcher icon twice,
when an application window is focused, the spread is initiated.

Definition at line 99 of file test_icon_behavior.py.

00099 
00100     def test_clicking_icon_twice_initiates_spread(self):
00101         """This tests shows that when you click on a launcher icon twice,
00102         when an application window is focused, the spread is initiated.
00103         """
00104         calc_win1 = self.start_app_window("Calculator")
00105         calc_win2 = self.start_app_window("Calculator")
00106         calc_app = calc_win1.application
00107 
00108         self.assertVisibleWindowStack([calc_win2, calc_win1])
00109         self.assertProperty(calc_win2, is_focused=True)
00110 
00111         calc_icon = self.launcher.model.get_icon_by_desktop_id(calc_app.desktop_file)
00112         self.addCleanup(self.keybinding, "spread/cancel")
00113         self.launcher_instance.click_launcher_icon(calc_icon)
00114 
00115         self.assertThat(self.window_manager.scale_active, Eventually(Equals(True)))
00116         self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True)))

Icons must stay on launcher when an application is quickly closed/reopened.

Definition at line 117 of file test_icon_behavior.py.

00117 
00118     def test_icon_shows_on_quick_application_reopen(self):
00119         """Icons must stay on launcher when an application is quickly closed/reopened."""
00120         calc = self.start_app("Calculator")
00121         desktop_file = calc.desktop_file
00122         calc_icon = self.launcher.model.get_icon_by_desktop_id(desktop_file)
00123         self.assertThat(calc_icon.visible, Eventually(Equals(True)))
00124 
00125         self.close_all_app("Calculator")
00126         calc = self.start_app("Calculator")
00127         sleep(2)
00128 
00129         calc_icon = self.launcher.model.get_icon_by_desktop_id(desktop_file)
00130         self.assertThat(calc_icon, NotEquals(None))
00131         self.assertThat(calc_icon.visible, Eventually(Equals(True)))
00132 

Activating a launcher icon must raise only the last focused instance
of that application.

Definition at line 64 of file test_icon_behavior.py.

00064 
00065     def test_launcher_activate_last_focused_window(self):
00066         """Activating a launcher icon must raise only the last focused instance
00067         of that application.
00068 
00069         """
00070         mah_win1 = self.start_app_window("Mahjongg")
00071         calc_win = self.start_app_window("Calculator")
00072         mah_win2 = self.start_app_window("Mahjongg")
00073 
00074         self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
00075 
00076         mahj_icon = self.launcher.model.get_icon_by_desktop_id(
00077             mah_win2.application.desktop_file)
00078         calc_icon = self.launcher.model.get_icon_by_desktop_id(
00079             calc_win.application.desktop_file)
00080 
00081         self.launcher_instance.click_launcher_icon(calc_icon)
00082         self.assertProperty(calc_win, is_focused=True)
00083         self.assertVisibleWindowStack([calc_win, mah_win2, mah_win1])
00084 
00085         self.launcher_instance.click_launcher_icon(mahj_icon)
00086         self.assertProperty(mah_win2, is_focused=True)
00087         self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
00088 
00089         self.keybinding("window/minimize")
00090 
00091         self.assertThat(lambda: mah_win2.is_hidden, Eventually(Equals(True)))
00092         self.assertProperty(calc_win, is_focused=True)
00093         self.assertVisibleWindowStack([calc_win, mah_win1])
00094 
00095         self.launcher_instance.click_launcher_icon(mahj_icon)
00096         self.assertProperty(mah_win1, is_focused=True)
00097         self.assertThat(lambda: mah_win2.is_hidden, Eventually(Equals(True)))
00098         self.assertVisibleWindowStack([mah_win1, calc_win])

Shift+Clicking MUST open a new instance of an already-running application.

Definition at line 51 of file test_icon_behavior.py.

00051 
00052     def test_shift_click_opens_new_application_instance(self):
00053         """Shift+Clicking MUST open a new instance of an already-running application."""
00054         app = self.start_app("Calculator")
00055         desktop_id = app.desktop_file
00056         icon = self.launcher.model.get_icon_by_desktop_id(desktop_id)
00057         launcher_instance = self.launcher.get_launcher_for_monitor(0)
00058 
00059         self.keyboard.press("Shift")
00060         self.addCleanup(self.keyboard.release, "Shift")
00061         launcher_instance.click_launcher_icon(icon)
00062 
00063         self.assertNumberWinsIsEventually(app, 2)

Here is the call graph for this function:

def unity.tests.UnityTestCase.window_manager (   self) [inherited]

Definition at line 140 of file __init__.py.

00140 
00141     def window_manager(self):
00142         if not getattr(self, '__window_manager', None):
00143             self.__window_manager = self._get_window_manager()
00144         return self.__window_manager

def unity.tests.UnityTestCase.workspace (   self) [inherited]

Definition at line 146 of file __init__.py.

00146 
00147     def workspace(self):
00148         if not getattr(self, '__workspace', None):
00149             self.__workspace = WorkspaceManager()
00150         return self.__workspace


Member Data Documentation

Definition at line 47 of file __init__.py.

Definition at line 42 of file __init__.py.


The documentation for this class was generated from the following file: