Python Browser.switch_to_chrome方法代码示例

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_back_button(self):
        # https://github.com/mozilla/gaia-ui-tests/issues/450
        browser = Browser(self.marionette)
        browser.launch()

        browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')

        browser.switch_to_content()
        self.verify_home_page()

        community_link = self.marionette.find_element(*self._community_link_locator)
        community_link.tap()
        # # TODO: remove this execute_script when bug 833370 has been fixed
        # self.marionette.execute_script("arguments[0].scrollIntoView(false);", [community_link])
        # self.marionette.tap(community_link)

        self.verify_community_page()
        browser.switch_to_chrome()
        browser.tap_back_button()

        browser.switch_to_content()
        self.verify_home_page()
        browser.switch_to_chrome()
        browser.tap_forward_button()

        browser.switch_to_content()
        self.verify_community_page()

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_persona_cookie(self):
        """
        Smoketest of cookie handling/Persona integration
        Log in with Persona user
        After refreshing 123done should still be logged in (cookie retained)
        """
        browser = Browser(self.marionette)
        browser.launch()

        browser.go_to_url('http://firefoxos.123done.org')

        browser.switch_to_content()

        self.wait_for_element_displayed(*self._logged_out_button_locator, timeout=120)

        login_button = self.marionette.find_element(*self._logged_out_button_locator)
        login_button.click()

        persona = Persona(self.marionette)
        persona.login(self.user.email, self.user.password)

        # wait to fall back to browser
        self.wait_for_condition(lambda m: self.apps.displayed_app.name == browser.name)
        self.apps.switch_to_displayed_app()

        browser.switch_to_content()
        self.wait_for_element_displayed(*self._logged_in_button_locator)

        browser.switch_to_chrome()
        # Refresh the page
        browser.tap_go_button()

        # Now we expect B2G to retain the Persona cookie and remain logged in
        browser.switch_to_content()
        self.wait_for_element_displayed(*self._logged_in_button_locator)

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_back_button(self):
        browser = Browser(self.marionette)
        browser.launch()

        browser.go_to_url("http://mozqa.com/data/firefox/layout/mozilla.html")

        browser.switch_to_content()
        self.verify_home_page()

        community_link = self.marionette.find_element(*self._community_link_locator)
        # TODO: remove the explicit scroll once bug 833370 is fixed
        self.marionette.execute_script("arguments[0].scrollIntoView(false);", [community_link])
        community_link.tap()

        self.verify_community_page()
        browser.switch_to_chrome()
        browser.tap_back_button()

        browser.switch_to_content()
        self.verify_home_page()
        browser.switch_to_chrome()
        browser.tap_forward_button()

        browser.switch_to_content()
        self.verify_community_page()

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_tabs(self):
        """ Open a new tab.
        Using Wifi/LAN

        Open Browser.
        Open tab menu.
        Add a new tab.
        Assert that the new tab has opened.
        Load a website ( http://mozqa.com/data/firefox/layout/mozilla.html)
        Switch back to the first tab.
        """
        browser = Browser(self.marionette)
        browser.launch()

        # Open tab menu.
        browser.tap_tab_badge_button()

        # Add a new tab and load a website.
        browser.tap_add_new_tab_button()
        browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
        browser.switch_to_content()
        self.wait_for_element_present(*self._page_title_locator)
        heading = self.marionette.find_element(*self._page_title_locator)
        self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')

        # Assert that the new tab has opened.
        browser.switch_to_chrome()
        self.assertEqual(browser.displayed_tabs_number, 2)
        # Assert that the displayed tabs number is equal with the actual number of opened tabs.
        self.assertEqual(browser.displayed_tabs_number, browser.tabs_count)

        # Switch back to the first tab.
        browser.tap_tab_badge_button()
        browser.tabs[0].tap_tab()
        self.assertTrue(browser.is_awesome_bar_visible)

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_tabs(self):
        """ Open a new tab.
        Open Browser.
        Open tab menu.
        Add a new tab.
        Assert that the new tab has opened.
        Load a website.
        Switch back to the first tab.
        """
        browser = Browser(self.marionette)
        browser.launch()

        # Open tab menu.
        browser.tap_tab_badge_button()

        # Add a new tab and load a website.
        browser.tap_add_new_tab_button()
        browser.go_to_url(self.test_url)
        browser.switch_to_content()
        Wait(self.marionette).until(lambda m: m.title == 'Mozilla')

        # Assert that the new tab has opened.
        browser.switch_to_chrome()
        self.assertEqual(browser.displayed_tabs_number, 2)
        # Assert that the displayed tabs number is equal with the actual number of opened tabs.
        self.assertEqual(browser.displayed_tabs_number, browser.tabs_count)

        # Switch back to the first tab.
        browser.tap_tab_badge_button()
        browser.tabs[0].tap_tab()
        self.assertTrue(browser.is_awesome_bar_visible)

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_cost_control_data_alert_mobile(self):
        """https://moztrap.mozilla.org/manage/case/8938/"""

        cost_control = CostControl(self.marionette)
        cost_control.launch()

        cost_control.switch_to_ftu()
        cost_control.run_ftu_accepting_defaults()

        self.assertTrue(cost_control.is_mobile_data_tracking_on)
        self.assertFalse(cost_control.is_wifi_data_tracking_on)

        settings = cost_control.tap_settings()
        settings.toggle_data_alert_switch(True)
        settings.select_when_use_is_above_unit_and_value(u'MB', '0.1')
        settings.reset_mobile_usage()
        settings.tap_done()
        self.assertTrue(cost_control.is_mobile_data_tracking_on)

        # open browser to get some data downloaded
        browser = Browser(self.marionette)
        browser.launch()
        browser.go_to_url('http://www.mozilla.org/', timeout=180)
        browser.switch_to_content()
        self.wait_for_condition(lambda m: "Home of the Mozilla Project" in  m.title)
        browser.switch_to_chrome()

        # get the notification bar
        self.device.touch_home_button()
        self.marionette.switch_to_frame()
        self.marionette.execute_script("window.wrappedJSObject.UtilityTray.show()")

        # switch to cost control widget
        usage_iframe = self.marionette.find_element(*self._cost_control_widget_locator)
        self.marionette.switch_to_frame(usage_iframe)

        # make sure the color changed
        self.wait_for_condition(
            lambda m: 'reached-limit' in self.marionette.find_element(
                *self._data_usage_view_locator).get_attribute('class'),
            message='Data usage bar did not breach limit')

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
class TestBrowserTabs(GaiaMtbfTestCase):

    _page_title_locator = (By.ID, 'page-title')

    def setUp(self):
        GaiaMtbfTestCase.setUp(self)
        self.connect_to_network()

        self.browser = Browser(self.marionette)
        self.browser.launch()

    def test_browser_tabs(self):
        # Remember the tabs number
        self.ori_tab_num = self.browser.displayed_tabs_number

        # Open tab menu.
        self.browser.tap_tab_badge_button()

        # Add a new tab and load a website.
        self.browser.tap_add_new_tab_button()
        self.browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
        self.browser.switch_to_content()
        self.wait_for_element_present(*self._page_title_locator)
        heading = self.marionette.find_element(*self._page_title_locator)
        self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')

        # Assert that the new tab has opened.
        self.browser.switch_to_chrome()
        self.assertEqual(self.browser.displayed_tabs_number, self.ori_tab_num + 1)
        # Assert that the displayed tabs number is equal with the actual number of opened tabs.
        self.assertEqual(self.browser.displayed_tabs_number, self.browser.tabs_count)

        # Switch back to the first tab.
        self.browser.tap_tab_badge_button()
        self.browser.tabs[0].tap_tab()
        self.assertTrue(self.browser.is_awesome_bar_visible)

    def tearDown(self):
        self.data_layer.disable_wifi()
        GaiaMtbfTestCase.tearDown(self)

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_back_button(self):
        # https://github.com/mozilla/gaia-ui-tests/issues/450
        browser = Browser(self.marionette)
        browser.launch()

        browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')

        browser.switch_to_content()
        self.verify_home_page()
        self.marionette.tap(self.marionette.find_element(*self._community_link_locator))

        self.verify_community_page()
        browser.switch_to_chrome()
        browser.tap_back_button()

        browser.switch_to_content()
        self.verify_home_page()
        browser.switch_to_chrome()
        browser.tap_forward_button()

        browser.switch_to_content()
        self.verify_community_page()

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_cost_control_data_alert_mobile(self):

        self.data_layer.connect_to_cell_data()
        cost_control = CostControl(self.marionette)
        cost_control.launch()
        cost_control.run_ftu_accepting_defaults()

        self.assertTrue(cost_control.is_mobile_data_tracking_on)
        self.assertFalse(cost_control.is_wifi_data_tracking_on)

        settings = cost_control.tap_settings()
        settings.toggle_data_alert_switch(True)
        settings.select_when_use_is_above_unit_and_value('MB', '0.1')
        settings.reset_data_usage()
        settings.tap_done()
        self.assertTrue(cost_control.is_mobile_data_tracking_on)

        # open browser to get some data downloaded
        # please remove this once there is a better way than launching browser app/obj to do so
        browser = Browser(self.marionette)
        browser.launch()
        browser.go_to_url('http://developer.mozilla.org/')
        browser.switch_to_content()
        self.wait_for_element_present(*self._page_body_locator, timeout=120)
        browser.switch_to_chrome()

        # get the notification bar
        self.marionette.switch_to_frame()
        self.marionette.execute_script("window.wrappedJSObject.UtilityTray.show()")

        # switch to cost control widget
        usage_iframe = self.marionette.find_element(*self._cost_control_widget_locator)
        self.marionette.switch_to_frame(usage_iframe)

        # make sure the color changed
        self.wait_for_condition(
            lambda m: 'reached-limit' in self.marionette.find_element(*self._data_usage_view_locator).get_attribute('class'),
            message='Data usage bar did not breach limit'
        )

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_back_button(self):
        browser = Browser(self.marionette)
        browser.launch()
        browser.go_to_url(self.test_url)

        browser.switch_to_content()
        Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
        link = self.marionette.find_element(By.CSS_SELECTOR, '#community a')
        # TODO: remove the explicit scroll once bug 833370 is fixed
        self.marionette.execute_script(
            'arguments[0].scrollIntoView(false);', [link])
        link.tap()
        Wait(self.marionette).until(lambda m: m.title == 'Mozilla Community')

        browser.switch_to_chrome()
        browser.tap_back_button()
        browser.switch_to_content()
        Wait(self.marionette).until(lambda m: m.title == 'Mozilla')

        browser.switch_to_chrome()
        browser.tap_forward_button()
        browser.switch_to_content()
        Wait(self.marionette).until(lambda m: m.title == 'Mozilla Community')

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_browser_https_auth_login(self):
        browser = Browser(self.marionette)
        browser.launch()

        browser.go_to_url('http://mozqa.com/data/mozqa.com/http_auth/')

        browser.switch_to_content()

        self.wait_for_element_present(*self._login_link_locator)
        login_link = self.marionette.find_element(*self._login_link_locator)
        login_link.tap()

        browser.switch_to_chrome()

        auth_region = AuthenticationDialog(self.marionette)
        auth_region.authenticate('mozilla', 'mozilla')

        self.wait_for_condition(lambda m: browser.url == self._success_redirect_url)

        browser.switch_to_content()

        self.wait_for_element_displayed(*self._success_message_locator)
        success_message = self.marionette.find_element(*self._success_message_locator)
        self.assertEquals('Basic Authentication is successful!', success_message.text)

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]

