Debian Codegraph @

tests/selenium/popup_test.py

raw
1 #!/usr/bin/env python
2
3 import time
4 import unittest
5
6 import pbtest
7
8 from selenium.common.exceptions import TimeoutException
9 from selenium.webdriver.common.by import By
10 from selenium.webdriver.support import expected_conditions as EC
11 from selenium.webdriver.support.ui import WebDriverWait
12
13
14 class PopupTest(pbtest.PBSeleniumTest):
15 """Make sure the popup works correctly."""
16
17 def wait_for_sliders(self, visible=True, timeout=5):
18 def invisibility_condition(dr):
19 """tests all are invisible"""
20 sliders = dr.find_elements(By.CSS_SELECTOR, "div.clicker")
21 for slider in sliders:
22 if slider.is_displayed():
23 return False
24 return True
25
26 try:
27 if visible:
28 WebDriverWait(self.driver, timeout).until(
29 EC.visibility_of_all_elements_located((By.CSS_SELECTOR, "div.clicker")))
30 else:
31 WebDriverWait(self.driver, timeout).until(
32 invisibility_condition)
33 except TimeoutException:
34 pass
35
36 def wait_for_page_to_start_loading(self, url, timeout=20):
37 """Wait until the title element is present. Use it to work around
38 Firefox not updating self.driver.current_url fast enough."""
39 try:
40 WebDriverWait(self.driver, timeout).until(
41 EC.presence_of_element_located((By.CSS_SELECTOR, "title")))
42 except TimeoutException:
43 # TODO debug info
44 print("\n")
45 print("driver.current_url=" + self.driver.current_url)
46 print()
47 print(self.driver.page_source[:5000])
48 print("...\n")
49
50 self.fail(f"Timed out waiting for {url} to start loading")
51
52 def test_welcome_page_reminder_overlay(self):
53 """Ensure overlay links to new user welcome page."""
54
55 # first close the welcome page if already open
56 try:
57 self.close_window_with_url(self.first_run_url, max_tries=1)
58 except pbtest.WindowNotFoundException:
59 pass
60
61 self.open_popup(show_reminder=True)
62 self.driver.find_element(By.ID, "intro-reminder-btn").click()
63
64 # switch to the welcome page or fail
65 self.switch_to_window_with_url(self.first_run_url)
66
67 def test_options_button(self):
68 """Ensure options page is opened when button is clicked."""
69 # first close the options page if already open
70 try:
71 self.switch_to_window_with_url(self.options_url, max_tries=1)
72 self.open_window()
73 self.switch_to_window_with_url(self.options_url)
74 self.driver.close()
75 self.driver.switch_to.window(self.driver.window_handles[0])
76 except pbtest.WindowNotFoundException:
77 pass
78 self.open_popup()
79 self.driver.find_element(By.ID, "options").click()
80 self.switch_to_window_with_url(self.options_url)
81
82 def test_toggling_sliders(self):
83 """Ensure toggling sliders is persisted."""
84
85 FIXTURE_URL = ("https://privacybadger-tests.eff.org/html/"
86 "assorted_thirdparties.html")
87 DOMAIN = "efforg.github.io"
88 DOMAIN_ID = DOMAIN.replace(".", "-")
89
90 self.clear_tracker_data()
91
92 # enable showing non-tracking domains in the popup
93 self.wait_for_script("return window.OPTIONS_INITIALIZED")
94 self.find_el_by_css('a[href="#tab-general-settings"]').click()
95 self.find_el_by_css('#local-learning-checkbox').click()
96 self.find_el_by_css('#show-nontracking-domains-checkbox').click()
97
98 self.load_url(FIXTURE_URL)
99 self.open_popup(FIXTURE_URL)
100
101 # click input with JavaScript to avoid "Element ... is not clickable" /
102 # "Other element would receive the click" Selenium limitation
103 self.js(f"$('#block-{DOMAIN_ID}').click()")
104
105 # retrieve the new action
106 self.load_url(self.options_url)
107 self.wait_for_script("return window.OPTIONS_INITIALIZED")
108 self.find_el_by_css('a[href="#tab-tracking-domains"]').click()
109 assert self.get_domain_slider_state(DOMAIN) == "block", (
110 "The domain should be blocked on options page")
111
112 self.open_popup(FIXTURE_URL)
113 assert self.driver.find_element(By.ID, "block-" + DOMAIN_ID).is_selected(), (
114 "The domain should be shown as blocked in popup")
115
116 # change to "cookieblock"
117 self.js(f"$('#cookieblock-{DOMAIN_ID}').click()")
118 # change again to "block"
119 self.js(f"$('#block-{DOMAIN_ID}').click()")
120
121 # retrieve the new action
122 self.load_url(self.options_url)
123 self.wait_for_script("return window.OPTIONS_INITIALIZED")
124 self.find_el_by_css('a[href="#tab-tracking-domains"]').click()
125 assert self.get_domain_slider_state(DOMAIN) == "block", (
126 "The domain should still be blocked on options page")
127
128 def test_reverting_control(self):
129 """Test restoring control of a domain to Privacy Badger."""
130
131 FIXTURE_URL = ("https://privacybadger-tests.eff.org/html/"
132 "assorted_thirdparties.html")
133 DOMAIN = "efforg.github.io"
134 DOMAIN_ID = DOMAIN.replace(".", "-")
135
136 self.clear_tracker_data()
137
138 # record the domain as cookieblocked by Badger
139 self.cookieblock_domain(DOMAIN)
140
141 self.load_url(FIXTURE_URL)
142 self.open_popup(FIXTURE_URL)
143
144 # reveal sliders
145 self.driver.find_element(By.ID, 'expand-blocked-resources').click()
146 self.wait_for_sliders()
147
148 # set the domain to user control
149 # click input with JavaScript to avoid "Element ... is not clickable" /
150 # "Other element would receive the click" Selenium limitation
151 self.js(f"$('#block-{DOMAIN_ID}').click()")
152
153 self.load_url(self.options_url)
154 self.wait_for_script("return window.OPTIONS_INITIALIZED")
155 self.find_el_by_css('a[href="#tab-tracking-domains"]').click()
156 action = self.get_domain_slider_state(DOMAIN)
157 assert action == "block", "Domain should be marked as blocked"
158 assert self.driver.find_element(By.CSS_SELECTOR,
159 f'div[data-origin="{DOMAIN}"] a.honeybadgerPowered').is_displayed(), (
160 "Undo arrow should be displayed")
161
162 # restore control to Badger
163 self.open_popup(FIXTURE_URL)
164 self.driver.find_element(By.CSS_SELECTOR,
165 f'div[data-origin="{DOMAIN}"] a.honeybadgerPowered').click()
166
167 # get back to a valid window handle as the window just got closed
168 self.driver.switch_to.window(self.driver.window_handles[0])
169 self.open_window()
170
171 # verify the domain is no longer user controlled
172 self.load_url(self.options_url)
173 self.wait_for_script("return window.OPTIONS_INITIALIZED")
174 self.find_el_by_css('a[href="#tab-tracking-domains"]').click()
175 action = self.get_domain_slider_state(DOMAIN)
176 assert action == "cookieblock", "Domain's action should have been restored"
177 assert not self.driver.find_element(By.CSS_SELECTOR,
178 f'div[data-origin="{DOMAIN}"] a.honeybadgerPowered').is_displayed(), (
179 "Undo arrow should not be displayed")
180
181 def test_disable_enable_buttons(self):
182 """Ensure disable/enable buttons change popup state."""
183
184 def get_enable_button():
185 return self.driver.find_element(By.ID, "activate_site_btn")
186
187 def get_disable_button():
188 return self.driver.find_element(By.ID, "deactivate_site_btn")
189
190 DISPLAYED_ERROR = " should not be displayed on popup"
191 NOT_DISPLAYED_ERROR = " should be displayed on popup"
192 DUMMY_PAGE_URL = "https://privacybadger-tests.eff.org/html/widget_frame.html"
193
194 self.load_url(DUMMY_PAGE_URL)
195 self.open_popup(DUMMY_PAGE_URL)
196 get_disable_button().click()
197
198 # get back to a valid window handle as the window just got closed
199 self.driver.switch_to.window(self.driver.window_handles[0])
200 self.open_popup(DUMMY_PAGE_URL)
201
202 # Check that popup state changed after disabling.
203 disable_button = get_disable_button()
204 assert not disable_button.is_displayed(), (
205 "Disable button" + DISPLAYED_ERROR)
206 enable_button = get_enable_button()
207 assert enable_button.is_displayed(), (
208 "Enable button" + NOT_DISPLAYED_ERROR)
209
210 enable_button.click()
211
212 self.driver.switch_to.window(self.driver.window_handles[0])
213 self.open_popup(DUMMY_PAGE_URL)
214
215 # Check that popup state changed after re-enabling.
216 disable_button = get_disable_button()
217 assert disable_button.is_displayed(), "Disable button" + NOT_DISPLAYED_ERROR
218 enable_button = get_enable_button()
219 assert not enable_button.is_displayed(), "Enable button" + DISPLAYED_ERROR
220
221 def test_error_button(self):
222 """Ensure error button opens report error overlay."""
223
224 DUMMY_PAGE_URL = "https://privacybadger-tests.eff.org/html/widget_frame.html"
225 self.load_url(DUMMY_PAGE_URL)
226 self.open_popup(DUMMY_PAGE_URL)
227
228 report_input = self.driver.find_element(By.ID, "error-input")
229 assert not report_input.is_displayed(), (
230 "Error reporting should be closed by default")
231
232 # click the "Report broken site" button
233 self.driver.find_element(By.ID, "error").click()
234 time.sleep(1)
235 assert report_input.is_displayed(), (
236 "Error reporting should be open")
237
238 self.driver.find_element(By.ID, "report-close").click()
239 time.sleep(1)
240 assert not report_input.is_displayed(), (
241 "Error reporting should have gotten closed")
242
243 # verify saving and restoring in-progress reports
244 ERROR_REPORT_TEXT = "The site isn't loading"
245 self.driver.find_element(By.ID, "error").click()
246 time.sleep(1)
247 report_input.send_keys(ERROR_REPORT_TEXT)
248 self.driver.close()
249 self.driver.switch_to.window(self.driver.window_handles[0])
250 self.open_popup(DUMMY_PAGE_URL)
251 time.sleep(1)
252 report_input = self.driver.find_element(By.ID, "error-input")
253 assert report_input.is_displayed(), "Error reporting should be open"
254 assert report_input.get_property('value') == ERROR_REPORT_TEXT, (
255 "Previously entered text should be displayed")
256
257 def test_breakage_warnings(self):
258 YLIST_DOMAIN = "code.jquery.com"
259 FIXTURE_URL = ("https://privacybadger-tests.eff.org/html/"
260 "assorted_thirdparties.html")
261 self.cookieblock_domain(YLIST_DOMAIN)
262
263 self.load_url(FIXTURE_URL)
264 self.open_popup(FIXTURE_URL)
265
266 def get_breakage_icon():
267 return self.driver.find_element(By.CSS_SELECTOR,
268 f'div.clicker[data-origin="{YLIST_DOMAIN}"] span.breakage-warning')
269
270 # reveal sliders
271 self.driver.find_element(By.ID, 'expand-blocked-resources').click()
272 self.wait_for_sliders()
273
274 # verify there is no breakage warning
275 breakage_icon = get_breakage_icon()
276 assert not breakage_icon.is_displayed()
277
278 # manually block the yellowlisted domain
279 self.js(f'$("#block-{YLIST_DOMAIN.replace(".", "-")}").click()')
280
281 # verify breakage warning is shown
282 breakage_icon = get_breakage_icon()
283 assert breakage_icon.is_displayed()
284
285 # verify breakage warning is there when reopened
286 self.open_popup(FIXTURE_URL)
287 breakage_icon = get_breakage_icon()
288 assert breakage_icon.is_displayed()
289
290 def test_slider_hiding(self):
291 FIXTURE_URL = ("https://privacybadger-tests.eff.org/html/"
292 "assorted_thirdparties.html")
293 YLIST_DOMAIN = "code.jquery.com"
294 BLOCKED_DOMAIN = "efforg.github.io"
295
296 def assert_hidden(sliders):
297 for slider in sliders:
298 assert not slider.is_displayed(), (
299 "{slider.get_dom_attribute('data-origin')} is visible but should be hidden")
300
301 def assert_visible(sliders):
302 for slider in sliders:
303 assert slider.is_displayed(), (
304 f"{slider.get_dom_attribute('data-origin')} is hidden but should be visible")
305
306 self.cookieblock_domain(YLIST_DOMAIN)
307 self.block_domain(BLOCKED_DOMAIN)
308
309 self.load_url(FIXTURE_URL)
310 self.open_popup(FIXTURE_URL)
311 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
312
313 # verify we have the expected number of sliders
314 assert len(sliders) == 2
315
316 # verify sliders are hidden
317 assert_hidden(sliders)
318
319 # reveal sliders
320 self.driver.find_element(By.ID, 'expand-blocked-resources').click()
321 self.wait_for_sliders()
322
323 # verify sliders are visible
324 assert_visible(sliders)
325
326 # reopen popup
327 self.open_popup(FIXTURE_URL)
328 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
329
330 # verify sliders are visible
331 assert_visible(sliders)
332
333 # verify domain is shown second in the list
334 assert sliders[1].get_dom_attribute('data-origin') == YLIST_DOMAIN
335
336 # manually block the yellowlisted domain
337 self.js(f'$("#block-{YLIST_DOMAIN.replace(".", "-")}").click()')
338
339 # hide sliders
340 self.driver.find_element(By.ID, 'collapse-blocked-resources').click()
341 self.wait_for_sliders(visible=False)
342
343 # verify sliders are hidden
344 assert_hidden(sliders)
345
346 # reopen popup
347 self.open_popup(FIXTURE_URL)
348 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
349
350 # verify sliders are visible
351 assert_visible(sliders)
352
353 # verify breakage warning slider is at the top
354 assert sliders[0].get_dom_attribute('data-origin') == YLIST_DOMAIN
355
356 # restore the user-set slider to default action
357 self.driver.find_element(By.CSS_SELECTOR,
358 f'div[data-origin="{YLIST_DOMAIN}"] a.honeybadgerPowered').click()
359
360 # get back to a valid window handle as the window just got closed
361 self.driver.switch_to.window(self.driver.window_handles[0])
362
363 # reopen popup
364 self.open_popup(FIXTURE_URL)
365 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
366
367 # verify sliders are hidden again
368 assert_hidden(sliders)
369
370 def test_nothing_blocked_slider_list(self):
371 """Verifies display of non-tracking domains."""
372
373 FIXTURE_URL = ("https://privacybadger-tests.eff.org/html/"
374 "assorted_thirdparties.html")
375 DOMAIN = "efforg.github.io"
376
377 self.load_url(FIXTURE_URL)
378
379 # base case: no sliders should be shown
380 self.open_popup(FIXTURE_URL)
381 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
382 assert not sliders
383
384 # enable local learning and showing non-tracking domains
385 self.load_url(self.options_url)
386 self.wait_for_script("return window.OPTIONS_INITIALIZED")
387 self.find_el_by_css('a[href="#tab-general-settings"]').click()
388 self.find_el_by_css('#local-learning-checkbox').click()
389 self.find_el_by_css('#show-nontracking-domains-checkbox').click()
390
391 # non-tracking sliders should now be shown (no collapsing)
392 self.open_popup(FIXTURE_URL)
393 sliders = self.driver.find_elements(By.CSS_SELECTOR, 'div.clicker')
394 assert sliders
395 slider = self.driver.find_element(By.CSS_SELECTOR,
396 f'div.clicker[data-origin="{DOMAIN}"]')
397 assert slider.is_displayed()
398 assert self.get_domain_slider_state(DOMAIN) == "allow"
399
400 # now block the domain and verify blocked slider is hidden (list is collapsed)
401 self.close_window_with_url(FIXTURE_URL)
402 self.block_domain(DOMAIN)
403 self.load_url(FIXTURE_URL)
404 self.open_popup(FIXTURE_URL)
405 slider = self.driver.find_element(By.CSS_SELECTOR,
406 f'div.clicker[data-origin="{DOMAIN}"]')
407 assert not slider.is_displayed()
408
409
410 if __name__ == "__main__":
411 unittest.main()