--- a/testing/marionette/client/marionette_driver/marionette.py
+++ b/testing/marionette/client/marionette_driver/marionette.py
@@ -1369,35 +1369,16 @@ class Marionette(object):
:returns: unique window handle
:rtype: string
"""
self.chrome_window = self._send_message(
"getCurrentChromeWindowHandle", key="value")
return self.chrome_window
- def get_window_position(self):
- """Get the current window's position.
-
- :returns: a dictionary with x and y
- """
- warnings.warn("get_window_position() has been deprecated, please use get_window_rect()",
- DeprecationWarning)
- return self._send_message("getWindowPosition")
-
- def set_window_position(self, x, y):
- """Set the position of the current window
-
- :param x: x coordinate for the top left of the window
- :param y: y coordinate for the top left of the window
- """
- warnings.warn("set_window_position() has been deprecated, please use set_window_rect()",
- DeprecationWarning)
- self._send_message("setWindowPosition", {"x": x, "y": y})
-
def set_window_rect(self, x=None, y=None, height=None, width=None):
"""Set the position and size of the current window.
The supplied width and height values refer to the window outerWidth
and outerHeight values, which include scroll bars, title bars, etc.
An error will be returned if the requested window size would result
in the window being in the maximised state.
@@ -2024,49 +2005,16 @@ class Marionette(object):
respectively, and "portrait-secondary" as well as
"landscape-secondary".
:param orientation: The orientation to lock the screen in.
"""
body = {"orientation": orientation}
self._send_message("setScreenOrientation", body)
- @property
- def window_size(self):
- """Get the current browser window size.
-
- Will return the current browser window size in pixels. Refers to
- window outerWidth and outerHeight values, which include scroll bars,
- title bars, etc.
-
- :returns: Window rect.
- """
- warnings.warn("window_size property has been deprecated, please use get_window_rect()",
- DeprecationWarning)
- return self._send_message("getWindowSize")
-
- def set_window_size(self, width, height):
- """Resize the browser window currently in focus.
-
- The supplied ``width`` and ``height`` values refer to the window `outerWidth`
- and `outerHeight` values, which include scroll bars, title bars, etc.
-
- An error will be returned if the requested window size would result
- in the window being in the maximised state.
-
- :param width: The width to resize the window to.
- :param height: The height to resize the window to.
-
- :returns Window rect.
- """
- warnings.warn("set_window_size() has been deprecated, please use set_window_rect()",
- DeprecationWarning)
- body = {"width": width, "height": height}
- return self._send_message("setWindowSize", body)
-
def minimize_window(self):
"""Iconify the browser window currently receiving commands.
The action should be equivalent to the user pressing the minimize
button in the OS window.
Note that this command is not available on Fennec. It may also
not be available in certain window managers.
--- a/testing/marionette/driver.js
+++ b/testing/marionette/driver.js
@@ -3619,38 +3619,34 @@ GeckoDriver.prototype.commands = {
"getPageSource": GeckoDriver.prototype.getPageSource,
"getScreenOrientation": GeckoDriver.prototype.getScreenOrientation,
"getSessionCapabilities": GeckoDriver.prototype.getSessionCapabilities,
"getTextFromDialog": GeckoDriver.prototype.getTextFromDialog,
"getTimeouts": GeckoDriver.prototype.getTimeouts,
"getTitle": GeckoDriver.prototype.getTitle,
"getWindowHandle": GeckoDriver.prototype.getWindowHandle,
"getWindowHandles": GeckoDriver.prototype.getWindowHandles,
- "getWindowPosition": GeckoDriver.prototype.getWindowRect, // redirect for compatibility
"getWindowRect": GeckoDriver.prototype.getWindowRect,
- "getWindowSize": GeckoDriver.prototype.getWindowRect, // redirect for compatibility
"getWindowType": GeckoDriver.prototype.getWindowType,
"goBack": GeckoDriver.prototype.goBack,
"goForward": GeckoDriver.prototype.goForward,
"isElementDisplayed": GeckoDriver.prototype.isElementDisplayed,
"isElementEnabled": GeckoDriver.prototype.isElementEnabled,
"isElementSelected": GeckoDriver.prototype.isElementSelected,
"maximizeWindow": GeckoDriver.prototype.maximizeWindow,
"multiAction": GeckoDriver.prototype.multiAction,
"newSession": GeckoDriver.prototype.newSession,
"performActions": GeckoDriver.prototype.performActions,
"refresh": GeckoDriver.prototype.refresh,
"releaseActions": GeckoDriver.prototype.releaseActions,
"sendKeysToDialog": GeckoDriver.prototype.sendKeysToDialog,
"sendKeysToElement": GeckoDriver.prototype.sendKeysToElement,
"setScreenOrientation": GeckoDriver.prototype.setScreenOrientation,
"setTimeouts": GeckoDriver.prototype.setTimeouts,
- "setWindowPosition": GeckoDriver.prototype.setWindowRect, // redirect for compatibility
"setWindowRect": GeckoDriver.prototype.setWindowRect,
- "setWindowSize": GeckoDriver.prototype.setWindowRect, // redirect for compatibility
"singleTap": GeckoDriver.prototype.singleTap,
"switchToFrame": GeckoDriver.prototype.switchToFrame,
"switchToParentFrame": GeckoDriver.prototype.switchToParentFrame,
"switchToShadowRoot": GeckoDriver.prototype.switchToShadowRoot,
"switchToWindow": GeckoDriver.prototype.switchToWindow,
"takeScreenshot": GeckoDriver.prototype.takeScreenshot,
};
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_window_rect.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_window_rect.py
@@ -3,74 +3,167 @@
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from __future__ import absolute_import, print_function
from marionette_driver.errors import InvalidArgumentException
from marionette_harness import MarionetteTestCase
-class TestPosition(MarionetteTestCase):
+class TestWindowRect(MarionetteTestCase):
def setUp(self):
- MarionetteTestCase.setUp(self)
- self.original_position = self.marionette.get_window_position()
+ super(TestWindowRect, self).setUp()
+
+ self.original_rect = self.marionette.window_rect
+
+ self.max = self.marionette.execute_script("""
+ return {
+ width: window.screen.availWidth,
+ height: window.screen.availHeight,
+ }""", sandbox=None)
+
+ # WebDriver spec says a resize cannot result in window being
+ # maximised, an error is returned if that is the case; therefore if
+ # the window is maximised at the start of this test, returning to
+ # the original size via set_window_rect size will result in error;
+ # so reset to original size minus 1 pixel width
+ start_size = {"height": self.original_rect["height"], "width": self.original_rect["width"]}
+ if start_size["width"] == self.max["width"] and start_size["height"] == self.max["height"]:
+ start_size["width"] -= 10
+ start_size["height"] -= 10
+ self.marionette.set_window_rect(height=start_size["height"], width=start_size["width"])
def tearDown(self):
- x, y = self.original_position["x"], self.original_position["y"]
- self.marionette.set_window_position(x, y)
- MarionetteTestCase.tearDown(self)
+ x, y = self.original_rect["x"], self.original_rect["y"]
+ height, width = self.original_rect["height"], self.original_rect["width"]
+
+ self.marionette.set_window_rect(x, y, height, width)
+
+ is_fullscreen = self.marionette.execute_script("return document.fullscreenElement;", sandbox=None)
+ if is_fullscreen:
+ self.marionette.fullscreen()
+
+ super(TestWindowRect, self).tearDown()
def test_get_types(self):
- position = self.marionette.get_window_position()
- self.assertIn("x", position)
- self.assertIn("y", position)
- self.assertIsInstance(position["x"], int)
- self.assertIsInstance(position["y"], int)
+ rect = self.marionette.window_rect
+ self.assertIn("x", rect)
+ self.assertIn("y", rect)
+ self.assertIn("height", rect)
+ self.assertIn("width", rect)
+ self.assertIsInstance(rect["x"], int)
+ self.assertIsInstance(rect["y"], int)
+ self.assertIsInstance(rect["height"], int)
+ self.assertIsInstance(rect["width"], int)
def test_set_types(self):
- for x, y in (["a", "b"], [1.2, 3.4], [True, False], [[], []], [{}, {}]):
+ illegal_rects = (["a", "b", "h", "w"],
+ [1.2, 3.4, 4.5, 5.6],
+ [True, False, True, False],
+ [[], [], [], []],
+ [{}, {}, {}, {}])
+ for x, y, h, w in illegal_rects:
print("testing invalid type position ({},{})".format(x, y))
with self.assertRaises(InvalidArgumentException):
- self.marionette.set_window_position(x, y)
+ self.marionette.set_window_rect(x, y, h, w)
def test_setting_window_rect_with_nulls_errors(self):
with self.assertRaises(InvalidArgumentException):
self.marionette.set_window_rect(height=None, width=None,
x=None, y=None)
- def test_set_position_with_rect(self):
+ def test_set_position(self):
old_position = self.marionette.window_rect
wanted_position = {"x": old_position["x"] + 10, "y": old_position["y"] + 10}
new_position = self.marionette.set_window_rect(x=wanted_position["x"], y=wanted_position["y"])
+ expected_position = self.marionette.window_rect
- self.assertNotEqual(old_position["x"], new_position["x"])
- self.assertNotEqual(old_position["y"], new_position["y"])
+ self.assertEqual(new_position["x"], wanted_position["x"])
+ self.assertEqual(new_position["y"], wanted_position["y"])
+ self.assertEqual(new_position["x"], expected_position["x"])
+ self.assertEqual(new_position["y"], expected_position["y"])
+
+ def test_set_size(self):
+ old_size = self.marionette.window_rect
+ wanted_size = {"height": old_size["height"] - 50, "width": old_size["width"] - 50}
+
+ new_size = self.marionette.set_window_rect(height=wanted_size["height"], weight=wanted_size["width"])
+ expected_size = self.marionette.window_rect
+
+ self.assertEqual(new_size["width"], wanted_size["width"],
+ "New width is {0} but should be {1}".format(new_size["width"], wanted_size["width"]))
+ self.assertEqual(new_size["height"], wanted_size["height"],
+ "New height is {0} but should be {1}".format(new_size["height"], wanted_dize["height"]))
+ self.assertEqual(new_size["width"], expected_size["width"],
+ "New width is {0} but should be {1}".format(new_size["width"], expected_size["width"]))
+ self.assertEqual(new_size["height"], expected_size["height"],
+ "New height is {0} but should be {1}".format(new_size["height"], expected_dize["height"]))
+
+ def test_set_position_and_size(self):
+ old_rect = self.marionette.window_rect
+ wanted_rect = {"x": old_rect["x"] + 10, "y": old_rect["y"] + 10,
+ "width": old_rect["width"] - 50, "height": old_rect["height"] - 50}
+
+ new_rect = self.marionette.set_window_rect(x=wanted_rect["x"], y=wanted_rect["y"],
+ width=wanted_rect["width"], height=wanted_rect["height"])
+ expected_rect = self.marionette.window_rect
- def test_move_to_new_position(self):
- old_position = self.marionette.get_window_position()
- new_position = {"x": old_position["x"] + 10, "y": old_position["y"] + 10}
- self.marionette.set_window_position(new_position["x"], new_position["y"])
- self.assertNotEqual(old_position["x"], new_position["x"])
- self.assertNotEqual(old_position["y"], new_position["y"])
+ self.assertEqual(new_rect["x"], wanted_rect["x"])
+ self.assertEqual(new_rect["y"], wanted_rect["y"])
+ self.assertEqual(new_rect["width"], wanted_rect["width"],
+ "New width is {0} but should be {1}".format(new_rect["width"], wanted_rect["width"]))
+ self.assertEqual(new_rect["height"], wanted_rect["height"],
+ "New height is {0} but should be {1}".format(new_rect["height"], wanted_rect["height"]))
+ self.assertEqual(new_rect["x"], expected_rect["x"])
+ self.assertEqual(new_rect["y"], expected_rect["y"])
+ self.assertEqual(new_rect["width"], expected_rect["width"],
+ "New width is {0} but should be {1}".format(new_rect["width"], expected_rect["width"]))
+ self.assertEqual(new_rect["height"], expected_rect["height"],
+ "New height is {0} but should be {1}".format(new_rect["height"], expected_rect["height"]))
+
+ def test_move_to_current_position(self):
+ old = self.marionette.window_rect
+ self.marionette.set_window_rect(x=old["x"], y=old["y"])
+
+ new = self.marionette.window_rect
- def test_move_to_existing_position(self):
- old_position = self.marionette.get_window_position()
- self.marionette.set_window_position(old_position["x"], old_position["y"])
- new_position = self.marionette.get_window_position()
- self.assertEqual(old_position["x"], new_position["x"])
- self.assertEqual(old_position["y"], new_position["y"])
+ self.assertEqual(new["x"], old["x"])
+ self.assertEqual(new["y"], old["y"])
+
+ def test_move_to_current_size(self):
+ old = self.marionette.window_rect
+ self.marionette.set_window_rect(height=old["height"], width=old["width"])
+
+ new = self.marionette.window_rect
+
+ self.assertEqual(new["height"], old["height"])
+ self.assertEuqal(new["width"], old["width"])
+
+ def test_move_to_current_position_and_size(self):
+ old = self.marionette.window_rect
+ self.marionette.set_window_rect(old["x"], old["y"],
+ old["height"], old["width"])
+
+ new = self.marionette.window_rect
+
+ self.assertEqual(new["x"], old["x"])
+ self.assertEqual(new["y"], old["y"])
+ self.assertEqual(new["width"], old["width"])
+ self.assertEqual(new["height"], old["height"])
def test_move_to_negative_coordinates(self):
+ position = self.marionette.window_rect
print("Current position: {}".format(
- self.marionette.get_window_position()))
- self.marionette.set_window_position(-8, -8)
- position = self.marionette.get_window_position()
- print("Position after requesting move to negative coordinates: {}".format(position))
+ position["x"], position["y"]))
+ self.marionette.set_window_rect(-8, -8)
+ position = self.marionette.window_rect
+ print("Position after requesting move to negative coordinates: {}, {}"
+ .format(position["x"], position["y"]))
# Different systems will report more or less than (-8,-8)
# depending on the characteristics of the window manager, since
# the screenX/screenY position measures the chrome boundaries,
# including any WM decorations.
#
# This makes this hard to reliably test across different
# environments. Generally we are happy when calling
@@ -105,108 +198,41 @@ class TestPosition(MarionetteTestCase):
self.assertEqual(23, position["y"])
# It turns out that Windows is the only platform on which the
# window can be reliably positioned off-screen.
elif os == "windows_nt":
self.assertEqual(-8, position["x"])
self.assertEqual(-8, position["y"])
-
-class TestSize(MarionetteTestCase):
-
- def setUp(self):
- super(MarionetteTestCase, self).setUp()
- self.max = self.marionette.execute_script("""
- return {
- width: window.screen.availWidth,
- height: window.screen.availHeight,
- }""", sandbox=None)
-
- # WebDriver spec says a resize cannot result in window being
- # maximised, an error is returned if that is the case; therefore if
- # the window is maximised at the start of this test, returning to
- # the original size via set_window_size size will result in error;
- # so reset to original size minus 1 pixel width
- start_size = self.marionette.window_size
- if start_size["width"] == self.max["width"] and start_size["height"] == self.max["height"]:
- start_size["width"] -= 10
- start_size["height"] -= 10
- self.marionette.set_window_size(start_size["width"], start_size["height"])
-
- self.original_size = self.marionette.window_size
-
- def tearDown(self):
- self.marionette.set_window_size(
- self.original_size["width"], self.original_size["height"])
- is_fullscreen = self.marionette.execute_script("return document.fullscreenElement;", sandbox=None)
- if is_fullscreen:
- self.marionette.fullscreen()
- super(MarionetteTestCase, self).tearDown()
-
- def test_get_types(self):
- size = self.marionette.window_size
- self.assertIn("width", size)
- self.assertIn("height", size)
- self.assertIsInstance(size["width"], int)
- self.assertIsInstance(size["height"], int)
-
- def test_set_types(self):
- for width, height in (["a", "b"], [1.2, 3.4], [True, False], [[], []], [{}, {}]):
- print("testing invalid type size ({},{})".format(width, height))
- with self.assertRaises(InvalidArgumentException):
- self.marionette.set_window_size(width, height)
-
- def test_setting_window_rect_with_nulls_errors(self):
- with self.assertRaises(InvalidArgumentException):
- self.marionette.set_window_rect(height=None, width=None,
- x=None, y=None)
-
- def test_set_size_with_rect(self):
- actual = self.marionette.window_size
- width = actual["width"] - 50
- height = actual["height"] - 50
-
- size = self.marionette.set_window_rect(width=width, height=height)
- self.assertEqual(size["width"], width,
- "New width is {0} but should be {1}".format(size["width"], width))
- self.assertEqual(size["height"], height,
- "New height is {0} but should be {1}".format(size["height"], height))
-
- def test_resize_to_new_size(self):
- old = self.marionette.window_size
- new = {"width": old["width"] + 10, "height": old["height"] + 10}
- self.marionette.set_window_size(new["width"], new["height"])
- actual = self.marionette.window_size
- self.assertEqual(actual["width"], new["width"])
- self.assertEqual(actual["height"], new["height"])
-
- def test_resize_to_existing_size(self):
- old = self.marionette.window_size
- self.marionette.set_window_size(old["width"], old["height"])
- new = self.marionette.window_size
- self.assertEqual(old["width"], new["width"])
- self.assertEqual(old["height"], new["height"])
-
def test_resize_larger_than_screen(self):
- self.marionette.set_window_size(
+ new = self.marionette.set_window_rect(
self.max["width"] * 2, self.max["height"] * 2)
- new = self.marionette.window_size
+ actual = self.marionette.window_rect
# in X the window size may be greater than the bounds of the screen
self.assertGreaterEqual(new["width"], self.max["width"])
self.assertGreaterEqual(new["height"], self.max["height"])
+ self.assertEqual(new["width"], actual["width"])
+ self.assertEqual(new["height"], actual["width"])
def test_resize_to_available_screen_size(self):
- result = self.marionette.set_window_rect(width=self.max['width'],
- height=self.max["height"])
+ expected = self.marionette.set_window_rect(width=self.max["width"],
+ height=self.max["height"])
+ result = self.marionette.window_rect
+
self.assertEqual(result["width"], self.max["width"])
self.assertEqual(result["height"], self.max["height"])
+ self.assertEqual(result["width"], self.expected["width"])
+ self.assertEqual(result["height"], self.expected["height"])
def test_resize_while_fullscreen(self):
self.marionette.fullscreen()
- result = self.marionette.set_window_rect(width=self.max["width"] - 100,
- height=self.max["height"] - 100)
+ expected = self.marionette.set_window_rect(width=self.max["width"] - 100,
+ height=self.max["height"] - 100)
+ result = self.marionette.window_rect
self.assertTrue(self.marionette.execute_script("return window.fullscreenElement == null",
sandbox=None))
self.assertEqual(result["width"], self.max["width"] - 100)
self.assertEqual(result["height"], self.max["height"] - 100)
+ self.assertEqual(result["width"], self.expected["width"])
+ self.assertEqual(result["height"], self.expected["height"])