def long_press(self, key, timeout=2000): if len(key) == 1: self._switch_to_keyboard() key_obj = self.marionette.find_element(*self._key_locator(key)) action = Actions(self.marionette) action.press(key_obj).wait(timeout / 1000).release().perform() self.marionette.switch_to_frame()
def send(self, string): self._switch_to_keyboard() for val in string: if ord(val) > 127: # this would get the right key to long press and switch to the right keyboard middle_key_val = self._find_key_for_longpress(val.encode('UTF-8')) self._switch_to_correct_layout(middle_key_val) # find the key to long press and press it to get the extended characters list middle_key = self.marionette.find_element(*self._key_locator(middle_key_val)) action = Actions(self.marionette) action.press(middle_key).wait(2).perform() # find the targeted extended key to send target_key = self.marionette.find_element(*self._key_locator(val)) action.move(target_key).release().perform() else: # after switching to correct keyboard, tap/click if the key is there self._switch_to_correct_layout(val) if self.is_element_present(*self._key_locator(val)): self._tap(val) else: assert False, 'Key %s not found on the keyboard' % val # after tap/click space key, it might get screwed up due to timing issue. adding 0.8sec for it. if ord(val) == int(self._space_key): time.sleep(0.8) self.marionette.switch_to_frame()
def send(self, string): self.switch_to_keyboard() for val in string: if ord(val) > 127: # this would get the right key to long press and switch to the right keyboard middle_key_val = self._find_key_for_longpress(val.encode('UTF-8')) self._switch_to_correct_layout(middle_key_val) # find the key to long press and press it to get the extended characters list middle_key = self.marionette.find_element(*self._key_locator(middle_key_val)) action = Actions(self.marionette) action.press(middle_key).wait(1).perform() # find the targeted extended key to send self.wait_for_element_displayed(*self._key_locator(val)) target_key = self.marionette.find_element(*self._key_locator(val)) action.move(target_key).release().perform() else: # after switching to correct keyboard, tap/click if the key is there self._switch_to_correct_layout(val) self._tap(val) # when we tap on '@' the layout switches to the default keyboard - Bug 996332 if val == '@': self.wait_for_condition(lambda m: self._layout_page == 0) self.apps.switch_to_displayed_app()
def move_slider(self, slider, dir_x): scale = self.marionette.find_element(*slider) finger = Actions(self.marionette) finger.press(scale) finger.move_by_offset(dir_x, 0) finger.release() finger.perform() time.sleep(2)
def _flick_to_image(self, direction): image = self.marionette.find_element(*self._current_image_locator) action = Actions(self.marionette) x_start = (image.size["width"] / 100) * (direction == "next" and 90 or 10) x_end = (image.size["width"] / 100) * (direction == "next" and 10 or 90) y_start = image.size["height"] / 4 y_end = image.size["height"] / 4 action.flick(image, x_start, y_start, x_end, y_end, 200).perform() Wait(self.marionette).until(lambda m: abs(image.location["x"]) >= image.size["width"])
def _flick_menu_down(self, locator): current_element = self.marionette.find_element(*self._current_element(*locator)) next_element = self.marionette.find_element(*self._next_element(*locator)) #TODO: update this with more accurate Actions action = Actions(self.marionette) action.press(current_element) action.move(next_element) action.release() action.perform()
def switch_keyboard_language(self, lang_code): keyboard_language_locator = (By.CSS_SELECTOR, ".keyboard-row button[data-keyboard='%s']" % lang_code) self.switch_to_keyboard() language_key = self.marionette.find_element(*self._language_key_locator) action = Actions(self.marionette) action.press(language_key).wait(1).perform() target_kb_layout = self.marionette.find_element(*keyboard_language_locator) action.move(target_kb_layout).release().perform() self.marionette.switch_to_frame()
def _flick_to_image(self, direction): image = self.marionette.find_element(*self._current_image_locator) action = Actions(self.marionette) x_start = (image.size['width'] / 100) * (direction == 'next' and 90 or 10) x_end = (image.size['width'] / 100) * (direction == 'next' and 10 or 90) y_start = image.size['height'] / 4 y_end = image.size['height'] / 4 action.flick(image, x_start, y_start, x_end, y_end, 200).perform() Wait(self.marionette).until( lambda m: abs(image.location['x']) >= image.size['width'])
def _flick_menu_up(self, locator): self.wait_for_element_displayed(*self._current_element(*locator)) current_element = self.marionette.find_element(*self._current_element(*locator)) next_element = self.marionette.find_element(*self._next_element(*locator)) #TODO: update this with more accurate Actions action = Actions(self.marionette) action.press(next_element) action.move(current_element) action.release() action.perform()
def spin_hour24(self): hour24_picker = self.marionette.find_element(*self._current_element(*self._hour24_picker_locator)) hour24_picker_move_y = hour24_picker.size['height'] * 2 hour24_picker_mid_x = hour24_picker.size['width'] / 2 hour24_picker_mid_y = hour24_picker.size['height'] / 2 if self.hour24 == 'AM': Actions(self.marionette).flick(hour24_picker, hour24_picker_mid_x, hour24_picker_mid_y, hour24_picker_mid_x, hour24_picker_mid_y - hour24_picker_move_y) else: Actions(self.marionette).flick(hour24_picker, hour24_picker_mid_x, hour24_picker_mid_y, hour24_picker_mid_x, hour24_picker_mid_y + hour24_picker_move_y) time.sleep(1)
def switch_keyboard_language(self, lang_code): # TODO At the moment this doesn't work because the UI has changed # An attempted repair ran into https://bugzilla.mozilla.org/show_bug.cgi?id=779284 (Modal dialog) keyboard_language_locator = (By.CSS_SELECTOR, ".keyboard-row button[data-keyboard='%s']" % lang_code) self.switch_to_keyboard() language_key = self.marionette.find_element(*self._language_key_locator) action = Actions(self.marionette) action.press(language_key).wait(1).perform() target_kb_layout = self.marionette.find_element(*keyboard_language_locator) action.move(target_kb_layout).release().perform() self.apps.switch_to_displayed_app()
def _flick_menu_down(self, locator): current_element = self.marionette.find_element(*self._current_element(*locator)) next_element = self.marionette.find_element(*self._next_element(*locator)) # TODO: update this with more accurate Actions action = Actions(self.marionette) action.press(current_element) action.move(next_element) action.release() action.perform()
def choose_extended_character(self, long_press_key, selection, movement=True): self.switch_to_keyboard() action = Actions(self.marionette) # after switching to correct keyboard, set long press if the key is there self._switch_to_correct_layout(long_press_key) try: key = self.marionette.find_element( *self._key_locator(long_press_key)) self.wait_for_condition(lambda m: key.is_displayed) except: raise Exception('Key %s not found on the keyboard' % long_press_key) action.press(key).wait(1).perform() # find the extended key and perform the action chain extend_keys = self.marionette.find_elements( *self._highlight_key_locator) if movement is True: action.move(extend_keys[selection - 1]).perform() action.release().perform() self.marionette.switch_to_frame()
def choose_extended_character(self, long_press_key, selection, movement=True): self._switch_to_keyboard() action = Actions(self.marionette) # after switching to correct keyboard, set long press if the key is there self._switch_to_correct_layout(long_press_key) key = self._key_locator(long_press_key) if self.is_element_present(*key): keyobj = self.marionette.find_element(*key) action.press(keyobj).wait(2).perform() else: assert False, 'Key %s not found on the keyboard' % long_press_key # find the extended key and perform the action chain extend_keys = self.marionette.find_elements( *self._highlight_key_locator) if movement == True: action.move(extend_keys[selection - 1]).perform() action.release().perform() time.sleep(1) self.marionette.switch_to_frame()
def _flick_to_month(self, direction): """Flick current monthly calendar to next or previous month. @param direction: flick to next month if direction='next', else flick to previous month """ action = Actions(self.marionette) current_monthly_calendar = self.marionette.find_element(*self._current_monthly_calendar_locator) flick_origin_x = current_monthly_calendar.size['width'] // 2 flick_origin_y = current_monthly_calendar.size['height'] // 2 flick_destination_x = 0 if direction == 'next' else 2 * flick_origin_x action.flick(current_monthly_calendar, flick_origin_x, flick_origin_y, flick_destination_x, flick_origin_y) action.perform()
def test_browser_save_image(self): """ https://moztrap.mozilla.org/manage/case/6889/ """ # Check that there are no images on sdcard before saving self.assertEqual(0, len(self.data_layer.sdcard_files('.jpeg'))) search = Search(self.marionette) search.launch() browser = search.go_to_url(self.test_url) browser.switch_to_content() # Long tap on the image inside the browser content image = self.marionette.find_element('css selector', 'img') Actions(self.marionette).\ press(image).\ wait(3).\ release().\ wait(1).\ perform() activities = Activities(self.marionette) activities.tap_save_image() system = System(self.marionette) system.wait_for_notification_toaster_displayed() system.wait_for_notification_toaster_not_displayed() self.assertEqual(1, len(self.data_layer.sdcard_files('.jpeg')))
def _activate_edit_mode(self): app = self.marionette.find_element(*self._visible_apps_locator) Actions(self.marionette). \ press(app).\ wait(3).\ release(). \ perform()
def test_music_album_mp3(self): """ https://moztrap.mozilla.org/manage/case/4031/ """ music_app = Music(self.marionette) music_app.launch() music_app.wait_for_music_tiles_displayed() self.take_screenshot() # switch to albums view list_view = music_app.tap_albums_tab() self.take_screenshot() # check that albums (at least one) are available albums = list_view.media self.assertGreater(len(albums), 0, 'The mp3 file could not be found') # select an album sublist_view = albums[0].tap_first_album() self.take_screenshot() # select play # This wait is timing out because of bug 862156 player_view = sublist_view.tap_play() # play for a short duration play_time = time.strptime('00:03', '%M:%S') Wait(self.marionette).until( lambda m: player_view.player_elapsed_time >= play_time, message='Mp3 sample did not start playing') ff_button = self.marionette.find_element( *self._player_controls_next_locator) Actions(self.marionette).tap(ff_button).perform() self.take_screenshot()
def flick_frequency_dialer_up(self): dialer = self.marionette.find_element(*self._frequency_dialer_locator) dialer_x_center = int(dialer.size['width'] / 2) dialer_y_center = int(dialer.size['height'] / 2) Actions(self.marionette).flick(dialer, dialer_x_center, dialer_y_center, 0, 800, 800).perform()
def test_music_songs_3gp(self): """https://moztrap.mozilla.org/manage/case/4031/""" music_app = Music(self.marionette) music_app.launch() music_app.wait_for_music_tiles_displayed() self.take_screenshot() # switch to songs view list_view = music_app.tap_songs_tab() # check that songs (at least one) are available songs = list_view.media self.assertGreater(len(songs), 0, 'The 3gp file could not be found') self.take_screenshot() player_view = songs[0].tap_first_song() play_time = time.strptime('00:03', '%M:%S') Wait(self.marionette).until( lambda m: player_view.player_elapsed_time >= play_time, message='3gp sample did not start playing') # validate playback self.assertTrue(player_view.is_player_playing(), 'The player is not playing') # select stop, then FF to the end of the song player_view.tap_play() ff_button = self.marionette.find_element( *self._player_controls_next_locator) Actions(self.marionette).tap(ff_button).perform() self.take_screenshot()
def _tap_page_switching_key(self, val): locator = (self._page_switching_key_locator[0], self._page_switching_key_locator[1] % val) self.wait_for_element_displayed(*locator) key = self.marionette.find_element(*locator) Actions(self.marionette).press(key).wait(0.1).release().perform()
def _tap(self, val): try: self.wait_for_condition(lambda m: m.find_element(*self._key_locator(val)).is_displayed()) key = self.marionette.find_element(*self._key_locator(val)) Actions(self.marionette).press(key).wait(0.1).release().perform() except (NoSuchElementException, ElementNotVisibleException): self.marionette.log('Key %s not found on the keyboard' % val) raise
def add_minute(self): current = self._current(self._minutes_picker_locator) minute = current.text next = current.find_element(By.XPATH, 'following-sibling::*') # TODO: Bug 1129907 - Unable to use precise actions to select timepicker values in Gaia # TODO: Bug 1031456 - invoking js event without release() loses context Actions(self.marionette).press(next).move(current).perform() Wait(self.marionette).until(lambda m: self.minute != minute)
def dial_phone_number(self, value): for i in value: if i == "+": zero_button = self.marionette.find_element(By.CSS_SELECTOR, 'div.keypad-key[data-value="0"]') Actions(self.marionette).long_press(zero_button, 1.2).perform() else: self.marionette.find_element(By.CSS_SELECTOR, 'div.keypad-key[data-value="%s"]' % i).tap() time.sleep(0.25)
def activate_edit_mode(self): app = self.marionette.find_element(*self._visible_icons_locator) Actions(self.marionette).\ press(app).\ wait(3).\ release().\ perform() self.wait_for_element_displayed(By.CSS_SELECTOR, 'div.dockWrapper ol[style*="transition: -moz-transform 0.5ms ease 0s;"]')
def long_press(self, key, timeout=2000): if len(key) == 1: self._switch_to_keyboard() key_obj = self.marionette.find_element(*self._key_locator(key)) from marionette.marionette import Actions Actions(self.marionette).long_press(key_obj, timeout).perform() time.sleep(timeout / 1000 + 1) self.marionette.switch_to_frame()
def test_delete_app(self): # install app self.marionette.switch_to_frame() self.marionette.execute_script('navigator.mozApps.install("%s")' % self.MANIFEST) # click YES on the installation dialog and wait for icon displayed self.wait_for_element_displayed(*self._yes_button_locator) yes = self.marionette.find_element(*self._yes_button_locator) self.marionette.tap(yes) self.APP_INSTALLED = True # wait for the app to be installed and the notification banner to be available self.wait_for_element_displayed(*self._notification_banner_locator) notification = self.marionette.find_element( *self._notification_banner_locator).text self.assertEqual('%s installed' % self.APP_NAME, notification) self.wait_for_element_not_displayed(*self._notification_banner_locator) self.marionette.switch_to_frame(self.homescreen.frame) self.assertTrue(self.is_element_present(*self._icon_locator), "The installed app can't be found") # switch pages until the app is found while not self.marionette.find_element( *self._icon_locator).is_displayed(): self._go_to_next_page() # check that the app is available app_icon = self.marionette.find_element(*self._icon_locator) self.assertTrue(app_icon.is_displayed()) # go to edit mode Actions(self.marionette). \ press(app_icon). \ wait(3). \ release(). \ perform() # delete the app delete_button = app_icon.find_element(*self._delete_app_locator) self.marionette.tap(delete_button) self.wait_for_element_displayed(*self._confirm_delete_locator) delete = self.marionette.find_element(*self._confirm_delete_locator) self.marionette.tap(delete) self.APP_INSTALLED = False self.wait_for_element_not_present(*self._icon_locator) # return to normal mode self.marionette.switch_to_frame() self._touch_home_button() # check that the app is no longer available with self.assertRaises(AssertionError): self.apps.launch(self.APP_NAME)
def test_that_app_can_be_launched_from_cards_view(self): """https://moztrap.mozilla.org/manage/case/2462/""" cards_view = CardsView(self.marionette) self.assertFalse(cards_view.is_cards_view_displayed, 'Cards view not expected to be visible') # Pull up the cards view self.device.hold_home_button() cards_view.wait_for_cards_view() # Wait till it really displayed _cards_view_locator = ('id', 'cards-view') self.wait_for_condition( lambda m: m.find_element(*_cards_view_locator).is_displayed()) time.sleep(5) cards = self.marionette.find_elements('css selector', 'ul#cards-list li.card') cards_num = len(cards) current = -1 for i in range(cards_num): # parse the cards for the displayed card for attr in cards[i].get_attribute('style').split(';'): if 'opacity: 1' in attr: current = i # if there is cards, don't run if current != -1: choose = random.randint(0, cards_num - 1) card_name = self.marionette.find_elements( 'css selector', 'ul#cards-list li.card')[choose].text current_frame = self.apps.displayed_app.frame final_x_position = current_frame.size['width'] # start swipe from center of window start_x_position = final_x_position // 2 start_y_position = current_frame.size['height'] // 2 # swipe forward to get another app card move = choose - current if move > 0: final_x_position = final_x_position * (-1) if move != 0: for i in range(abs(move)): Actions(self.marionette).flick(current_frame, start_x_position, start_y_position, final_x_position, start_y_position).perform() self.wait_for_condition(lambda m: 'opacity: 1;' in m.find_elements( 'css selector', 'ul#cards-list li.card')[choose].get_attribute( 'style')) self.marionette.find_elements( 'css selector', 'ul#cards-list li.card')[choose].tap() self.assertEqual(self.apps.displayed_app.name, card_name)
def _flick_to_image(self, direction): action = Actions(self.marionette) current_image = self.marionette.find_element(*self._current_image_locator) current_image_move_x = current_image.size["width"] / 2 current_image_mid_x = current_image.size["width"] / 2 current_image_mid_y = current_image.size["height"] / 2 if direction == "next": action.flick( current_image, current_image_mid_x, current_image_mid_y, current_image_mid_x - current_image_move_x, current_image_mid_y, ) else: action.flick( current_image, current_image_mid_x, current_image_mid_y, current_image_mid_x + current_image_move_x, current_image_mid_y, ) action.perform() self.wait_for_element_displayed(*self._current_image_locator)
def open_utility_tray(self): statusbar = self.marionette.find_element(*self._status_bar_locator) statusbar_x = int(statusbar.size['width']) statusbar_y_start = int(statusbar.size['height'] / 2) statusbar_y_end = int(statusbar.size['height'] * 160) Actions(self.marionette).flick(statusbar, statusbar_x, statusbar_y_start, statusbar_x, statusbar_y_end, 100).perform() from gaiatest.apps.system.regions.utility_tray import UtilityTray return UtilityTray(self.marionette)
def open_utility_tray(self): body = self.marionette.find_element(By.TAG_NAME, 'body') statusbar = self.marionette.find_element(*self._status_bar_locator) statusbar_x = int(statusbar.size['width']/2) statusbar_y_end = int(body.size['height']) Actions(self.marionette).press(statusbar).move_by_offset(statusbar_x, statusbar_y_end).release().perform() from gaiatest.apps.system.regions.utility_tray import UtilityTray return UtilityTray(self.marionette)
def activate_edit_mode(self): app = self.marionette.find_element(*self._visible_icons_locator) Actions(self.marionette).\ press(app).\ wait(3).\ release().\ perform() self.wait_for_condition(lambda m: self.marionette.execute_script( "return window.wrappedJSObject.Homescreen.isInEditMode()"))
def open_context_menu(self): test = self.marionette.find_element(*self._landing_page_locator) Actions(self.marionette).\ press(test, 0, 0).\ wait(3).\ release().\ perform() from gaiatest.apps.homescreen.regions.context_menu import ContextMenu return ContextMenu(self.marionette)
def swipe_to_next_app(self): current_frame = self.apps.displayed_app.frame start_x_position = current_frame.size['width'] start_y_position = current_frame.size['height'] // 2 # swipe backward to get next app card Actions(self.marionette).flick(current_frame, start_x_position, start_y_position, 0, start_y_position).perform()
def _flick_to_month(self, direction): """Flick current monthly calendar to next or previous month. @param direction: flick to next month if direction='next', else flick to previous month """ action = Actions(self.marionette) month = self.marionette.find_element( *self._current_monthly_calendar_locator) month_year = self.current_month_year x_start = (month.size['width'] / 100) * (direction == 'next' and 90 or 10) x_end = (month.size['width'] / 100) * (direction == 'next' and 10 or 90) y_start = month.size['height'] / 4 y_end = month.size['height'] / 4 action.flick(month, x_start, y_start, x_end, y_end, 200).perform() Wait(self.marionette).until(lambda m: self.current_month_year != month_year)
def tap_switch_source(self): self.wait_for_element_displayed(*self._switch_button_locator) switch = self.marionette.find_element(*self._switch_button_locator) # TODO: Use marionette.tap(_switch_button_locator) to switch camera mode Actions(self.marionette).press(switch).move_by_offset( 0, 0).release().perform() self.wait_for_condition(lambda m: m.find_element( *self._controls_locator).get_attribute('data-enabled') == 'true') self.wait_for_capture_ready()
def activate_edit_mode(self): app = self.marionette.find_element(*self._homescreen_all_icons_locator) Actions(self.marionette).\ press(app).\ wait(3).\ release().\ perform() self.wait_for_condition(lambda m: app.is_displayed()) # Ensure that edit mode is active self.wait_for_condition(lambda m: self.is_edit_mode_active)
def move_app_to_position(self, app_position, to_position): app_elements = self.app_elements Actions(self.marionette).\ press(app_elements[app_position]).\ wait(3).\ move(app_elements[to_position]).\ wait(1).\ release().\ wait(1).\ perform()
def send(self, string): self.switch_to_keyboard() for val in string: if ord(val) > 127: # this would get the right key to long press and switch to the right keyboard middle_key_val = self._find_key_for_longpress(val.encode('UTF-8')) self._switch_to_correct_layout(middle_key_val) # find the key to long press and press it to get the extended characters list middle_key = self.marionette.find_element(*self._key_locator(middle_key_val)) action = Actions(self.marionette) action.press(middle_key).wait(1).perform() # find the targeted extended key to send target_key = self.marionette.find_element(*self._key_locator(val)) action.move(target_key).release().perform() else: # after switching to correct keyboard, tap/click if the key is there self._switch_to_correct_layout(val) self._tap(val) self.marionette.switch_to_frame()
def test_three_fingers(self): testAction = self.marionette.absolute_url("testAction.html") self.marionette.navigate(testAction) start_one = self.marionette.find_element("id", "button1") start_two = self.marionette.find_element("id", "button2") element1 = self.marionette.find_element("id", "button3") element2 = self.marionette.find_element("id", "button4") multi_action = MultiActions(self.marionette) action1 = Actions(self.marionette) action2 = Actions(self.marionette) action3 = Actions(self.marionette) action1.press(start_one).move_by_offset(0,300).release() action2.press(element1).wait().wait(5).release() action3.press(element2).wait().wait().release() multi_action.add(action1).add(action2).add(action3).perform() expected = "button1-touchstart" self.wait_for_condition(lambda m: m.execute_script("return document.getElementById('button1').innerHTML;") == expected) self.assertEqual("button2-touchmove-touchend", self.marionette.execute_script("return document.getElementById('button2').innerHTML;")) button3_text = self.marionette.execute_script("return document.getElementById('button3').innerHTML;") button4_text = self.marionette.execute_script("return document.getElementById('button4').innerHTML;") self.assertTrue("button3-touchstart-touchend" in button3_text) self.assertTrue("button4-touchstart-touchend" in button4_text) self.assertTrue(int(button3_text.rsplit("-")[-1]) >= 5000) self.assertTrue(int(button4_text.rsplit("-")[-1]) >= 5000)
def choose_extended_character(self, long_press_key, selection, movement=True): self.switch_to_keyboard() action = Actions(self.marionette) # after switching to correct keyboard, set long press if the key is there self._switch_to_correct_layout(long_press_key) self.wait_for_element_displayed(*self._key_locator(long_press_key)) key = self.marionette.find_element(*self._key_locator(long_press_key)) action.press(key).wait(1).perform() # find the extended key and perform the action chain extend_keys = self.marionette.find_elements(*self._highlight_key_locator) if movement is True: action.move(extend_keys[selection - 1]).perform() action.release().perform() self.apps.switch_to_displayed_app()
def test_move_offset_element(self): testAction = self.marionette.absolute_url("testAction.html") self.marionette.navigate(testAction) start = self.marionette.find_element("id", "button1") ele = self.marionette.find_element("id", "button3") multi_action = MultiActions(self.marionette) action1 = Actions(self.marionette) action2 = Actions(self.marionette) action1.press(start).move_by_offset(0,300).wait().release() action2.press(ele).wait(5).release() multi_action.add(action1).add(action2).perform() expected = "button1-touchstart" self.wait_for_condition(lambda m: m.execute_script("return document.getElementById('button1').innerHTML;") == expected) self.assertEqual("button2-touchmove-touchend", self.marionette.execute_script("return document.getElementById('button2').innerHTML;")) self.assertTrue("button3-touchstart-touchend" in self.marionette.execute_script("return document.getElementById('button3').innerHTML;"))
def choose_extended_character(self, long_press_key, selection, movement=True): self.switch_to_keyboard() action = Actions(self.marionette) # after switching to correct keyboard, set long press if the key is there self._switch_to_correct_layout(long_press_key) try: key = self.marionette.find_element(*self._key_locator(long_press_key)) self.wait_for_condition(lambda m: key.is_displayed) except: raise Exception("Key %s not found on the keyboard" % long_press_key) action.press(key).wait(1).perform() # find the extended key and perform the action chain extend_keys = self.marionette.find_elements(*self._highlight_key_locator) if movement is True: action.move(extend_keys[selection - 1]).perform() action.release().perform() self.marionette.switch_to_frame()
def choose_extended_character(self, long_press_key, selection, movement=True): self._switch_to_keyboard() action = Actions(self.marionette) # after switching to correct keyboard, set long press if the key is there self._switch_to_correct_layout(long_press_key) key = self._key_locator(long_press_key) if self.is_element_present(*key): keyobj = self.marionette.find_element(*key) action.press(keyobj).wait(2).perform() else: assert False, 'Key %s not found on the keyboard' % long_press_key # find the extended key and perform the action chain extend_keys = self.marionette.find_elements(*self._highlight_key_locator) if movement is True: action.move(extend_keys[selection - 1]).perform() action.release().perform() time.sleep(1) self.marionette.switch_to_frame()
def test_edge_gestures(self): ''' Test swiping between apps with edge gestures As this is non-default (ie pref set) Gaia behaviour I have eschewed app objects ''' # Swipe to the left on the displayed frame displayed_frame = self.apps.displayed_app.frame action = Actions(self.marionette) action.flick(displayed_frame, 0, 100, -200, 0, 50).perform() self.wait_for_condition(lambda m: self.apps.displayed_app.name == self._apps_under_test[0]) # Swipe to the right displayed_frame = self.apps.displayed_app.frame action = Actions(self.marionette) action.flick(displayed_frame, displayed_frame.size['width'], 100, 200, 0, 50).perform() self.wait_for_condition(lambda m: self.apps.displayed_app.name == self._apps_under_test[1])
def double_tap_image(self): image = self.marionette.find_element(*self._current_image_locator) action = Actions(self.marionette) action.double_tap(image) action.perform()