diff options
Diffstat (limited to 'testing/firefox-ui/tests/puppeteer/test_windows.py')
| -rw-r--r-- | testing/firefox-ui/tests/puppeteer/test_windows.py | 259 |
1 files changed, 259 insertions, 0 deletions
diff --git a/testing/firefox-ui/tests/puppeteer/test_windows.py b/testing/firefox-ui/tests/puppeteer/test_windows.py new file mode 100644 index 000000000..1ba13fa37 --- /dev/null +++ b/testing/firefox-ui/tests/puppeteer/test_windows.py @@ -0,0 +1,259 @@ +# 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 +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import firefox_puppeteer.errors as errors + +from firefox_puppeteer import PuppeteerMixin +from firefox_puppeteer.ui.windows import BaseWindow +from marionette_driver import By, Wait +from marionette_driver.errors import NoSuchWindowException +from marionette_harness import MarionetteTestCase + + +class BaseWindowTestCase(PuppeteerMixin, MarionetteTestCase): + + def setUp(self): + """ + These tests open and close windows pretty rapidly, which + (since bug 1261842) can cause content processes to be + spawned and discarded in large numbers. By default, Firefox + has a 5 second timeout for shutting down content processes, + but we can get into cases where the content process just + doesn't have enough time to get itself all sorted before + the timeout gets hit, which results in the parent killing + the content process manually, which generates a crash report, + which causes these tests to orange. We side-step this by + setting dom.ipc.tabs.shutdownTimeoutSecs to 0, which disables + the shutdown timer. + """ + super(BaseWindowTestCase, self).setUp() + + self.marionette.set_pref('dom.ipc.tabs.shutdownTimeoutSecs', 0) + + def tearDown(self): + try: + self.marionette.clear_pref('dom.ipc.tabs.shutdownTimeoutSecs') + finally: + super(BaseWindowTestCase, self).tearDown() + + +class TestWindows(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + super(TestWindows, self).tearDown() + + def test_switch_to(self): + url = self.marionette.absolute_url('layout/mozilla.html') + + # Open two more windows + for index in range(0, 2): + self.marionette.execute_script(""" window.open(); """) + + windows = self.puppeteer.windows.all + self.assertEquals(len(windows), 3) + + # Switch to the 2nd window + self.puppeteer.windows.switch_to(windows[1].handle) + self.assertEquals(windows[1].handle, self.marionette.current_chrome_window_handle) + + # TODO: Needs updated tabs module for improved navigation + with self.marionette.using_context('content'): + self.marionette.navigate(url) + + # Switch to the last window and find 2nd window by URL + self.puppeteer.windows.switch_to(windows[2].handle) + + # TODO: A window can have multiple tabs, so this may need an update + # when the tabs module gets implemented + def find_by_url(win): + with win.marionette.using_context('content'): + return win.marionette.get_url() == url + + self.puppeteer.windows.switch_to(find_by_url) + self.assertEquals(windows[1].handle, self.marionette.current_chrome_window_handle) + + self.puppeteer.windows.switch_to(find_by_url) + + # Switching to an unknown handles has to fail + self.assertRaises(NoSuchWindowException, + self.puppeteer.windows.switch_to, "humbug") + self.assertRaises(NoSuchWindowException, + self.puppeteer.windows.switch_to, lambda win: False) + + self.puppeteer.windows.close_all([self.browser]) + self.browser.switch_to() + + self.assertEqual(len(self.puppeteer.windows.all), 1) + + def test_switch_to_unknown_window_type(self): + def open_by_js(_): + with self.marionette.using_context('chrome'): + self.marionette.execute_script(""" + window.open('chrome://browser/content/safeMode.xul', '_blank', + 'chrome,centerscreen,resizable=no'); + """) + + win = self.browser.open_window(callback=open_by_js, expected_window_class=BaseWindow) + win.close() + self.browser.switch_to() + + +class TestBaseWindow(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + BaseWindowTestCase.tearDown(self) + + def test_basics(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + self.assertEquals(win1.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win1.window_element, + self.marionette.find_element(By.CSS_SELECTOR, ':root')) + self.assertEquals(win1.window_element.get_attribute('windowtype'), + self.marionette.get_window_type()) + self.assertFalse(win1.closed) + + # Test invalid parameters for BaseWindow constructor + self.assertRaises(errors.UnknownWindowError, + BaseWindow, self.marionette, 10) + + # Test invalid shortcuts + self.assertRaises(KeyError, + win1.send_shortcut, 'l', acel=True) + + def test_open_close(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + # Open a new window (will be focused), and check states + win2 = win1.open_window() + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(len(self.marionette.chrome_window_handles), 2) + self.assertNotEquals(win1.handle, win2.handle) + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + + win2.close() + + self.assertTrue(win2.closed) + self.assertEquals(len(self.marionette.chrome_window_handles), 1) + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + Wait(self.marionette).until(lambda _: win1.focused) # catch the no focused window + + win1.focus() + + # Open and close a new window by a custom callback + def opener(window): + window.marionette.execute_script(""" window.open(); """) + + def closer(window): + window.marionette.execute_script(""" window.close(); """) + + win2 = win1.open_window(callback=opener) + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(len(self.marionette.chrome_window_handles), 2) + win2.close(callback=closer) + + win1.focus() + + # Check for an unexpected window class + self.assertRaises(errors.UnexpectedWindowTypeError, + win1.open_window, expected_window_class=BaseWindow) + self.puppeteer.windows.close_all([win1]) + + def test_switch_to_and_focus(self): + # force BaseWindow instance + win1 = BaseWindow(self.marionette, self.browser.handle) + + # Open a new window (will be focused), and check states + win2 = win1.open_window() + + # force BaseWindow instance + win2 = BaseWindow(self.marionette, win2.handle) + + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win2.handle, self.puppeteer.windows.focused_chrome_window_handle) + self.assertFalse(win1.focused) + self.assertTrue(win2.focused) + + # Switch back to win1 without moving the focus, but focus separately + win1.switch_to() + self.assertEquals(win1.handle, self.marionette.current_chrome_window_handle) + self.assertTrue(win2.focused) + + win1.focus() + self.assertTrue(win1.focused) + + # Switch back to win2 by focusing it directly + win2.focus() + self.assertEquals(win2.handle, self.marionette.current_chrome_window_handle) + self.assertEquals(win2.handle, self.puppeteer.windows.focused_chrome_window_handle) + self.assertTrue(win2.focused) + + # Close win2, and check that it keeps active but looses focus + win2.switch_to() + win2.close() + + win1.switch_to() + + +class TestBrowserWindow(BaseWindowTestCase): + + def tearDown(self): + try: + self.puppeteer.windows.close_all([self.browser]) + finally: + BaseWindowTestCase.tearDown(self) + + def test_basic(self): + self.assertNotEqual(self.browser.dtds, []) + self.assertNotEqual(self.browser.properties, []) + + self.assertFalse(self.browser.is_private) + + self.assertIsNotNone(self.browser.menubar) + self.assertIsNotNone(self.browser.navbar) + self.assertIsNotNone(self.browser.tabbar) + + def test_open_close(self): + # open and close a new browser windows by menu + win2 = self.browser.open_browser(trigger='menu') + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertFalse(self.browser.is_private) + win2.close(trigger='menu') + + # open and close a new browser window by shortcut + win2 = self.browser.open_browser(trigger='shortcut') + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertFalse(self.browser.is_private) + win2.close(trigger='shortcut') + + # open and close a new private browsing window + win2 = self.browser.open_browser(is_private=True) + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertTrue(win2.is_private) + win2.close() + + # open and close a new private browsing window + win2 = self.browser.open_browser(trigger='shortcut', is_private=True) + self.assertEquals(win2, self.puppeteer.windows.current) + self.assertTrue(win2.is_private) + win2.close() + + # force closing a window + win2 = self.browser.open_browser() + self.assertEquals(win2, self.puppeteer.windows.current) + win2.close(force=True) |