Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
import contextlib
import os
from six.moves.urllib.parse import quote
from marionette_driver import By, errors, expected, Wait
from marionette_driver.keys import Keys
from marionette_driver.marionette import Alert
from marionette_harness import (
MarionetteTestCase,
run_if_manage_instance,
WindowManagerMixin,
)
here = os.path.abspath(os.path.dirname(__file__))
BLACK_PIXEL = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" # noqa
RED_PIXEL = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEX/TQBcNTh/AAAAAXRSTlPM0jRW/QAAAApJREFUeJxjYgAAAAYAAzY3fKgAAAAASUVORK5CYII=" # noqa
def inline(doc):
return "data:text/html;charset=utf-8,%s" % quote(doc)
def inline_image(data):
return "data:image/png;base64,%s" % data
class BaseNavigationTestCase(WindowManagerMixin, MarionetteTestCase):
def setUp(self):
super(BaseNavigationTestCase, self).setUp()
file_path = os.path.join(here, "data", "test.html").replace("\\", "/")
self.test_page_frameset = self.marionette.absolute_url("frameset.html")
self.test_page_insecure = self.fixtures.where_is("test.html", on="https")
self.test_page_not_remote = "about:robots"
self.test_page_push_state = self.marionette.absolute_url(
"navigation_pushstate.html"
)
self.test_page_remote = self.marionette.absolute_url("test.html")
if self.marionette.session_capabilities["platformName"] == "mac":
self.mod_key = Keys.META
else:
self.mod_key = Keys.CONTROL
# Always use a blank new tab for an empty history
self.new_tab = self.open_tab()
self.marionette.switch_to_window(self.new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda _: self.history_length == 1,
message="The newly opened tab doesn't have a browser history length of 1",
)
def tearDown(self):
self.marionette.timeout.reset()
self.close_all_tabs()
super(BaseNavigationTestCase, self).tearDown()
@property
def history_length(self):
return self.marionette.execute_script("return window.history.length;")
@property
def is_remote_tab(self):
with self.marionette.using_context("chrome"):
# TODO: DO NOT USE MOST RECENT WINDOW BUT CURRENT ONE
return self.marionette.execute_script(
"""
const { AppConstants } = ChromeUtils.importESModule(
"resource://gre/modules/AppConstants.sys.mjs"
);
let win = null;
if (AppConstants.MOZ_APP_NAME == "fennec") {
win = Services.wm.getMostRecentWindow("navigator:browser");
} else {
const { BrowserWindowTracker } = ChromeUtils.importESModule(
"resource:///modules/BrowserWindowTracker.sys.mjs"
);
win = BrowserWindowTracker.getTopWindow();
}
let tabBrowser = null;
// Fennec
if (win.BrowserApp) {
tabBrowser = win.BrowserApp.selectedBrowser;
// Firefox
} else if (win.gBrowser) {
tabBrowser = win.gBrowser.selectedBrowser;
} else {
return null;
}
return tabBrowser.isRemoteBrowser;
"""
)
@property
def ready_state(self):
return self.marionette.execute_script(
"return window.document.readyState;", sandbox=None
)
class TestNavigate(BaseNavigationTestCase):
def test_set_location_through_execute_script(self):
# To avoid unexpected remoteness changes and a hang in any non-navigation
# pre-load a page which causes a remoteness change.
self.marionette.navigate(self.test_page_push_state)
self.marionette.execute_script(
"window.location.href = arguments[0];",
script_args=(self.test_page_remote,),
sandbox=None,
)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
expected.element_present(*(By.ID, "testh1")),
message="Target element 'testh1' has not been found",
)
self.assertEqual(self.test_page_remote, self.marionette.get_url())
def test_navigate_chrome_unsupported_error(self):
with self.marionette.using_context("chrome"):
self.assertRaises(
errors.UnsupportedOperationException,
self.marionette.navigate,
"about:blank",
)
self.assertRaises(
errors.UnsupportedOperationException, self.marionette.go_back
)
self.assertRaises(
errors.UnsupportedOperationException, self.marionette.go_forward
)
self.assertRaises(
errors.UnsupportedOperationException, self.marionette.refresh
)
def test_get_current_url_returns_top_level_browsing_context_url(self):
page_iframe = self.marionette.absolute_url("test_iframe.html")
self.marionette.navigate(page_iframe)
self.assertEqual(page_iframe, self.marionette.get_url())
frame = self.marionette.find_element(By.CSS_SELECTOR, "#test_iframe")
self.marionette.switch_to_frame(frame)
self.assertEqual(page_iframe, self.marionette.get_url())
def test_get_current_url(self):
self.marionette.navigate(self.test_page_remote)
self.assertEqual(self.test_page_remote, self.marionette.get_url())
self.marionette.navigate("about:blank")
self.assertEqual("about:blank", self.marionette.get_url())
def test_navigate_in_child_frame_changes_to_top(self):
self.marionette.navigate(self.test_page_frameset)
frame = self.marionette.find_element(By.NAME, "third")
self.marionette.switch_to_frame(frame)
self.assertRaises(
errors.NoSuchElementException,
self.marionette.find_element,
By.NAME,
"third",
)
self.marionette.navigate(self.test_page_frameset)
self.marionette.find_element(By.NAME, "third")
def test_invalid_url(self):
with self.assertRaises(errors.MarionetteException):
self.marionette.navigate("foo")
with self.assertRaises(errors.MarionetteException):
self.marionette.navigate("thisprotocoldoesnotexist://")
def test_find_element_state_complete(self):
self.marionette.navigate(self.test_page_remote)
self.assertEqual("complete", self.ready_state)
self.assertTrue(self.marionette.find_element(By.ID, "mozLink"))
def test_navigate_timeout_error_no_remoteness_change(self):
is_remote_before_timeout = self.is_remote_tab
self.marionette.timeout.page_load = 0.5
with self.assertRaises(errors.TimeoutException):
self.marionette.navigate(self.marionette.absolute_url("slow"))
self.assertEqual(self.is_remote_tab, is_remote_before_timeout)
def test_navigate_timeout_error_remoteness_change(self):
self.assertTrue(self.is_remote_tab)
self.marionette.navigate("about:robots")
self.assertFalse(self.is_remote_tab)
self.marionette.timeout.page_load = 0.5
with self.assertRaises(errors.TimeoutException):
self.marionette.navigate(self.marionette.absolute_url("slow"))
def test_navigate_to_same_image_document_twice(self):
self.marionette.navigate(self.fixtures.where_is("black.png"))
self.assertIn("black.png", self.marionette.title)
self.marionette.navigate(self.fixtures.where_is("black.png"))
self.assertIn("black.png", self.marionette.title)
def test_navigate_hash_change(self):
doc = inline("<p id=foo>")
self.marionette.navigate(doc)
self.marionette.execute_script("window.visited = true", sandbox=None)
self.marionette.navigate("{}#foo".format(doc))
self.assertTrue(
self.marionette.execute_script("return window.visited", sandbox=None)
)
def test_navigate_hash_argument_identical(self):
test_page = "{}#foo".format(inline("<p id=foo>"))
self.marionette.navigate(test_page)
self.marionette.find_element(By.ID, "foo")
self.marionette.navigate(test_page)
self.marionette.find_element(By.ID, "foo")
def test_navigate_hash_argument_differnt(self):
test_page = "{}#Foo".format(inline("<p id=foo>"))
self.marionette.navigate(test_page)
self.marionette.find_element(By.ID, "foo")
self.marionette.navigate(test_page.lower())
self.marionette.find_element(By.ID, "foo")
def test_navigate_history_pushstate(self):
target_page = self.marionette.absolute_url("navigation_pushstate_target.html")
self.marionette.navigate(self.test_page_push_state)
self.marionette.find_element(By.ID, "forward").click()
# By using pushState() the URL is updated but the target page is not loaded
# and as such the element is not displayed
self.assertEqual(self.marionette.get_url(), target_page)
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(By.ID, "target")
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), self.test_page_push_state)
# The target page still gets not loaded
self.marionette.go_forward()
self.assertEqual(self.marionette.get_url(), target_page)
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(By.ID, "target")
# Navigating to a different page, and returning to the injected
# page, it will be loaded.
self.marionette.navigate(self.test_page_remote)
self.assertEqual(self.marionette.get_url(), self.test_page_remote)
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), target_page)
self.marionette.find_element(By.ID, "target")
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), self.test_page_push_state)
def test_navigate_file_url(self):
self.marionette.navigate(self.test_page_file_url)
self.marionette.find_element(By.ID, "file-url")
self.marionette.navigate(self.test_page_remote)
def test_navigate_file_url_remoteness_change(self):
self.marionette.navigate("about:robots")
self.assertFalse(self.is_remote_tab)
self.marionette.navigate(self.test_page_file_url)
self.assertTrue(self.is_remote_tab)
self.marionette.find_element(By.ID, "file-url")
self.marionette.navigate("about:robots")
self.assertFalse(self.is_remote_tab)
def test_no_such_element_after_remoteness_change(self):
self.marionette.navigate(self.test_page_file_url)
self.assertTrue(self.is_remote_tab)
elem = self.marionette.find_element(By.ID, "file-url")
self.marionette.navigate("about:robots")
self.assertFalse(self.is_remote_tab)
with self.assertRaises(errors.StaleElementException):
elem.click()
def test_about_blank_for_new_docshell(self):
self.assertEqual(self.marionette.get_url(), "about:blank")
self.marionette.navigate("about:blank")
def test_about_newtab(self):
with self.marionette.using_prefs({"browser.newtabpage.enabled": True}):
self.marionette.navigate("about:newtab")
self.marionette.navigate(self.test_page_remote)
self.marionette.find_element(By.ID, "testDiv")
@run_if_manage_instance("Only runnable if Marionette manages the instance")
def test_focus_after_navigation(self):
self.marionette.restart()
self.marionette.navigate(inline("<input autofocus>"))
# Per spec, autofocus candidates will be
# flushed by next paint, so we use rAF here to
# ensure the candidates are flushed.
self.marionette.execute_async_script(
"""
const callback = arguments[arguments.length - 1];
window.requestAnimationFrame(function() {
window.requestAnimationFrame(callback);
});
"""
)
focus_el = self.marionette.find_element(By.CSS_SELECTOR, ":focus")
self.assertEqual(self.marionette.get_active_element(), focus_el)
def test_no_hang_when_navigating_after_closing_original_tab(self):
# Close the start tab
self.marionette.switch_to_window(self.start_tab)
self.marionette.close()
self.marionette.switch_to_window(self.new_tab)
self.marionette.navigate(self.test_page_remote)
def test_type_to_non_remote_tab(self):
self.marionette.navigate(self.test_page_not_remote)
self.assertFalse(self.is_remote_tab)
with self.marionette.using_context("chrome"):
urlbar = self.marionette.execute_script("return gURLBar.inputField")
urlbar.send_keys(self.mod_key + "a")
urlbar.send_keys(self.mod_key + "x")
urlbar.send_keys("about:support" + Keys.ENTER)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == "about:support",
message="'about:support' hasn't been loaded",
)
self.assertFalse(self.is_remote_tab)
def test_type_to_remote_tab(self):
self.assertTrue(self.is_remote_tab)
with self.marionette.using_context("chrome"):
urlbar = self.marionette.execute_script("return gURLBar.inputField")
urlbar.send_keys(self.mod_key + "a")
urlbar.send_keys(self.mod_key + "x")
urlbar.send_keys(self.test_page_remote + Keys.ENTER)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.test_page_remote,
message="'{}' hasn't been loaded".format(self.test_page_remote),
)
self.assertTrue(self.is_remote_tab)
def test_navigate_after_deleting_session(self):
self.marionette.delete_session()
self.marionette.start_session()
self.marionette.navigate(self.test_page_remote)
self.assertEqual(self.test_page_remote, self.marionette.get_url())
class TestBackForwardNavigation(BaseNavigationTestCase):
def run_bfcache_test(self, test_pages):
# Helper method to run simple back and forward testcases.
def check_page_status(page, expected_history_length):
if "alert_text" in page:
self.assertEqual(Alert(self.marionette).text, page["alert_text"])
self.assertEqual(self.marionette.get_url(), page["url"])
self.assertEqual(self.history_length, expected_history_length)
if "is_remote" in page:
self.assertEqual(
page["is_remote"],
self.is_remote_tab,
"'{}' doesn't match expected remoteness state: {}".format(
page["url"], page["is_remote"]
),
)
if "callback" in page and callable(page["callback"]):
page["callback"]()
for index, page in enumerate(test_pages):
if "error" in page:
with self.assertRaises(page["error"]):
self.marionette.navigate(page["url"])
else:
self.marionette.navigate(page["url"])
check_page_status(page, index + 1)
# Now going back in history for all test pages by backward iterating
# through the list (-1) and skipping the first entry at the end (-2).
for page in test_pages[-2::-1]:
if "error" in page:
with self.assertRaises(page["error"]):
self.marionette.go_back()
else:
self.marionette.go_back()
check_page_status(page, len(test_pages))
# Now going forward in history by skipping the first entry.
for page in test_pages[1::]:
if "error" in page:
with self.assertRaises(page["error"]):
self.marionette.go_forward()
else:
self.marionette.go_forward()
check_page_status(page, len(test_pages))
def test_no_history_items(self):
# Both methods should not raise a failure if no navigation is possible
self.marionette.go_back()
self.marionette.go_forward()
def test_data_urls(self):
test_pages = [
{"url": inline("<p>foobar</p>")},
{"url": self.test_page_remote},
{"url": inline("<p>foobar</p>")},
]
self.run_bfcache_test(test_pages)
def test_same_document_hash_change(self):
test_pages = [
{"url": "{}#23".format(self.test_page_remote)},
{"url": self.test_page_remote},
{"url": "{}#42".format(self.test_page_remote)},
]
self.run_bfcache_test(test_pages)
def test_file_url(self):
test_pages = [
{"url": self.test_page_remote},
{"url": self.test_page_file_url},
{"url": self.test_page_remote},
]
self.run_bfcache_test(test_pages)
def test_frameset(self):
test_pages = [
{"url": self.marionette.absolute_url("frameset.html")},
{"url": self.test_page_remote},
{"url": self.marionette.absolute_url("frameset.html")},
]
self.run_bfcache_test(test_pages)
def test_frameset_after_navigating_in_frame(self):
test_element_locator = (By.ID, "email")
self.marionette.navigate(self.test_page_remote)
self.assertEqual(self.marionette.get_url(), self.test_page_remote)
self.assertEqual(self.history_length, 1)
page = self.marionette.absolute_url("frameset.html")
self.marionette.navigate(page)
self.assertEqual(self.marionette.get_url(), page)
self.assertEqual(self.history_length, 2)
frame = self.marionette.find_element(By.ID, "fifth")
self.marionette.switch_to_frame(frame)
link = self.marionette.find_element(By.ID, "linkId")
link.click()
# We cannot use get_url() to wait until the target page has been loaded,
# because it will return the URL of the top browsing context and doesn't
# wait for the page load to be complete.
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
expected.element_present(*test_element_locator),
message="Target element 'email' has not been found",
)
self.assertEqual(self.history_length, 3)
# Go back to the frame the click navigated away from
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), page)
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(*test_element_locator)
# Go back to the non-frameset page
self.marionette.switch_to_parent_frame()
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), self.test_page_remote)
# Go forward to the frameset page
self.marionette.go_forward()
self.assertEqual(self.marionette.get_url(), page)
# Go forward to the frame the click navigated to
# TODO: See above for automatic browser context switches. Hard to do here
frame = self.marionette.find_element(By.ID, "fifth")
self.marionette.switch_to_frame(frame)
self.marionette.go_forward()
self.marionette.find_element(*test_element_locator)
self.assertEqual(self.marionette.get_url(), page)
def test_image_to_html_to_image(self):
test_pages = [
{"url": self.marionette.absolute_url("black.png")},
{"url": self.test_page_remote},
{"url": self.marionette.absolute_url("white.png")},
]
self.run_bfcache_test(test_pages)
def test_image_to_image(self):
test_pages = [
{"url": self.marionette.absolute_url("black.png")},
{"url": self.marionette.absolute_url("white.png")},
{"url": inline_image(RED_PIXEL)},
{"url": inline_image(BLACK_PIXEL)},
{"url": self.marionette.absolute_url("black.png")},
]
self.run_bfcache_test(test_pages)
def test_remoteness_change(self):
test_pages = [
{"url": "about:robots", "is_remote": False},
{"url": self.test_page_remote, "is_remote": True},
{"url": "about:robots", "is_remote": False},
]
self.run_bfcache_test(test_pages)
def test_non_remote_about_pages(self):
test_pages = [
{"url": "about:preferences", "is_remote": False},
{"url": "about:robots", "is_remote": False},
{"url": "about:support", "is_remote": False},
]
self.run_bfcache_test(test_pages)
def test_navigate_to_requested_about_page_after_error_page(self):
test_pages = [
{"url": "about:neterror"},
{"url": self.test_page_remote},
{"url": "about:blocked"},
]
self.run_bfcache_test(test_pages)
def test_timeout_error(self):
urls = [
self.marionette.absolute_url("slow?delay=3"),
self.test_page_remote,
self.marionette.absolute_url("slow?delay=4"),
]
# First, load all pages completely to get them added to the cache
for index, url in enumerate(urls):
self.marionette.navigate(url)
self.assertEqual(url, self.marionette.get_url())
self.assertEqual(self.history_length, index + 1)
self.marionette.go_back()
self.assertEqual(urls[1], self.marionette.get_url())
# Force triggering a timeout error
self.marionette.timeout.page_load = 0.5
with self.assertRaises(errors.TimeoutException):
self.marionette.go_back()
self.marionette.timeout.reset()
delay = Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
expected.element_present(By.ID, "delay"),
message="Target element 'delay' has not been found after timeout in 'back'",
)
self.assertEqual(delay.text, "3")
self.marionette.go_forward()
self.assertEqual(urls[1], self.marionette.get_url())
# Force triggering a timeout error
self.marionette.timeout.page_load = 0.5
with self.assertRaises(errors.TimeoutException):
self.marionette.go_forward()
self.marionette.timeout.reset()
delay = Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
expected.element_present(By.ID, "delay"),
message="Target element 'delay' has not been found after timeout in 'forward'",
)
self.assertEqual(delay.text, "4")
def test_certificate_error(self):
test_pages = [
{
"url": self.test_page_insecure,
"error": errors.InsecureCertificateException,
},
{"url": self.test_page_remote},
{
"url": self.test_page_insecure,
"error": errors.InsecureCertificateException,
},
]
self.run_bfcache_test(test_pages)
class TestRefresh(BaseNavigationTestCase):
def test_basic(self):
self.marionette.navigate(self.test_page_remote)
self.assertEqual(self.test_page_remote, self.marionette.get_url())
self.marionette.execute_script(
"""
let elem = window.document.createElement('div');
elem.id = 'someDiv';
window.document.body.appendChild(elem);
"""
)
self.marionette.find_element(By.ID, "someDiv")
self.marionette.refresh()
self.assertEqual(self.test_page_remote, self.marionette.get_url())
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(By.ID, "someDiv")
def test_refresh_in_child_frame_navigates_to_top(self):
self.marionette.navigate(self.test_page_frameset)
self.assertEqual(self.test_page_frameset, self.marionette.get_url())
frame = self.marionette.find_element(By.NAME, "third")
self.marionette.switch_to_frame(frame)
self.assertRaises(
errors.NoSuchElementException,
self.marionette.find_element,
By.NAME,
"third",
)
self.marionette.refresh()
self.marionette.find_element(By.NAME, "third")
def test_file_url(self):
self.marionette.navigate(self.test_page_file_url)
self.assertEqual(self.test_page_file_url, self.marionette.get_url())
self.marionette.refresh()
self.assertEqual(self.test_page_file_url, self.marionette.get_url())
def test_image(self):
image = self.marionette.absolute_url("black.png")
self.marionette.navigate(image)
self.assertEqual(image, self.marionette.get_url())
self.marionette.refresh()
self.assertEqual(image, self.marionette.get_url())
def test_history_pushstate(self):
target_page = self.marionette.absolute_url("navigation_pushstate_target.html")
self.marionette.navigate(self.test_page_push_state)
self.marionette.find_element(By.ID, "forward").click()
# By using pushState() the URL is updated but the target page is not loaded
# and as such the element is not displayed
self.assertEqual(self.marionette.get_url(), target_page)
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(By.ID, "target")
# Refreshing the target page will trigger a full page load.
self.marionette.refresh()
self.assertEqual(self.marionette.get_url(), target_page)
self.marionette.find_element(By.ID, "target")
self.marionette.go_back()
self.assertEqual(self.marionette.get_url(), self.test_page_push_state)
def test_timeout_error(self):
slow_page = self.marionette.absolute_url("slow?delay=3")
self.marionette.navigate(slow_page)
self.assertEqual(slow_page, self.marionette.get_url())
self.marionette.timeout.page_load = 0.5
with self.assertRaises(errors.TimeoutException):
self.marionette.refresh()
self.assertEqual(slow_page, self.marionette.get_url())
def test_insecure_error(self):
with self.assertRaises(errors.InsecureCertificateException):
self.marionette.navigate(self.test_page_insecure)
self.assertEqual(self.marionette.get_url(), self.test_page_insecure)
with self.assertRaises(errors.InsecureCertificateException):
self.marionette.refresh()
class TestTLSNavigation(BaseNavigationTestCase):
insecure_tls = {"acceptInsecureCerts": True}
secure_tls = {"acceptInsecureCerts": False}
def setUp(self):
super(TestTLSNavigation, self).setUp()
self.test_page_insecure = self.fixtures.where_is("test.html", on="https")
self.marionette.delete_session()
self.capabilities = self.marionette.start_session(self.insecure_tls)
def tearDown(self):
try:
self.marionette.delete_session()
self.marionette.start_session()
except:
pass
super(TestTLSNavigation, self).tearDown()
@contextlib.contextmanager
def safe_session(self):
try:
self.capabilities = self.marionette.start_session(self.secure_tls)
self.assertFalse(self.capabilities["acceptInsecureCerts"])
# Always use a blank new tab for an empty history
self.new_tab = self.open_tab()
self.marionette.switch_to_window(self.new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda _: self.history_length == 1,
message="The newly opened tab doesn't have a browser history length of 1",
)
yield self.marionette
finally:
self.close_all_tabs()
self.marionette.delete_session()
@contextlib.contextmanager
def unsafe_session(self):
try:
self.capabilities = self.marionette.start_session(self.insecure_tls)
self.assertTrue(self.capabilities["acceptInsecureCerts"])
# Always use a blank new tab for an empty history
self.new_tab = self.open_tab()
self.marionette.switch_to_window(self.new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda _: self.history_length == 1,
message="The newly opened tab doesn't have a browser history length of 1",
)
yield self.marionette
finally:
self.close_all_tabs()
self.marionette.delete_session()
def test_navigate_by_command(self):
self.marionette.navigate(self.test_page_insecure)
self.assertIn("https", self.marionette.get_url())
def test_navigate_by_click(self):
link_url = self.test_page_insecure
self.marionette.navigate(
inline("<a href=%s>https is the future</a>" % link_url)
)
self.marionette.find_element(By.TAG_NAME, "a").click()
self.assertIn("https", self.marionette.get_url())
def test_deactivation(self):
invalid_cert_url = self.test_page_insecure
self.marionette.delete_session()
print("with safe session")
with self.safe_session() as session:
with self.assertRaises(errors.InsecureCertificateException):
session.navigate(invalid_cert_url)
print("with unsafe session")
with self.unsafe_session() as session:
session.navigate(invalid_cert_url)
print("with safe session again")
with self.safe_session() as session:
with self.assertRaises(errors.InsecureCertificateException):
session.navigate(invalid_cert_url)
class TestPageLoadStrategy(BaseNavigationTestCase):
def setUp(self):
super(TestPageLoadStrategy, self).setUp()
# Test page that delays the response and as such the document to be
# loaded. It is used for testing the page load strategy "none".
self.test_page_slow = self.marionette.absolute_url("slow")
# Similar to "slow" but additionally triggers a cross group navigation
# which triggers a replacement of the top-level browsing context.
self.test_page_slow_coop = self.marionette.absolute_url("slow-coop")
# Test page that contains a slow loading <img> element which delays the
# "load" but not the "DOMContentLoaded" event.
self.test_page_slow_resource = self.marionette.absolute_url(
"slow_resource.html"
)
def tearDown(self):
self.marionette.delete_session()
self.marionette.start_session()
super(TestPageLoadStrategy, self).tearDown()
def test_none(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "none"})
# Navigate will return immediately. As such wait for the target URL to
# be the current location, and the element to exist.
self.marionette.navigate(self.test_page_slow)
with self.assertRaises(errors.NoSuchElementException):
self.marionette.find_element(By.ID, "delay")
Wait(
self.marionette,
ignored_exceptions=errors.NoSuchElementException,
timeout=self.marionette.timeout.page_load,
).until(lambda _: self.marionette.find_element(By.ID, "delay"))
self.assertEqual(self.marionette.get_url(), self.test_page_slow)
def test_none_with_new_session_waits_for_page_loaded(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "none"})
# Navigate will return immediately.
self.marionette.navigate(self.test_page_slow)
# Make sure that when creating a new session right away it waits
# until the page has been finished loading.
self.marionette.delete_session()
self.marionette.start_session()
self.assertEqual(self.marionette.get_url(), self.test_page_slow)
self.assertEqual(self.ready_state, "complete")
self.marionette.find_element(By.ID, "delay")
def test_none_with_new_session_waits_for_page_loaded_remoteness_change(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "none"})
# Navigate will return immediately.
self.marionette.navigate(self.test_page_slow_coop)
# Make sure that when creating a new session right away it waits
# until the page has been finished loading.
self.marionette.delete_session()
self.marionette.start_session()
self.assertEqual(self.marionette.get_url(), self.test_page_slow_coop)
self.assertEqual(self.ready_state, "complete")
self.marionette.find_element(By.ID, "delay")
def test_eager(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "eager"})
self.marionette.navigate(self.test_page_slow_resource)
self.assertEqual(self.ready_state, "interactive")
self.assertEqual(self.marionette.get_url(), self.test_page_slow_resource)
self.marionette.find_element(By.ID, "slow")
def test_normal(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "normal"})
self.marionette.navigate(self.test_page_slow_resource)
self.assertEqual(self.marionette.get_url(), self.test_page_slow_resource)
self.assertEqual(self.ready_state, "complete")
self.marionette.find_element(By.ID, "slow")
def test_strategy_after_remoteness_change(self):
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "eager"})
# Trigger a remoteness change which will reload the listener script
self.assertTrue(
self.is_remote_tab, "Initial tab doesn't have remoteness flag set"
)
self.marionette.navigate("about:robots")
self.assertFalse(self.is_remote_tab, "Tab has remoteness flag set")
self.marionette.navigate(self.test_page_slow_resource)
self.assertEqual(self.ready_state, "interactive")