def download_lesson(driver: WebDriver, lesson: WebElement, module_path: pathlib.Path) -> None: lesson_url = lesson.get_attribute('href') course_page = driver.current_window_handle driver.execute_script('window.open()') driver.switch_to.window(driver.window_handles[1]) driver.get(lesson_url) youtube_url = get_youtube_url(driver) if youtube_url is not None: # BUG: the output option is not working; fix it; output_path = module_path / '%(title)s.%(ext)s' ydl_opts = { 'output': str(output_path), 'retries': 10, } try: with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([youtube_url]) except youtube_dl.utils.DownloadError as e: print(e) driver.close() driver.switch_to.window(course_page)
def increase_quantity_to_two(driver: WebDriver): print("Attempting to increase quantity to two!") # Open quantity selection quantity_open_button = "guest-counter" WebDriverWait(driver, 5).until( EC.presence_of_element_located((By.ID, quantity_open_button))) open_quantity_button = driver.find_element_by_id(quantity_open_button) driver.execute_script("arguments[0].click();", open_quantity_button) # Find the div that holds the increase quantity button div_holder_of_increase_button = "rec-guest-counter-row" WebDriverWait(driver, 5).until( EC.presence_of_element_located( (By.CLASS_NAME, div_holder_of_increase_button))) open_div_holder_of_increase_button: WebElement = driver.find_element_by_class_name( div_holder_of_increase_button) # Get the button we want from within this element plus_and_minus_button_class_name = "sarsa-button-subtle" buttons = open_div_holder_of_increase_button.find_elements_by_class_name( plus_and_minus_button_class_name) select_plus_button = buttons[1] driver.execute_script("arguments[0].click();", select_plus_button) # # Hit close and continue (probably not needed) # close_button_selector = "sarsa-button-link" # button = open_div_holder_of_increase_button.find_element_by_class_name(close_button_selector) # driver.execute_script("arguments[0].click();", button) print("Successful at increasing quantity to two!")
def log_in(driver: WebDriver): print("Logging in...") global PASSWORD, USERNAME username = USERNAME password = PASSWORD sign_in_div: WebElement = driver.find_element_by_class_name("nav-user-sign-in") # type: ignore sign_in_buttons: list[WebElement] = sign_in_div.find_elements_by_class_name("nav-header-button") for button in sign_in_buttons: if button.text == "Log In": driver.execute_script("arguments[0].click();", button) email_input = driver.find_element_by_id("rec-acct-sign-in-email-address") password_input = driver.find_element_by_id("rec-acct-sign-in-password") email_input.send_keys(username) # type: ignore password_input.send_keys(password) # type: ignore # Press Log In Button log_in_btn = driver.find_element_by_class_name("rec-acct-sign-in-btn") driver.execute_script("arguments[0].click();", log_in_btn) print("Logged in.") # Wait till login page is gone. WebDriverWait(driver, 10).until(EC.invisibility_of_element((By.ID, "signInModalHeading")))
def installAddon_cleanTabs_getLoginWindow(self, driver: WebDriver) -> None: """ 1) Install UblockOrigin 2) If any "welcome" windows open, close them 3) Click on login button """ driver.install_addon( f"{self.cfg['EXTENSIONS']['FOX_EXT_BASE_PATH']}/{self.cfg['EXTENSIONS']['UBO']}" ) driver.get(self.cfg["LOGIN"]["LOGIN_FROM"]) WebDriverWait(self.driver, 7).until( EC.presence_of_all_elements_located((By.TAG_NAME, "main"))) # wait for the page to load # Points to ww login-page MAIN_HANDLE: str = driver.current_window_handle for window_handle in driver.window_handles: if window_handle != MAIN_HANDLE: driver.switch_to.window(window_handle) # after closing all irrelevant tabs driver will focus back to the main one driver.close() # Puts focus back on ww login-page driver.switch_to.window(MAIN_HANDLE) # Use this stuff to setup the login window (You don't want any junk in some new tab) sleep(2) # click the first button on the page, it will make login button visible driver.execute_script( self.clickFirstElementFromElementList("button") + self.clickElementWithInnerTextS("button", "log in"))
class BaseLiveServerTestCase(LiveServerTestCase): def setUp(self): get_or_create_test_admin() self.browser = WebDriver() self.do_admin_login('test', 'test') def tearDown(self): self.browser.quit() def do_admin_login(self, username, password): self.browser.get('%s%s' % (self.live_server_url, '/admin/')) username_input = self.browser.find_element_by_name("username") username_input.send_keys(username) password_input = self.browser.find_element_by_name("password") password_input.send_keys(password) self.browser.find_element_by_xpath('//input[@value="Log in"]').click() def new_window(self, name='other'): self.browser.execute_script('window.open("/admin/", "'+ name +'")') self.browser.switch_to_window(self.browser.window_handles[1]) while self.warning_element() is False: time.sleep(0.1) self.browser.switch_to_window(self.browser.window_handles[0]) def press_space(self): a = ActionChains(self.browser) a.key_down(Keys.SPACE) a.perform() def wait_for_pages_loaded(self): for win in self.browser.window_handles: while self.warning_element() is False: time.sleep(0.1)
class StickToTopTest(LiveServerTestCase): def setUp(self): self.browser = WebDriver() self.browser.implicitly_wait(3) self.n1 = Node.objects.create( title='TestNodeOne', description='The first test node' ) self.u1 = User.objects.create_user( username='******', email='*****@*****.**', password='******' ) self.super_user = User.objects.create_user( username='******', email='*****@*****.**', password='******' ) self.super_user.is_superuser = True self.super_user.is_staff = True self.super_user.save() # Create 99 topics for i in range(1, 100): setattr( self, 't%s' % i, Topic.objects.create( title='Test Topic %s' % i, user=self.u1, content_raw='This is test topic __%s__' % i, node=self.n1 ) ) def tearDown(self): self.browser.quit() def test_stick_to_top_admin(self): self.browser.get(self.live_server_url + reverse("niji:index")) login(self.browser, 'super', '123') self.assertIn("Log out", self.browser.page_source) lucky_topic1 = getattr(self, 't%s' % random.randint(1, 50)) self.browser.get(self.live_server_url+reverse('niji:topic', kwargs={"pk": lucky_topic1.pk})) self.browser.find_element_by_class_name('move-topic-up').click() up_level = WebDriverWait( self.browser, 10 ).until( expected_conditions.presence_of_element_located( (By.NAME, 'move-topic-up-level') ) ) up_level = Select(up_level) up_level.select_by_visible_text('1') time.sleep(1) self.browser.execute_script("$('.modal-confirm').click()") self.browser.get(self.live_server_url+reverse('niji:index')) first_topic_title = self.browser.find_elements_by_class_name('entry-link')[0].text self.assertEqual(first_topic_title, lucky_topic1.title)
def scroll_down(driver: WebDriver): scrollheight = driver.execute_script("return document.body.scrollHeight") if type(scrollheight) == str: scrollheight = int(scrollheight) ## lets finish the page scroll by 10 count scroll_amount = scrollheight / 10 ### not we might have some remainder for num in range(11): scrollable = scroll_amount * (num + 1) driver.execute_script(f"window.scrollTo(0, {scrollable});") time.sleep(0.3) driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
def open_link_in_new_tab(browser: webdriver.WebDriver, url: str): logging.info("Opening the new tab with the url {}".format(url)) browser.execute_script("window.open('{}', 'new_window')".format(url)) logging.info("Waiting for the tab to be opened") WebDriverWait(browser, 10).until(ec.new_window_is_opened) logging.info("Switching to newly opened tab") browser.switch_to.window( browser.window_handles[get_last_opened_tab_id(browser)]) WebDriverWait(browser, 10).until(ec.url_contains(url))
def parse_all_saints(driver: WebDriver, url): driver.get(get_url_view(url)) driver.implicitly_wait(30) time.sleep(10) try: driver.execute_script("window.scrollTo(0, 40000)") time.sleep(10) except NoSuchElementException: pass product_list = make_soup(driver.page_source).find_all("div", class_="product") return map(parse_product, product_list)
def add_campsite_to_cart( driver: WebDriver, rows: list[WebElement], desired_date: str, prefer_sites=set(range(107, 125)), reserved_count: int = 0, ): global curr_site, url_of_site for row in rows: campsite: list[WebElement] = row.find_elements_by_class_name("rec-availability-item") assert len(campsite) == 1 campsite_num = campsite[0].text matched: list[WebElement] = row.find_elements_by_class_name("rec-availability-date") for element in matched: aria_label: str = element.get_attribute("aria-label") date_from_aria = aria_label.split(" - ")[0] availability = element.text # print( # f"Campsite {campsite_num} at Date {date_from_aria} is currently: {'available' if availability not in ['R', 'X'] else 'reserved'}" # ) parsed_date = parse_dates(desired_date) if date_from_aria != parsed_date: continue if availability not in ["R", "X"]: driver.execute_script("arguments[0].click();", element) print(f"Pressed Button on {desired_date} for campsite: {campsite_num}") add_to_cart = driver.find_element_by_class_name("availability-page-book-now-button-tracker") driver.execute_script("arguments[0].click();", add_to_cart) print(f"Pressed add to cart for campsite {campsite_num} at date {desired_date}") send_discord_notification( f"Campsite {campsite_num} available at date: {parsed_date}!", curr_site, url_of_site ) # for _ in range(5): # playsound('beep-01a.mp3') time.sleep(2) check_availability_and_reserve(driver, url_of_site, reserved_count + 1) return print("No available sites. Nothing has been added to cart.")
def run(*, driver: WebDriver, url: str, opt: int): driver.get(url) try: main_node = driver.find_element_by_xpath("/html/body/form/div[1]") els: list = main_node.find_elements_by_tag_name("input") el = els[int(opt) - 1] driver.execute_script("arguments[0].click();", el) # delay time.sleep(3) logger.info("ok") except: # noqa logger.info("ko") finally: driver.close()
def refresh_table(driver: WebDriver): # Be wary of the booking notification block after hitting add to cart. # need to navigate around it. It's class name is: booking-notification-block buttons: list[WebElement] = driver.find_elements_by_class_name("sarsa-button-sm") # type: ignore smart_sleep() print("Looking for refresh table button.") for button in buttons: span_contents: list[WebElement] = driver.find_elements_by_class_name("sarsa-button-content") # type: ignore for content in span_contents: if content.text == "Refresh Table": print("Refreshing table.") driver.execute_script("arguments[0].click();", button) return
def parse_topman_page(driver: WebDriver, url): driver.get(url) driver.implicitly_wait(15) time.sleep(5) set_grid_to_4(driver) sources = [driver.page_source] position = 700 while not is_bottom(driver): driver.execute_script("window.scrollTo(0, {})".format(position)) sources.append(driver.page_source) time.sleep(0.3) position += 700 product_list = (make_soup(source).find_all("div", class_="product") for source in sources) items = [] for l in product_list: items.extend(filter(bool, map(parse_product, l))) return items
def harvestChapterLinks(self, driver: WebDriver, novelPageUrl: str): """ 1) Assuming in novel page -> open "Chapters" section 2) Find div elements with chapter links 3) Get the returned list of chapter links NOTE: You NEED to be in the novel_page for this to work """ driver.get(novelPageUrl) sleep(5) driver.execute_script(self.clickElementWithInnerTextS("button", "chapters")) driver.execute_script(self.openAccordian(self.accordianText)) sleep(2) clsTuple = ("grid", "grid-cols-1", "md:grid-cols-2", "w-full") divList = driver.find_elements( By.XPATH, self.getXpathStrFrClsNames("div", *clsTuple), ) return get_hrefList(divList)
def get_links_on_mobile_website(driver: WebDriver) -> List[str]: page_num = 0 outer_html = "" driver.get(mobile_website_url) try: while True: driver.find_element_by_css_selector('#btn_showmore').click() page_num += 1 print(f'getting page number {str(page_num)}') time.sleep(1) outer_html_new = driver.execute_script("return document.documentElement.outerHTML") if outer_html == outer_html_new: break outer_html = outer_html_new except Exception as e: print('Aborting page load:', e) new_links = get_links_from_driver(driver) print(f'Found {len(new_links)} links on mobile') return new_links
def test_selenium_works(): """ Initialize and authenticate the selenium driver """ options = Options() print("CI:", os.getenv("CI")) print("PATH:", os.getenv("PATH")) if os.getenv("CI"): options.headless = True options.log.level = "trace" print(list(Path().iterdir())) try: driver = WebDriver(firefox_options=options) driver.get("https://example.com") content = driver.execute_script( "return document.getElementsByTagName('html')[0].innerHTML") except Exception as exc: print("Exception happened!", exc) print(list(Path().iterdir())) raise assert 'This domain is for use in illustrative examples in documents' in content
).click() try: WebDriverWait(driver, args.timeout).until( EC.visibility_of_element_located( (By.XPATH, "//div[contains(text(),'User name or password incorrect')]"))) print(bad("User name or password incorrect")) driver.quit() exit(1) except TimeoutException: print(good("Successfully Logged in")) driver.find_element_by_xpath( "//span[contains(text(),'Open/Close Extensions')]").click() last_height = driver.execute_script("return document.body.scrollHeight") while True: driver.execute_script("window.scrollTo(0, document.body.scrollHeight);") time.sleep(args.timeout) new_height = driver.execute_script("return document.body.scrollHeight") if new_height == last_height: break last_height = new_height driver.find_element_by_xpath( "//body/div[@id='oe_container']/div[@id='oe_admin-content']/div[@id='oe_sidebar']/aside[1]/nav[1]/ul[1]/li[5]/ul[1]/li[6]/a[1]" ).click() driver.find_element_by_xpath( "//a[contains(text(),'Add User Defined Tag')]").click() print(info("Creating vulnerable user tag")) driver.find_element_by_xpath("//input[@id='name']").send_keys(U) driver.find_element_by_xpath("//textarea[@id='udtcode']").send_keys(
class ScriptTestCase(LiveServerTestCase): def setUp(self): self.browser = WebDriver() self.do_admin_login('test', 'test') def tearDown(self): self.browser.quit() def do_admin_login(self, username, password): self.browser.get('%s%s' % (self.live_server_url, '/admin/')) username_input = self.browser.find_element_by_name("username") username_input.send_keys(username) password_input = self.browser.find_element_by_name("password") password_input.send_keys(password) self.browser.find_element_by_xpath('//input[@value="Log in"]').click() def new_window(self, name='other'): self.browser.execute_script('window.open("/admin/", "'+ name +'")') self.browser.switch_to_window(self.browser.window_handles[1]) while self.warning_element() is False: time.sleep(0.1) self.browser.switch_to_window(self.browser.window_handles[0]) def press_space(self): a = ActionChains(self.browser) a.key_down(Keys.SPACE) a.perform() def warning_element(self): try: return self.browser.find_elements_by_css_selector( '#session_security_warning')[0] except IndexError: return False def wait_for_pages_loaded(self): for win in self.browser.window_handles: while self.warning_element() is False: time.sleep(0.1) def deadline_passed(self, now, deadline): return (datetime.now() - now).seconds > deadline def assertWarningShows(self, max_seconds): now = datetime.now() for win in self.browser.window_handles: self.browser.switch_to_window(win) while self.warning_element() is False: time.sleep(0.1) if self.deadline_passed(now, max_seconds): self.fail('Warning did not make it into DOM') for win in self.browser.window_handles: self.browser.switch_to_window(win) while self.warning_element().is_displayed() is False: time.sleep(0.1) if self.deadline_passed(now, max_seconds): self.fail('Warning did not make it into DOM') def assertWarningHides(self, max_seconds): now = datetime.now() for win in self.browser.window_handles: self.browser.switch_to_window(win) while self.warning_element().is_displayed() is not False: time.sleep(0.1) if self.deadline_passed(now, max_seconds): self.fail('Warning did not hide') def assertExpires(self, max_seconds): now = datetime.now() for win in self.browser.window_handles: self.browser.switch_to_window(win) while self.warning_element() is not False: time.sleep(0.1) if self.deadline_passed(now, max_seconds): self.fail('Warning did not make it out of DOM') def assertWarningShown(self): for win in self.browser.window_handles: self.browser.switch_to_window(win) self.assertTrue(self.warning_element().is_displayed()) def assertWarningHidden(self): for win in self.browser.window_handles: self.browser.switch_to_window(win) self.assertFalse(self.warning_element().is_displayed()) def assertWarningNotInPage(self): for win in self.browser.window_handles: self.browser.switch_to_window(win) self.assertTrue(self.warning_element() is False) def test_single_window_inactivity(self): self.wait_for_pages_loaded() self.assertWarningHidden() self.assertWarningShows(9) self.assertExpires(9) def test_single_dont_show_warning(self): self.wait_for_pages_loaded() self.assertWarningHidden() time.sleep(3.5) self.press_space() self.assertWarningHidden() time.sleep(4) self.assertWarningHidden() def test_single_hide_warning(self): self.assertWarningShows(9) self.press_space() self.assertWarningHides(2) def test_double_window_inactivity(self): self.new_window() self.wait_for_pages_loaded() self.assertWarningHidden() self.assertWarningShows(9) self.assertExpires(9) def test_double_dont_show_warning(self): self.new_window() self.wait_for_pages_loaded() self.assertWarningHidden() time.sleep(3.5) self.press_space() self.assertWarningHidden() time.sleep(4) self.assertWarningHidden() def test_double_hide_warning(self): self.new_window() self.assertWarningShows(9) self.press_space() self.assertWarningHides(6)
class LiveServerTest(object): fixtures = ['rules.json'] DOWNLOAD_DIRECTORY = '/tmp/work/downloads' ## List all ajax enabled pages that have initialization code and must wait AJAX_WAIT = ['mock_galaxy_factory', 'view_job'] SUMMARY_INDEX = str(len(MODULE_INDICES)+1) OUTPUT_FORMATS = [ {'value':'csv', 'text':'CSV (Text)', 'extension':'csv'}, {'value':'hdf5', 'text':'HDF5', 'extension':'hdf5'}, {'value': 'fits', 'text': 'FITS', 'extension': 'fits'}, {'value': 'votable', 'text': 'VOTable', 'extension': 'xml'} ] def wait(self, secs=1): time.sleep(secs * 1.0) def setUp(self): from selenium.webdriver.firefox.webdriver import FirefoxProfile fp = FirefoxProfile() fp.set_preference("browser.download.folderList", 2) fp.set_preference("browser.download.dir", self.DOWNLOAD_DIRECTORY) fp.set_preference("browser.helperApps.neverAsk.saveToDisk", "text/html, application/zip, text/plain, application/force-download, application/x-tar") self.selenium = WebDriver(firefox_profile=fp) self.selenium.implicitly_wait(1) # wait one second before failing to find # create the download dir if not os.path.exists(self.DOWNLOAD_DIRECTORY): os.makedirs(self.DOWNLOAD_DIRECTORY) def tearDown(self): self.selenium.quit() # remove the download dir for root, dirs, files in os.walk(self.DOWNLOAD_DIRECTORY, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) def lc_id(self, bare_field): return '#id_light_cone-%s' % bare_field def lc_2select(self, bare_field): return 'id_light_cone-output_properties_%s' % bare_field def rf_id(self, bare_field): return '#id_record_filter-%s' % bare_field def sed(self, bare_field): return 'id_sed-%s' % bare_field def mi_id(self, bare_field): return 'id_mock_image-%s' % bare_field def sed_id(self, bare_field): return '#%s' % self.sed(bare_field) def sed_2select(self, bare_field): return 'id_sed-band_pass_filters_%s' % bare_field def job_select(self, bare_field): return 'id-job_%s' % bare_field def job_id(self, bare_field): return '#%s' % self.job_select(bare_field) def get_parent_element(self, element): return self.selenium.execute_script('return arguments[0].parentNode;', element) def get_element_css_classes(self, element): list = [] found = element.get_attribute('class') if found is not None: list = found.split() return list def get_closest_by_class(self, element, css_class): while css_class not in self.get_element_css_classes(element): element = self.get_parent_element(element) return element def get_summary_selector(self, form_name, field_name): return 'div.summary_%s .%s' % (form_name, field_name) def get_summary_field(self, form_name, field_name): summary_selector = self.get_summary_selector(form_name, field_name) return self.selenium.find_element_by_css_selector(summary_selector) def get_summary_field_text(self, form_name, field_name): return self.get_summary_field(form_name, field_name).text def get_info_field(self, section, field): elem = self.selenium.find_element_by_css_selector("div.%(section)s-info .%(field)s" % {'section': section, 'field': field}) return elem.text def find_element_by_css_selector(self, selector): retries = 3 while retries > 0: try: elem = self.selenium.find_element_by_css_selector(selector) return elem except NoSuchElementException: retries -= 1 self.wait(1) # If it hasn't been found by now, try one more time and let the exception through return self.selenium.find_element_by_css_selector(selector) def find_element_by_id(self, elem_id): retries = 3 while retries > 0: try: elem = self.selenium.find_element_by_id(elem_id) return elem except NoSuchElementException: retries -= 1 self.wait(1) # If it hasn't been found by now, try one more time and let the exception through return self.selenium.find_element_by_id(elem_id) def assert_email_body_contains(self, email, text): pattern = re.escape(text) matches = re.search(pattern, email.body) self.assertTrue(matches, "Email does not contain " + text) def get_page_source(self): try: return self.selenium.page_source except: while True: self.wait(0.2) try: self.selenium.switch_to_alert().accept() except: return self.selenium.page_source def assertTrue(self, value, msg): if not value: raise AssertionError(msg) return def assertEqual(self, vala, valb): if vala != valb: msg = 'FAIL: "{0}" != "{1}"'.format(vala, valb) raise AssertionError(msg) return def assert_page_has_content(self, string): page_source = self.get_page_source() pattern = re.escape(string) self.assertTrue((string in page_source) or re.search(pattern, page_source), "page source did not contain %s" % pattern) def assert_page_does_not_contain(self, string): page_source = self.get_page_source() pattern = re.escape(string) self.assertFalse(re.search(pattern, page_source), "page source contained %s" % pattern) def assert_element_text_equals(self, selector, expected_value): text = self.find_visible_element(selector).text.strip() self.assertEqual(expected_value.strip(), text.strip()) def assert_element_value_equals(self, selector, expected_value): text = self.find_visible_element(selector).get_attribute('value') self.assertEqual(expected_value.strip(), text.strip()) def assert_selector_texts_equals_expected_values(self, selector_value): # selector_value is a dict of selectors to expected text values for selector, expected_value in selector_value.items(): self.assert_element_text_equals(selector, unicode(expected_value)) def assert_attribute_equals(self, attribute, selector_values): # selector_values is a dict of selectors to attribute values for selector, expected_value in selector_values.items(): element = self.find_visible_element(selector) actual_value = element.get_attribute(attribute) self.assertEqual(expected_value, actual_value) def assert_is_checked(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertEqual('true', field.get_attribute('checked')) def assert_is_unchecked(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertIsNone(field.get_attribute('checked')) def assert_is_enabled(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertIsNone(field.get_attribute('disabled')) def assert_is_disabled(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertEqual('true', field.get_attribute('disabled')) def assert_are_displayed(self, name): fields = self.selenium.find_elements_by_name(name) self.assertTrue([field.is_displayed() for field in fields]) def assert_are_displayed_by_class_name(self, name): fields = self.selenium.find_elements_by_class_name(name) self.assertTrue([field.is_displayed() for field in fields]) def assert_are_not_displayed(self, name): fields = self.selenium.find_elements_by_name(name) self.assertFalse(all([field.is_displayed() for field in fields])) def assert_is_displayed(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertTrue(field.is_displayed()) def assert_not_displayed(self, selector): field = self.selenium.find_element_by_css_selector(selector) self.assertFalse(field.is_displayed()) def assert_not_in_page(self, selector): "Assert that the supplied selector is not part of the page content" elements = self.selenium.find_elements_by_css_selector(selector) self.assertTrue(len(elements) == 0) def assert_on_page(self, url_name, ignore_query_string=False): retries = 30 while retries > 0: try: self._assert_on_page(url_name, ignore_query_string) return except AssertionError: retries -= 1 print "assert_on_page: retry" self.wait(1) self._assert_on_page(url_name, ignore_query_string) def _assert_on_page(self, url_name, ignore_query_string=False): if not ignore_query_string: self.assertEqual(self.selenium.current_url, self.get_full_url(url_name)) else: split_url = self.selenium.current_url.split('?') url = split_url[0] self.assertEqual(url, self.get_full_url(url_name)) def assert_multi_selected_text_equals(self, id_of_select, expected): actual = self.get_multi_selected_option_text(id_of_select) remaining = [] for value in expected: if value not in actual: remaining.append(value) else: actual.remove(value) self.assertTrue(not actual and not remaining) def assert_summary_field_correctly_shown(self, expected_value, form_name, field_name): value_displayed = self.get_summary_field_text(form_name, field_name) self.assertEqual(expected_value, strip_tags(value_displayed)) def fill_in_fields(self, field_data, id_wrap=None, clear=False): for selector, text_to_input in field_data.items(): if id_wrap: selector = id_wrap(selector) elem = self.selenium.find_element_by_css_selector(selector) if elem.tag_name == 'select': self.select(selector, str(text_to_input)) else: if clear: elem.clear() elem.send_keys(str(text_to_input)) self.wait(0.5) def clear(self, selector): elem = self.selenium.find_element_by_css_selector(selector) elem.clear() def click(self, elem_id): elem = self.find_element_by_id(elem_id) elem.click() self.wait(0.5) def click_by_css(self, element_css): elem = self.selenium.find_element_by_css_selector(element_css) elem.click() self.wait(0.5) def click_by_class_name(self, class_name): elem = self.selenium.find_element_by_class_name(class_name) elem.click() self.wait(0.5) def login(self, username, password): self.visit('accounts/login') username_input = self.selenium.find_element_by_id('id_username') password_input = self.selenium.find_element_by_id('id_password') submit_button = self.selenium.find_element_by_tag_name('button') # TODO make this more specific username_input.send_keys(username) password_input.send_keys(password) submit_button.submit() def visit(self, url_name, *args, **kwargs): """ self.visit(name_of_url_as_defined_in_your_urlconf) """ self.selenium.get(self.get_full_url(url_name, *args, **kwargs)) if url_name in LiveServerTest.AJAX_WAIT: self.wait(2) self.assertTrue(self.selenium.execute_script('return (window.catalogue !== undefined ? catalogue._loaded : true)'), 'catalogue.js loading error') def get_actual_filter_options(self): option_selector = '%s option' % self.rf_id('filter') return [x.get_attribute('value').encode('ascii') for x in self.selenium.find_elements_by_css_selector(option_selector)] def get_expected_filter_options(self, data_set): def gen_bp_pairs(objs): for obj in objs: yield ('B-' + str(obj.id) + '_apparent') yield ('B-' + str(obj.id) + '_absolute') normal_parameters = datasets.filter_choices(data_set.simulation.id, data_set.galaxy_model.id) bandpass_parameters = datasets.band_pass_filters_objects() return ['D-' + str(x.id) for x in normal_parameters] + [pair for pair in gen_bp_pairs(bandpass_parameters)] def get_actual_snapshot_options(self): option_selector = '%s option' % self.lc_id('snapshot') return [x.get_attribute("innerHTML") for x in self.selenium.find_elements_by_css_selector(option_selector)] def get_expected_snapshot_options(self, snapshots): return [str("%.5g" % snapshot.redshift) for snapshot in snapshots] def get_full_url(self, url_name, *args, **kwargs): return "%s%s" % (self.job_params.BASE_URL, url_name) def get_selected_option_text(self, id_of_select): select = self.selenium.find_element_by_css_selector(id_of_select) options = select.find_elements_by_css_selector('option') selected_option = None for option in options: if option.get_attribute('selected'): selected_option = option return selected_option.text def get_multi_selected_option_text(self, id_of_select): select = self.selenium.find_element_by_css_selector(id_of_select) options = select.find_elements_by_css_selector('option') return [option.text for option in options] def get_selector_value(self, selector): return self.selenium.find_element_by_css_selector(selector).get_attribute('value') def select(self, selector, value): from selenium.webdriver.support.ui import Select elem = self.selenium.find_element_by_css_selector(selector) select = Select(elem) select.select_by_visible_text(value) def find_visible_elements(self, css_selector): elements = self.selenium.find_elements_by_css_selector(css_selector) return [elem for elem in elements if elem.is_displayed()] def find_visible_element(self, css_selector): elements = self.find_visible_elements(css_selector) num_elements = len(elements) if num_elements != 1: raise Exception("Found %s elements for selector %s" % (num_elements, css_selector)) return elements[0] def select_dark_matter_simulation(self, simulation): self.select(self.lc_id('dark_matter_simulation'), simulation.name) self.wait(0.5) def select_galaxy_model(self, galaxy_model): self.select(self.lc_id('galaxy_model'), galaxy_model.name) self.wait(0.5) def select_stellar_model(self, stellar_model): self.select(self.sed_id('single_stellar_population_model'), stellar_model.label) self.wait(0.5) def select_record_filter(self, filter, extension=None): text = '' if isinstance(filter, DataSetProperty): units_str = '' if filter.units is not None and len(filter.units) > 0: units_str = ' (' + filter.units + ')' text = filter.label + units_str elif isinstance(filter, BandPassFilter): text = filter.label if extension is not None: text += ' (' + extension.capitalize() + ')' else: raise TypeError("Unknown filter type") self.select(self.rf_id('filter'), text) #a function to make a list of list of text inside the table def table_as_text_rows(self, selector): table = self.selenium.find_element_by_css_selector(selector) rows = table.find_elements_by_css_selector('tr') cells = [[cell.text for cell in row.find_elements_by_css_selector('th, td')] for row in rows] return cells def submit_support_form(self): submit_button = self.selenium.find_element_by_css_selector('button[type="submit"]') submit_button.submit()
driver.find_element_by_xpath("//ul[@class='ari-caused-spacer-expand']/li[3]").click() driver.find_element_by_id("arisearch_txtSearch").click() driver.find_element_by_id("arisearch_txtSearch").clear() driver.find_element_by_id("arisearch_txtSearch").send_keys("209617GS") driver.find_element_by_id("arisearch_btnLookup").click() # The following div classes get in the way of our user click as seen in errors # and we must change the css with javascript to allow the button click without a sleep statement # <div class="blockUI blockOverlay" ... wait; position: absolute;"></div> try: hideElement = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "blockUI"))) except Exception, e: print("BlockUI not found") try: driver.execute_script("document.getElementsByClassName('blockUI blockOverlay')[0].style.height = '1px';") except Exception, e: print('blocking class not there') # The curtain <div> also prevents us from click so that is handled by a wait statement check = WebDriverWait(driver, 10).until_not(EC.presence_of_element_located((By.ID, "curtain"))) # Add item 209617GS to cart WebDriverWait(driver, 10).until( EC.presence_of_element_located((By.CSS_SELECTOR, "input.ariPartListAddToCart.ariImageOverride"))) element = driver.find_element_by_xpath("//input[@id='aripartsSearch_btnCart0']") WebDriverWait(driver, 10).until_not(EC.presence_of_element_located((By.ID, "curtain"))) driver.find_element_by_id('aripartsSearch_btnCart0').click() # Click My Cart(1) to load Shopping cart page wait = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.LINK_TEXT, "My Cart(1)")))
def scroll_to_and_hover_over_element(browser: webdriver.WebDriver, element: WebElement): logging.info(f"Scrolling to and hovering over element {element}") browser.execute_script("arguments[0].scrollIntoView();", element) actions = ActionChains(browser) actions.move_to_element(element).perform()
def dictwebpage(request): # case 1: (OUTDATED since Glosbe doesn't work anymore) It needs to fetch an API. # AJAX has fetched the JSON on the wwww, then # the JSON obj from the www is sent to the view dictwebpage which processes it and # and sends back html. if 'json_obj' in request.GET.keys(): parsed_json_obj = json.loads(request.GET['json_obj']) return render(request, 'lwt/_glosbe_api.html', {'result': parsed_json_obj}) # case 2: AJAX sends the link to process to the view dictwebpage, # and the view sends backs a JSON containing the string URL. <iframe> displays it then. else: word = request.GET['word'] word_escaped = urllibparsequote(word) wbl = request.GET['wbl'] # case where it's a lookup sentence: if 'issentence' in request.GET.keys() and request.GET[ 'issentence'] != '': # no key "issentence" is sent if the value of 'issentence' is empty in AJAX wo_id = int(request.GET['issentence']) word = Sentences.objects.values_list( 'sentencetext', flat=True).get(sentence_having_this_word=wo_id) word_escaped = urllibparsequote(word) finalurl = wbl.replace('<WORD>', word_escaped) # finalurl = createTheDictLink(wbl, word) # create the url of the dictionary, integrating the searched word # case where we can't put the url in an iframe src. we must request the entire html webpage # and will display it in the iframe srcdoc if finalurl[0] == '^' or finalurl[ 0] == '!': # case where we open into the frame # try: # check that the URL is working. else display a well-formed error headers = { "User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30)", "Accept": "text/html,application/xhtml+xml,application/xml; q=0.9,image/webp,*/*;q=0.8" } reqest = Request(finalurl[1:], headers=headers) try: content = urlopen(reqest) # catch the redirect from Wiktionary except urllib.error.HTTPError as httpError: error = httpError.read().decode() # wiktionary has a special way to redirect to similar word if nothing found if 'wiktionary' in finalurl: redirect_url = _wiki_API_redirect(error, finalurl[1:], word_escaped) reqest = Request(redirect_url, headers=headers) try: content = urlopen(reqest) except: content = error # redirect doesn't work neither, so display the error else: content = error if finalurl[0] == '^': try: soup = BeautifulSoup(content, 'html.parser') html = _clean_soup(soup, finalurl) except: html = render_to_string('lwt/dictwebpage_not_working.html') result_str = escape(html) return HttpResponse(json.dumps(result_str)) if finalurl[ 0] == '#': # case where we use Selenium (Tricky website where scrapping is bloked) # detect if mac or else system = platform.system().lower() if system == 'windows' or system == 'linux': is_Mac = False else: is_Mac = True from selenium.webdriver.firefox.webdriver import WebDriver from functional_tests.selenium_base import Base from selenium.webdriver.common.by import By from selenium.webdriver.firefox.options import Options as FirefoxOptions options = FirefoxOptions() options.add_argument("--headless") selenium = WebDriver(options=options) selenium.get('{}'.format(finalurl[1:])) base = Base() base.selenium = selenium if 'naver' in finalurl: base.wait_until_appear(By.ID, 'searchPage_entry') content = selenium.execute_script( "return document.documentElement.outerHTML;") if 'naver' in finalurl: translation_result = _naver_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'naver' } context['is_Mac'] = is_Mac return render(request, 'lwt/_translation_api.html', context) if finalurl[0] == '!' or finalurl[ 0] == '#': # this dictionary uses my custom APIs (for ex. Google translate) context = {} # detect if mac or else system = platform.system().lower() if system == 'windows' or system == 'linux': is_Mac = False else: is_Mac = True if 'https://translate.google.com' in finalurl: translation_result = _google_API(content) context = { 'url': finalurl[1:], 'url_name': 'Google Translate', 'trans_item_nb': len(translation_result), 'translation_result': translation_result, 'word_OR_sentence_origin': word, 'is_Mac': is_Mac } return render(request, 'lwt/_google_api.html', context) if 'pons.com/translate' in finalurl: translation_result = _pons_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'pons' } if 'dict.cc' in finalurl: translation_result = _dictcc_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'dictcc' } if 'wordref' in finalurl: translation_result = _wordref_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'wordref' } if 'wiktionary' in finalurl: translation_result = _wiki_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'wiki' } if 'youdao' in finalurl: translation_result = _youdao_API(content, finalurl) context = { 'translation_result': translation_result, 'API_name': 'youdao' } context['is_Mac'] = is_Mac return render(request, 'lwt/_translation_api.html', context) return HttpResponse( json.dumps(finalurl)) # case where we open into a new window
def wait_until_ready(self): self.wait.until(lambda driver: WebDriver.execute_script( driver, 'return document.readyState;') == 'complete')