class DisabledTogglesTestCase(gallery.GalleryTestCase): toggles_scenarios = [('checkbox disabled unchecked', dict(object_name='checkbox_disabled_unchecked', initial_state=False)), ('checkbox disabled checked', dict(object_name='checkbox_disabled_checked', initial_state=True)), ('switch disabled unchecked', dict(object_name='switch_disabled_unchecked', initial_state=False)), ('switch disabled checked', dict(object_name='switch_disabled_checked', initial_state=True))] scenarios = testscenarios.multiply_scenarios( ubuntu_scenarios.get_device_simulation_scenarios(), toggles_scenarios) def setUp(self): super().setUp() self.open_page('togglesElement') def test_change_toggles_state(self): toggle = self.main_view.select_single(emulators.CheckBox, objectName=self.object_name) self.assertThat(toggle.enabled, Equals(False)) self.assertThat(toggle.checked, Equals(self.initial_state)) self.assertRaises(AssertionError, toggle.change_state, timeout=1)
class MainWindowTestCase(tests.UnityTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def setUp(self): super().setUp() self.launch_unity() process_helpers.unlock_unity()
class IndicatorTestCase(tests.UnityTestCase): device_emulation_scenarios = ( ubuntu_scenarios.get_device_simulation_scenarios()) def setUp(self): super().setUp() self.unity_proxy = self.launch_unity() process_helpers.unlock_unity()
def test_get_nexus_4_scenario(self): expected_scenarios = [ ('Simulating Nexus 4 in desktop', dict(app_width=768, app_height=1280, grid_unit_px=18)), ] with mock.patch('autopilot.platform.model') as mock_model: mock_model.return_value = 'Desktop' scenarios = ubuntu_scenarios.get_device_simulation_scenarios( devices=ubuntu_scenarios.NEXUS4_DEVICE) self.assertEqual(expected_scenarios, scenarios)
def test_get_default_scenarios_must_return_supported_devices(self): expected_scenarios = [ ('Simulating Nexus 4 in desktop', dict(app_width=768, app_height=1280, grid_unit_px=18)), ('Simulating Nexus 10 in desktop', dict(app_width=2560, app_height=1600, grid_unit_px=20)) ] with mock.patch('autopilot.platform.model') as mock_model: mock_model.return_value = 'Desktop' scenarios = ubuntu_scenarios.get_device_simulation_scenarios() self.assertEqual(expected_scenarios, scenarios)
class WriteAndClearTextInputTestCase(GalleryTestCase): def text_to_write_string(): return 'Hello World' def text_to_write_number(): return locale.format('%.2f', -1001.23) # text_to_write is a function to ensure # that locale is evaluated after setUp text_input_scenarios = [ ('standard textfield', dict( objectName='textfield_standard', text_to_write=text_to_write_string, expected_text=text_to_write_string())), ('password textfield', dict( objectName='textfield_password', text_to_write=text_to_write_string, expected_text=text_to_write_string())), # The text_to_write contains a decimal separator based on locale # eg. -1001.23 or -1001,23 or -۱۰۰۱٫۲۳ # The test expects integers, TextField rejects that character ('only integers textfield', dict( objectName='textfield_numbers', text_to_write=text_to_write_number, expected_text='-100123')) ] scenarios = testscenarios.multiply_scenarios( ubuntu_scenarios.get_device_simulation_scenarios(), text_input_scenarios) def setUp(self): super().setUp() # Apply the user locale from the environment # The UITK does the same, so the test must be localized locale.setlocale(locale.LC_ALL, "") self.open_page('textinputsElement') def test_write_on_textfield_must_update_text(self): textfield = self.main_view.select_single( emulators.TextField, objectName=self.objectName) textfield.write(self.text_to_write()) self.assertEqual(self.expected_text, textfield.text) def test_clear_textfield_must_remove_text(self): textfield = self.main_view.select_single( emulators.TextField, objectName=self.objectName) textfield.write(self.text_to_write()) textfield.clear() self.assertEqual('', textfield.text)
class GalleryAppTestCase(gallery.GalleryTestCase): """Generic tests for the Gallery""" scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def test_select_main_view_must_return_main_window_emulator(self): main_view = self.main_view self.assertIsInstance(main_view, ubuntuuitoolkit.MainView) def test_slider(self): self.open_page('slidersElement') item_data = [["slider_standard"], ["slider_live"], ["slider_range"]] for data in item_data: objName = data[0] self.getObject(objName) self.tap(objName) # TODO: move slider value def test_progress_and_activity(self): self.open_page('progressBarsElement') item_data = [["progressbar_standard"], ["progressbar_indeterminate"], ["activityindicator_standard"]] for data in item_data: objName = data[0] self.getObject(objName) self.tap(objName) # TODO: check for properties def test_ubuntushape(self): # Flaky test case # FIXME: https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1308979 return self.open_page('ubuntuShapesElement') item_data = [["ubuntushape_color_hex"], ["ubuntushape_color_lightblue"], ["ubuntushape_color_darkgray"], ["ubuntushape_image"], ["ubuntushape_radius_small"], ["ubuntushape_radius_medium"], ["ubuntushape_sizes_15_6"], ["ubuntushape_sizes_10_14"]] for data in item_data: objName = data[0] self.getObject(objName)
class SystemIntegrationTests(UnityTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() @unittest.skipIf(platform.model() == "Desktop", "Test is broken on otto, see bug 1281634.") def test_networkmanager_integration(self): self.launch_unity() # invoke policykit to check permissions pid = subprocess.check_output(["pidof", "-s", "unity8"], universal_newlines=True) subprocess.check_call( "pkcheck --action-id " "org.freedesktop.NetworkManager.enable-disable-network " "--process " + pid, shell=True)
class OptionSelectorTestCase(GalleryTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def setUp(self): super().setUp() self.open_page('optionSelectorsElement') def test_select_option_from_collapsed_optionselector(self): collapsed_option_selector = self.main_view.select_single( ubuntuuitoolkit.OptionSelector, objectName='optionselector_collapsed') self.assertEqual(collapsed_option_selector.get_selected_text(), 'Value 1') collapsed_option_selector.select_option( 'UCLabel', text='Once upon a time there was a story nobody told.') self.assertEqual(collapsed_option_selector.get_selected_index(), 3) def test_select_option_from_expanded_optionselector(self): expanded_option_selector = self.main_view.select_single( ubuntuuitoolkit.OptionSelector, objectName='optionselector_expanded') self.assertEqual(expanded_option_selector.get_selected_text(), 'Value 1') expanded_option_selector.select_option( 'UCLabel', text='Once upon a time there was a story nobody told.') self.assertEqual(expanded_option_selector.get_selected_index(), 3) def test_select_option_from_optionselector_with_custom_model(self): option_selector_with_custom_model = self.main_view.select_single( ubuntuuitoolkit.OptionSelector, objectName='optionselector_custommodel') option_selector_with_custom_model.swipe_into_view() self.assertEqual( option_selector_with_custom_model.get_selected_index(), 0) option_selector_with_custom_model.select_option('UCLabel', text='Name 4') self.assertEqual( option_selector_with_custom_model.get_selected_index(), 3)
class DisabledTextInputTestCase(GalleryTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def setUp(self): super().setUp() self.open_page('textinputsElement') def test_textfield_disabled(self): textfield_disabled = self.main_view.select_single( emulators.TextField, objectName='textfield_disabled') self.assertFalse(textfield_disabled.enabled) disabled_text = textfield_disabled.text self.assertRaises(AssertionError, textfield_disabled.write, 'This should not be written') self.assertEqual(disabled_text, textfield_disabled.text)
class ScrollBarTestCase(gallery.GalleryTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def setUp(self): super().setUp() self.open_page('navigationElement') self.scrollview = self.main_view.wait_select_single( 'ScrollView', objectName="TemplateScrollView") self.scrollbar = self.scrollview.select_single( objectName="verticalScrollbar") def move_mouse_to_thumb(self): # TODO we need a helper to move the interactive thumb. # --elopio 2014-05-06 thumb = self.get_mouse_thumb() self.pointing_device.move_to_object(thumb) def get_mouse_thumb(self): return self.scrollbar.select_single( objectName='interactiveScrollbarThumb') def test_drag_thumb_down_must_make_bottom_visible(self): if platform.model() != 'Desktop': self.skipTest( 'The interactive thumb is activated by the move of a mouse') bottom_section = self.main_view.select_single(className='PageStack') flickable = self.main_view.select_single( 'QQuickFlickable', objectName='TemplateFlickable') self.assertEqual(flickable.is_child_visible(bottom_section), False) self.move_mouse_to_thumb() mouse_thumb = self.get_mouse_thumb() x, y, width, height = mouse_thumb.globalRect start_x = stop_x = x + (width // 2) start_y = y + (height // 2) stop_y = self.main_view.y + self.main_view.height self.pointing_device.drag(start_x, start_y, stop_x, stop_y) self.assertEqual(flickable.is_child_visible(bottom_section), True)
class OpenPagesTestCase(gallery.GalleryTestCase): names = [ 'navigation', 'toggles', 'buttons', 'sliders', 'textinputs', 'optionSelectors', 'pickers', 'progressBars', 'ubuntuShapes', 'icons', 'labels', 'listItems', 'ubuntuListView', 'dialogs', 'popovers', 'sheets', 'animations' ] pages_scenarios = [(name, dict(element_name=name + 'Element', template_name=name + 'Template')) for name in names] scenarios = testscenarios.multiply_scenarios( ubuntu_scenarios.get_device_simulation_scenarios(), pages_scenarios) def test_open_page(self): self.open_page(self.element_name) self.main_view.wait_select_single(objectName=self.template_name)
def test_get_scenarios_on_device_must_return_no_simulation_scenarios(self): with mock.patch('autopilot.platform.model') as mock_model: mock_model.return_value = 'Not Desktop' scenarios = ubuntu_scenarios.get_device_simulation_scenarios() self.assertEqual([('Not Desktop', {})], scenarios)
class DashBaseTestCase(AutopilotTestCase): scenarios = ubuntu_scenarios.get_device_simulation_scenarios() qml_mock_enabled = True environment = {} def setUp(self): super().setUp() if is_unity7_running(): self.useFixture(toolkit_fixtures.HideUnity7Launcher()) if model() != 'Desktop': # On the phone, we need unity to be running and unlocked. self.addCleanup(process_helpers.stop_job, 'unity8') process_helpers.restart_unity_with_testability() process_helpers.unlock_unity() self.ensure_dash_not_running() if self.qml_mock_enabled: self.environment['QML2_IMPORT_PATH'] = ( get_qml_import_path_with_mock()) if self.should_simulate_device(): # This sets the grid units, so it should be called before launching # the app. self.simulate_device() binary_path = get_binary_path('unity8-dash') dash_proxy = self.launch_dash(binary_path, self.environment) self.dash_app = dash_helpers.DashApp(dash_proxy) self.dash = self.dash_app.dash self.wait_for_dash() def ensure_dash_not_running(self): if process_helpers.is_job_running('unity8-dash'): process_helpers.stop_job('unity8-dash') def launch_dash(self, binary_path, variables): launch_dash_app_fixture = fixture_setup.LaunchDashApp( binary_path, variables) self.useFixture(launch_dash_app_fixture) return launch_dash_app_fixture.application_proxy def wait_for_dash(self): home_scope = self.dash.get_scope_by_index(0) # FIXME! There is a huge timeout here for when we're doing CI on # VMs. See lp:1203715 self.assertThat(home_scope.isLoaded, Eventually(Equals(True), timeout=60)) self.assertThat(home_scope.isCurrent, Eventually(Equals(True))) def should_simulate_device(self): return (hasattr(self, 'app_width') and hasattr(self, 'app_height') and hasattr(self, 'grid_unit_px')) def simulate_device(self): simulate_device_fixture = self.useFixture( toolkit_fixtures.SimulateDevice(self.app_width, self.app_height, self.grid_unit_px)) self.environment['GRID_UNIT_PX'] = simulate_device_fixture.grid_unit_px self.environment['ARGS'] = '-windowgeometry {0}x{1}'\ .format(simulate_device_fixture.app_width, simulate_device_fixture.app_height)
class NotificationsBase(UnityTestCase): """Base class for all notification tests that provides helper methods.""" scenarios = ubuntu_scenarios.get_device_simulation_scenarios( ubuntu_scenarios.NEXUS4_DEVICE) def _get_icon_path(self, icon_name): """Given an icons file name returns the full path (either system or source tree. Consider the graphics directory as root so for example (running tests from installed unity8-autopilot package): >>> self.get_icon_path('clock.png') /usr/share/unity8/graphics/clock.png >>> self.get_icon_path('applicationIcons/facebook.png') /usr/share/unity8/graphics/applicationIcons/facebook.png """ if os.path.abspath(__file__).startswith('/usr/'): return '/usr/share/unity8/graphics/' + icon_name else: return os.path.dirname(__file__) + ( "/../../../../../tests/graphics/" + icon_name) def _get_notifications_list(self): return self.main_window.select_single( "Notifications", objectName='notificationList' ) def _assert_notification( self, notification, summary=None, body=None, icon=True, secondary_icon=False, opacity=None ): """Assert that the expected qualities of a notification are as expected. """ if summary is not None: self.assertThat(notification.summary, Eventually(Equals(summary))) if body is not None: self.assertThat(notification.body, Eventually(Equals(body))) if icon: self.assertThat(notification.iconSource, Eventually(NotEquals(""))) else: self.assertThat(notification.iconSource, Eventually(Equals(""))) if secondary_icon: self.assertThat( notification.secondaryIconSource, Eventually(NotEquals("")) ) else: self.assertThat( notification.secondaryIconSource, Eventually(Equals("")) ) if opacity is not None: self.assertThat(notification.opacity, Eventually(Equals(opacity)))
class TestLockscreen(UnityTestCase): """Tests for the lock screen.""" scenarios = ubuntu_scenarios.get_device_simulation_scenarios() def test_can_unlock_pin_screen(self): """Must be able to unlock the PIN entry lock screen.""" self._environment['LIBLIGHTDM_MOCK_MODE'] = "single-pin" self.launch_unity() greeter = self.main_window.get_greeter() if not greeter.tabletMode: greeter.swipe() self._wait_for_lockscreen() self.main_window.enter_pin_code("1234") else: self._enter_prompt_passphrase("1234\n") self.assertThat(greeter.shown, Eventually(Equals(False))) def test_can_unlock_passphrase_screen(self): """Must be able to unlock the passphrase entry screen.""" self._environment['LIBLIGHTDM_MOCK_MODE'] = "single-passphrase" self.launch_unity() greeter = self.main_window.get_greeter() if not greeter.tabletMode: greeter.swipe() self._wait_for_lockscreen() self._enter_pin_passphrase("password") else: self._enter_prompt_passphrase("password") self.assertThat(greeter.shown, Eventually(Equals(False))) def test_pin_screen_wrong_code(self): """Entering the wrong pin code must not dismiss the lock screen.""" self._environment['LIBLIGHTDM_MOCK_MODE'] = "single-pin" self.launch_unity() greeter = self.main_window.get_greeter() if not greeter.tabletMode: greeter.swipe() self._wait_for_lockscreen() self.main_window.enter_pin_code("4321") pinentryField = self.main_window.get_pinentryField() self.assertThat(pinentryField.text, Eventually(Equals(""))) else: self._enter_prompt_passphrase("4231\n") prompt = self.main_window.get_greeter().get_prompt() self.assertThat(prompt.text, Eventually(Equals(""))) self.assertThat(greeter.shown, Eventually(Equals(True))) def test_passphrase_screen_wrong_password(self): """Entering the wrong password must not dismiss the lock screen.""" self._environment['LIBLIGHTDM_MOCK_MODE'] = "single-passphrase" self.launch_unity() greeter = self.main_window.get_greeter() if not greeter.tabletMode: greeter.swipe() self._wait_for_lockscreen() self._enter_pin_passphrase("foobar") pinentryField = self.main_window.get_pinentryField() self.assertThat(pinentryField.text, Eventually(Equals(""))) else: self._enter_prompt_passphrase("foobar") prompt = self.main_window.get_greeter().get_prompt() self.assertThat(prompt.text, Eventually(Equals(""))) self.assertThat(greeter.shown, Eventually(Equals(True))) def _wait_for_lockscreen(self): """Wait for the lock screen to load, and return it.""" pinPadLoader = self.main_window.get_pinPadLoader() self.assertThat(pinPadLoader.progress, Eventually(Equals(1))) lockscreen = self.main_window.get_lockscreen() self.assertThat(lockscreen.shown, Eventually(Equals(True))) return lockscreen def _enter_pin_passphrase(self, passphrase): """Enter the password specified in 'passphrase' into the password entry field of the pin lock screen. :param passphrase: The string you want to enter. :raises: TypeError if passphrase is not a string. """ if not isinstance(passphrase, str): raise TypeError( "'passphrase' parameter must be a string, not %r." % type(passphrase)) pin_entry_field = self.main_window.get_pinentryField() # pinentryField should automatically have focus self.keyboard.type(passphrase) logger.debug("Typed passphrase: %s", pin_entry_field.text) self.assertEqual(pin_entry_field.text, passphrase) self.keyboard.type("\n") def _enter_prompt_passphrase(self, passphrase): """Enter the password specified in 'passphrase' into the password entry field of the main user list's prompt. :param passphrase: The string you want to enter. :raises: TypeError if passphrase is not a string. """ if not isinstance(passphrase, str): raise TypeError( "'passphrase' parameter must be a string, not %r." % type(passphrase)) prompt = self.main_window.get_greeter().get_prompt() prompt.write(passphrase) logger.debug("Typed passphrase: %s", prompt.text) self.keyboard.type("\n")