#.........这里部分代码省略.........
        #raise Exception("Can't get profile archive for Android fennec browser")
        pass

    def copy_profiles(self):
        try:
            self.dm.pushDir(self.localProfile, self.remoteProfile)
        except:
            return False
        return True

    def get_git_revision(self):
        gitrev = subprocess.check_output("git show HEAD | grep '^commit'",
                                         shell=True)
        rev = gitrev.strip().split(' ')
        return rev[1]

    def device_has_tests(self):
        htmlRev = self.get_git_revision()
        print "Local REV: %s" % (htmlRev,)
        remoteRev = None
        if 'html.rev' in self.dm.listFiles('/mnt/sdcard'):
            data = self.dm.pullFile('/mnt/sdcard/html.rev')
            dataLines = [line.strip() for line in data.split('\n')]
            if len(dataLines) > 0:
                remoteRev = dataLines[0]
                print "Remote REV: %s" % (remoteRev,)
        return htmlRev == remoteRev

    def mark_device_has_tests(self):
        htmlRev = self.get_git_revision()
        f = tempfile.NamedTemporaryFile()
        localName = f.name
        f.write(htmlRev)
        f.flush()
        self.dm.pushFile(localName, "/mnt/sdcard/html.rev")
        f.close()

    def copy_tests(self):
        if re.match('file:\/\/\/.*', config.test_base_url):
            if not self.device_has_tests():
                try:
                    self.dm.pushDir(os.path.join('..', 'html'),
                                    '/mnt/sdcard/html')
                    self.mark_device_has_tests()
                except:
                    return False
        return True

    def launch(self, url=None):
        # Unlock the screen
        gaiatest.LockScreen(self.marionette).unlock()

        # Ensure browser app is installed
        if not gaiatest.GaiaApps(self.marionette).is_app_installed("Browser"):
            raise Exception("Browser app is not installed, cannot continue.")

        # Kill any running apps; after b2g restart it is possible the first time use app comes up
        gaiatest.GaiaApps(self.marionette).kill_all()
        time.sleep(2)

        # Ensure are on homescreen (should be after kill all above anyway)
        self.marionette.execute_script('window.wrappedJSObject.dispatchEvent(new Event("home"));')

        # Start browser app
        self.browser = Browser(self.marionette)
        self.browser.launch()

        # Verify browser app is now running
        if not self.running():
            raise Exception("Browser app failed to start. Cannot continue.")

        # Wait time for browser app to 'settle'
        time.sleep(30)

        # Launch the test by navigating to the URL
        url = url.replace('&', '\\&')
        self.browser.switch_to_chrome()
        #print url
        self.launch_time = datetime.datetime.now()
        self.marionette.execute_script("return window.wrappedJSObject.Browser.navigate('%s');" %url)
        return self.running()

    def getBrowserPid(self):
        result = self.dm.processExist(self.browserPackage)
        #print "getBrowserPid -> ", str(result)
        if result is not None:
            return result
        return -1

    def running(self):
        self.marionette.switch_to_frame()
    	apps = gaiatest.GaiaApps(self.marionette).runningApps()
    	currently_running_apps = ''.join(apps)
        return "browser" in currently_running_apps

    def terminate(self):
        # Kill all apps running on Firefox OS
        gaiatest.GaiaApps(self.marionette).kill_all()
        time.sleep(10)
        self.clean_up()

