taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py

   1 #!/usr/bin/env python3
   2 # This Source Code Form is subject to the terms of the Mozilla Public
   3 # License, v. 2.0. If a copy of the MPL was not distributed with this
   4 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
   5
   6
   7 import os
   8 import random
   9 import tempfile
  10 import time
  11
  12 from basic_tests import SnapTestsBase
  13 from selenium.common.exceptions import TimeoutException
  14 from selenium.webdriver.common.action_chains import ActionChains
  15 from selenium.webdriver.common.by import By
  16 from selenium.webdriver.common.keys import Keys
  17 from selenium.webdriver.support import expected_conditions as EC
  18 from selenium.webdriver.support.select import Select
  19
  20
  21 class QATests(SnapTestsBase):
  22     def __init__(self):
  23         self._dir = "qa_tests"
  24
  25         super(QATests, self).__init__(
  26             exp=os.path.join(self._dir, "qa_expectations.json")
  27         )
  28
  29     def _test_audio_playback(
  30         self, url, iframe_selector=None, click_to_play=False, video_selector=None
  31     ):
  32         self._logger.info("open url {}".format(url))
  33         if url:
  34             self.open_tab(url)
  35
  36         if iframe_selector:
  37             self._logger.info("find iframe")
  38             iframe = self._wait.until(
  39                 EC.visibility_of_element_located((By.CSS_SELECTOR, iframe_selector))
  40             )
  41             self._driver.switch_to.frame(iframe)
  42
  43         self._logger.info("find video")
  44         video = self._wait.until(
  45             EC.visibility_of_element_located(
  46                 (By.CSS_SELECTOR, video_selector or "video")
  47             )
  48         )
  49         self._wait.until(lambda d: type(video.get_property("duration")) == float)
  50         assert video.get_property("duration") > 0.0, "<video> duration null"
  51
  52         # For HE-AAC page, Google Drive does not like SPACE
  53         if not click_to_play and video.get_property("autoplay") is False:
  54             self._logger.info("force play")
  55             video.send_keys(Keys.SPACE)
  56
  57         # Mostly for Google Drive video, click()/play() seems not to really
  58         # work to trigger, but 'k' is required
  59         if click_to_play:
  60             self._driver.execute_script("arguments[0].click();", video)
  61             video.send_keys("k")
  62
  63         ref_volume = video.get_property("volume")
  64
  65         self._logger.info("find video: wait readyState")
  66         self._wait.until(lambda d: video.get_property("readyState") >= 4)
  67
  68         # Some videos sometimes self-pause?
  69         self._logger.info(
  70             "find video: check paused: {}".format(video.get_property("paused"))
  71         )
  72         self._logger.info(
  73             "find video: check autoplay: {}".format(video.get_property("autoplay"))
  74         )
  75         if not click_to_play and video.get_property("paused") is True:
  76             self._driver.execute_script("arguments[0].play()", video)
  77
  78         self._logger.info("find video: sleep")
  79         # let it play at least 500ms
  80         time.sleep(0.5)
  81
  82         self._logger.info("find video: wait currentTime")
  83         self._wait.until(lambda d: video.get_property("currentTime") >= 0.01)
  84         assert (
  85             video.get_property("currentTime") >= 0.01
  86         ), "<video> currentTime not moved"
  87
  88         # this should pause
  89         self._logger.info("find video: pause")
  90         if click_to_play:
  91             video.send_keys("k")
  92         else:
  93             self._driver.execute_script("arguments[0].pause()", video)
  94         datum = video.get_property("currentTime")
  95         time.sleep(1)
  96         datum_after_sleep = video.get_property("currentTime")
  97         self._logger.info(
  98             "datum={} datum_after_sleep={}".format(datum, datum_after_sleep)
  99         )
 100         assert datum == datum_after_sleep, "<video> is sleeping"
 101         assert video.get_property("paused") is True, "<video> is paused"
 102
 103         self._logger.info("find video: unpause")
 104         # unpause and verify playback
 105         if click_to_play:
 106             video.send_keys("k")
 107         else:
 108             self._driver.execute_script("arguments[0].play()", video)
 109         assert video.get_property("paused") is False, "<video> is not paused"
 110         time.sleep(2)
 111         datum_after_resume = video.get_property("currentTime")
 112         self._logger.info(
 113             "datum_after_resume={} datum_after_sleep={}".format(
 114                 datum_after_resume, datum_after_sleep
 115             )
 116         )
 117         # we wait for 2s but it's not super accurate on CI (vbox VMs?),
 118         # observed values +/- 15% so check for more that should avoid
 119         # intermittent failures
 120         assert (
 121             datum_after_resume >= datum_after_sleep + 0.5
 122         ), "<video> progressed after pause"
 123
 124         self._logger.info("find video: volume")
 125         self._driver.execute_script(
 126             "arguments[0].volume = arguments[1]", video, ref_volume * 0.25
 127         )
 128         assert (
 129             video.get_property("volume") == ref_volume * 0.25
 130         ), "<video> sound volume increased"
 131
 132         self._logger.info("find video: done")
 133
 134     def _test_audio_video_playback(self, url):
 135         self._logger.info("open url {}".format(url))
 136         self.open_tab(url)
 137         self._logger.info("find thumbnail")
 138         thumbnail = self._longwait.until(
 139             EC.visibility_of_element_located((By.CSS_SELECTOR, "img"))
 140         )
 141         self._logger.info("click")
 142         self._driver.execute_script("arguments[0].click()", thumbnail)
 143         self._logger.info("audio test")
 144         self._test_audio_playback(
 145             url=None,
 146             iframe_selector="#drive-viewer-video-player-object-0",
 147             click_to_play=True,
 148         )
 149
 150         self._logger.info("find video again")
 151         # we are still in the iframe
 152         video = self._wait.until(
 153             EC.visibility_of_element_located((By.CSS_SELECTOR, "video"))
 154         )
 155         self._logger.info("try fullscreen")
 156         promise = self._driver.execute_script(
 157             "return arguments[0].requestFullscreen().then(() => { return true; }).catch(() => { return false; })",
 158             video,
 159         )
 160         assert promise is True, "<video> full screen promised fullfilled"
 161
 162         self._driver.execute_script("arguments[0].pause();", video)
 163         self._driver.execute_script("document.exitFullscreen()")
 164
 165     def test_h264_mov(self, exp):
 166         """
 167         C95233
 168         """
 169
 170         self._test_audio_video_playback(
 171             "https://drive.google.com/file/d/0BwxFVkl63-lEY3l3ODJReDg3RzQ/view?resourcekey=0-5kDw2QbFk9eLrWE1N9M1rQ"
 172         )
 173
 174         return True
 175
 176     def test_he_aac(self, exp):
 177         """
 178         C95239
 179         """
 180         self._test_audio_playback(
 181             url="https://www2.iis.fraunhofer.de/AAC/multichannel.html",
 182             video_selector="p.inlineVideo > video",
 183         )
 184
 185         return True
 186
 187     def test_flac(self, exp):
 188         """
 189         C95240
 190         """
 191
 192         self._test_audio_playback(
 193             "http://www.hyperion-records.co.uk/audiotest/18%20MacCunn%20The%20Lay%20of%20the%20Last%20Minstrel%20-%20Part%202%20Final%20chorus%20O%20Caledonia!%20stern%20and%20wild.FLAC"
 194         )
 195
 196         return True
 197
 198     def test_mp3(self, exp):
 199         """
 200         C95241
 201         """
 202         self._test_audio_playback(
 203             "https://freetestdata.com/wp-content/uploads/2021/09/Free_Test_Data_5MB_MP3.mp3"
 204         )
 205
 206         return True
 207
 208     def test_ogg(self, exp):
 209         """
 210         C95244
 211         """
 212         self._test_audio_playback(
 213             "http://www.metadecks.org/software/sweep/audio/demos/beats1.ogg"
 214         )
 215
 216         return True
 217
 218     def test_custom_fonts(self, exp):
 219         """
 220         C128146
 221         """
 222
 223         self.open_tab(
 224             "http://codinginparadise.org/projects/svgweb/samples/demo.html?name=droid%20font1"
 225         )
 226
 227         renderer = self._wait.until(
 228             EC.visibility_of_element_located((By.ID, "selectRenderer"))
 229         )
 230         self._wait.until(lambda d: len(renderer.text) > 0)
 231
 232         renderer_drop = Select(renderer)
 233         renderer_drop.select_by_visible_text("browser native svg")
 234
 235         font = self._wait.until(EC.visibility_of_element_located((By.ID, "selectSVG")))
 236         self._wait.until(lambda d: len(font.text) > 0)
 237
 238         font_drop = Select(font)
 239         font_drop.select_by_value("droid font1")
 240
 241         svg_div = self._wait.until(
 242             EC.visibility_of_element_located((By.ID, "__svg__random___1__object"))
 243         )
 244         self._wait.until(lambda d: svg_div.is_displayed() is True)
 245
 246         self.assert_rendering(exp, svg_div)
 247
 248         return True
 249
 250     def pdf_select_zoom(self, value):
 251         pdf_zoom = self._wait.until(
 252             EC.visibility_of_element_located((By.ID, "scaleSelect"))
 253         )
 254         self._wait.until(lambda d: len(pdf_zoom.text) > 0)
 255
 256         pdf_zoom_drop = Select(pdf_zoom)
 257         pdf_zoom_drop.select_by_value(value)
 258
 259     def pdf_wait_div(self):
 260         pdf_div = self._wait.until(EC.visibility_of_element_located((By.ID, "viewer")))
 261         self._wait.until(lambda d: pdf_div.is_displayed() is True)
 262         return pdf_div
 263
 264     def is_esr(self):
 265         self._driver.set_context("chrome")
 266         update_channel = self._driver.execute_script(
 267             "return Services.prefs.getStringPref('app.update.channel');"
 268         )
 269         self._logger.info("Update channel: {}".format(update_channel))
 270         self._driver.set_context("content")
 271         return update_channel == "esr"
 272
 273     def pdf_get_page(self, page, long=False):
 274         waiter = self._longwait if long is True else self._wait
 275         page = waiter.until(
 276             EC.visibility_of_element_located(
 277                 (By.CSS_SELECTOR, "div.page[data-page-number='{}'] canvas".format(page))
 278             )
 279         )
 280
 281         if not self.is_esr():
 282             self._wait.until(
 283                 lambda d: d.execute_script(
 284                     'return window.getComputedStyle(document.querySelector(".loadingInput.start"), "::after").getPropertyValue("visibility");'
 285                 )
 286                 != "visible"
 287             )
 288             # PDF.js can take time to settle and we don't have a nice way to wait
 289             # for an event on it
 290             time.sleep(1)
 291         else:
 292             self._logger.info("Running against ESR, just wait too much.")
 293             # Big but let's be safe, this is only for ESR because its PDF.js
 294             # does not have "<span class='loadingInput start'>"
 295             time.sleep(10)
 296
 297         # Rendering can be slower on debug build so give more time to settle
 298         if self.is_debug_build():
 299             time.sleep(3)
 300
 301         return page
 302
 303     def pdf_go_to_page(self, page):
 304         pagenum = self._wait.until(
 305             EC.visibility_of_element_located((By.ID, "pageNumber"))
 306         )
 307         pagenum.send_keys(Keys.BACKSPACE)
 308         pagenum.send_keys("{}".format(page))
 309
 310     def test_pdf_navigation(self, exp):
 311         """
 312         C3927
 313         """
 314
 315         self.open_tab("http://www.pdf995.com/samples/pdf.pdf")
 316
 317         # Test basic rendering
 318         self.pdf_wait_div()
 319         self.pdf_select_zoom("1")
 320         self.pdf_get_page(1)
 321         self.assert_rendering(exp["base"], self._driver)
 322
 323         # Navigating to page X, we know the PDF has 5 pages.
 324         rand_page = random.randint(1, 5)
 325         self.pdf_go_to_page(rand_page)
 326         # the click step ensures we change page
 327         self.pdf_wait_div().click()
 328         # getting page X will wait on is_displayed() so if page X is not visible
 329         # this will timeout
 330         self.pdf_get_page(rand_page)
 331
 332         # press down/up/right/left/PageDown/PageUp/End/Home
 333         key_presses = [
 334             (Keys.DOWN, "down"),
 335             (Keys.UP, "up"),
 336             (Keys.RIGHT, "right"),
 337             (Keys.LEFT, "left"),
 338             (Keys.PAGE_DOWN, "pagedown"),
 339             (Keys.PAGE_UP, "pageup"),
 340             (Keys.END, "end"),
 341             (Keys.HOME, "home"),
 342         ]
 343
 344         for key, ref in key_presses:
 345             # reset to page 2
 346             self.pdf_go_to_page(2)
 347             pdfjs = self._wait.until(
 348                 EC.visibility_of_element_located((By.CSS_SELECTOR, "html"))
 349             )
 350             pdfjs.send_keys(key)
 351             self.pdf_get_page(2)
 352             # give some time for rendering to update
 353             time.sleep(0.2)
 354             self._logger.info("assert {}".format(ref))
 355             self.assert_rendering(exp[ref], self._driver)
 356
 357         # click Next/Previous page
 358         self.pdf_go_to_page(1)
 359         button_next = self._wait.until(
 360             EC.visibility_of_element_located((By.ID, "next"))
 361         )
 362         button_next.click()
 363         button_next.click()
 364         self._logger.info("assert next twice 1 => 3")
 365         self.assert_rendering(exp["next"], self._driver)
 366
 367         button_previous = self._wait.until(
 368             EC.visibility_of_element_located((By.ID, "previous"))
 369         )
 370         button_previous.click()
 371         self._logger.info("assert previous 3 => 2")
 372         self.assert_rendering(exp["previous"], self._driver)
 373
 374         secondary_menu = self._wait.until(
 375             EC.visibility_of_element_located((By.ID, "secondaryToolbarToggle"))
 376         )
 377
 378         # Use tools button
 379         #  - first/lage page
 380         #  - rotate left/right
 381         #  - doc properties
 382         menu_buttons = [
 383             "firstPage",
 384             "lastPage",
 385             "pageRotateCw",
 386             "pageRotateCcw",
 387             "documentProperties",
 388         ]
 389
 390         for menu_id in menu_buttons:
 391             self._logger.info("reset to page for {}".format(menu_id))
 392             if menu_id != "firstPage":
 393                 self.pdf_go_to_page(1)
 394             else:
 395                 self.pdf_go_to_page(2)
 396             time.sleep(0.2)
 397
 398             self._logger.info("click menu for {}".format(menu_id))
 399             # open menu
 400             secondary_menu.click()
 401
 402             self._logger.info("find button for {}".format(menu_id))
 403             button_to_test = self._wait.until(
 404                 EC.visibility_of_element_located((By.ID, menu_id))
 405             )
 406
 407             self._logger.info("click button for {}".format(menu_id))
 408             button_to_test.click()
 409
 410             # rotation does not close the menu?:
 411             if menu_id == "pageRotateCw" or menu_id == "pageRotateCcw":
 412                 secondary_menu.click()
 413
 414             time.sleep(0.75)
 415
 416             self._logger.info("assert {}".format(menu_id))
 417             if self.is_esr() and menu_id == "documentProperties":
 418                 # on ESR pdf.js misreports in mm instead of inches
 419                 title = self._wait.until(
 420                     EC.visibility_of_element_located((By.ID, "titleField"))
 421                 )
 422                 author = self._wait.until(
 423                     EC.visibility_of_element_located((By.ID, "authorField"))
 424                 )
 425                 subject = self._wait.until(
 426                     EC.visibility_of_element_located((By.ID, "subjectField"))
 427                 )
 428                 version = self._wait.until(
 429                     EC.visibility_of_element_located((By.ID, "versionField"))
 430                 )
 431                 assert title.text == "PDF", "Incorrect PDF title reported: {}".format(
 432                     title
 433                 )
 434                 assert (
 435                     author.text == "Software 995"
 436                 ), "Incorrect PDF author reported: {}".format(author)
 437                 assert (
 438                     subject.text == "Create PDF with Pdf 995"
 439                 ), "Incorrect PDF subject reported: {}".format(subject)
 440                 assert (
 441                     version.text == "1.3"
 442                 ), "Incorrect PDF version reported: {}".format(version)
 443             else:
 444                 self.assert_rendering(exp[menu_id], self._driver)
 445
 446             if menu_id == "documentProperties":
 447                 close = self._wait.until(
 448                     EC.visibility_of_element_located((By.ID, "documentPropertiesClose"))
 449                 )
 450                 close.click()
 451
 452         self.pdf_go_to_page(1)
 453
 454         #  - select text
 455         secondary_menu.click()
 456         text_selection = self._wait.until(
 457             EC.visibility_of_element_located((By.ID, "cursorSelectTool"))
 458         )
 459         text_selection.click()
 460
 461         action = ActionChains(self._driver)
 462         paragraph = self._wait.until(
 463             EC.visibility_of_element_located(
 464                 (By.CSS_SELECTOR, "span[role=presentation]")
 465             )
 466         )
 467         action.drag_and_drop_by_offset(paragraph, 50, 10).perform()
 468         time.sleep(0.75)
 469         self.assert_rendering(exp["select_text"], self._driver)
 470
 471         # release select selection
 472         action.move_by_offset(0, 150).perform()
 473         action.click()
 474         # make sure we go back to page 1
 475         self.pdf_go_to_page(1)
 476
 477         #  - hand tool
 478         secondary_menu.click()
 479         hand_tool = self._wait.until(
 480             EC.visibility_of_element_located((By.ID, "cursorHandTool"))
 481         )
 482         hand_tool.click()
 483         action.drag_and_drop_by_offset(paragraph, 0, -200).perform()
 484         self.assert_rendering(exp["hand_tool"], self._driver)
 485
 486         return True
 487
 488     def test_pdf_zoom(self, exp):
 489         """
 490         C3929
 491         """
 492
 493         self.open_tab("http://www.pdf995.com/samples/pdf.pdf")
 494
 495         self.pdf_wait_div()
 496
 497         zoom_levels = [
 498             ("1", 1, "p1_100p"),
 499             ("0.5", 1, "p1_50p"),
 500             ("0.75", 1, "p1_75p"),
 501             ("1.5", 1, "p1_150p"),
 502             ("4", 1, "p1_400p"),
 503             ("page-actual", 1, "p1_actual"),
 504             ("page-fit", 1, "p1_fit"),
 505             ("page-width", 1, "p1_width"),
 506         ]
 507
 508         for zoom, page, ref in zoom_levels:
 509             self.pdf_select_zoom(zoom)
 510             self.pdf_get_page(page, long=True)
 511             self._logger.info("assert {}".format(ref))
 512             self.assert_rendering(exp[ref], self._driver)
 513
 514         return True
 515
 516     def test_pdf_download(self, exp):
 517         """
 518         C936503
 519         """
 520
 521         self.open_tab(
 522             "https://file-examples.com/index.php/sample-documents-download/sample-pdf-download/"
 523         )
 524
 525         try:
 526             consent = self._wait.until(
 527                 EC.visibility_of_element_located((By.CSS_SELECTOR, ".fc-cta-consent"))
 528             )
 529             consent.click()
 530         except TimeoutException:
 531             self._logger.info("Wait for consent form: timed out, maybe it is not here")
 532
 533         for iframe in self._driver.find_elements(By.CSS_SELECTOR, "iframe"):
 534             self._driver.execute_script("arguments[0].remove();", iframe)
 535
 536         download_button = self._wait.until(
 537             EC.presence_of_element_located((By.CSS_SELECTOR, ".download-button"))
 538         )
 539         self._driver.execute_script("arguments[0].scrollIntoView();", download_button)
 540         self._driver.execute_script("this.window.scrollBy(0, -100);")
 541         self._wait.until(
 542             EC.visibility_of_element_located((By.CSS_SELECTOR, ".download-button"))
 543         )
 544         # clicking seems to break on CI because we nuke ads
 545         self._driver.get(download_button.get_property("href"))
 546
 547         self.pdf_get_page(1)
 548
 549         self.assert_rendering(exp, self._driver)
 550
 551         return True
 552
 553     def context_menu_copy(self, element, mime_type):
 554         action = ActionChains(self._driver)
 555
 556         # Open context menu and copy
 557         action.context_click(element).perform()
 558         self._driver.set_context("chrome")
 559         context_menu = self._wait.until(
 560             EC.visibility_of_element_located((By.ID, "contentAreaContextMenu"))
 561         )
 562         copy = self._wait.until(
 563             EC.visibility_of_element_located(
 564                 (
 565                     By.ID,
 566                     "context-copyimage-contents"
 567                     if mime_type.startswith("image/")
 568                     else "context-copy",
 569                 )
 570             )
 571         )
 572         copy.click()
 573         self.wait_for_element_in_clipboard(mime_type, False)
 574         context_menu.send_keys(Keys.ESCAPE)
 575
 576         # go back to content context
 577         self._driver.set_context("content")
 578
 579     def verify_clipboard(self, mime_type, should_be_present):
 580         self._driver.set_context("chrome")
 581         in_clipboard = self._driver.execute_script(
 582             "return Services.clipboard.hasDataMatchingFlavors([arguments[0]], Ci.nsIClipboard.kGlobalClipboard);",
 583             mime_type,
 584         )
 585         self._driver.set_context("content")
 586         assert (
 587             in_clipboard == should_be_present
 588         ), "type {} should/should ({}) not be in clipboard".format(
 589             mime_type, should_be_present
 590         )
 591
 592     def wait_for_element_in_clipboard(self, mime_type, context_change=False):
 593         if context_change:
 594             self._driver.set_context("chrome")
 595         self._wait.until(
 596             lambda d: self._driver.execute_script(
 597                 "return Services.clipboard.hasDataMatchingFlavors([arguments[0]], Ci.nsIClipboard.kGlobalClipboard);",
 598                 mime_type,
 599             )
 600             is True
 601         )
 602         if context_change:
 603             self._driver.set_context("content")
 604
 605     def test_copy_paste_image_text(self, exp):
 606         """
 607         C464474
 608         """
 609
 610         mystor = self.open_tab("https://mystor.github.io/dragndrop/#")
 611         images = self.open_tab("https://1stwebdesigner.com/image-file-types/")
 612
 613         image = self._wait.until(
 614             EC.presence_of_element_located((By.CSS_SELECTOR, ".wp-image-42224"))
 615         )
 616         self._driver.execute_script("arguments[0].scrollIntoView();", image)
 617         self._wait.until(
 618             EC.visibility_of_element_located((By.CSS_SELECTOR, ".wp-image-42224"))
 619         )
 620         self.verify_clipboard("image/png", False)
 621         self.context_menu_copy(image, "image/png")
 622         self.verify_clipboard("image/png", True)
 623
 624         self._driver.switch_to.window(mystor)
 625         link = self._wait.until(
 626             EC.visibility_of_element_located(
 627                 (By.CSS_SELECTOR, "#testlist > li:nth-child(11) > a:nth-child(1)")
 628             )
 629         )
 630         link.click()
 631         drop_area = self._wait.until(
 632             EC.visibility_of_element_located((By.CSS_SELECTOR, "html"))
 633         )
 634         drop_area.click()
 635         drop_area.send_keys(Keys.CONTROL + "v")
 636         self.verify_clipboard("image/png", True)
 637
 638         matching_text = self._wait.until(
 639             EC.visibility_of_element_located((By.ID, "matching"))
 640         )
 641         assert matching_text.text == "MATCHING", "copy/paste image should match"
 642
 643         self._driver.switch_to.window(images)
 644         text = self._wait.until(
 645             EC.presence_of_element_located(
 646                 (By.CSS_SELECTOR, ".entry-content > p:nth-child(1)")
 647             )
 648         )
 649         self._driver.execute_script("arguments[0].scrollIntoView();", text)
 650
 651         action = ActionChains(self._driver)
 652         action.drag_and_drop_by_offset(text, 50, 10).perform()
 653
 654         self.context_menu_copy(text, "text/plain")
 655
 656         self._driver.switch_to.window(mystor)
 657         link = self._wait.until(
 658             EC.visibility_of_element_located(
 659                 (By.CSS_SELECTOR, "#testlist > li:nth-child(12) > a:nth-child(1)")
 660             )
 661         )
 662         link.click()
 663         drop_area = self._wait.until(
 664             EC.visibility_of_element_located((By.CSS_SELECTOR, "html"))
 665         )
 666         drop_area.click()
 667         drop_area.send_keys(Keys.CONTROL + "v")
 668
 669         matching_text = self._wait.until(
 670             EC.visibility_of_element_located((By.ID, "matching"))
 671         )
 672         assert matching_text.text == "MATCHING", "copy/paste html should match"
 673
 674         return True
 675
 676     def accept_download(self):
 677         # check the Firefox UI
 678         self._driver.set_context("chrome")
 679         download_button = self._wait.until(
 680             EC.visibility_of_element_located((By.ID, "downloads-button"))
 681         )
 682         download_button.click()
 683         time.sleep(1)
 684
 685         blocked_item = self._wait.until(
 686             EC.visibility_of_element_located(
 687                 (By.CSS_SELECTOR, ".download-state .downloadTarget")
 688             )
 689         )
 690         blocked_item.click()
 691         download_name = blocked_item.get_property("value")
 692
 693         download_allow = self._wait.until(
 694             EC.presence_of_element_located(
 695                 (By.ID, "downloadsPanel-blockedSubview-unblockButton")
 696             )
 697         )
 698         download_allow.click()
 699
 700         # back to page
 701         self._driver.set_context("content")
 702
 703         return download_name
 704
 705     def wait_for_download(self):
 706         # check the Firefox UI
 707         self._driver.set_context("chrome")
 708         download_button = self._wait.until(
 709             EC.visibility_of_element_located((By.ID, "downloads-button"))
 710         )
 711         download_button.click()
 712         time.sleep(1)
 713
 714         download_item = self._wait.until(
 715             EC.visibility_of_element_located(
 716                 (By.CSS_SELECTOR, ".download-state .downloadTarget")
 717             )
 718         )
 719         download_name = download_item.get_property("value")
 720
 721         download_progress = self._wait.until(
 722             EC.presence_of_element_located(
 723                 (By.CSS_SELECTOR, ".download-state .downloadProgress")
 724             )
 725         )
 726         self._wait.until(lambda d: download_progress.get_property("value") == 100)
 727
 728         # back to page
 729         self._driver.set_context("content")
 730         return download_name
 731
 732     def change_download_folder(self, previous=None, new=None):
 733         self._logger.info("Download change folder: {} => {}".format(previous, new))
 734         self._driver.set_context("chrome")
 735         self._driver.execute_script(
 736             "Services.prefs.setIntPref('browser.download.folderList', 2);"
 737         )
 738         self._driver.execute_script(
 739             "Services.prefs.setCharPref('browser.download.dir', arguments[0]);", new
 740         )
 741         download_dir_pref = self._driver.execute_script(
 742             "return Services.prefs.getCharPref('browser.download.dir', null);"
 743         )
 744         self._driver.set_context("content")
 745         self._logger.info("Download folder pref: {}".format(download_dir_pref))
 746         assert (
 747             download_dir_pref == new
 748         ), "download directory from pref should match new directory"
 749
 750     def open_lafibre(self):
 751         download_site = self.open_tab("https://ip.lafibre.info/test-debit.php")
 752         return download_site
 753
 754     def test_download_folder_change(self, exp):
 755         """
 756         C1756713
 757         """
 758
 759         download_site = self.open_lafibre()
 760         extra_small = self._wait.until(
 761             EC.presence_of_element_located(
 762                 (
 763                     By.CSS_SELECTOR,
 764                     ".tableau > tbody:nth-child(1) > tr:nth-child(6) > td:nth-child(2) > a:nth-child(1)",
 765                 )
 766             )
 767         )
 768         self._driver.execute_script("arguments[0].click();", extra_small)
 769
 770         download_name = self.accept_download()
 771         self.wait_for_download()
 772
 773         self.open_tab("about:preferences")
 774         download_folder = self._wait.until(
 775             EC.presence_of_element_located((By.ID, "downloadFolder"))
 776         )
 777         previous_folder = (
 778             download_folder.get_property("value")
 779             .replace("\u2066", "")
 780             .replace("\u2069", "")
 781         )
 782         self._logger.info(
 783             "Download folder from about:preferences: {}".format(previous_folder)
 784         )
 785         if not os.path.isabs(previous_folder):
 786             previous_folder = os.path.join(os.environ.get("HOME", ""), previous_folder)
 787         with tempfile.TemporaryDirectory() as tmpdir:
 788             assert os.path.isdir(tmpdir), "tmpdir download should exists"
 789
 790             download_1 = os.path.abspath(os.path.join(previous_folder, download_name))
 791             self._logger.info("Download 1 assert: {}".format(download_1))
 792             assert os.path.isfile(download_1), "downloaded file #1 should exists"
 793
 794             self.change_download_folder(previous_folder, tmpdir)
 795
 796             self._driver.switch_to.window(download_site)
 797             self._driver.execute_script("arguments[0].click();", extra_small)
 798             self.accept_download()
 799             download_name2 = self.wait_for_download()
 800             download_2 = os.path.join(tmpdir, download_name2)
 801
 802             self._logger.info("Download 2 assert: {}".format(download_2))
 803             assert os.path.isfile(download_2), "downloaded file #2 should exists"
 804
 805         return True
 806
 807     def test_download_folder_removal(self, exp):
 808         """
 809         C1756715
 810         """
 811
 812         download_site = self.open_lafibre()
 813         extra_small = self._wait.until(
 814             EC.presence_of_element_located(
 815                 (
 816                     By.CSS_SELECTOR,
 817                     ".tableau > tbody:nth-child(1) > tr:nth-child(6) > td:nth-child(2) > a:nth-child(1)",
 818                 )
 819             )
 820         )
 821
 822         with tempfile.TemporaryDirectory() as tmpdir:
 823             self.change_download_folder(None, tmpdir)
 824
 825             self._driver.switch_to.window(download_site)
 826             self._driver.execute_script("arguments[0].click();", extra_small)
 827
 828             self.accept_download()
 829             download_name = self.wait_for_download()
 830             download_file = os.path.join(tmpdir, download_name)
 831             self._logger.info("Download assert: {}".format(download_file))
 832             assert os.path.isdir(tmpdir), "tmpdir download should exists"
 833             assert os.path.isfile(download_file), "downloaded file should exists"
 834
 835             self._driver.set_context("chrome")
 836             download_button = self._wait.until(
 837                 EC.visibility_of_element_located((By.ID, "downloads-button"))
 838             )
 839             download_button.click()
 840             time.sleep(1)
 841
 842             download_details = self._wait.until(
 843                 EC.visibility_of_element_located(
 844                     (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal")
 845                 )
 846             )
 847             assert download_details.get_property("value").startswith(
 848                 "Completed"
 849             ), "download should be marked as completed"
 850
 851         # TemporaryDirectory out of focus so folder removed
 852
 853         # Close panel we will re-open it
 854         self._driver.execute_script("this.window.DownloadsButton.hide();")
 855         self._wait.until(
 856             EC.invisibility_of_element_located(
 857                 (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal")
 858             )
 859         )
 860
 861         assert os.path.isdir(tmpdir) is False, "tmpdir should have been removed"
 862         assert (
 863             os.path.isfile(download_file) is False
 864         ), "downloaded file should have been removed"
 865
 866         download_button.click()
 867         time.sleep(1)
 868
 869         download_item = self._wait.until(
 870             EC.visibility_of_element_located(
 871                 (By.CSS_SELECTOR, ".download-state .downloadTarget")
 872             )
 873         )
 874         download_name_2 = download_item.get_property("value")
 875         assert download_name == download_name_2, "downloaded names should match"
 876
 877         download_details = self._wait.until(
 878             EC.visibility_of_element_located(
 879                 (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal")
 880             )
 881         )
 882         assert download_details.get_property("value").startswith(
 883             "File moved or missing"
 884         ), "download panel should report file moved/missing"
 885
 886         self._driver.execute_script("this.window.DownloadsButton.hide();")
 887
 888         self._driver.set_context("content")
 889
 890         return True
 891
 892
 893 if __name__ == "__main__":
 894     QATests()