Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-19 00:05:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Backed out 6 changesets (bug 1504756) as requested by whimboo in order to stop some wpt and mn intermittents. a=backout

Browse Source 
Backed out changeset d7d78e79f0b3 (bug 1504756)
Backed out changeset 5c495fd7f64d (bug 1504756)
Backed out changeset 5c2826c58f9e (bug 1504756)
Backed out changeset f23b667d8bfa (bug 1504756)
Backed out changeset 6068c233f4ef (bug 1504756)
Backed out changeset 65858c8c0fbd (bug 1504756)

--HG--
extra : rebase_source : 6b895c62a74c6f7521e4a4baff3b0498c65fcbf9
This commit is contained in:
Cosmin Sabou 2018-12-20 18:07:02 +02:00
parent 9528360768
commit 4d5fd1304e
24 changed files with 685 additions and 943 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
testing/marionette/browser.js
View File

@ -12,8 +12,7 @@ const {
UnsupportedOperationError,
} = ChromeUtils.import("chrome://marionette/content/error.js", {});
const {
waitForEvent,
waitForObserverTopic,
MessageManagerDestroyedPromise,
} = ChromeUtils.import("chrome://marionette/content/sync.js", {});
this.EXPORTED_SYMBOLS = ["browser", "Context", "WindowState"];
@ -71,11 +70,11 @@ this.Context = Context;
*/
browser.getBrowserForTab = function(tab) {
// Fennec
if (tab && "browser" in tab) {
if ("browser" in tab) {
return tab.browser;
// Firefox
} else if (tab && "linkedBrowser" in tab) {
} else if ("linkedBrowser" in tab) {
return tab.linkedBrowser;
}
@ -288,59 +287,17 @@ browser.Context = class {
* A promise which is resolved when the current window has been closed.
*/
closeWindow() {
// Create a copy of the messageManager before it is disconnected
let messageManager = this.window.messageManager;
let disconnected = waitForObserverTopic("message-manager-disconnect",
subject => subject === messageManager);
let unloaded = waitForEvent(this.window, "unload");
return new Promise(resolve => {
// Wait for the window message manager to be destroyed
let destroyed = new MessageManagerDestroyedPromise(
this.window.messageManager);
this.window.close();
return Promise.all([disconnected, unloaded]);
}
/**
* Open a new browser window.
*
* @return {Promise}
* A promise resolving to the newly created chrome window.
*/
async openBrowserWindow(focus = false) {
switch (this.driver.appName) {
case "firefox":
// Open new browser window, and wait until it is fully loaded.
// Also wait for the window to be focused and activated to prevent a
// race condition when promptly focusing to the original window again.
let win = this.window.OpenBrowserWindow();
// Bug 1509380 - Missing focus/activate event when Firefox is not
// the top-most application. As such wait for the next tick, and
// manually focus the newly opened window.
win.setTimeout(() => win.focus(), 0);
let activated = waitForEvent(win, "activate");
let focused = waitForEvent(win, "focus", {capture: true});
let startup = waitForObserverTopic("browser-delayed-startup-finished",
subject => subject == win);
await Promise.all([activated, focused, startup]);
if (!focus) {
// The new window shouldn't get focused. As such set the
// focus back to the currently selected window.
activated = waitForEvent(this.window, "activate");
focused = waitForEvent(this.window, "focus", {capture: true});
this.window.focus();
await Promise.all([activated, focused]);
}
return win;
default:
throw new UnsupportedOperationError(
`openWindow() not supported in ${this.driver.appName}`);
}
this.window.addEventListener("unload", async () => {
await destroyed;
resolve();
}, {once: true});
this.window.close();
});
}
/**
@ -362,65 +319,40 @@ browser.Context = class {
return this.closeWindow();
}
// Create a copy of the messageManager before it is disconnected
let messageManager = this.messageManager;
let disconnected = waitForObserverTopic("message-manager-disconnect",
subject => subject === messageManager);
return new Promise((resolve, reject) => {
// Wait for the browser message manager to be destroyed
let browserDetached = async () => {
await new MessageManagerDestroyedPromise(this.messageManager);
resolve();
};
let tabClosed;
switch (this.driver.appName) {
case "fennec":
if (this.tabBrowser.closeTab) {
// Fennec
tabClosed = waitForEvent(this.tabBrowser.deck, "TabClose");
this.tabBrowser.deck.addEventListener(
"TabClose", browserDetached, {once: true});
this.tabBrowser.closeTab(this.tab);
break;
case "firefox":
tabClosed = waitForEvent(this.tab, "TabClose");
} else if (this.tabBrowser.removeTab) {
// Firefox
this.tab.addEventListener(
"TabClose", browserDetached, {once: true});
this.tabBrowser.removeTab(this.tab);
break;
default:
throw new UnsupportedOperationError(
`closeTab() not supported in ${this.driver.appName}`);
}
return Promise.all([disconnected, tabClosed]);
} else {
reject(new UnsupportedOperationError(
`closeTab() not supported in ${this.driver.appName}`));
}
});
}
/**
* Open a new tab in the currently selected chrome window.
* Opens a tab with given URI.
*
* @param {string} uri
* URI to open.
*/
async openTab(focus = false) {
let tab = null;
let tabOpened = waitForEvent(this.window, "TabOpen");
switch (this.driver.appName) {
case "fennec":
tab = this.tabBrowser.addTab(null, {selected: focus});
break;
case "firefox":
this.window.BrowserOpenTab();
tab = this.tabBrowser.selectedTab;
// The new tab is always selected by default. If focus is not wanted,
// the previously tab needs to be selected again.
if (!focus) {
this.tabBrowser.selectedTab = this.tab;
}
break;
default:
throw new UnsupportedOperationError(
`openTab() not supported in ${this.driver.appName}`);
}
await tabOpened;
return tab;
addTab(uri) {
return this.tabBrowser.addTab(uri, true);
}
/**
@ -454,18 +386,16 @@ browser.Context = class {
this.tab = this.tabBrowser.tabs[index];
if (focus) {
switch (this.driver.appName) {
case "fennec":
this.tabBrowser.selectTab(this.tab);
break;
if (this.tabBrowser.selectTab) {
// Fennec
this.tabBrowser.selectTab(this.tab);
case "firefox":
this.tabBrowser.selectedTab = this.tab;
break;
} else if ("selectedTab" in this.tabBrowser) {
// Firefox
this.tabBrowser.selectedTab = this.tab;
default:
throw new UnsupportedOperationError(
`switchToTab() not supported in ${this.driver.appName}`);
} else {
throw new UnsupportedOperationError("switchToTab() not supported");
}
}
}

14
testing/marionette/client/marionette_driver/marionette.py
View File

@ -1428,20 +1428,6 @@ class Marionette(object):
return self._send_message("WebDriver:GetPageSource",
key="value")
def open(self, type=None, focus=False):
"""Open a new window, or tab based on the specified context type.
If no context type is given the application will choose the best
option based on tab and window support.
:param type: Type of window to be opened. Can be one of "tab" or "window"
:param focus: If true, the opened window will be focused
:returns: Dict with new window handle, and type of opened window
"""
body = {"type": type, "focus": focus}
return self._send_message("WebDriver:NewWindow", body)
def close(self):
"""Close the current window, ending the session if it's the last
window currently open.

9
testing/marionette/doc/internals/sync.rst
View File

@ -3,7 +3,8 @@ sync module
Provides an assortment of synchronisation primitives.
.. js:autofunction:: executeSoon
.. js:autoclass:: MessageManagerDestroyedPromise
:members:
.. js:autoclass:: PollPromise
:members:
@ -13,9 +14,3 @@ Provides an assortment of synchronisation primitives.
.. js:autoclass:: TimedPromise
:members:
.. js:autofunction:: waitForEvent
.. js:autofunction:: waitForMessage
.. js:autofunction:: waitForObserverTopic

119
testing/marionette/driver.js
View File

@ -62,8 +62,6 @@ const {
IdlePromise,
PollPromise,
TimedPromise,
waitForEvent,
waitForObserverTopic,
} = ChromeUtils.import("chrome://marionette/content/sync.js", {});
XPCOMUtils.defineLazyGetter(this, "logger", Log.get);
@ -108,12 +106,13 @@ const globalMessageManager = Services.mm;
*
* @class GeckoDriver
*
* @param {string} appId
* Unique identifier of the application.
* @param {MarionetteServer} server
* The instance of Marionette server.
*/
this.GeckoDriver = function(server) {
this.appId = Services.appinfo.ID;
this.appName = Services.appinfo.name.toLowerCase();
this.GeckoDriver = function(appId, server) {
this.appId = appId;
this._server = server;
this.sessionID = null;
@ -1308,7 +1307,6 @@ GeckoDriver.prototype.getIdForBrowser = function(browser) {
if (browser === null) {
return null;
}
let permKey = browser.permanentKey;
if (this._browserIds.has(permKey)) {
return this._browserIds.get(permKey);
@ -2724,73 +2722,6 @@ GeckoDriver.prototype.deleteCookie = async function(cmd) {
}
};
/**
* Open a new top-level browsing context.
*
* @param {string=} type
* Optional type of the new top-level browsing context. Can be one of
* `tab` or `window`.
* @param {boolean=} focus
* Optional flag if the new top-level browsing context should be opened
* in foreground (focused) or background (not focused).
*
* @return {Object.<string, string>}
* Handle and type of the new browsing context.
*/
GeckoDriver.prototype.newWindow = async function(cmd) {
assert.open(this.getCurrentWindow(Context.Content));
await this._handleUserPrompts();
let focus = false;
if (typeof cmd.parameters.focus != "undefined") {
focus = assert.boolean(cmd.parameters.focus,
pprint`Expected "focus" to be a boolean, got ${cmd.parameters.focus}`);
}
let type;
if (typeof cmd.parameters.type != "undefined") {
type = assert.string(cmd.parameters.type,
pprint`Expected "type" to be a string, got ${cmd.parameters.type}`);
}
let types = ["tab", "window"];
switch (this.appName) {
case "firefox":
if (typeof type == "undefined" || !types.includes(type)) {
type = "window";
}
break;
case "fennec":
if (typeof type == "undefined" || !types.includes(type)) {
type = "tab";
}
break;
}
let contentBrowser;
switch (type) {
case "tab":
let tab = await this.curBrowser.openTab(focus);
contentBrowser = browser.getBrowserForTab(tab);
break;
default:
let win = await this.curBrowser.openBrowserWindow(focus);
contentBrowser = browser.getTabBrowser(win).selectedBrowser;
}
// Even with the framescript registered, the browser might not be known to
// the parent process yet. Wait until it is available.
// TODO: Fix by using `Browser:Init` or equivalent on bug 1311041
let windowId = await new PollPromise((resolve, reject) => {
let id = this.getIdForBrowser(contentBrowser);
this.windowHandles.includes(id) ? resolve(id) : reject();
});
return {"handle": windowId.toString(), type};
};
/**
* Close the currently selected tab/window.
*
@ -3170,14 +3101,16 @@ GeckoDriver.prototype.dismissDialog = async function() {
let win = assert.open(this.getCurrentWindow());
this._checkIfAlertIsPresent();
let dialogClosed = waitForEvent(win, "DOMModalDialogClosed");
await new Promise(resolve => {
win.addEventListener("DOMModalDialogClosed", async () => {
await new IdlePromise(win);
this.dialog = null;
resolve();
}, {once: true});
let {button0, button1} = this.dialog.ui;
(button1 ? button1 : button0).click();
await dialogClosed;
this.dialog = null;
let {button0, button1} = this.dialog.ui;
(button1 ? button1 : button0).click();
});
};
/**
@ -3188,14 +3121,16 @@ GeckoDriver.prototype.acceptDialog = async function() {
let win = assert.open(this.getCurrentWindow());
this._checkIfAlertIsPresent();
let dialogClosed = waitForEvent(win, "DOMModalDialogClosed");
await new Promise(resolve => {
win.addEventListener("DOMModalDialogClosed", async () => {
await new IdlePromise(win);
this.dialog = null;
resolve();
}, {once: true});
let {button0} = this.dialog.ui;
button0.click();
await dialogClosed;
this.dialog = null;
let {button0} = this.dialog.ui;
button0.click();
});
};
/**
@ -3366,10 +3301,15 @@ GeckoDriver.prototype.quit = async function(cmd) {
this.deleteSession();
// delay response until the application is about to quit
let quitApplication = waitForObserverTopic("quit-application");
let quitApplication = new Promise(resolve => {
Services.obs.addObserver(
(subject, topic, data) => resolve(data),
"quit-application");
});
Services.startup.quit(mode);
return {cause: (await quitApplication).data};
return {cause: await quitApplication};
};
GeckoDriver.prototype.installAddon = function(cmd) {
@ -3631,7 +3571,6 @@ GeckoDriver.prototype.commands = {
"WebDriver:MaximizeWindow": GeckoDriver.prototype.maximizeWindow,
"WebDriver:Navigate": GeckoDriver.prototype.get,
"WebDriver:NewSession": GeckoDriver.prototype.newSession,
"WebDriver:NewWindow": GeckoDriver.prototype.newWindow,
"WebDriver:PerformActions": GeckoDriver.prototype.performActions,
"WebDriver:Refresh": GeckoDriver.prototype.refresh,
"WebDriver:ReleaseActions": GeckoDriver.prototype.releaseActions,

47
testing/marionette/harness/marionette_harness/runner/mixins/window_manager.py
View File

@ -6,12 +6,14 @@ from __future__ import absolute_import
import sys
from marionette_driver import Wait
from marionette_driver import By, Wait
from six import reraise
class WindowManagerMixin(object):
_menu_item_new_tab = (By.ID, "menu_newNavigatorTab")
def setUp(self):
super(WindowManagerMixin, self).setUp()
@ -58,18 +60,15 @@ class WindowManagerMixin(object):
self.marionette.switch_to_window(self.start_window)
def open_tab(self, callback=None, focus=False):
def open_tab(self, trigger="menu"):
current_tabs = self.marionette.window_handles
try:
if callable(callback):
callback()
else:
result = self.marionette.open(type="tab", focus=focus)
if result["type"] != "tab":
raise Exception(
"Newly opened browsing context is of type {} and not tab.".format(
result["type"]))
if callable(trigger):
trigger()
elif trigger == 'menu':
with self.marionette.using_context("chrome"):
self.marionette.find_element(*self._menu_item_new_tab).click()
except Exception:
exc, val, tb = sys.exc_info()
reraise(exc, 'Failed to trigger opening a new tab: {}'.format(val), tb)
@ -83,9 +82,8 @@ class WindowManagerMixin(object):
return new_tab
def open_window(self, callback=None, focus=False):
def open_window(self, trigger=None):
current_windows = self.marionette.chrome_window_handles
current_tabs = self.marionette.window_handles
def loaded(handle):
with self.marionette.using_context("chrome"):
@ -97,14 +95,11 @@ class WindowManagerMixin(object):
""", script_args=[handle])
try:
if callable(callback):
callback()
if callable(trigger):
trigger()
else:
result = self.marionette.open(type="window", focus=focus)
if result["type"] != "window":
raise Exception(
"Newly opened browsing context is of type {} and not window.".format(
result["type"]))
with self.marionette.using_context("chrome"):
self.marionette.execute_script("OpenBrowserWindow();")
except Exception:
exc, val, tb = sys.exc_info()
reraise(exc, 'Failed to trigger opening a new window: {}'.format(val), tb)
@ -121,16 +116,9 @@ class WindowManagerMixin(object):
lambda _: loaded(new_window),
message="Window with handle '{}'' did not finish loading".format(new_window))
# Bug 1507771 - Return the correct handle based on the currently selected context
# as long as "WebDriver:NewWindow" is not handled separtely in chrome context
context = self.marionette._send_message("Marionette:GetContext", key="value")
if context == "chrome":
return new_window
elif context == "content":
[new_tab] = list(set(self.marionette.window_handles) - set(current_tabs))
return new_tab
return new_window
def open_chrome_window(self, url, focus=False):
def open_chrome_window(self, url):
"""Open a new chrome window with the specified chrome URL.
Can be replaced with "WebDriver:NewWindow" once the command
@ -178,5 +166,4 @@ class WindowManagerMixin(object):
})();
""", script_args=(url,))
with self.marionette.using_context("chrome"):
return self.open_window(callback=open_with_js, focus=focus)
return self.open_window(trigger=open_with_js)

29
testing/marionette/harness/marionette_harness/tests/unit/test_chrome.py
View File

@ -1,5 +1,22 @@
#Copyright 2007-2009 WebDriver committers
#Copyright 2007-2009 Google Inc.
#
#Licensed under the Apache License, Version 2.0 (the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.
from __future__ import absolute_import
from marionette_driver import By
from marionette_harness import MarionetteTestCase, WindowManagerMixin
@ -8,13 +25,18 @@ class ChromeTests(WindowManagerMixin, MarionetteTestCase):
def setUp(self):
super(ChromeTests, self).setUp()
self.marionette.set_context('chrome')
def tearDown(self):
self.close_all_windows()
super(ChromeTests, self).tearDown()
def test_hang_until_timeout(self):
with self.marionette.using_context("chrome"):
new_window = self.open_window()
def open_with_menu():
menu = self.marionette.find_element(By.ID, 'aboutName')
menu.click()
new_window = self.open_window(trigger=open_with_menu)
self.marionette.switch_to_window(new_window)
try:
@ -23,8 +45,7 @@ class ChromeTests(WindowManagerMixin, MarionetteTestCase):
# while running this test. Otherwise it would mask eg. IOError as
# thrown for a socket timeout.
raise NotImplementedError('Exception should not cause a hang when '
'closing the chrome window in content '
'context')
'closing the chrome window')
finally:
self.marionette.close_chrome_window()
self.marionette.switch_to_window(self.start_window)

12
testing/marionette/harness/marionette_harness/tests/unit/test_click.py
View File

@ -449,16 +449,20 @@ class TestClickCloseContext(WindowManagerMixin, MarionetteTestCase):
super(TestClickCloseContext, self).tearDown()
def test_click_close_tab(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
self.marionette.navigate(self.marionette.absolute_url("windowHandles.html"))
tab = self.open_tab(
lambda: self.marionette.find_element(By.ID, "new-tab").click())
self.marionette.switch_to_window(tab)
self.marionette.navigate(self.test_page)
self.marionette.find_element(By.ID, "close-window").click()
@skip_if_mobile("Fennec doesn't support other chrome windows")
def test_click_close_window(self):
new_tab = self.open_window()
self.marionette.switch_to_window(new_tab)
self.marionette.navigate(self.marionette.absolute_url("windowHandles.html"))
win = self.open_window(
lambda: self.marionette.find_element(By.ID, "new-window").click())
self.marionette.switch_to_window(win)
self.marionette.navigate(self.test_page)
self.marionette.find_element(By.ID, "close-window").click()

19
testing/marionette/harness/marionette_harness/tests/unit/test_key_actions.py
View File

@ -77,3 +77,22 @@ class TestKeyActions(WindowManagerMixin, MarionetteTestCase):
.key_down("x")
.perform())
self.assertEqual(self.key_reporter_value, "")
@skip_if_mobile("Interacting with chrome windows not available for Fennec")
def test_open_in_new_window_shortcut(self):
def open_window_with_action():
el = self.marionette.find_element(By.TAG_NAME, "a")
(self.key_action.key_down(Keys.SHIFT)
.press(el)
.release()
.key_up(Keys.SHIFT)
.perform())
self.marionette.navigate(inline("<a href='#'>Click</a>"))
new_window = self.open_window(trigger=open_window_with_action)
self.marionette.switch_to_window(new_window)
self.marionette.close_chrome_window()
self.marionette.switch_to_window(self.start_window)

26
testing/marionette/harness/marionette_harness/tests/unit/test_navigation.py
View File

@ -55,8 +55,13 @@ class BaseNavigationTestCase(WindowManagerMixin, MarionetteTestCase):
else:
self.mod_key = Keys.CONTROL
def open_with_link():
link = self.marionette.find_element(By.ID, "new-blank-tab")
link.click()
# Always use a blank new tab for an empty history
self.new_tab = self.open_tab()
self.marionette.navigate(self.marionette.absolute_url("windowHandles.html"))
self.new_tab = self.open_tab(open_with_link)
self.marionette.switch_to_window(self.new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda _: self.history_length == 1,
@ -293,6 +298,7 @@ class TestNavigate(BaseNavigationTestCase):
focus_el = self.marionette.find_element(By.CSS_SELECTOR, ":focus")
self.assertEqual(self.marionette.get_active_element(), focus_el)
@skip_if_mobile("Needs application independent method to open a new tab")
def test_no_hang_when_navigating_after_closing_original_tab(self):
# Close the start tab
self.marionette.switch_to_window(self.start_tab)
@ -334,6 +340,22 @@ class TestNavigate(BaseNavigationTestCase):
message="'{}' hasn't been loaded".format(self.test_page_remote))
self.assertTrue(self.is_remote_tab)
@skip_if_mobile("On Android no shortcuts are available")
def test_navigate_shortcut_key(self):
def open_with_shortcut():
self.marionette.navigate(self.test_page_remote)
with self.marionette.using_context("chrome"):
main_win = self.marionette.find_element(By.ID, "main-window")
main_win.send_keys(self.mod_key, Keys.SHIFT, "a")
new_tab = self.open_tab(trigger=open_with_shortcut)
self.marionette.switch_to_window(new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == "about:addons",
message="'about:addons' hasn't been loaded")
class TestBackForwardNavigation(BaseNavigationTestCase):
@ -801,7 +823,7 @@ class TestPageLoadStrategy(BaseNavigationTestCase):
@skip("Bug 1422741 - Causes following tests to fail in loading remote browser")
@run_if_e10s("Requires e10s mode enabled")
def test_strategy_after_remoteness_change(self):
"""Bug 1378191 - Reset of capabilities after listener reload."""
"""Bug 1378191 - Reset of capabilities after listener reload"""
self.marionette.delete_session()
self.marionette.start_session({"pageLoadStrategy": "eager"})

8
testing/marionette/harness/marionette_harness/tests/unit/test_screenshot.py
View File

@ -253,8 +253,7 @@ class TestScreenCaptureChrome(WindowManagerMixin, ScreenCaptureTestCase):
chrome_document_element = self.document_element
with self.marionette.using_context('content'):
self.assertRaisesRegexp(NoSuchElementException,
"Web element reference not seen before",
self.assertRaisesRegexp(NoSuchElementException, "Web element reference not seen before",
self.marionette.screenshot,
highlights=[chrome_document_element])
@ -275,9 +274,10 @@ class TestScreenCaptureContent(WindowManagerMixin, ScreenCaptureTestCase):
return [document.body.scrollWidth, document.body.scrollHeight]
"""))
@skip_if_mobile("Needs application independent method to open a new tab")
def test_capture_tab_already_closed(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
tab = self.open_tab()
self.marionette.switch_to_window(tab)
self.marionette.close()
self.assertRaises(NoSuchWindowException, self.marionette.screenshot)

76
testing/marionette/harness/marionette_harness/tests/unit/test_switch_window_chrome.py
View File

@ -6,9 +6,10 @@ from __future__ import absolute_import
import os
import sys
from unittest import skipIf
from marionette_driver import By
# add this directory to the path
sys.path.append(os.path.dirname(__file__))
@ -27,70 +28,119 @@ class TestSwitchWindowChrome(TestSwitchToWindowContent):
super(TestSwitchWindowChrome, self).tearDown()
@skipIf(sys.platform.startswith("linux"),
"Bug 1511970 - New window isn't moved to the background on Linux")
def open_window_in_background(self):
with self.marionette.using_context("chrome"):
self.marionette.execute_async_script("""
let callback = arguments[0];
(async function() {
function promiseEvent(target, type, args) {
return new Promise(r => {
let params = Object.assign({once: true}, args);
target.addEventListener(type, r, params);
});
}
function promiseWindowFocus(w) {
return Promise.all([
promiseEvent(w, "focus", {capture: true}),
promiseEvent(w, "activate"),
]);
}
// Open a window, wait for it to receive focus
let win = OpenBrowserWindow();
await promiseWindowFocus(win);
// Now refocus our original window and wait for that to happen.
let windowFocusPromise = promiseWindowFocus(window);
window.focus();
return windowFocusPromise;
})().then(() => {
// can't just pass `callback`, as we can't JSON-ify the events it'd get passed.
callback()
});
""")
def open_window_in_foreground(self):
with self.marionette.using_context("content"):
self.marionette.navigate(self.test_page)
link = self.marionette.find_element(By.ID, "new-window")
link.click()
def test_switch_tabs_for_new_background_window_without_focus_change(self):
# Open an additional tab in the original window so we can better check
# Open an addition tab in the original window so we can better check
# the selected index in thew new window to be opened.
second_tab = self.open_tab(focus=True)
second_tab = self.open_tab(trigger=self.open_tab_in_foreground)
self.marionette.switch_to_window(second_tab, focus=True)
second_tab_index = self.get_selected_tab_index()
self.assertNotEqual(second_tab_index, self.selected_tab_index)
# Open a new background window, but we are interested in the tab
with self.marionette.using_context("content"):
tab_in_new_window = self.open_window()
# Opens a new background window, but we are interested in the tab
tab_in_new_window = self.open_tab(trigger=self.open_window_in_background)
self.assertEqual(self.marionette.current_window_handle, second_tab)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.empty_page)
# Switch to the tab in the new window but don't focus it
self.marionette.switch_to_window(tab_in_new_window, focus=False)
self.assertEqual(self.marionette.current_window_handle, tab_in_new_window)
self.assertNotEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), "about:blank")
def test_switch_tabs_for_new_foreground_window_with_focus_change(self):
# Open an addition tab in the original window so we can better check
# the selected index in thew new window to be opened.
second_tab = self.open_tab()
second_tab = self.open_tab(trigger=self.open_tab_in_foreground)
self.marionette.switch_to_window(second_tab, focus=True)
second_tab_index = self.get_selected_tab_index()
self.assertNotEqual(second_tab_index, self.selected_tab_index)
# Opens a new window, but we are interested in the tab
with self.marionette.using_context("content"):
tab_in_new_window = self.open_window(focus=True)
tab_in_new_window = self.open_tab(trigger=self.open_window_in_foreground)
self.assertEqual(self.marionette.current_window_handle, second_tab)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertNotEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
self.marionette.switch_to_window(tab_in_new_window)
self.assertEqual(self.marionette.current_window_handle, tab_in_new_window)
self.assertNotEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertNotEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.empty_page)
self.marionette.switch_to_window(second_tab, focus=True)
self.assertEqual(self.marionette.current_window_handle, second_tab)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
# Bug 1335085 - The focus doesn't change even as requested so.
# self.assertEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_switch_tabs_for_new_foreground_window_without_focus_change(self):
# Open an addition tab in the original window so we can better check
# the selected index in thew new window to be opened.
second_tab = self.open_tab()
second_tab = self.open_tab(trigger=self.open_tab_in_foreground)
self.marionette.switch_to_window(second_tab, focus=True)
second_tab_index = self.get_selected_tab_index()
self.assertNotEqual(second_tab_index, self.selected_tab_index)
self.open_window(focus=True)
# Opens a new window, but we are interested in the tab which automatically
# gets the focus.
self.open_tab(trigger=self.open_window_in_foreground)
self.assertEqual(self.marionette.current_window_handle, second_tab)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertNotEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
# Switch to the second tab in the first window, but don't focus it.
self.marionette.switch_to_window(second_tab, focus=False)
self.assertEqual(self.marionette.current_window_handle, second_tab)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.assertNotEqual(self.get_selected_tab_index(), second_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)

82
testing/marionette/harness/marionette_harness/tests/unit/test_switch_window_content.py
View File

@ -4,10 +4,10 @@
from __future__ import absolute_import
from marionette_driver import By
from marionette_driver import Actions, By, Wait
from marionette_driver.keys import Keys
from marionette_harness import MarionetteTestCase, WindowManagerMixin
from marionette_harness import MarionetteTestCase, skip_if_mobile, WindowManagerMixin
class TestSwitchToWindowContent(WindowManagerMixin, MarionetteTestCase):
@ -20,8 +20,14 @@ class TestSwitchToWindowContent(WindowManagerMixin, MarionetteTestCase):
else:
self.mod_key = Keys.CONTROL
self.empty_page = self.marionette.absolute_url("empty.html")
self.test_page = self.marionette.absolute_url("windowHandles.html")
self.selected_tab_index = self.get_selected_tab_index()
with self.marionette.using_context("content"):
self.marionette.navigate(self.test_page)
def tearDown(self):
self.close_all_tabs()
@ -63,51 +69,78 @@ class TestSwitchToWindowContent(WindowManagerMixin, MarionetteTestCase):
}
""")
def open_tab_in_background(self):
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-tab")
action = Actions(self.marionette)
action.key_down(self.mod_key).click(link).perform()
def open_tab_in_foreground(self):
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
def test_switch_tabs_with_focus_change(self):
new_tab = self.open_tab(focus=True)
new_tab = self.open_tab(self.open_tab_in_foreground)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertNotEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
# Switch to new tab first because it is already selected
self.marionette.switch_to_window(new_tab)
self.assertEqual(self.marionette.current_window_handle, new_tab)
self.assertNotEqual(self.get_selected_tab_index(), self.selected_tab_index)
# Switch to original tab by explicitely setting the focus
with self.marionette.using_context("content"):
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda _: self.marionette.get_url() == self.empty_page,
message="{} has been loaded in the newly opened tab.".format(self.empty_page))
self.marionette.switch_to_window(self.start_tab, focus=True)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
self.marionette.switch_to_window(new_tab)
self.marionette.close()
self.marionette.switch_to_window(self.start_tab)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_switch_tabs_without_focus_change(self):
new_tab = self.open_tab(focus=True)
new_tab = self.open_tab(self.open_tab_in_foreground)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertNotEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
# Switch to new tab first because it is already selected
self.marionette.switch_to_window(new_tab)
self.assertEqual(self.marionette.current_window_handle, new_tab)
# Switch to original tab by explicitely not setting the focus
self.marionette.switch_to_window(self.start_tab, focus=False)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertNotEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
self.marionette.switch_to_window(new_tab)
self.marionette.close()
self.marionette.switch_to_window(self.start_tab)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertEqual(self.get_selected_tab_index(), self.selected_tab_index)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_switch_from_content_to_chrome_window_should_not_change_selected_tab(self):
new_tab = self.open_tab(focus=True)
new_tab = self.open_tab(self.open_tab_in_foreground)
self.marionette.switch_to_window(new_tab)
self.assertEqual(self.marionette.current_window_handle, new_tab)
@ -117,31 +150,24 @@ class TestSwitchToWindowContent(WindowManagerMixin, MarionetteTestCase):
self.assertEqual(self.marionette.current_window_handle, new_tab)
self.assertEqual(self.get_selected_tab_index(), new_tab_index)
def test_switch_to_new_private_browsing_tab(self):
@skip_if_mobile("New windows not supported in Fennec")
def test_switch_to_new_private_browsing_window_has_to_register_browsers(self):
# Test that tabs (browsers) are correctly registered for a newly opened
# private browsing window/tab. This has to also happen without explicitely
# private browsing window. This has to also happen without explicitely
# switching to the tab itself before using any commands in content scope.
#
# Note: Not sure why this only affects private browsing windows only.
new_tab = self.open_tab(focus=True)
self.marionette.switch_to_window(new_tab)
def open_private_browsing_window_firefox():
def open_private_browsing_window():
with self.marionette.using_context("content"):
self.marionette.find_element(By.ID, "startPrivateBrowsing").click()
self.marionette.navigate("about:privatebrowsing")
button = self.marionette.find_element(By.ID, "startPrivateBrowsing")
button.click()
def open_private_browsing_tab_fennec():
with self.marionette.using_context("content"):
self.marionette.find_element(By.ID, "newPrivateTabLink").click()
new_window = self.open_window(open_private_browsing_window)
self.marionette.switch_to_window(new_window)
self.assertEqual(self.marionette.current_chrome_window_handle, new_window)
self.assertNotEqual(self.marionette.current_window_handle, self.start_tab)
with self.marionette.using_context("content"):
self.marionette.navigate("about:privatebrowsing")
if self.marionette.session_capabilities["browserName"] == "fennec":
new_pb_tab = self.open_tab(open_private_browsing_tab_fennec)
else:
new_pb_tab = self.open_tab(open_private_browsing_window_firefox)
self.marionette.switch_to_window(new_pb_tab)
self.assertEqual(self.marionette.current_window_handle, new_pb_tab)
self.marionette.execute_script(" return true; ")
self.marionette.execute_script(" return true; ")

22
testing/marionette/harness/marionette_harness/tests/unit/test_window_close_chrome.py
View File

@ -21,14 +21,14 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
super(TestCloseWindow, self).tearDown()
def test_close_chrome_window_for_browser_window(self):
new_window = self.open_window()
self.marionette.switch_to_window(new_window)
win = self.open_window()
self.marionette.switch_to_window(win)
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertNotIn(win, self.marionette.window_handles)
chrome_window_handles = self.marionette.close_chrome_window()
self.assertNotIn(new_window, chrome_window_handles)
self.assertNotIn(win, chrome_window_handles)
self.assertListEqual(self.start_windows, chrome_window_handles)
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertNotIn(win, self.marionette.window_handles)
def test_close_chrome_window_for_non_browser_window(self):
win = self.open_chrome_window("chrome://marionette/content/test.xul")
@ -50,20 +50,20 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
self.assertIsNotNone(self.marionette.session)
def test_close_window_for_browser_tab(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
tab = self.open_tab()
self.marionette.switch_to_window(tab)
window_handles = self.marionette.close()
self.assertNotIn(new_tab, window_handles)
self.assertNotIn(tab, window_handles)
self.assertListEqual(self.start_tabs, window_handles)
def test_close_window_for_browser_window_with_single_tab(self):
new_window = self.open_window()
self.marionette.switch_to_window(new_window)
win = self.open_window()
self.marionette.switch_to_window(win)
self.assertEqual(len(self.start_tabs) + 1, len(self.marionette.window_handles))
window_handles = self.marionette.close()
self.assertNotIn(new_window, window_handles)
self.assertNotIn(win, window_handles)
self.assertListEqual(self.start_tabs, window_handles)
self.assertListEqual(self.start_windows, self.marionette.chrome_window_handles)

47
testing/marionette/harness/marionette_harness/tests/unit/test_window_close_content.py
View File

@ -24,27 +24,26 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
@skip_if_mobile("Interacting with chrome windows not available for Fennec")
def test_close_chrome_window_for_browser_window(self):
with self.marionette.using_context("chrome"):
new_window = self.open_window()
self.marionette.switch_to_window(new_window)
win = self.open_window()
self.marionette.switch_to_window(win)
self.assertIn(new_window, self.marionette.chrome_window_handles)
self.assertNotIn(win, self.marionette.window_handles)
chrome_window_handles = self.marionette.close_chrome_window()
self.assertNotIn(new_window, chrome_window_handles)
self.assertNotIn(win, chrome_window_handles)
self.assertListEqual(self.start_windows, chrome_window_handles)
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertNotIn(win, self.marionette.window_handles)
@skip_if_mobile("Interacting with chrome windows not available for Fennec")
def test_close_chrome_window_for_non_browser_window(self):
new_window = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(new_window)
win = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(win)
self.assertIn(new_window, self.marionette.chrome_window_handles)
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertIn(win, self.marionette.chrome_window_handles)
self.assertNotIn(win, self.marionette.window_handles)
chrome_window_handles = self.marionette.close_chrome_window()
self.assertNotIn(new_window, chrome_window_handles)
self.assertNotIn(win, chrome_window_handles)
self.assertListEqual(self.start_windows, chrome_window_handles)
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertNotIn(win, self.marionette.window_handles)
@skip_if_mobile("Interacting with chrome windows not available for Fennec")
def test_close_chrome_window_for_last_open_window(self):
@ -55,17 +54,19 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
self.assertListEqual([self.start_window], self.marionette.chrome_window_handles)
self.assertIsNotNone(self.marionette.session)
@skip_if_mobile("Needs application independent method to open a new tab")
def test_close_window_for_browser_tab(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
tab = self.open_tab()
self.marionette.switch_to_window(tab)
window_handles = self.marionette.close()
self.assertNotIn(new_tab, window_handles)
self.assertNotIn(tab, window_handles)
self.assertListEqual(self.start_tabs, window_handles)
@skip_if_mobile("Needs application independent method to open a new tab")
def test_close_window_with_dismissed_beforeunload_prompt(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
tab = self.open_tab()
self.marionette.switch_to_window(tab)
self.marionette.navigate(inline("""
<input type="text">
@ -81,12 +82,12 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
@skip_if_mobile("Interacting with chrome windows not available for Fennec")
def test_close_window_for_browser_window_with_single_tab(self):
new_tab = self.open_window()
self.marionette.switch_to_window(new_tab)
win = self.open_window()
self.marionette.switch_to_window(win)
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(len(self.start_tabs) + 1, len(self.marionette.window_handles))
window_handles = self.marionette.close()
self.assertNotIn(new_tab, window_handles)
self.assertNotIn(win, window_handles)
self.assertListEqual(self.start_tabs, window_handles)
self.assertListEqual(self.start_windows, self.marionette.chrome_window_handles)
@ -103,8 +104,8 @@ class TestCloseWindow(WindowManagerMixin, MarionetteTestCase):
self.close_all_tabs()
test_page = self.marionette.absolute_url("windowHandles.html")
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
tab = self.open_tab()
self.marionette.switch_to_window(tab)
self.marionette.navigate(test_page)
self.marionette.switch_to_window(self.start_tab)

220
testing/marionette/harness/marionette_harness/tests/unit/test_window_handles_chrome.py
View File

@ -6,7 +6,7 @@ from __future__ import absolute_import
import types
from marionette_driver import errors
from marionette_driver import By, errors, Wait
from marionette_harness import MarionetteTestCase, WindowManagerMixin
@ -16,7 +16,9 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
def setUp(self):
super(TestWindowHandles, self).setUp()
self.xul_dialog = "chrome://marionette/content/test_dialog.xul"
self.empty_page = self.marionette.absolute_url("empty.html")
self.test_page = self.marionette.absolute_url("windowHandles.html")
self.marionette.navigate(self.test_page)
self.marionette.set_context("chrome")
@ -40,16 +42,17 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.assertIsInstance(handle, types.StringTypes)
def test_chrome_window_handles_with_scopes(self):
new_browser = self.open_window()
# Open a browser and a non-browser (about window) chrome window
self.open_window(
trigger=lambda: self.marionette.execute_script("OpenBrowserWindow();"))
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows) + 1)
self.assertIn(new_browser, self.marionette.chrome_window_handles)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
new_dialog = self.open_chrome_window(self.xul_dialog)
self.open_window(
trigger=lambda: self.marionette.find_element(By.ID, "aboutName").click())
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows) + 2)
self.assertIn(new_dialog, self.marionette.chrome_window_handles)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
chrome_window_handles_in_chrome_scope = self.marionette.chrome_window_handles
@ -61,112 +64,117 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.assertEqual(self.marionette.window_handles,
window_handles_in_chrome_scope)
def test_chrome_window_handles_after_opening_new_chrome_window(self):
new_window = self.open_chrome_window(self.xul_dialog)
def test_chrome_window_handles_after_opening_new_dialog(self):
xul_dialog = "chrome://marionette/content/test_dialog.xul"
new_win = self.open_chrome_window(xul_dialog)
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows) + 1)
self.assertIn(new_window, self.marionette.chrome_window_handles)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
# Check that the new chrome window has the correct URL loaded
self.marionette.switch_to_window(new_window)
# Check that the new tab has the correct page loaded
self.marionette.switch_to_window(new_win)
self.assert_window_handles()
self.assertEqual(self.marionette.current_chrome_window_handle, new_window)
self.assertEqual(self.marionette.get_url(), self.xul_dialog)
self.assertEqual(self.marionette.current_chrome_window_handle, new_win)
self.assertEqual(self.marionette.get_url(), xul_dialog)
# Close the chrome window, and carry on in our original window.
# Close the opened dialog and carry on in our original tab.
self.marionette.close_chrome_window()
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows))
self.assertNotIn(new_window, self.marionette.chrome_window_handles)
self.marionette.switch_to_window(self.start_window)
self.assert_window_handles()
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_chrome_window_handles_after_opening_new_window(self):
new_window = self.open_window()
def open_with_link():
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-window")
link.click()
# We open a new window but are actually interested in the new tab
new_win = self.open_window(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows) + 1)
self.assertIn(new_window, self.marionette.chrome_window_handles)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.marionette.switch_to_window(new_window)
# Check that the new tab has the correct page loaded
self.marionette.switch_to_window(new_win)
self.assert_window_handles()
self.assertEqual(self.marionette.current_chrome_window_handle, new_window)
self.assertEqual(self.marionette.current_chrome_window_handle, new_win)
with self.marionette.using_context("content"):
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.empty_page,
message="{} did not load after opening a new tab".format(self.empty_page))
# Close the opened window and carry on in our original window.
# Ensure navigate works in our current window
other_page = self.marionette.absolute_url("test.html")
with self.marionette.using_context("content"):
self.marionette.navigate(other_page)
self.assertEqual(self.marionette.get_url(), other_page)
# Close the opened window and carry on in our original tab.
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows))
self.assertNotIn(new_window, self.marionette.chrome_window_handles)
self.marionette.switch_to_window(self.start_window)
self.assert_window_handles()
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_window_handles_after_opening_new_tab(self):
with self.marionette.using_context("content"):
new_tab = self.open_tab()
def open_with_link():
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertIn(new_tab, self.marionette.window_handles)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
with self.marionette.using_context("content"):
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.empty_page,
message="{} did not load after opening a new tab".format(self.empty_page))
# Ensure navigate works in our current tab
other_page = self.marionette.absolute_url("test.html")
with self.marionette.using_context("content"):
self.marionette.navigate(other_page)
self.assertEqual(self.marionette.get_url(), other_page)
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
self.marionette.switch_to_window(new_tab)
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertNotIn(new_tab, self.marionette.window_handles)
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def test_window_handles_after_opening_new_foreground_tab(self):
with self.marionette.using_context("content"):
new_tab = self.open_tab(focus=True)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertIn(new_tab, self.marionette.window_handles)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
# We still have the default tab set as our window handle. This
# get_url command should be sent immediately, and not be forever-queued.
with self.marionette.using_context("content"):
self.marionette.get_url()
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
self.marionette.close()
def test_window_handles_after_opening_new_dialog(self):
xul_dialog = "chrome://marionette/content/test_dialog.xul"
new_win = self.open_chrome_window(xul_dialog)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertNotIn(new_tab, self.marionette.window_handles)
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def test_window_handles_after_opening_new_chrome_window(self):
new_window = self.open_chrome_window(self.xul_dialog)
self.marionette.switch_to_window(new_win)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertNotIn(new_window, self.marionette.window_handles)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.marionette.switch_to_window(new_window)
self.assert_window_handles()
self.assertEqual(self.marionette.get_url(), self.xul_dialog)
self.assertEqual(self.marionette.get_url(), xul_dialog)
# Check that the opened dialog is not accessible via window handles
with self.assertRaises(errors.NoSuchWindowException):
@ -182,24 +190,112 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def test_window_handles_after_closing_original_tab(self):
with self.marionette.using_context("content"):
new_tab = self.open_tab()
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_window_handles_after_opening_new_window(self):
def open_with_link():
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-window")
link.click()
# We open a new window but are actually interested in the new tab
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
# Check that the new tab has the correct page loaded
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
with self.marionette.using_context("content"):
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.empty_page,
message="{} did not load after opening a new tab".format(self.empty_page))
# Ensure navigate works in our current window
other_page = self.marionette.absolute_url("test.html")
with self.marionette.using_context("content"):
self.marionette.navigate(other_page)
self.assertEqual(self.marionette.get_url(), other_page)
# Close the opened window and carry on in our original tab.
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
def test_window_handles_after_closing_original_tab(self):
def open_with_link():
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertIn(new_tab, self.marionette.window_handles)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertIn(new_tab, self.marionette.window_handles)
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
with self.marionette.using_context("content"):
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.empty_page,
message="{} did not load after opening a new tab".format(self.empty_page))
def test_window_handles_no_switch(self):
"""Regression test for bug 1294456.
This test is testing the case where Marionette attempts to send a
command to a window handle when the browser has opened and selected
a new tab. Before bug 1294456 landed, the Marionette driver was getting
confused about which window handle the client cared about, and assumed
it was the window handle for the newly opened and selected tab.
This caused Marionette to think that the browser needed to do a remoteness
flip in the e10s case, since the tab opened by menu_newNavigatorTab is
about:newtab (which is currently non-remote). This meant that commands
sent to what should have been the original window handle would be
queued and never sent, since the remoteness flip in the new tab was
never going to happen.
"""
def open_with_menu():
menu_new_tab = self.marionette.find_element(By.ID, 'menu_newNavigatorTab')
menu_new_tab.click()
new_tab = self.open_tab(trigger=open_with_menu)
self.assert_window_handles()
# We still have the default tab set as our window handle. This
# get_url command should be sent immediately, and not be forever-queued.
with self.marionette.using_context("content"):
self.assertEqual(self.marionette.get_url(), self.test_page)
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def test_window_handles_after_closing_last_window(self):
self.close_all_windows()
self.assertEqual(self.marionette.close_chrome_window(), [])

72
testing/marionette/harness/marionette_harness/tests/unit/test_window_handles_content.py
View File

@ -7,7 +7,7 @@ from __future__ import absolute_import
import types
import urllib
from marionette_driver import errors
from marionette_driver import By, errors, Wait
from marionette_harness import MarionetteTestCase, skip_if_mobile, WindowManagerMixin
@ -21,7 +21,9 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
def setUp(self):
super(TestWindowHandles, self).setUp()
self.xul_dialog = "chrome://marionette/content/test_dialog.xul"
self.empty_page = self.marionette.absolute_url("empty.html")
self.test_page = self.marionette.absolute_url("windowHandles.html")
self.marionette.navigate(self.test_page)
def tearDown(self):
self.close_all_tabs()
@ -37,8 +39,12 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
for handle in self.marionette.window_handles:
self.assertIsInstance(handle, types.StringTypes)
def tst_window_handles_after_opening_new_tab(self):
new_tab = self.open_tab()
def test_window_handles_after_opening_new_tab(self):
def open_with_link():
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
@ -46,9 +52,13 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
lambda mn: mn.get_url() == self.empty_page,
message="{} did not load after opening a new tab".format(self.empty_page))
self.marionette.switch_to_window(self.start_tab)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertEqual(self.marionette.get_url(), self.test_page)
self.marionette.switch_to_window(new_tab)
self.marionette.close()
@ -59,15 +69,29 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def tst_window_handles_after_opening_new_browser_window(self):
new_tab = self.open_window()
def test_window_handles_after_opening_new_browser_window(self):
def open_with_link():
link = self.marionette.find_element(By.ID, "new-window")
link.click()
# We open a new window but are actually interested in the new tab
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
# Check that the new tab has the correct page loaded
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
Wait(self.marionette, self.marionette.timeout.page_load).until(
lambda _: self.marionette.get_url() == self.empty_page,
message="The expected page '{}' has not been loaded".format(self.empty_page))
# Ensure navigate works in our current window
other_page = self.marionette.absolute_url("test.html")
self.marionette.navigate(other_page)
self.assertEqual(self.marionette.get_url(), other_page)
# Close the opened window and carry on in our original tab.
self.marionette.close()
@ -77,16 +101,31 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertEqual(self.marionette.get_url(), self.test_page)
@skip_if_mobile("Fennec doesn't support other chrome windows")
def tst_window_handles_after_opening_new_non_browser_window(self):
new_window = self.open_chrome_window(self.xul_dialog)
def test_window_handles_after_opening_new_non_browser_window(self):
def open_with_link():
self.marionette.navigate(inline("""
<a id="blob-download" download="foo.html">Download</a>
<script>
const string = "test";
const blob = new Blob([string], { type: "text/html" });
const link = document.getElementById("blob-download");
link.href = URL.createObjectURL(blob);
</script>
"""))
link = self.marionette.find_element(By.ID, "blob-download")
link.click()
new_win = self.open_window(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertNotIn(new_window, self.marionette.window_handles)
self.marionette.switch_to_window(new_window)
self.marionette.switch_to_window(new_win)
self.assert_window_handles()
# Check that the opened window is not accessible via window handles
@ -105,21 +144,26 @@ class TestWindowHandles(WindowManagerMixin, MarionetteTestCase):
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
def test_window_handles_after_closing_original_tab(self):
new_tab = self.open_tab()
def open_with_link():
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
new_tab = self.open_tab(trigger=open_with_link)
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs) + 1)
self.assertEqual(self.marionette.current_window_handle, self.start_tab)
self.assertIn(new_tab, self.marionette.window_handles)
self.marionette.close()
self.assert_window_handles()
self.assertEqual(len(self.marionette.window_handles), len(self.start_tabs))
self.assertNotIn(self.start_tab, self.marionette.window_handles)
self.marionette.switch_to_window(new_tab)
self.assert_window_handles()
self.assertEqual(self.marionette.current_window_handle, new_tab)
Wait(self.marionette, self.marionette.timeout.page_load).until(
lambda _: self.marionette.get_url() == self.empty_page,
message="The expected page '{}' has not been loaded".format(self.empty_page))
def tst_window_handles_after_closing_last_tab(self):
def test_window_handles_after_closing_last_tab(self):
self.close_all_tabs()
self.assertEqual(self.marionette.close(), [])

86
testing/marionette/harness/marionette_harness/tests/unit/test_window_management.py
View File

@ -21,9 +21,15 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
@skip_if_mobile("Fennec doesn't support other chrome windows")
def test_closed_chrome_window(self):
with self.marionette.using_context("chrome"):
new_window = self.open_window()
self.marionette.switch_to_window(new_window)
def open_with_link():
with self.marionette.using_context("content"):
test_page = self.marionette.absolute_url("windowHandles.html")
self.marionette.navigate(test_page)
self.marionette.find_element(By.ID, "new-window").click()
win = self.open_window(open_with_link)
self.marionette.switch_to_window(win)
self.marionette.close_chrome_window()
# When closing a browser window both handles are not available
@ -37,12 +43,12 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_window)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_window)
self.marionette.switch_to_window(win)
@skip_if_mobile("Fennec doesn't support other chrome windows")
def test_closed_chrome_window_while_in_frame(self):
new_window = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(new_window)
win = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(win)
with self.marionette.using_context("chrome"):
self.marionette.switch_to_frame("iframe")
self.marionette.close_chrome_window()
@ -55,12 +61,13 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_window)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_window)
self.marionette.switch_to_window(win)
def test_closed_tab(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
self.marionette.close()
with self.marionette.using_context("content"):
tab = self.open_tab()
self.marionette.switch_to_window(tab)
self.marionette.close()
# Check that only the content window is not available in both contexts
for context in ("chrome", "content"):
@ -72,26 +79,25 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_tab)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_tab)
self.marionette.switch_to_window(tab)
def test_closed_tab_while_in_frame(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
with self.marionette.using_context("content"):
tab = self.open_tab()
self.marionette.switch_to_window(tab)
self.marionette.navigate(self.marionette.absolute_url("test_iframe.html"))
frame = self.marionette.find_element(By.ID, "test_iframe")
self.marionette.switch_to_frame(frame)
self.marionette.close()
self.marionette.close()
with self.assertRaises(NoSuchWindowException):
self.marionette.current_window_handle
self.marionette.current_chrome_window_handle
with self.assertRaises(NoSuchWindowException):
self.marionette.current_window_handle
self.marionette.current_chrome_window_handle
self.marionette.switch_to_window(self.start_tab)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_tab)
self.marionette.switch_to_window(tab)
class TestNoSuchWindowChrome(TestNoSuchWindowContent):
@ -115,22 +121,42 @@ class TestSwitchWindow(WindowManagerMixin, MarionetteTestCase):
self.close_all_windows()
super(TestSwitchWindow, self).tearDown()
def test_switch_window_after_open_and_close(self):
with self.marionette.using_context("chrome"):
new_window = self.open_window()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows) + 1)
self.assertIn(new_window, self.marionette.chrome_window_handles)
def test_windows(self):
def open_browser_with_js():
self.marionette.execute_script(" window.open(); ")
new_window = self.open_window(trigger=open_browser_with_js)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
# switch to the new chrome window and close it
# switch to the other window
self.marionette.switch_to_window(new_window)
self.assertEqual(self.marionette.current_chrome_window_handle, new_window)
self.assertNotEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.marionette.close_chrome_window()
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows))
self.assertNotIn(new_window, self.marionette.chrome_window_handles)
# switch back to the original chrome window
# switch back and close original window
self.marionette.switch_to_window(self.start_window)
self.assertEqual(self.marionette.current_chrome_window_handle, self.start_window)
self.marionette.close_chrome_window()
self.assertNotIn(self.start_window, self.marionette.chrome_window_handles)
self.assertEqual(len(self.marionette.chrome_window_handles), len(self.start_windows))
def test_should_load_and_close_a_window(self):
def open_window_with_link():
test_html = self.marionette.absolute_url("test_windows.html")
with self.marionette.using_context("content"):
self.marionette.navigate(test_html)
self.marionette.find_element(By.LINK_TEXT, "Open new window").click()
new_window = self.open_window(trigger=open_window_with_link)
self.marionette.switch_to_window(new_window)
self.assertEqual(self.marionette.current_chrome_window_handle, new_window)
self.assertEqual(len(self.marionette.chrome_window_handles), 2)
with self.marionette.using_context('content'):
self.assertEqual(self.marionette.title, "We Arrive Here")
# Let's close and check
self.marionette.close_chrome_window()
self.marionette.switch_to_window(self.start_window)
self.assertEqual(len(self.marionette.chrome_window_handles), 1)

55
testing/marionette/harness/marionette_harness/tests/unit/test_window_status_content.py
View File

@ -15,15 +15,30 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
def setUp(self):
super(TestNoSuchWindowContent, self).setUp()
self.test_page = self.marionette.absolute_url("windowHandles.html")
with self.marionette.using_context("content"):
self.marionette.navigate(self.test_page)
def tearDown(self):
self.close_all_windows()
super(TestNoSuchWindowContent, self).tearDown()
def open_tab_in_foreground(self):
with self.marionette.using_context("content"):
link = self.marionette.find_element(By.ID, "new-tab")
link.click()
@skip_if_mobile("Fennec doesn't support other chrome windows")
def test_closed_chrome_window(self):
with self.marionette.using_context("chrome"):
new_window = self.open_window()
self.marionette.switch_to_window(new_window)
def open_with_link():
with self.marionette.using_context("content"):
test_page = self.marionette.absolute_url("windowHandles.html")
self.marionette.navigate(test_page)
self.marionette.find_element(By.ID, "new-window").click()
win = self.open_window(open_with_link)
self.marionette.switch_to_window(win)
self.marionette.close_chrome_window()
# When closing a browser window both handles are not available
@ -37,13 +52,12 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_window)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_window)
self.marionette.switch_to_window(win)
@skip_if_mobile("Fennec doesn't support other chrome windows")
def test_closed_chrome_window_while_in_frame(self):
new_window = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(new_window)
win = self.open_chrome_window("chrome://marionette/content/test.xul")
self.marionette.switch_to_window(win)
with self.marionette.using_context("chrome"):
self.marionette.switch_to_frame("iframe")
self.marionette.close_chrome_window()
@ -56,12 +70,13 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_window)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_window)
self.marionette.switch_to_window(win)
def test_closed_tab(self):
new_tab = self.open_tab(focus=True)
self.marionette.switch_to_window(new_tab)
self.marionette.close()
with self.marionette.using_context("content"):
tab = self.open_tab(self.open_tab_in_foreground)
self.marionette.switch_to_window(tab)
self.marionette.close()
# Check that only the content window is not available in both contexts
for context in ("chrome", "content"):
@ -73,24 +88,22 @@ class TestNoSuchWindowContent(WindowManagerMixin, MarionetteTestCase):
self.marionette.switch_to_window(self.start_tab)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_tab)
self.marionette.switch_to_window(tab)
def test_closed_tab_while_in_frame(self):
new_tab = self.open_tab()
self.marionette.switch_to_window(new_tab)
with self.marionette.using_context("content"):
tab = self.open_tab(self.open_tab_in_foreground)
self.marionette.switch_to_window(tab)
self.marionette.navigate(self.marionette.absolute_url("test_iframe.html"))
frame = self.marionette.find_element(By.ID, "test_iframe")
self.marionette.switch_to_frame(frame)
self.marionette.close()
self.marionette.close()
with self.assertRaises(NoSuchWindowException):
self.marionette.current_window_handle
self.marionette.current_chrome_window_handle
with self.assertRaises(NoSuchWindowException):
self.marionette.current_window_handle
self.marionette.current_chrome_window_handle
self.marionette.switch_to_window(self.start_tab)
with self.assertRaises(NoSuchWindowException):
self.marionette.switch_to_window(new_tab)
self.marionette.switch_to_window(tab)

6
testing/marionette/proxy.js
View File

@ -15,7 +15,7 @@ ChromeUtils.import("chrome://marionette/content/evaluate.js");
const {Log} = ChromeUtils.import("chrome://marionette/content/log.js", {});
ChromeUtils.import("chrome://marionette/content/modal.js");
const {
waitForObserverTopic,
MessageManagerDestroyedPromise,
} = ChromeUtils.import("chrome://marionette/content/sync.js", {});
this.EXPORTED_SYMBOLS = ["proxy"];
@ -156,9 +156,7 @@ proxy.AsyncMessageChannel = class {
break;
}
await waitForObserverTopic("message-manager-disconnect",
subject => subject === messageManager);
await new MessageManagerDestroyedPromise(messageManager);
this.removeHandlers();
resolve();
};

3
testing/marionette/server.js
View File

@ -11,6 +11,7 @@ const ServerSocket = CC(
"nsIServerSocket",
"initSpecialConnection");
ChromeUtils.import("resource://gre/modules/Services.jsm");
ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
ChromeUtils.import("chrome://marionette/content/assert.js");
@ -73,7 +74,7 @@ class TCPListener {
*/
driverFactory() {
MarionettePrefs.contentListener = false;
return new GeckoDriver(this);
return new GeckoDriver(Services.appinfo.ID, this);
}
set acceptConnections(value) {

250
testing/marionette/sync.js
View File

@ -13,42 +13,23 @@ const {
stack,
TimeoutError,
} = ChromeUtils.import("chrome://marionette/content/error.js", {});
const {truncate} = ChromeUtils.import("chrome://marionette/content/format.js", {});
const {Log} = ChromeUtils.import("chrome://marionette/content/log.js", {});
XPCOMUtils.defineLazyGetter(this, "log", Log.get);
this.EXPORTED_SYMBOLS = [
"executeSoon",
"DebounceCallback",
"IdlePromise",
"MessageManagerDestroyedPromise",
"PollPromise",
"Sleep",
"TimedPromise",
"waitForEvent",
"waitForMessage",
"waitForObserverTopic",
];
const {TYPE_ONE_SHOT, TYPE_REPEATING_SLACK} = Ci.nsITimer;
const PROMISE_TIMEOUT = AppConstants.DEBUG ? 4500 : 1500;
/**
* Dispatch a function to be executed on the main thread.
*
* @param {function} func
* Function to be executed.
*/
function executeSoon(func) {
if (typeof func != "function") {
throw new TypeError();
}
Services.tm.dispatchToMainThread(func);
}
/**
* @callback Condition
*
@ -255,6 +236,46 @@ function Sleep(timeout) {
return new TimedPromise(() => {}, {timeout, throws: null});
}
/**
* Detects when the specified message manager has been destroyed.
*
* One can observe the removal and detachment of a content browser
* (`<xul:browser>`) or a chrome window by its message manager
* disconnecting.
*
* When a browser is associated with a tab, this is safer than only
* relying on the event `TabClose` which signalises the _intent to_
* remove a tab and consequently would lead to the destruction of
* the content browser and its browser message manager.
*
* When closing a chrome window it is safer than only relying on
* the event 'unload' which signalises the _intent to_ close the
* chrome window and consequently would lead to the destruction of
* the window and its window message manager.
*
* @param {MessageListenerManager} messageManager
* The message manager to observe for its disconnect state.
* Use the browser message manager when closing a content browser,
* and the window message manager when closing a chrome window.
*
* @return {Promise}
* A promise that resolves when the message manager has been destroyed.
*/
function MessageManagerDestroyedPromise(messageManager) {
return new Promise(resolve => {
function observe(subject, topic) {
log.trace(`Received observer notification ${topic}`);
if (subject == messageManager) {
Services.obs.removeObserver(this, "message-manager-disconnect");
resolve();
}
}
Services.obs.addObserver(observe, "message-manager-disconnect");
});
}
/**
* Throttle until the main thread is idle and `window` has performed
* an animation frame (in that order).
@ -330,192 +351,3 @@ class DebounceCallback {
}
}
this.DebounceCallback = DebounceCallback;
/**
* Wait for an event to be fired on a specified element.
*
* This method has been duplicated from BrowserTestUtils.jsm.
*
* Because this function is intended for testing, any error in checkFn
* will cause the returned promise to be rejected instead of waiting for
* the next event, since this is probably a bug in the test.
*
* Usage::
*
* let promiseEvent = waitForEvent(element, "eventName");
* // Do some processing here that will cause the event to be fired
* // ...
* // Now wait until the Promise is fulfilled
* let receivedEvent = await promiseEvent;
*
* The promise resolution/rejection handler for the returned promise is
* guaranteed not to be called until the next event tick after the event
* listener gets called, so that all other event listeners for the element
* are executed before the handler is executed::
*
* let promiseEvent = waitForEvent(element, "eventName");
* // Same event tick here.
* await promiseEvent;
* // Next event tick here.
*
* If some code, such like adding yet another event listener, needs to be
* executed in the same event tick, use raw addEventListener instead and
* place the code inside the event listener::
*
* element.addEventListener("load", () => {
* // Add yet another event listener in the same event tick as the load
* // event listener.
* p = waitForEvent(element, "ready");
* }, { once: true });
*
* @param {Element} subject
* The element that should receive the event.
* @param {string} eventName
* Name of the event to listen to.
* @param {Object=} options
* Extra options.
* @param {boolean=} options.capture
* True to use a capturing listener.
* @param {function(Event)=} options.checkFn
* Called with the ``Event`` object as argument, should return ``true``
* if the event is the expected one, or ``false`` if it should be
* ignored and listening should continue. If not specified, the first
* event with the specified name resolves the returned promise.
* @param {boolean=} options.wantsUntrusted
* True to receive synthetic events dispatched by web content.
*
* @return {Promise.<Event>}
* Promise which resolves to the received ``Event`` object, or rejects
* in case of a failure.
*/
function waitForEvent(subject, eventName,
{capture = false, checkFn = null, wantsUntrusted = false} = {}) {
if (subject == null || !("addEventListener" in subject)) {
throw new TypeError();
}
if (typeof eventName != "string") {
throw new TypeError();
}
if (capture != null && typeof capture != "boolean") {
throw new TypeError();
}
if (checkFn != null && typeof checkFn != "function") {
throw new TypeError();
}
if (wantsUntrusted != null && typeof wantsUntrusted != "boolean") {
throw new TypeError();
}
return new Promise((resolve, reject) => {
subject.addEventListener(eventName, function listener(event) {
log.trace(`Received DOM event ${event.type} for ${event.target}`);
try {
if (checkFn && !checkFn(event)) {
return;
}
subject.removeEventListener(eventName, listener, capture);
executeSoon(() => resolve(event));
} catch (ex) {
try {
subject.removeEventListener(eventName, listener, capture);
} catch (ex2) {
// Maybe the provided object does not support removeEventListener.
}
executeSoon(() => reject(ex));
}
}, capture, wantsUntrusted);
});
}
/**
* Wait for a message to be fired from a particular message manager.
*
* This method has been duplicated from BrowserTestUtils.jsm.
*
* @param {nsIMessageManager} messageManager
* The message manager that should be used.
* @param {string} messageName
* The message to wait for.
* @param {Object=} options
* Extra options.
* @param {function(Message)=} options.checkFn
* Called with the ``Message`` object as argument, should return ``true``
* if the message is the expected one, or ``false`` if it should be
* ignored and listening should continue. If not specified, the first
* message with the specified name resolves the returned promise.
*
* @return {Promise.<Object>}
* Promise which resolves to the data property of the received
* ``Message``.
*/
function waitForMessage(messageManager, messageName,
{checkFn = undefined} = {}) {
if (messageManager == null || !("addMessageListener" in messageManager)) {
throw new TypeError();
}
if (typeof messageName != "string") {
throw new TypeError();
}
if (checkFn && typeof checkFn != "function") {
throw new TypeError();
}
return new Promise(resolve => {
messageManager.addMessageListener(messageName, function onMessage(msg) {
log.trace(`Received ${messageName} for ${msg.target}`);
if (checkFn && !checkFn(msg)) {
return;
}
messageManager.removeMessageListener(messageName, onMessage);
resolve(msg.data);
});
});
}
/**
* Wait for the specified observer topic to be observed.
*
* This method has been duplicated from TestUtils.jsm.
*
* Because this function is intended for testing, any error in checkFn
* will cause the returned promise to be rejected instead of waiting for
* the next notification, since this is probably a bug in the test.
*
* @param {string} topic
* The topic to observe.
* @param {Object=} options
* Extra options.
* @param {function(String,Object)=} options.checkFn
* Called with ``subject``, and ``data`` as arguments, should return true
* if the notification is the expected one, or false if it should be
* ignored and listening should continue. If not specified, the first
* notification for the specified topic resolves the returned promise.
*
* @return {Promise.<Array<String, Object>>}
* Promise which resolves to an array of ``subject``, and ``data`` from
* the observed notification.
*/
function waitForObserverTopic(topic, {checkFn = null} = {}) {
if (typeof topic != "string") {
throw new TypeError();
}
if (checkFn != null && typeof checkFn != "function") {
throw new TypeError();
}
return new Promise((resolve, reject) => {
Services.obs.addObserver(function observer(subject, topic, data) {
log.trace(`Received observer notification ${topic}`);
try {
if (checkFn && !checkFn(subject, data)) {
return;
}
Services.obs.removeObserver(observer, topic);
resolve({subject, data});
} catch (ex) {
Services.obs.removeObserver(observer, topic);
reject(ex);
}
}, topic);
});
}

246
testing/marionette/test/unit/test_sync.js
View File

@ -2,93 +2,16 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
ChromeUtils.import("resource://gre/modules/Services.jsm");
const {
DebounceCallback,
IdlePromise,
PollPromise,
Sleep,
TimedPromise,
waitForEvent,
waitForMessage,
waitForObserverTopic,
} = ChromeUtils.import("chrome://marionette/content/sync.js", {});
const DEFAULT_TIMEOUT = 2000;
/**
* Mimic a DOM node for listening for events.
*/
class MockElement {
constructor() {
this.capture = false;
this.func = null;
this.eventName = null;
this.untrusted = false;
}
addEventListener(name, func, capture, untrusted) {
this.eventName = name;
this.func = func;
if (capture != null) {
this.capture = capture;
}
if (untrusted != null) {
this.untrusted = untrusted;
}
}
click() {
if (this.func) {
let details = {
capture: this.capture,
target: this,
type: this.eventName,
untrusted: this.untrusted,
};
this.func(details);
}
}
removeEventListener(name, func) {
this.capture = false;
this.func = null;
this.eventName = null;
this.untrusted = false;
}
}
/**
* Mimic a message manager for sending messages.
*/
class MessageManager {
constructor() {
this.func = null;
this.message = null;
}
addMessageListener(message, func) {
this.func = func;
this.message = message;
}
removeMessageListener(message) {
this.func = null;
this.message = null;
}
send(message, data) {
if (this.func) {
this.func({
data,
message,
target: this,
});
}
}
}
/**
* Mimics nsITimer, but instead of using a system clock you can
* preprogram it to invoke the callback after a given number of ticks.
@ -112,23 +35,6 @@ class MockTimer {
}
}
add_test(function test_executeSoon_callback() {
// executeSoon() is already defined for xpcshell in head.js. As such import
// our implementation into a custom namespace.
let sync = {};
ChromeUtils.import("chrome://marionette/content/sync.js", sync);
for (let func of ["foo", null, true, [], {}]) {
Assert.throws(() => sync.executeSoon(func), /TypeError/);
}
let a;
sync.executeSoon(() => { a = 1; });
executeSoon(() => equal(1, a));
run_next_test();
});
add_test(function test_PollPromise_funcTypes() {
for (let type of ["foo", 42, null, undefined, true, [], {}]) {
Assert.throws(() => new PollPromise(type), /TypeError/);
@ -307,155 +213,3 @@ add_task(async function test_DebounceCallback_repeatedCallback() {
equal(ncalls, 1);
ok(debouncer.timer.cancelled);
});
add_task(async function test_waitForEvent_subjectAndEventNameTypes() {
let element = new MockElement();
for (let subject of ["foo", 42, null, undefined, true, [], {}]) {
Assert.throws(() => waitForEvent(subject, "click"), /TypeError/);
}
for (let eventName of [42, null, undefined, true, [], {}]) {
Assert.throws(() => waitForEvent(element, eventName), /TypeError/);
}
let clicked = waitForEvent(element, "click");
element.click();
let event = await clicked;
equal(element, event.target);
});
add_task(async function test_waitForEvent_captureTypes() {
let element = new MockElement();
for (let capture of ["foo", 42, [], {}]) {
Assert.throws(() => waitForEvent(
element, "click", {capture}), /TypeError/);
}
for (let capture of [null, undefined, false, true]) {
let expected_capture = (capture == null) ? false : capture;
element = new MockElement();
let clicked = waitForEvent(element, "click", {capture});
element.click();
let event = await clicked;
equal(element, event.target);
equal(expected_capture, event.capture);
}
});
add_task(async function test_waitForEvent_checkFnTypes() {
let element = new MockElement();
for (let checkFn of ["foo", 42, true, [], {}]) {
Assert.throws(() => waitForEvent(
element, "click", {checkFn}), /TypeError/);
}
let count;
for (let checkFn of [null, undefined, event => count++ > 0]) {
let expected_count = (checkFn == null) ? 0 : 2;
count = 0;
element = new MockElement();
let clicked = waitForEvent(element, "click", {checkFn});
element.click();
element.click();
let event = await clicked;
equal(element, event.target);
equal(expected_count, count);
}
});
add_task(async function test_waitForEvent_wantsUntrustedTypes() {
let element = new MockElement();
for (let wantsUntrusted of ["foo", 42, [], {}]) {
Assert.throws(() => waitForEvent(
element, "click", {wantsUntrusted}), /TypeError/);
}
for (let wantsUntrusted of [null, undefined, false, true]) {
let expected_untrusted = (wantsUntrusted == null) ? false : wantsUntrusted;
element = new MockElement();
let clicked = waitForEvent(element, "click", {wantsUntrusted});
element.click();
let event = await clicked;
equal(element, event.target);
equal(expected_untrusted, event.untrusted);
}
});
add_task(async function test_waitForMessage_messageManagerAndMessageTypes() {
let messageManager = new MessageManager();
for (let manager of ["foo", 42, null, undefined, true, [], {}]) {
Assert.throws(() => waitForMessage(manager, "message"), /TypeError/);
}
for (let message of [42, null, undefined, true, [], {}]) {
Assert.throws(() => waitForEvent(messageManager, message), /TypeError/);
}
let data = {"foo": "bar"};
let sent = waitForMessage(messageManager, "message");
messageManager.send("message", data);
equal(data, await sent);
});
add_task(async function test_waitForMessage_checkFnTypes() {
let messageManager = new MessageManager();
for (let checkFn of ["foo", 42, true, [], {}]) {
Assert.throws(() => waitForMessage(
messageManager, "message", {checkFn}), /TypeError/);
}
let data1 = {"fo": "bar"};
let data2 = {"foo": "bar"};
for (let checkFn of [null, undefined, msg => "foo" in msg.data]) {
let expected_data = (checkFn == null) ? data1 : data2;
messageManager = new MessageManager();
let sent = waitForMessage(messageManager, "message", {checkFn});
messageManager.send("message", data1);
messageManager.send("message", data2);
equal(expected_data, await sent);
}
});
add_task(async function test_waitForObserverTopic_topicTypes() {
for (let topic of [42, null, undefined, true, [], {}]) {
Assert.throws(() => waitForObserverTopic(topic), /TypeError/);
}
let data = {"foo": "bar"};
let sent = waitForObserverTopic("message");
Services.obs.notifyObservers(this, "message", data);
let result = await sent;
equal(this, result.subject);
equal(data, result.data);
});
add_task(async function test_waitForObserverTopic_checkFnTypes() {
for (let checkFn of ["foo", 42, true, [], {}]) {
Assert.throws(() => waitForObserverTopic(
"message", {checkFn}), /TypeError/);
}
let data1 = {"fo": "bar"};
let data2 = {"foo": "bar"};
for (let checkFn of [null, undefined, (subject, data) => data == data2]) {
let expected_data = (checkFn == null) ? data1 : data2;
let sent = waitForObserverTopic("message");
Services.obs.notifyObservers(this, "message", data1);
Services.obs.notifyObservers(this, "message", data2);
let result = await sent;
equal(expected_data, result.data);
}
});

19
testing/marionette/transport.js
View File

@ -10,17 +10,14 @@ const CC = Components.Constructor;
ChromeUtils.import("resource://gre/modules/Services.jsm");
ChromeUtils.import("resource://gre/modules/EventEmitter.jsm");
const {
StreamUtils,
} = ChromeUtils.import("chrome://marionette/content/stream-utils.js", {});
const {
BulkPacket,
JSONPacket,
Packet,
} = ChromeUtils.import("chrome://marionette/content/packets.js", {});
const {
executeSoon,
} = ChromeUtils.import("chrome://marionette/content/sync.js", {});
const {StreamUtils} =
ChromeUtils.import("chrome://marionette/content/stream-utils.js", {});
const {Packet, JSONPacket, BulkPacket} =
ChromeUtils.import("chrome://marionette/content/packets.js", {});
const executeSoon = function(func) {
Services.tm.dispatchToMainThread(func);
};
const flags = {wantVerbose: false, wantLogging: false};

1
testing/web-platform/meta/webdriver/tests/execute_script/promise.py.ini
View File

@ -1,4 +1,5 @@
[promise.py]
expected: TIMEOUT
[test_promise_timeout]
expected: FAIL