# 需要导入模块: from gaiatest.apps.browser.app import Browser [as 别名]
# 或者: from gaiatest.apps.browser.app.Browser import switch_to_chrome [as 别名]
    def test_cost_control_data_alert_mobile(self):
        # go through ftu if there is any, otherwise pass it
        try:
            # if there is fte coming up
            self.wait_for_element_displayed(*self._welcome_title_locator)

            # go through 1st step in fte
            self.wait_for_element_displayed(*self._welcome_title_locator)
            next = self.marionette.find_element(*self._next_button_locator_1)
            self.marionette.tap(next)

            # go through 2nd step in fte
            self.wait_for_element_displayed(*self._data_report_title_locator)
            next = self.marionette.find_element(*self._next_button_locator_2)
            self.marionette.tap(next)

            # go through final step in fte
            self.wait_for_element_displayed(*self._data_alert_title_locator)
            next = self.marionette.find_element(*self._go_button_locator)
            self.marionette.tap(next)
        except:
            # if there is no fte coming up
            pass

        # wait for usage app main screen to come out
        self.wait_for_element_displayed(*self._usage_app_main_locator)

        # make sure wifi tracking is on and mobile data tracking is off
        self.wait_for_element_displayed(*self._mobile_data_item_locator)
        mobileswitch = self.marionette.find_element(*self._mobile_data_tracking_locator)
        wifiswitch = self.marionette.find_element(*self._wifi_data_tracking_locator)
        mobileswitch_click = self.marionette.find_element(*self._mobile_data_label_locator)
        wifiswitch_click = self.marionette.find_element(*self._wifi_data_label_locator)
        if not mobileswitch.is_selected():
            self.marionette.tap(mobileswitch_click)
        if wifiswitch.is_selected():
            self.marionette.tap(wifiswitch_click)

        # go to settings section
        settings = self.marionette.find_element(*self._settings_button_locator)
        self.marionette.tap(settings)

        # go into iframe of usage app settings
        self.wait_for_element_displayed(*self._settings_iframe_locator)
        settings_iframe = self.marionette.find_element(*self._settings_iframe_locator)
        self.marionette.switch_to_frame(settings_iframe)

        # enable data use alert if not enabled
        # there is a bug that marionette 0.5.20 can't detect if some elements are displayed or not
        self.wait_for_element_displayed(*self._settings_title_locator)
        switch = self.marionette.find_element(*self._data_alert_switch_locator)

        if not switch.is_selected():
            self.marionette.tap(switch)

        # make sure the data alert is 0.1MB, or we would set it to 0.1MB
        detail_section = self.marionette.find_element('css selector', 'ul.settings button span')
        self.marionette.tap(detail_section)
        capacity = self.marionette.find_element(*self._capacity_button_locator)
        # there are two choice in this switch u'GB' or u'MB'. if it is u'GB', try to switch to u'MB'
        if capacity.text == u'GB':
            self.marionette.tap(capacity)
        # clear the default value and set it to 0.1
        size = self.marionette.find_element(*self._size_input_locator)
        size.clear()
        size.send_keys('0.1')
        done = self.marionette.find_element(*self._usage_done_button_locator)
        self.marionette.tap(done)

        # reset data
        self.wait_for_element_displayed(*self._settings_title_locator)
        reset = self.marionette.find_element(*self._reset_button_locator)
        self.marionette.tap(reset)
        self.wait_for_element_displayed(*self._reset_confirm_locator)
        confirm = self.marionette.find_element(*self._reset_confirm_locator)
        self.marionette.tap(confirm)

        # done with settings section
        self.wait_for_element_displayed(*self._done_button_locator)
        done = self.marionette.find_element(*self._done_button_locator)
        self.marionette.tap(done)

        # open browser to get some data downloaded
        # please remove this once there is a better way than launching browser app/obj to do so
        browser = Browser(self.marionette)
        browser.launch()
        browser.go_to_url('http://www.mozilla.org/')
        browser.switch_to_content()
        self.wait_for_element_present(*self._page_end_locator)
        browser.switch_to_chrome()

        # get the notification bar
        self.marionette.switch_to_frame()
        self.marionette.execute_script("window.wrappedJSObject.UtilityTray.show()")

        # switch to cost control widget
        usage_iframe = self.marionette.find_element(*self._cost_control_widget_locator)
        self.marionette.switch_to_frame(usage_iframe)

        # make sure the color changed
#.........这里部分代码省略.........