diff options
Diffstat (limited to 'taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py')
| -rw-r--r-- | taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py | 860 |
1 files changed, 860 insertions, 0 deletions
diff --git a/taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py b/taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py new file mode 100644 index 0000000000..781000981e --- /dev/null +++ b/taskcluster/docker/snap-coreXX-build/snap-tests/qa_tests.py @@ -0,0 +1,860 @@ +#!/usr/bin/env python3 +# 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 https://mozilla.org/MPL/2.0/. + + +import os +import random +import tempfile +import time + +from basic_tests import SnapTestsBase +from selenium.common.exceptions import StaleElementReferenceException, TimeoutException +from selenium.webdriver.common.action_chains import ActionChains +from selenium.webdriver.common.by import By +from selenium.webdriver.common.keys import Keys +from selenium.webdriver.support import expected_conditions as EC +from selenium.webdriver.support.select import Select + + +class QATests(SnapTestsBase): + def __init__(self): + self._dir = "qa_tests" + + super(QATests, self).__init__( + exp=os.path.join(self._dir, "qa_expectations.json") + ) + + def _test_audio_playback( + self, url, iframe_selector=None, click_to_play=False, video_selector=None + ): + self._logger.info("open url {}".format(url)) + if url: + self.open_tab(url) + + if iframe_selector: + self._logger.info("find iframe") + iframe = self._driver.find_element(By.CSS_SELECTOR, iframe_selector) + self._driver.switch_to.frame(iframe) + + self._logger.info("find video") + video = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, video_selector or "video") + ) + ) + self._wait.until(lambda d: type(video.get_property("duration")) == float) + assert video.get_property("duration") > 0.0, "<video> duration null" + + # For HE-AAC page, Google Drive does not like SPACE + if not click_to_play and video.get_property("autoplay") is False: + self._logger.info("force play") + video.send_keys(Keys.SPACE) + + # Mostly for Google Drive video, click()/play() seems not to really + # work to trigger, but 'k' is required + if click_to_play: + self._driver.execute_script("arguments[0].click();", video) + video.send_keys("k") + + ref_volume = video.get_property("volume") + + self._logger.info("find video: wait readyState") + self._wait.until(lambda d: video.get_property("readyState") >= 4) + + # Some videos sometimes self-pause? + self._logger.info( + "find video: check paused: {}".format(video.get_property("paused")) + ) + self._logger.info( + "find video: check autoplay: {}".format(video.get_property("autoplay")) + ) + if not click_to_play and video.get_property("paused") is True: + self._driver.execute_script("arguments[0].play()", video) + + self._logger.info("find video: sleep") + # let it play at least 500ms + time.sleep(0.5) + + self._logger.info("find video: wait currentTime") + self._wait.until(lambda d: video.get_property("currentTime") >= 0.01) + assert ( + video.get_property("currentTime") >= 0.01 + ), "<video> currentTime not moved" + + # this should pause + self._logger.info("find video: pause") + if click_to_play: + video.send_keys("k") + else: + self._driver.execute_script("arguments[0].pause()", video) + datum = video.get_property("currentTime") + time.sleep(1) + datum_after_sleep = video.get_property("currentTime") + self._logger.info( + "datum={} datum_after_sleep={}".format(datum, datum_after_sleep) + ) + assert datum == datum_after_sleep, "<video> is sleeping" + assert video.get_property("paused") is True, "<video> is paused" + + self._logger.info("find video: unpause") + # unpause and verify playback + if click_to_play: + video.send_keys("k") + else: + self._driver.execute_script("arguments[0].play()", video) + assert video.get_property("paused") is False, "<video> is not paused" + time.sleep(2) + datum_after_resume = video.get_property("currentTime") + self._logger.info( + "datum_after_resume={} datum_after_sleep={}".format( + datum_after_resume, datum_after_sleep + ) + ) + # we wait for 2s but it's not super accurate on CI (vbox VMs?), + # observed values +/- 15% so check for more that should avoid + # intermittent failures + assert ( + datum_after_resume >= datum_after_sleep + 0.5 + ), "<video> progressed after pause" + + self._logger.info("find video: volume") + self._driver.execute_script( + "arguments[0].volume = arguments[1]", video, ref_volume * 0.25 + ) + assert ( + video.get_property("volume") == ref_volume * 0.25 + ), "<video> sound volume increased" + + self._logger.info("find video: done") + + def _test_audio_video_playback(self, url): + self._logger.info("open url {}".format(url)) + self.open_tab(url) + self._logger.info("find thumbnail") + thumbnail = self._longwait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, "img")) + ) + self._logger.info("click") + self._driver.execute_script("arguments[0].click()", thumbnail) + self._logger.info("audio test") + self._test_audio_playback( + url=None, + iframe_selector="#drive-viewer-video-player-object-0", + click_to_play=True, + ) + + self._logger.info("find video again") + # we are still in the iframe + video = self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, "video")) + ) + self._logger.info("try fullscreen") + promise = self._driver.execute_script( + "return arguments[0].requestFullscreen().then(() => { return true; }).catch(() => { return false; })", + video, + ) + assert promise is True, "<video> full screen promised fullfilled" + + self._driver.execute_script("arguments[0].pause();", video) + self._driver.execute_script("document.exitFullscreen()") + + def test_h264_mov(self, exp): + """ + C95233 + """ + + self._test_audio_video_playback( + "https://drive.google.com/file/d/0BwxFVkl63-lEY3l3ODJReDg3RzQ/view?resourcekey=0-5kDw2QbFk9eLrWE1N9M1rQ" + ) + + return True + + def test_he_aac(self, exp): + """ + C95239 + """ + self._test_audio_playback( + url="https://www2.iis.fraunhofer.de/AAC/multichannel.html", + video_selector="p.inlineVideo > video", + ) + + return True + + def test_flac(self, exp): + """ + C95240 + """ + + self._test_audio_playback( + "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" + ) + + return True + + def test_mp3(self, exp): + """ + C95241 + """ + self._test_audio_playback( + "https://freetestdata.com/wp-content/uploads/2021/09/Free_Test_Data_5MB_MP3.mp3" + ) + + return True + + def test_ogg(self, exp): + """ + C95244 + """ + self._test_audio_playback( + "http://www.metadecks.org/software/sweep/audio/demos/beats1.ogg" + ) + + return True + + def test_custom_fonts(self, exp): + """ + C128146 + """ + + self.open_tab( + "http://codinginparadise.org/projects/svgweb/samples/demo.html?name=droid%20font1" + ) + + renderer = self._wait.until( + EC.visibility_of_element_located((By.ID, "selectRenderer")) + ) + self._wait.until(lambda d: len(renderer.text) > 0) + + renderer_drop = Select(renderer) + renderer_drop.select_by_visible_text("browser native svg") + + font = self._wait.until(EC.visibility_of_element_located((By.ID, "selectSVG"))) + self._wait.until(lambda d: len(font.text) > 0) + + font_drop = Select(font) + font_drop.select_by_value("droid font1") + + svg_div = self._wait.until( + EC.visibility_of_element_located((By.ID, "__svg__random___1__object")) + ) + self._wait.until(lambda d: svg_div.is_displayed() is True) + + self.assert_rendering(exp, svg_div) + + return True + + def pdf_select_zoom(self, value): + pdf_zoom = self._wait.until( + EC.visibility_of_element_located((By.ID, "scaleSelect")) + ) + self._wait.until(lambda d: len(pdf_zoom.text) > 0) + + pdf_zoom_drop = Select(pdf_zoom) + pdf_zoom_drop.select_by_value(value) + + def pdf_wait_div(self): + pdf_div = self._wait.until(EC.visibility_of_element_located((By.ID, "viewer"))) + self._wait.until(lambda d: pdf_div.is_displayed() is True) + return pdf_div + + def pdf_get_page(self, page, long=False): + waiter = self._longwait if long is True else self._wait + page = waiter.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, "div.page[data-page-number='{}'] canvas".format(page)) + ) + ) + + try: + self._wait.until(lambda d: page.is_displayed() is True) + except StaleElementReferenceException as ex: + self._logger.info("Stale element but who cares?: {}".format(ex)) + time.sleep(2) + + # self._wait.until( + # lambda d: d.execute_script( + # 'return window.getComputedStyle(document.querySelector(".loadingInput.start"), "::after").getPropertyValue("visibility");' + # ) + # == "hidden" + # ) + + # PDF.js can take time to settle and we don't have a nice way to wait + # for an event on it + time.sleep(2) + return page + + def pdf_go_to_page(self, page): + pagenum = self._wait.until( + EC.visibility_of_element_located((By.ID, "pageNumber")) + ) + pagenum.send_keys(Keys.BACKSPACE) + pagenum.send_keys("{}".format(page)) + + def test_pdf_navigation(self, exp): + """ + C3927 + """ + + self.open_tab("http://www.pdf995.com/samples/pdf.pdf") + + # Test basic rendering + self.pdf_wait_div() + self.pdf_select_zoom("1") + page_1 = self.pdf_get_page(1) + self.assert_rendering(exp["base"], page_1) + + # Navigating to page X, we know the PDF has 5 pages. + rand_page = random.randint(1, 5) + self.pdf_go_to_page(rand_page) + # the click step ensures we change page + self.pdf_wait_div().click() + # getting page X will wait on is_displayed() so if page X is not visible + # this will timeout + self.pdf_get_page(rand_page) + + # press down/up/right/left/PageDown/PageUp/End/Home + key_presses = [ + (Keys.DOWN, "down"), + (Keys.UP, "up"), + (Keys.RIGHT, "right"), + (Keys.LEFT, "left"), + (Keys.PAGE_DOWN, "pagedown"), + (Keys.PAGE_UP, "pageup"), + (Keys.END, "end"), + (Keys.HOME, "home"), + ] + + for key, ref in key_presses: + # reset to page 2 + self.pdf_go_to_page(2) + pdfjs = self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, "html")) + ) + pdfjs.send_keys(key) + self.pdf_get_page(2) + # give some time for rendering to update + time.sleep(0.2) + self._logger.info("assert {}".format(ref)) + self.assert_rendering(exp[ref], self._driver) + + # click Next/Previous page + self.pdf_go_to_page(1) + button_next = self._wait.until( + EC.visibility_of_element_located((By.ID, "next")) + ) + button_next.click() + button_next.click() + self._logger.info("assert next twice 1 => 3") + self.assert_rendering(exp["next"], self._driver) + + button_previous = self._wait.until( + EC.visibility_of_element_located((By.ID, "previous")) + ) + button_previous.click() + self._logger.info("assert previous 3 => 2") + self.assert_rendering(exp["previous"], self._driver) + + secondary_menu = self._wait.until( + EC.visibility_of_element_located((By.ID, "secondaryToolbarToggle")) + ) + + # Use tools button + # - first/lage page + # - rotate left/right + # - doc properties + menu_buttons = [ + "firstPage", + "lastPage", + "pageRotateCw", + "pageRotateCcw", + "documentProperties", + ] + + for menu_id in menu_buttons: + self._logger.info("reset to page for {}".format(menu_id)) + if menu_id != "firstPage": + self.pdf_go_to_page(1) + else: + self.pdf_go_to_page(2) + time.sleep(0.2) + + self._logger.info("click menu for {}".format(menu_id)) + # open menu + secondary_menu.click() + + self._logger.info("find button for {}".format(menu_id)) + button_to_test = self._wait.until( + EC.visibility_of_element_located((By.ID, menu_id)) + ) + + self._logger.info("click button for {}".format(menu_id)) + button_to_test.click() + + # rotation does not close the menu?: + if menu_id == "pageRotateCw" or menu_id == "pageRotateCcw": + secondary_menu.click() + + time.sleep(0.2) + + self._logger.info("assert {}".format(menu_id)) + self.assert_rendering(exp[menu_id], self._driver) + + if menu_id == "documentProperties": + close = self._wait.until( + EC.visibility_of_element_located((By.ID, "documentPropertiesClose")) + ) + close.click() + + self.pdf_go_to_page(1) + + # - select text + secondary_menu.click() + text_selection = self._wait.until( + EC.visibility_of_element_located((By.ID, "cursorSelectTool")) + ) + text_selection.click() + + action = ActionChains(self._driver) + paragraph = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, "span[role=presentation]") + ) + ) + action.drag_and_drop_by_offset(paragraph, 50, 10).perform() + self.assert_rendering(exp["select_text"], self._driver) + + # release select selection + action.move_by_offset(0, 150).perform() + action.click() + # make sure we go back to page 1 + self.pdf_go_to_page(1) + + # - hand tool + secondary_menu.click() + hand_tool = self._wait.until( + EC.visibility_of_element_located((By.ID, "cursorHandTool")) + ) + hand_tool.click() + action.drag_and_drop_by_offset(paragraph, 0, -200).perform() + self.assert_rendering(exp["hand_tool"], self._driver) + + return True + + def test_pdf_zoom(self, exp): + """ + C3929 + """ + + self.open_tab("http://www.pdf995.com/samples/pdf.pdf") + + self.pdf_wait_div() + + zoom_levels = [ + ("1", 1, "p1_100p"), + ("0.5", 1, "p1_50p"), + ("0.75", 1, "p1_75p"), + ("1.5", 1, "p1_150p"), + ("4", 1, "p1_400p"), + ("page-actual", 1, "p1_actual"), + ("page-fit", 1, "p1_fit"), + ("page-width", 1, "p1_width"), + ] + + for zoom, page, ref in zoom_levels: + self.pdf_select_zoom(zoom) + self.pdf_get_page(page) + self._logger.info("assert {}".format(ref)) + self.assert_rendering(exp[ref], self._driver) + + return True + + def test_pdf_download(self, exp): + """ + C936503 + """ + + self.open_tab( + "https://file-examples.com/index.php/sample-documents-download/sample-pdf-download/" + ) + + try: + consent = self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, ".fc-cta-consent")) + ) + consent.click() + except TimeoutException: + self._logger.info("Wait for consent form: timed out, maybe it is not here") + + for iframe in self._driver.find_elements(By.CSS_SELECTOR, "iframe"): + self._driver.execute_script("arguments[0].remove();", iframe) + + download_button = self._wait.until( + EC.presence_of_element_located((By.CSS_SELECTOR, ".download-button")) + ) + self._driver.execute_script("arguments[0].scrollIntoView();", download_button) + self._driver.execute_script("this.window.scrollBy(0, -100);") + self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, ".download-button")) + ) + # clicking seems to break on CI because we nuke ads + self._driver.get(download_button.get_property("href")) + + self.pdf_get_page(1) + + self.assert_rendering(exp, self._driver) + + return True + + def context_menu_copy(self, element, mime_type): + action = ActionChains(self._driver) + + # Open context menu and copy + action.context_click(element).perform() + self._driver.set_context("chrome") + context_menu = self._wait.until( + EC.visibility_of_element_located((By.ID, "contentAreaContextMenu")) + ) + copy = self._wait.until( + EC.visibility_of_element_located( + ( + By.ID, + "context-copyimage-contents" + if mime_type.startswith("image/") + else "context-copy", + ) + ) + ) + copy.click() + self.wait_for_element_in_clipboard(mime_type, False) + context_menu.send_keys(Keys.ESCAPE) + + # go back to content context + self._driver.set_context("content") + + def verify_clipboard(self, mime_type, should_be_present): + self._driver.set_context("chrome") + in_clipboard = self._driver.execute_script( + "return Services.clipboard.hasDataMatchingFlavors([arguments[0]], Ci.nsIClipboard.kGlobalClipboard);", + mime_type, + ) + self._driver.set_context("content") + assert ( + in_clipboard == should_be_present + ), "type {} should/should ({}) not be in clipboard".format( + mime_type, should_be_present + ) + + def wait_for_element_in_clipboard(self, mime_type, context_change=False): + if context_change: + self._driver.set_context("chrome") + self._wait.until( + lambda d: self._driver.execute_script( + "return Services.clipboard.hasDataMatchingFlavors([arguments[0]], Ci.nsIClipboard.kGlobalClipboard);", + mime_type, + ) + is True + ) + if context_change: + self._driver.set_context("content") + + def test_copy_paste_image_text(self, exp): + """ + C464474 + """ + + mystor = self.open_tab("https://mystor.github.io/dragndrop/#") + images = self.open_tab("https://1stwebdesigner.com/image-file-types/") + + image = self._wait.until( + EC.presence_of_element_located((By.CSS_SELECTOR, ".wp-image-42224")) + ) + self._driver.execute_script("arguments[0].scrollIntoView();", image) + self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, ".wp-image-42224")) + ) + self.verify_clipboard("image/png", False) + self.context_menu_copy(image, "image/png") + self.verify_clipboard("image/png", True) + + self._driver.switch_to.window(mystor) + link = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, "#testlist > li:nth-child(11) > a:nth-child(1)") + ) + ) + link.click() + drop_area = self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, "html")) + ) + drop_area.click() + drop_area.send_keys(Keys.CONTROL + "v") + self.verify_clipboard("image/png", True) + + matching_text = self._wait.until( + EC.visibility_of_element_located((By.ID, "matching")) + ) + assert matching_text.text == "MATCHING", "copy/paste image should match" + + self._driver.switch_to.window(images) + text = self._wait.until( + EC.presence_of_element_located( + (By.CSS_SELECTOR, ".entry-content > p:nth-child(1)") + ) + ) + self._driver.execute_script("arguments[0].scrollIntoView();", text) + + action = ActionChains(self._driver) + action.drag_and_drop_by_offset(text, 50, 10).perform() + + self.context_menu_copy(text, "text/plain") + + self._driver.switch_to.window(mystor) + link = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, "#testlist > li:nth-child(12) > a:nth-child(1)") + ) + ) + link.click() + drop_area = self._wait.until( + EC.visibility_of_element_located((By.CSS_SELECTOR, "html")) + ) + drop_area.click() + drop_area.send_keys(Keys.CONTROL + "v") + + matching_text = self._wait.until( + EC.visibility_of_element_located((By.ID, "matching")) + ) + assert matching_text.text == "MATCHING", "copy/paste html should match" + + return True + + def accept_download(self): + # check the Firefox UI + self._driver.set_context("chrome") + download_button = self._wait.until( + EC.visibility_of_element_located((By.ID, "downloads-button")) + ) + download_button.click() + time.sleep(1) + + blocked_item = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadTarget") + ) + ) + blocked_item.click() + download_name = blocked_item.get_property("value") + + download_allow = self._wait.until( + EC.presence_of_element_located( + (By.ID, "downloadsPanel-blockedSubview-unblockButton") + ) + ) + download_allow.click() + + # back to page + self._driver.set_context("content") + + return download_name + + def wait_for_download(self): + # check the Firefox UI + self._driver.set_context("chrome") + download_button = self._wait.until( + EC.visibility_of_element_located((By.ID, "downloads-button")) + ) + download_button.click() + time.sleep(1) + + download_item = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadTarget") + ) + ) + download_name = download_item.get_property("value") + + download_progress = self._wait.until( + EC.presence_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadProgress") + ) + ) + self._wait.until(lambda d: download_progress.get_property("value") == 100) + + # back to page + self._driver.set_context("content") + return download_name + + def change_download_folder(self, previous=None, new=None): + self._logger.info("Download change folder: {} => {}".format(previous, new)) + self._driver.set_context("chrome") + self._driver.execute_script( + "Services.prefs.setIntPref('browser.download.folderList', 2);" + ) + self._driver.execute_script( + "Services.prefs.setCharPref('browser.download.dir', arguments[0]);", new + ) + download_dir_pref = self._driver.execute_script( + "return Services.prefs.getCharPref('browser.download.dir', null);" + ) + self._driver.set_context("content") + self._logger.info("Download folder pref: {}".format(download_dir_pref)) + assert ( + download_dir_pref == new + ), "download directory from pref should match new directory" + + def open_thinkbroadband(self): + download_site = self.open_tab("https://www.thinkbroadband.com/download") + try: + consent = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".t-acceptAllButton") + ) + ) + consent.click() + except TimeoutException: + self._logger.info("Wait for consent form: timed out, maybe it is not here") + return download_site + + def test_download_folder_change(self, exp): + """ + C1756713 + """ + + download_site = self.open_thinkbroadband() + extra_small = self._wait.until( + EC.presence_of_element_located( + ( + By.CSS_SELECTOR, + "div.module:nth-child(8) > p:nth-child(1) > a:nth-child(1)", + ) + ) + ) + self._driver.execute_script("arguments[0].click();", extra_small) + + download_name = self.accept_download() + self.wait_for_download() + + self.open_tab("about:preferences") + download_folder = self._wait.until( + EC.presence_of_element_located((By.ID, "downloadFolder")) + ) + previous_folder = ( + download_folder.get_property("value") + .replace("\u2066", "") + .replace("\u2069", "") + ) + self._logger.info( + "Download folder from about:preferences: {}".format(previous_folder) + ) + if not os.path.isabs(previous_folder): + previous_folder = os.path.join(os.environ.get("HOME", ""), previous_folder) + with tempfile.TemporaryDirectory() as tmpdir: + assert os.path.isdir(tmpdir), "tmpdir download should exists" + + download_1 = os.path.abspath(os.path.join(previous_folder, download_name)) + self._logger.info("Download 1 assert: {}".format(download_1)) + assert os.path.isfile(download_1), "downloaded file #1 should exists" + + self.change_download_folder(previous_folder, tmpdir) + + self._driver.switch_to.window(download_site) + self._driver.execute_script("arguments[0].click();", extra_small) + self.accept_download() + download_name2 = self.wait_for_download() + download_2 = os.path.join(tmpdir, download_name2) + + self._logger.info("Download 2 assert: {}".format(download_2)) + assert os.path.isfile(download_2), "downloaded file #2 should exists" + + return True + + def test_download_folder_removal(self, exp): + """ + C1756715 + """ + + download_site = self.open_thinkbroadband() + extra_small = self._wait.until( + EC.presence_of_element_located( + ( + By.CSS_SELECTOR, + "div.module:nth-child(8) > p:nth-child(1) > a:nth-child(1)", + ) + ) + ) + + with tempfile.TemporaryDirectory() as tmpdir: + self.change_download_folder(None, tmpdir) + + self._driver.switch_to.window(download_site) + self._driver.execute_script("arguments[0].click();", extra_small) + + self.accept_download() + download_name = self.wait_for_download() + download_file = os.path.join(tmpdir, download_name) + self._logger.info("Download assert: {}".format(download_file)) + assert os.path.isdir(tmpdir), "tmpdir download should exists" + assert os.path.isfile(download_file), "downloaded file should exists" + + self._driver.set_context("chrome") + download_button = self._wait.until( + EC.visibility_of_element_located((By.ID, "downloads-button")) + ) + download_button.click() + time.sleep(1) + + download_details = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal") + ) + ) + assert download_details.get_property("value").startswith( + "Completed" + ), "download should be marked as completed" + + # TemporaryDirectory out of focus so folder removed + + # Close panel we will re-open it + self._driver.execute_script("this.window.DownloadsButton.hide();") + self._wait.until( + EC.invisibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal") + ) + ) + + assert os.path.isdir(tmpdir) is False, "tmpdir should have been removed" + assert ( + os.path.isfile(download_file) is False + ), "downloaded file should have been removed" + + download_button.click() + time.sleep(1) + + download_item = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadTarget") + ) + ) + download_name_2 = download_item.get_property("value") + assert download_name == download_name_2, "downloaded names should match" + + download_details = self._wait.until( + EC.visibility_of_element_located( + (By.CSS_SELECTOR, ".download-state .downloadDetailsNormal") + ) + ) + assert download_details.get_property("value").startswith( + "File moved or missing" + ), "download panel should report file moved/missing" + + self._driver.execute_script("this.window.DownloadsButton.hide();") + + self._driver.set_context("content") + + return True + + +if __name__ == "__main__": + QATests() |