def wait_for_condition(self, method, timeout=None, message=None): Wait(self.marionette, timeout).until(method, message=message)
def header_text(self): header = Wait(self.marionette).until( expected.element_present(*self._message_header_locator)) Wait(self.marionette).until(expected.element_displayed(header)) return header.text
def _assert_n_errors(self, n): Wait(self.marionette).until(lambda _: (len( self._get_error_lines_including_ignored_errors()) == n)) self.assertEqual(0, len(self._get_error_lines()))
def wait_for_element_exists(self, by, locator, timeout=None): Wait(self.marionette, timeout, ignored_exceptions=[NoSuchElementException, StaleElementException]) \ .until(lambda m: m.find_element(by, locator)) return self.marionette.find_element(by, locator)
def wait_for_history_to_load(self, number_of_items=1): Wait(self.marionette).until(lambda m: len( m.find_elements(*self._history_item_locator)) == number_of_items)
def test_dv_cert(self): with self.marionette.using_context('content'): self.marionette.navigate(self.url) # The lock icon should be shown self.assertIn( 'identity-secure', self.locationbar.connection_icon.value_of_css_property( 'list-style-image')) self.assertEqual( self.locationbar.identity_box.get_attribute('className'), 'verifiedDomain') # Open the identity popup self.locationbar.open_identity_popup() # Check the identity popup doorhanger self.assertEqual( self.identity_popup.element.get_attribute('connection'), 'secure') cert = self.browser.tabbar.selected_tab.certificate # The shown host equals to the certificate self.assertEqual( self.identity_popup.view.main.host.get_attribute('textContent'), cert['commonName']) # Only the secure label is visible in the main view secure_label = self.identity_popup.view.main.secure_connection_label self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') insecure_label = self.identity_popup.view.main.insecure_connection_label self.assertEqual(insecure_label.value_of_css_property('display'), 'none') self.identity_popup.view.main.expander.click() Wait(self.marionette).until( lambda _: self.identity_popup.view.security.selected) # Only the secure label is visible in the security view secure_label = self.identity_popup.view.security.secure_connection_label self.assertNotEqual(secure_label.value_of_css_property('display'), 'none') insecure_label = self.identity_popup.view.security.insecure_connection_label self.assertEqual(insecure_label.value_of_css_property('display'), 'none') verifier_label = self.browser.get_property( 'identity.identified.verifier') self.assertEqual( self.identity_popup.view.security.verifier.get_attribute( 'textContent'), verifier_label.replace("%S", cert['issuerOrganization'])) def opener(mn): self.identity_popup.view.security.more_info_button.click() page_info_window = self.browser.open_page_info_window(opener) deck = page_info_window.deck self.assertEqual(deck.selected_panel, deck.security) self.assertEqual(deck.security.domain.get_attribute('value'), cert['commonName']) self.assertEqual(deck.security.owner.get_attribute('value'), page_info_window.get_property('securityNoOwner')) self.assertEqual(deck.security.verifier.get_attribute('value'), cert['issuerOrganization'])
def test_settings_app(self): settings = Settings(self.marionette) settings.launch() ################### Sound ###################### sound_page = settings.open_sound() self.take_screenshot('sound') GaiaImageCompareTestCase.scroll( self.marionette, 'down', sound_page.screen_element.size['height'], screen=sound_page.screen_element) self.take_screenshot('sound') ringtone_page = sound_page.tap_ring_tone_selector() self.take_screenshot('sound-ringtones') for i in range(0, 5): GaiaImageCompareTestCase.scroll( self.marionette, 'down', ringtone_page.screen_element.size['height'], screen=ringtone_page.screen_element) self.take_screenshot('sound-ringtones') ringtone_page.tap_exit() Wait(self.marionette).until( lambda m: sound_page.ring_tone_selector_visible) alerts_page = sound_page.tap_alerts_selector() self.take_screenshot('sound-alerts') for i in range(0, 5): GaiaImageCompareTestCase.scroll( self.marionette, 'down', alerts_page.screen_element.size['height'], screen=alerts_page.screen_element) self.take_screenshot('sound-alerts') alerts_page.tap_exit() Wait(self.marionette).until( lambda m: sound_page.ring_tone_selector_visible) manage_page = sound_page.tap_manage_tones_selector() self.take_screenshot('sound-manage_tones') for i in range(0, 5): GaiaImageCompareTestCase.scroll( self.marionette, 'down', manage_page.screen_element.size['height'], screen=manage_page.screen_element) self.take_screenshot('sound-manage_tones') manage_page.ring_tones[1].select_option() self.take_screenshot('sound-manage_tones-share') manage_page.cancel_share() manage_page.tap_exit() Wait(self.marionette).until( lambda m: sound_page.ring_tone_selector_visible) settings.return_to_prev_menu(settings.screen_element, sound_page.screen_element) #################### Display ###################### display_page = settings.open_display() self.take_screenshot('display') display_page.tap_timeout_selector() self.take_screenshot('display-timeout_values', top_frame=True) display_page.tap_timeout_confirmation() settings.return_to_prev_menu(settings.screen_element, display_page.screen_element) #################### Homescreen ###################### homescreen_page = settings.open_homescreen() self.take_screenshot('homescreen') homescreen_page.pick_wallpaper() self.take_screenshot('wallpaper') homescreen_page.cancel_pick_wallpaper() homescreen_page.select_change_icon_layout() self.take_screenshot('layout', top_frame=True) homescreen_page.confirm_icon_layout() homescreen_page.open_change_home_screen() self.take_screenshot('homescreen-change_homescreen') homescreen_page.open_get_more_home_screen() self.take_screenshot('homescreen-get_more_homescreen', top_frame=True) homescreen_page.cancel_get_more_home_screen() settings.return_to_prev_menu( homescreen_page.screen_element, homescreen_page.change_homescreen_screen_element) settings.return_to_prev_menu(settings.screen_element, homescreen_page.screen_element) ################### Search ###################### search_page = settings.open_search() self.take_screenshot('search') search_page.open_select_search_engine() self.take_screenshot('search-engine_list') search_page.close_select_search_engine() settings.return_to_prev_menu(settings.screen_element, search_page.screen_element) ################## Navigation ###################### nav_page = settings.open_navigation() self.take_screenshot('navigation') settings.return_to_prev_menu(settings.screen_element, nav_page.screen_element) ################# Notifications ###################### notif_page = settings.open_notification() self.take_screenshot('notification') settings.return_to_prev_menu(settings.screen_element, notif_page.screen_element) ################ Date and Time ###################### # Only the main page and Time Format selection is checked date_time_page = settings.open_date_and_time() self.take_screenshot('date_and_time') GaiaImageCompareTestCase.scroll( self.marionette, 'down', date_time_page.screen_element.size['height'], screen=date_time_page.screen_element) self.take_screenshot('date_and_time') date_time_page.disable_default_format() date_time_page.open_time_format() self.take_screenshot('date_and_time-time_format', top_frame=True) date_time_page.close_time_format() settings.return_to_prev_menu(settings.screen_element, date_time_page.screen_element) ############### Language ###################### # 'Get more languages' menu cannot be opened due to css bug language_page = settings.open_language() self.take_screenshot('language') language_page.open_select_language() self.take_screenshot('language-select', top_frame=True) language_page.close_select_language() settings.return_to_prev_menu(settings.screen_element, language_page.screen_element) # This involves app switching, and often would cause whitescreen issue under 319MB memory config # Please run in 512 or 1024 MB mode to avoid this issue ############### Keyboards ###################### keyboard_page = settings.open_keyboard() self.take_screenshot('keyboard') builtin_page = keyboard_page.tap_built_in_keyboards() self.take_screenshot('keyboard-built_in') builtin_page.tap_user_dictionary() self.take_screenshot('keyboard-user-dict') builtin_page.tap_user_dict_exit() builtin_page.tap_exit() keyboard_page.wait_until_page_ready() morekb_page = keyboard_page.tap_add_more_keyboards() self.take_screenshot('keyboard-more_kb') settings.return_to_prev_menu(keyboard_page.screen_element, morekb_page.screen_element) settings.return_to_prev_menu(settings.screen_element, keyboard_page.screen_element) ############## Themes ###################### themes_page = settings.open_themes() self.take_screenshot('themes') settings.return_to_prev_menu(settings.screen_element, themes_page.screen_element) ############# Addons ###################### addons_page = settings.open_addons() self.take_screenshot('addons') addons_page.tap_item(0) self.take_screenshot('addons-addon_enabled') addons_page.toggle_addon_status() # addons are enabled by default Wait(self.marionette).until(lambda m: not addons_page.is_addon_enabled) self.take_screenshot('addons-addon_disabled') addons_page.toggle_addon_status() # revert to original state settings.return_to_prev_menu(addons_page.screen_element, addons_page.details_screen_element) addons_page.tap_item(1) self.take_screenshot('addons-nouse_addon') settings.return_to_prev_menu(addons_page.screen_element, addons_page.details_screen_element) addons_page.tap_item(2) self.take_screenshot('addons-obsolete_addon') settings.return_to_prev_menu(addons_page.screen_element, addons_page.details_screen_element)
def test_settings_app(self): settings = Settings(self.marionette) settings.launch() # opening each subpage in Settings menu. # some subpages have their own subpages, and they need to be opened as well. #################### Wi-Fi and its subpages ###################### wifi_page = settings.open_wifi() Wait( self.marionette).until(lambda m: wifi_page.is_wifi_enabled is True) self.take_screenshot('wifi-enabled') wifi_page.tap_connect_with_wps() self.take_screenshot('wifi-wps') settings.return_to_prev_menu(wifi_page.screen_element, wifi_page.wps_screen_element) self.marionette.execute_script('arguments[0].scrollIntoView(false);', [wifi_page.manage_network_button]) wifi_page.tap_manage_networks() wifi_page.tap_join_hidden_network() wifi_page.tap_security_selector() self.take_screenshot('wifi-securityType', top_frame=True) wifi_page.tap_security_ok() self.take_screenshot('wifi-joinHidden') settings.return_to_prev_menu( wifi_page.manage_network_screen_element, wifi_page.join_hidden_network_screen_element) self.take_screenshot('wifi-manageNetwork') settings.return_to_prev_menu(wifi_page.screen_element, wifi_page.manage_network_screen_element) wifi_page.tap_manage_certs() wifi_page.tap_import_certs() self.take_screenshot('wifi-importCert') settings.return_to_prev_menu(wifi_page.manage_certs_screen_element, wifi_page.select_certs_screen_element) self.take_screenshot('wifi-manageCert') settings.return_to_prev_menu(wifi_page.screen_element, wifi_page.manage_certs_screen_element) wifi_page.disable_wifi() self.take_screenshot('wifi-disabled') settings.return_to_prev_menu(settings.screen_element, wifi_page.screen_element) #################### Sim manager and its subpages ###################### sim_page = settings.open_sim_manager() self.take_screenshot('sim_manager') GaiaImageCompareTestCase.scroll(self.marionette, 'down', sim_page.screen_element.size['height'], screen=sim_page.screen_element) self.take_screenshot('sim_manager') sim_page.tap_sim_security() sim_page.enable_sim_pin() self.take_screenshot('sim_manager-pin_page') settings.return_to_prev_menu(sim_page.security_screen_element, sim_page.sim_pin_screen_element) self.take_screenshot('sim_manager-security') settings.return_to_prev_menu(sim_page.screen_element, sim_page.security_screen_element) settings.return_to_prev_menu(settings.screen_element, sim_page.screen_element) ################### Call Settings and its subpages ###################### cs_page = settings.open_call() self.take_screenshot('cs-selectSIM') cs_page.tap_sim_1() self.take_screenshot('callsettings') cs_page.tap_voicemail() self.take_screenshot('voicemail') settings.return_to_prev_menu(cs_page.cs_screen_element, cs_page.vm_screen_element) cs_page.tap_caller_id_selection() self.take_screenshot('callerID', top_frame=True) cs_page.confirm_caller_id_selection() cs_page.tap_fixed_dialing() self.take_screenshot('fixeddialing') cs_page.tap_auth_numbers() self.take_screenshot('authNumbers') settings.return_to_prev_menu(cs_page.fixed_dialing_screen_element, cs_page.auth_screen_element) cs_page.enable_fixed_dialing() self.take_screenshot('enableFDN') settings.return_to_prev_menu( cs_page.fixed_dialing_screen_element, cs_page.fixed_dialing_simpin_screen_element) settings.return_to_prev_menu(cs_page.cs_screen_element, cs_page.fixed_dialing_screen_element) cs_page.tap_call_forwarding() self.take_screenshot('callforward_init') cs_page.wait_until_call_forwarding_info_received() self.take_screenshot('callforward') cs_page.tap_always_forward() self.take_screenshot('alwaysFwd') settings.return_to_prev_menu( cs_page.call_forwarding_screen_element, cs_page.call_forwarding_always_screen_element) cs_page.tap_forward_when_busy() self.take_screenshot('busyFwd') settings.return_to_prev_menu( cs_page.call_forwarding_screen_element, cs_page.call_forwarding_busy_screen_element) cs_page.tap_forward_unanswered() self.take_screenshot('unansweredFwd') settings.return_to_prev_menu( cs_page.call_forwarding_screen_element, cs_page.call_forwarding_unans_screen_element) cs_page.tap_forward_unreachable() self.take_screenshot('unreachFwd') settings.return_to_prev_menu( cs_page.call_forwarding_screen_element, cs_page.call_forwarding_unreach_screen_element) settings.return_to_prev_menu(cs_page.cs_screen_element, cs_page.call_forwarding_screen_element) cs_page.tap_call_barring() self.take_screenshot('callBarring-init') cs_page.wait_until_call_barring_info_received( ) # this sometimes happens in less than a second, # making it difficult to obtain init view self.take_screenshot('callBarring') GaiaImageCompareTestCase.scroll( self.marionette, 'down', cs_page.call_barring_screen_element.size['height'], screen=cs_page.call_barring_screen_element) self.take_screenshot('callBarring') cs_page.tap_change_passcode() self.take_screenshot('callBarring-passcode') settings.return_to_prev_menu( cs_page.call_barring_screen_element, cs_page.call_barring_passcode_screen_element) cs_page.tap_call_barring_all() self.take_screenshot('callBarring-passcode2') cs_page.tap_call_barring_all_cancel() settings.return_to_prev_menu(cs_page.cs_screen_element, cs_page.call_barring_screen_element) settings.return_to_prev_menu(cs_page.screen_element, cs_page.cs_screen_element) settings.return_to_prev_menu(settings.screen_element, cs_page.screen_element) ################## Messaging Settings and its subpages ###################### messaging_page = settings.open_message() self.take_screenshot('message') GaiaImageCompareTestCase.scroll( self.marionette, 'down', messaging_page.screen_element.size['height'], screen=messaging_page.screen_element) self.take_screenshot('message') messaging_page.tap_auto_retrieve_selector() self.take_screenshot('message-autoretrieve_options', top_frame=True) messaging_page.close_retrieve_dialog() messaging_page.select_sim_1() self.take_screenshot('message-sim_1') settings.return_to_prev_menu(messaging_page.screen_element, messaging_page.settings_screen_element) settings.return_to_prev_menu(settings.screen_element, messaging_page.screen_element) ################### Cellular & Data and its subpages ###################### cell_data_page = settings.open_cell_and_data() self.take_screenshot('cell_and_data') cell_data_page.enable_data() self.take_screenshot('data_enable_prompt') cell_data_page.data_prompt.turn_on() Wait(self.marionette).until( lambda m: cell_data_page.is_data_toggle_checked is True) cell_data_page.enable_roaming() self.take_screenshot('roaming_enable_prompt') cell_data_page.data_prompt.turn_on() Wait(self.marionette).until( lambda m: cell_data_page.is_roaming_toggle_checked is True) self.take_screenshot('cell_and_data_enabled') sim_settings_page = cell_data_page.tap_sim_1_setting() self.take_screenshot('sim_1_setting') sim_settings_page.tap_network_operator() self.take_screenshot('network_op') sim_settings_page.tap_network_type() self.take_screenshot('cell_network_type', top_frame=True) sim_settings_page.confirm_network_type() settings.return_to_prev_menu( sim_settings_page.screen_element, sim_settings_page.network_op_screen_element) sim_settings_page.tap_apn_settings() self.take_screenshot('apn_settings') sim_settings_page.tap_reset_to_default() self.take_screenshot('apn_setting_reset') sim_settings_page.tap_cancel_reset() sim_settings_page.tap_data_settings() self.take_screenshot( 'apn_list') # all other settings show the same dialog sim_settings_page.tap_add_new_apn() self.take_screenshot('apn_editor') for i in range(0, 2): GaiaImageCompareTestCase.scroll( self.marionette, 'down', sim_settings_page.apn_editor_screen_element.size['height'], screen=sim_settings_page.apn_editor_screen_element) self.take_screenshot('apn_editor') sim_settings_page.select_authentication() self.take_screenshot('apn_authentication', top_frame=True) sim_settings_page.confirm_apn_selection() sim_settings_page.select_protocol() self.take_screenshot('apn_protocol', top_frame=True) sim_settings_page.confirm_apn_selection() sim_settings_page.select_roaming_protocol() self.take_screenshot('apn_roaming', top_frame=True) sim_settings_page.confirm_apn_selection() settings.return_to_prev_menu( sim_settings_page.data_settings_screen_element, sim_settings_page.apn_editor_screen_element) settings.return_to_prev_menu( sim_settings_page.apn_settings_screen_element, sim_settings_page.data_settings_screen_element) settings.return_to_prev_menu( sim_settings_page.screen_element, sim_settings_page.apn_settings_screen_element) settings.return_to_prev_menu(cell_data_page.screen_element, sim_settings_page.screen_element) settings.return_to_prev_menu(settings.screen_element, cell_data_page.screen_element) ################# Bluetooth and its subpages ###################### bluetooth_page = settings.open_bluetooth() self.take_screenshot('bluetooth-disabled') bluetooth_page.refresh_root_element( ) # frame is switched, need to refresh the root bluetooth_page.enable_bluetooth() self.take_screenshot('bluetooth-enabled') bluetooth_page.refresh_root_element() bluetooth_page.tap_rename_my_device() self.take_screenshot('bluetooth-renameDevice') bluetooth_page.refresh_root_element() bluetooth_page.tap_update_device_name_ok() bluetooth_page.disable_bluetooth() settings.return_to_prev_menu(settings.screen_element, bluetooth_page.screen_element) ##################### Internet sharing and its subpages ###################### internet_settings_page = settings.open_internet_sharing() self.take_screenshot('internet_sharing') internet_settings_page.enable_hotspot() self.take_screenshot('internet_sharing-hotspot_enabled') hotspot_page = internet_settings_page.tap_hotspot_settings() self.take_screenshot('internet_sharing-hotspot') hotspot_page.tap_security_settings() self.take_screenshot('internet_sharing-hotspot-security', top_frame=True) hotspot_page.confirm_security_settings() settings.return_to_prev_menu(internet_settings_page.screen_element, hotspot_page.screen_element) settings.return_to_prev_menu(settings.screen_element, internet_settings_page.screen_element)
def test_ftu_skip_tour(self): """ https://moztrap.mozilla.org/manage/case/6119/ """ ssid = self.testvars['wifi']['ssid'] psk = self.testvars['wifi'].get('psk') keymanagement = self.testvars['wifi'].get('keyManagement') share_data_default = True geolocation_default = True # Assume a SIM is present if we assigned a phone number # Don't trust internal API for this, since it's an external condition has_a_sim = bool(self.environment.phone_numbers) self.wait_for_condition(lambda m: self.ftu.languages_list > 0, message="No languages listed on screen") # select en-US due to the condition of this test is only for en-US self.ftu.tap_language("en-US") # If a SIM is present, the cell data screen comes up if has_a_sim: self.ftu.tap_next_to_cell_data_section() # Tap enable data if connection is also present. You might have # a SIM, but without a valid connection. if self.device.has_mobile_connection: self.ftu.enable_data() self.wait_for_condition( lambda m: self.data_layer.is_cell_data_connected, message='Cell data was not connected by FTU app') # Tap next self.ftu.tap_next_to_wifi_section() self.ftu.wait_for_networks_available() self.ftu.connect_to_wifi(ssid, psk, keymanagement) Wait(self.marionette, timeout=60, ignored_exceptions=StaleElementException).until( lambda m: 'connected' in m.find_element( By.CSS_SELECTOR, '#networks-list li[data-ssid="%s"] aside' % self.testvars['wifi']['ssid']).get_attribute('class')) self.assertTrue( self.data_layer.is_wifi_connected(self.testvars['wifi']), "WiFi was not connected via FTU app") self.apps.switch_to_displayed_app() # Set timezone if there's no connection if not self.device.has_mobile_connection: self.ftu.tap_next_to_timezone_section() # UTC-05:00 America/New York is the default info if no network is detected self.assertEqual(self.ftu.timezone_title, "UTC-05:00 America/New York") self.ftu.set_timezone_continent("Asia") self.ftu.set_timezone_city("Almaty") self.assertEqual(self.ftu.timezone_title, "UTC+06:00 Asia/Almaty") # Verify Geolocation section appears self.ftu.tap_next_to_geolocation_section() # Verify the "geolocation" option matches expected initial state # There's a very small lag on this after the dialog appears. Wait(self.marionette).until( lambda m: self.ftu.is_geolocation_enabled == geolocation_default, message="Geolocation state should match initial internal state") # Verify that internal state matches UI state self.assertEqual( self.data_layer.get_setting('geolocation.enabled'), self.ftu.is_geolocation_enabled, msg='Geolocation internal state should match UI state') # Toggle geolocation and verify that it also toggled internal state self.ftu.toggle_geolocation() self.assertEqual( self.data_layer.get_setting('geolocation.enabled'), not geolocation_default, msg='Geolocation internal state should be changed by UI') self.ftu.tap_next_to_import_contacts_section() # If there's a SIM, try importing from it if has_a_sim: # You can do this as many times as you like without db conflict self.ftu.tap_import_from_sim() self.ftu.wait_for_contacts_imported() self.assertEqual(self.ftu.count_imported_contacts, len(self.data_layer.all_contacts)) # all_contacts switches to top frame; Marionette needs to be switched back to ftu self.apps.switch_to_displayed_app() self.ftu.tap_next_to_firefox_accounts_section() self.ftu.tap_next_to_welcome_browser_section() # Verify the "Share Data" option matches expected initial state # There's a very small lag on this after the dialog appears. Wait(self.marionette).until( lambda m: self.ftu.is_share_data_enabled == share_data_default, message="Send Data UI state should match initial internal state") # Verify that internal state matches UI state self.assertEqual( self.data_layer.get_setting('debug.performance_data.shared'), self.ftu.is_share_data_enabled, msg='Send Data internal state should match UI state') # Toggle "Share Data" and verify that it also toggled internal state self.ftu.toggle_share_data() self.assertEqual( self.data_layer.get_setting('debug.performance_data.shared'), not share_data_default, msg='Send Data internal state should be changed by UI') self.ftu.tap_next_to_privacy_browser_section() # Enter a dummy email address and check it set inside the os # TODO assert that this is preserved in the system somewhere. Currently it is not used self.ftu.enter_email_address("*****@*****.**") self.ftu.tap_next_to_finish_section() # Skip the tour self.ftu.tap_skip_tour() # Switch back to top level now that FTU app is gone self.wait_for_condition( lambda m: self.apps.displayed_app.name == Homescreen.name)
def wait_for_search_popup_visible(self): Wait(self.marionette).until( expected.element_displayed(*self._search_popup_locator))
def test_install_and_execute_bing_map(self): marketplace = Marketplace(self.marionette) marketplace.launch() results = marketplace.search(self.app_search) first_result = results.search_results[0] app_name = first_result.get_app_name() first_result.tap_install_button() # Confirm the installation and wait for the app icon to be present confirm_install = ConfirmInstall(self.marionette) confirm_install.tap_confirm() self.assertEqual(self.apps.displayed_app.name, 'Marketplace') self.device.touch_home_button() # Check that the icon of the app is on the homescreen homescreen = Homescreen(self.marionette) homescreen.wait_for_app_icon_present(app_name) installed_app = homescreen.installed_app(app_name) installed_app.tap_icon() Wait(self.marionette).until(lambda m: m.title == self.app_title) bingmap = self.marionette.find_element(*self._map_locator) Wait(self.marionette).until(lambda m: bingmap.is_displayed()) time.sleep(self.draw_wait_time) self.take_screenshot() # once the map is completely loaded, use the UI to render different views # zoom in self.marionette.find_element(*self._zoom_in_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot() self.marionette.find_element(*self._zoom_in_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot() self.marionette.find_element(*self._zoom_in_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot() # move around self.scroll(self._map_locator, 'right', 100) time.sleep(self.draw_wait_time) self.take_screenshot() self.scroll(self._map_locator, 'down', 100) time.sleep(self.draw_wait_time) self.take_screenshot() # zoom out self.marionette.find_element(*self._zoom_out_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot() self.marionette.find_element(*self._zoom_out_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot() self.marionette.find_element(*self._zoom_out_locator).tap() time.sleep(self.draw_wait_time) self.take_screenshot()
def __init__(self, marionette): Base.__init__(self, marionette) form = self.marionette.find_element(*self._form_locator) Wait(self.marionette).until(lambda m: form.location['y'] == 0)
def wait_for_phone_number_ready(self): # entering dialer and expecting a phone number there is javascript that # sets the phone value and enables this button add_contact = self.marionette.find_element( *self._add_new_contact_button_locator) Wait(self.marionette).until(expected.element_enabled(add_contact))
def wait_to_not_be_displayed(self): Wait(self.marionette).until(lambda m: self.apps.displayed_app.manifest_url != self.manifest_url)
def wait_for_cards_view_not_displayed(self): Wait(self.marionette).until( expected.element_not_displayed(self.root_element))
def wait_for_enable_switch_to_be_turned_on(self): Wait(self.marionette, timeout=60).until( expected.element_displayed(*self._checkbox_locator)) Wait(self.marionette).until(lambda m: GaiaBinaryControl( m, self._checkbox_locator).is_checked is True)
def test_verify_phone_not_bricked(self): Wait(self.marionette).until( lambda m: self.apps.displayed_app.name == Homescreen.name)
def __init__(self, marionette): Base.__init__(self, marionette) element = self.marionette.find_element(*self._page_locator) Wait(self.marionette).until( lambda m: 'current' in element.get_attribute('class'))
def check_get_me_out_of_here_button(self, unsafe_page): button = self.marionette.find_element(By.ID, "getMeOutButton") button.click() Wait(self.marionette, timeout=self.marionette.timeout.page_load).until( lambda mn: self.browser.default_homepage in mn.get_url())
def test_insecure_website(self): with self.marionette.using_context('content'): self.marionette.navigate(self.urls[2]) Wait(self.marionette).until(lambda _: (self.identity_box.get_property( 'className') == 'unknownIdentity'))
def wait_for_subelement_displayed(self, parent, by, locator, timeout=None): Wait(self.marionette, timeout, ignored_exceptions=[NoSuchElementException, StaleElementException])\ .until(lambda m: parent.find_element(by, locator).is_displayed()) return parent.find_element(by, locator)
def test_launch_manifest(self): browser_manifest_url = 'app://search.gaiamobile.org/manifest.webapp' app = self.apps.launch('Browser', manifest_url=browser_manifest_url) self.assertTrue(app.frame) Wait(self.marionette).until(lambda m: 'search' in m.get_url())
def wait_for_element_enabled(self, element, timeout=10): Wait(self.marionette, timeout) \ .until(lambda e: element.is_enabled(), message="Timed out waiting for element to be enabled")
def wait_for_centered(self): Wait(self.marionette).until(lambda m: self.is_centered)
def wait_for_received_messages(self, interval=5, timeout=300): Wait(self.marionette, timeout).until( expected.element_displayed( Wait(self.marionette, timeout).until( expected.element_present( *self._received_message_content_locator))))
def wait_for_no_card_displayed(self): Wait(self.marionette).until(lambda m: self.is_no_card_displayed)
def switch_to_frame(self): frame = Wait(self.marionette).until( expected.element_present(*self._frame_locator)) Wait(self.marionette).until(expected.element_displayed(frame)) self.marionette.switch_to_frame(frame)
def wait_for_cards_view(self): Wait(self.marionette).until( lambda m: self.root_element.get_attribute('class') == 'active')
def wait_for_panel_to_load(self): Wait(self.marionette).until(expected.element_displayed( Wait(self.marionette).until(expected.element_present( *self._event_title_input_locator))))
def wait_for_element_present(self, by, locator, timeout=None): return Wait(self.marionette, timeout, ignored_exceptions=NoSuchElementException).until( lambda m: m.find_element(by, locator))