Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: os == 'linux' && os_version == '18.04' && !swgl
- Manifest: testing/marionette/harness/marionette_harness/tests/unit/unit-tests.toml
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
from marionette_driver.errors import InvalidArgumentException
from marionette_harness import MarionetteTestCase
class TestWindowRect(MarionetteTestCase):
def setUp(self):
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_rect["x"], self.original_rect["y"]
height, width = self.original_rect["height"], self.original_rect["width"]
self.marionette.set_window_rect(x=x, y=y, height=height, width=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):
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):
invalid_rects = (
["a", "b", "h", "w"],
[1.2, 3.4, 4.5, 5.6],
[True, False, True, False],
[[], [], [], []],
[{}, {}, {}, {}],
)
for x, y, h, w in invalid_rects:
print("testing invalid type position ({},{})".format(x, y))
with self.assertRaises(InvalidArgumentException):
self.marionette.set_window_rect(x=x, y=y, height=h, width=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(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.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"], width=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_size["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_size["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
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_position = self.marionette.window_rect
new_position = self.marionette.set_window_rect(
x=old_position["x"], y=old_position["y"]
)
self.assertEqual(new_position["x"], old_position["x"])
self.assertEqual(new_position["y"], old_position["y"])
def test_move_to_current_size(self):
old_size = self.marionette.window_rect
new_size = self.marionette.set_window_rect(
height=old_size["height"], width=old_size["width"]
)
self.assertEqual(new_size["height"], old_size["height"])
self.assertEqual(new_size["width"], old_size["width"])
def test_move_to_current_position_and_size(self):
old_position_and_size = self.marionette.window_rect
new_position_and_size = self.marionette.set_window_rect(
x=old_position_and_size["x"],
y=old_position_and_size["y"],
height=old_position_and_size["height"],
width=old_position_and_size["width"],
)
self.assertEqual(new_position_and_size["x"], old_position_and_size["x"])
self.assertEqual(new_position_and_size["y"], old_position_and_size["y"])
self.assertEqual(new_position_and_size["width"], old_position_and_size["width"])
self.assertEqual(
new_position_and_size["height"], old_position_and_size["height"]
)
def test_move_to_negative_coordinates(self):
old_position = self.marionette.window_rect
print("Current position: {}".format(old_position["x"], old_position["y"]))
new_position = self.marionette.set_window_rect(x=-8, y=-8)
print(
"Position after requesting move to negative coordinates: {}, {}".format(
new_position["x"], new_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
# marionette.set_window_position with negative coordinates does
# not throw.
#
# Because we have to cater to an unknown set of environments,
# the following assertions are the most common denominator that
# make this test pass, irregardless of system characteristics.
os = self.marionette.session_capabilities["platformName"]
# Regardless of platform, headless always supports being positioned
# off-screen.
if self.marionette.session_capabilities["moz:headless"]:
self.assertEqual(-8, new_position["x"])
self.assertEqual(-8, new_position["y"])
# Certain WMs prohibit windows from being moved off-screen,
# but we don't have this information. It should be safe to
# assume a window can be moved to (0,0) or less.
elif os == "linux":
# certain WMs prohibit windows from being moved off-screen
self.assertLessEqual(new_position["x"], 0)
self.assertLessEqual(new_position["y"], 0)
# On macOS, windows can only be moved off the screen on the
# horizontal axis. The system menu bar also blocks windows from
# being moved to (0,0).
elif os == "mac":
self.assertEqual(-8, new_position["x"])
self.assertEqual(23, new_position["y"])
# It turns out that Windows is the only platform on which the
# window can be reliably positioned off-screen.
elif os == "windows":
self.assertEqual(-8, new_position["x"])
self.assertEqual(-8, new_position["y"])
def test_resize_larger_than_screen(self):
new_size = self.marionette.set_window_rect(
width=self.max["width"] * 2, height=self.max["height"] * 2
)
actual_size = self.marionette.window_rect
# in X the window size may be greater than the bounds of the screen
self.assertGreaterEqual(new_size["width"], self.max["width"])
self.assertGreaterEqual(new_size["height"], self.max["height"])
self.assertEqual(actual_size["width"], new_size["width"])
self.assertEqual(actual_size["height"], new_size["height"])
def test_resize_to_available_screen_size(self):
expected_size = self.marionette.set_window_rect(
width=self.max["width"], height=self.max["height"]
)
result_size = self.marionette.window_rect
self.assertGreaterEqual(expected_size["width"], self.max["width"])
self.assertGreaterEqual(expected_size["height"], self.max["height"])
self.assertEqual(result_size["width"], expected_size["width"])
self.assertEqual(result_size["height"], expected_size["height"])
def test_resize_while_fullscreen(self):
self.marionette.fullscreen()
expected_size = self.marionette.set_window_rect(
width=self.max["width"] - 100, height=self.max["height"] - 100
)
result_size = self.marionette.window_rect
self.assertTrue(
self.marionette.execute_script(
"return window.fullscreenElement == null", sandbox=None
)
)
self.assertEqual(self.max["width"] - 100, expected_size["width"])
self.assertEqual(self.max["height"] - 100, expected_size["height"])
self.assertEqual(result_size["width"], expected_size["width"])
self.assertEqual(result_size["height"], expected_size["height"])