testing/marionette/harness/marionette_harness/tests/unit/test_modal_dialogs.py

   1 # This Source Code Form is subject to the terms of the Mozilla Public
   2 # License, v. 2.0. If a copy of the MPL was not distributed with this
   3 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   4
   5 from marionette_driver.by import By
   6 from marionette_driver.expected import element_present
   7 from marionette_driver import errors
   8 from marionette_driver.marionette import Alert
   9 from marionette_driver.wait import Wait
  10
  11 from marionette_harness import MarionetteTestCase, WindowManagerMixin
  12
  13
  14 class BaseAlertTestCase(WindowManagerMixin, MarionetteTestCase):
  15
  16     def alert_present(self):
  17         try:
  18             Alert(self.marionette).text
  19             return True
  20         except errors.NoAlertPresentException:
  21             return False
  22
  23     def wait_for_alert(self, timeout=None):
  24         Wait(self.marionette, timeout=timeout).until(
  25             lambda _: self.alert_present())
  26
  27     def wait_for_alert_closed(self, timeout=None):
  28         Wait(self.marionette, timeout=timeout).until(
  29             lambda _: not self.alert_present())
  30
  31
  32 class TestTabModalAlerts(BaseAlertTestCase):
  33
  34     def setUp(self):
  35         super(TestTabModalAlerts, self).setUp()
  36         self.assertTrue(self.marionette.get_pref("prompts.tab_modal.enabled",
  37                         "Tab modal alerts should be enabled by default."))
  38
  39         self.marionette.navigate(self.marionette.absolute_url("test_tab_modal_dialogs.html"))
  40
  41     def tearDown(self):
  42         self.marionette.execute_script("window.onbeforeunload = null;")
  43
  44         # Ensure to close a possible remaining tab modal dialog
  45         try:
  46             alert = self.marionette.switch_to_alert()
  47             alert.dismiss()
  48
  49             self.wait_for_alert_closed()
  50         except:
  51             pass
  52
  53         super(TestTabModalAlerts, self).tearDown()
  54
  55     def test_no_alert_raises(self):
  56         with self.assertRaises(errors.NoAlertPresentException):
  57             Alert(self.marionette).accept()
  58         with self.assertRaises(errors.NoAlertPresentException):
  59             Alert(self.marionette).dismiss()
  60
  61     def test_alert_accept(self):
  62         self.marionette.find_element(By.ID, "tab-modal-alert").click()
  63         self.wait_for_alert()
  64         alert = self.marionette.switch_to_alert()
  65         alert.accept()
  66
  67     def test_alert_dismiss(self):
  68         self.marionette.find_element(By.ID, "tab-modal-alert").click()
  69         self.wait_for_alert()
  70         alert = self.marionette.switch_to_alert()
  71         alert.dismiss()
  72
  73     def test_confirm_accept(self):
  74         self.marionette.find_element(By.ID, "tab-modal-confirm").click()
  75         self.wait_for_alert()
  76         alert = self.marionette.switch_to_alert()
  77         alert.accept()
  78         self.wait_for_condition(
  79             lambda mn: mn.find_element(By.ID, "confirm-result").text == "true")
  80
  81     def test_confirm_dismiss(self):
  82         self.marionette.find_element(By.ID, "tab-modal-confirm").click()
  83         self.wait_for_alert()
  84         alert = self.marionette.switch_to_alert()
  85         alert.dismiss()
  86         self.wait_for_condition(
  87             lambda mn: mn.find_element(By.ID, "confirm-result").text == "false")
  88
  89     def test_prompt_accept(self):
  90         self.marionette.find_element(By.ID, "tab-modal-prompt").click()
  91         self.wait_for_alert()
  92         alert = self.marionette.switch_to_alert()
  93         alert.accept()
  94         self.wait_for_condition(
  95             lambda mn: mn.find_element(By.ID, "prompt-result").text == "")
  96
  97     def test_prompt_dismiss(self):
  98         self.marionette.find_element(By.ID, "tab-modal-prompt").click()
  99         self.wait_for_alert()
 100         alert = self.marionette.switch_to_alert()
 101         alert.dismiss()
 102         self.wait_for_condition(
 103             lambda mn: mn.find_element(By.ID, "prompt-result").text == "null")
 104
 105     def test_alert_opened_before_session_starts(self):
 106         self.marionette.find_element(By.ID, "tab-modal-alert").click()
 107         self.wait_for_alert()
 108
 109         # Restart the session to ensure we still find the formerly left-open dialog.
 110         self.marionette.delete_session()
 111         self.marionette.start_session()
 112
 113         alert = self.marionette.switch_to_alert()
 114         alert.dismiss()
 115
 116     def test_alert_text(self):
 117         with self.assertRaises(errors.NoAlertPresentException):
 118             alert = self.marionette.switch_to_alert()
 119             alert.text
 120         self.marionette.find_element(By.ID, "tab-modal-alert").click()
 121         self.wait_for_alert()
 122         alert = self.marionette.switch_to_alert()
 123         self.assertEqual(alert.text, "Marionette alert")
 124         alert.accept()
 125
 126     def test_prompt_text(self):
 127         with self.assertRaises(errors.NoAlertPresentException):
 128             alert = self.marionette.switch_to_alert()
 129             alert.text
 130         self.marionette.find_element(By.ID, "tab-modal-prompt").click()
 131         self.wait_for_alert()
 132         alert = self.marionette.switch_to_alert()
 133         self.assertEqual(alert.text, "Marionette prompt")
 134         alert.accept()
 135
 136     def test_confirm_text(self):
 137         with self.assertRaises(errors.NoAlertPresentException):
 138             alert = self.marionette.switch_to_alert()
 139             alert.text
 140         self.marionette.find_element(By.ID, "tab-modal-confirm").click()
 141         self.wait_for_alert()
 142         alert = self.marionette.switch_to_alert()
 143         self.assertEqual(alert.text, "Marionette confirm")
 144         alert.accept()
 145
 146     def test_set_text_throws(self):
 147         with self.assertRaises(errors.NoAlertPresentException):
 148             Alert(self.marionette).send_keys("Foo")
 149         self.marionette.find_element(By.ID, "tab-modal-alert").click()
 150         self.wait_for_alert()
 151         alert = self.marionette.switch_to_alert()
 152         with self.assertRaises(errors.ElementNotInteractableException):
 153             alert.send_keys("Foo")
 154         alert.accept()
 155
 156     def test_set_text_accept(self):
 157         self.marionette.find_element(By.ID, "tab-modal-prompt").click()
 158         self.wait_for_alert()
 159         alert = self.marionette.switch_to_alert()
 160         alert.send_keys("Some text!")
 161         alert.accept()
 162         self.wait_for_condition(
 163             lambda mn: mn.find_element(By.ID, "prompt-result").text == "Some text!")
 164
 165     def test_set_text_dismiss(self):
 166         self.marionette.find_element(By.ID, "tab-modal-prompt").click()
 167         self.wait_for_alert()
 168         alert = self.marionette.switch_to_alert()
 169         alert.send_keys("Some text!")
 170         alert.dismiss()
 171         self.wait_for_condition(
 172             lambda mn: mn.find_element(By.ID, "prompt-result").text == "null")
 173
 174     def test_onbeforeunload_dismiss(self):
 175         start_url = self.marionette.get_url()
 176         self.marionette.find_element(By.ID, "onbeforeunload-handler").click()
 177         self.wait_for_condition(
 178             lambda mn: mn.execute_script("""
 179               return window.onbeforeunload !== null;
 180             """))
 181         self.marionette.navigate("about:blank")
 182         self.wait_for_alert()
 183         alert = self.marionette.switch_to_alert()
 184         self.assertTrue(alert.text.startswith("This page is asking you to confirm"))
 185         alert.dismiss()
 186         self.assertTrue(self.marionette.get_url().startswith(start_url))
 187
 188     def test_onbeforeunload_accept(self):
 189         self.marionette.find_element(By.ID, "onbeforeunload-handler").click()
 190         self.wait_for_condition(
 191             lambda mn: mn.execute_script("""
 192               return window.onbeforeunload !== null;
 193             """))
 194         self.marionette.navigate("about:blank")
 195         self.wait_for_alert()
 196         alert = self.marionette.switch_to_alert()
 197         self.assertTrue(alert.text.startswith("This page is asking you to confirm"))
 198         alert.accept()
 199         self.wait_for_condition(lambda mn: mn.get_url() == "about:blank")
 200
 201     def test_unrelated_command_when_alert_present(self):
 202         self.marionette.find_element(By.ID, "tab-modal-alert").click()
 203         self.wait_for_alert()
 204         with self.assertRaises(errors.UnexpectedAlertOpen):
 205             self.marionette.find_element(By.ID, "click-result")
 206
 207     def test_modal_is_dismissed_after_unexpected_alert(self):
 208         self.marionette.find_element(By.ID, "tab-modal-alert").click()
 209         self.wait_for_alert()
 210         with self.assertRaises(errors.UnexpectedAlertOpen):
 211             self.marionette.find_element(By.ID, "click-result")
 212
 213         assert not self.alert_present()
 214
 215
 216 class TestModalAlerts(BaseAlertTestCase):
 217
 218     def setUp(self):
 219         super(TestModalAlerts, self).setUp()
 220
 221     def tearDown(self):
 222         # Ensure to close a possible remaining modal dialog
 223         self.close_all_windows()
 224
 225         super(TestModalAlerts, self).tearDown()
 226
 227     def test_http_auth_dismiss(self):
 228         self.marionette.navigate(self.marionette.absolute_url("http_auth"))
 229         self.wait_for_alert(timeout=self.marionette.timeout.page_load)
 230
 231         alert = self.marionette.switch_to_alert()
 232         alert.dismiss()
 233
 234         self.wait_for_alert_closed()
 235
 236         status = Wait(self.marionette, timeout=self.marionette.timeout.page_load).until(
 237             element_present(By.ID, "status")
 238         )
 239         self.assertEqual(status.text, "restricted")
 240
 241     def test_alert_opened_before_session_starts(self):
 242         self.marionette.navigate(self.marionette.absolute_url("http_auth"))
 243         self.wait_for_alert(timeout=self.marionette.timeout.page_load)
 244
 245         # Restart the session to ensure we still find the formerly left-open dialog.
 246         self.marionette.delete_session()
 247         self.marionette.start_session()
 248
 249         alert = self.marionette.switch_to_alert()
 250         alert.dismiss()
 251
 252         self.wait_for_alert_closed()