def test_guest_should_see_login_link(self, browser: RemoteWebDriver):
"""
:param WebDriver browser: The browser's driver
:return:
"""
browser.get(link)
browser.find_element_by_css_selector("#login_link")
def _set_time(driver: WebDriver, upload_time: datetime):
# Start time scheduling
WebDriverWait(driver,
20).until(EC.element_to_be_clickable(
(By.NAME, "SCHEDULE"))).click()
# Open date_picker
driver.find_element_by_css_selector(
"#datepicker-trigger > ytcp-dropdown-trigger:nth-child(1)").click()
date_input: WebElement = driver.find_element_by_css_selector(
"input.tp-yt-paper-input")
date_input.clear()
# Transform date into required format: Mar 19, 2021
date_input.send_keys(upload_time.strftime("%b %d, %Y"))
date_input.send_keys(Keys.RETURN)
# Open time_picker
driver.find_element_by_css_selector(
"#time-of-day-trigger > ytcp-dropdown-trigger:nth-child(1) > div:nth-child(2)"
).click()
time_list = driver.find_elements_by_css_selector(
"tp-yt-paper-item.tp-yt-paper-item")
# Transform time into required format: 8:15 PM
time_str = upload_time.strftime("%I:%M %p").strip("0")
time = [time for time in time_list[2:] if time.text == time_str][0]
time.click()
def fill_out_product(driver: WebDriver, products: str):
product_btn = find_element(
driver, find_selector_by_name(SELECTORS, "product-btn")
)
product_btn.click()
if driver.find_element_by_css_selector("body > div:nth-child(11) > div > div > button").is_displayed():
driver.find_element_by_css_selector("body > div:nth-child(11) > div > div > button").click()
driver.find_element_by_xpath(
"//body/div[2]/nav/span[2]/span/button")
#"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/div[1]/input[1]").send_keys(products)
driver.find_element_by_xpath(
"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/button[1]/i[1]").click()
while True:
find_and_select_random_radio_and_click_next(driver)
time.sleep(1) # seconds
try:
if driver.find_element_by_xpath("//button[contains(text(),'Save product')]").is_displayed():
driver.find_element_by_xpath("//button[contains(text(),'Save product')]").click()
break
else:
continue
except:
pass
def upload_ldss_batch(p_browser: WebDriver, upload_files):
logger = logging.getLogger('upload_ldss_batch')
p_browser.get('https://eit1-i.svcs.hp.com/cds/LoadLdssAsync')
ret_file_name = []
for single_file in upload_files:
c_dir = os.getcwd()
full_path_file = os.path.join(c_dir, LDSS_INPUT, single_file)
logger.info('full_path_file %r' % full_path_file)
p_browser.find_element_by_css_selector('input[id = "ldssfile"]').send_keys(full_path_file)
validation_option = p_browser.find_element_by_css_selector('select[id = "UploadOptionList"]')
validation_option.send_keys('Validate Only')
upload_button = p_browser.find_element_by_css_selector('input[value = "Upload"]')
upload_button.click()
time.sleep(5)
for repeat in range(9):
upload_status = p_browser.find_element_by_id('tbMontor').get_attribute('value')
if 'go to CDS Console' in upload_status and 'Load LDSS Successful:' in upload_status:
logger.info('[UPLOAD LDSS OK] Upload {} {}.'.format(full_path_file, upload_status))
ret_file_name.append(os.path.split(full_path_file)[-1])
break
else:
time.sleep(5)
logger.info('sleep 5 seconds...')
else:
logger.info('{} upload failed.'.format(os.path.split(full_path_file)[-1]))
print(upload_status)
return ret_file_name
def find_a_job(browser: WebDriver, tran_name: str):
i = 5 # how many second will CDS wait to check the validation status
browser.get("https://eit1-i.svcs.hp.com/cds/ConsoleRead")
Submitter = browser.find_element_by_css_selector('input[id = "Filters_Submitter"]')
Transactionname = browser.find_element_by_css_selector('input[id = "Filters_TranName"]')
showtime = browser.find_element_by_css_selector('select[id = "Filters_Timefilterval"]')
# show = browser.find_element_by_id('Filters_Timefilterval')
filter = browser.find_element_by_css_selector('input[id = "ApplyFilterButton"]')
Submitter.clear()
Transactionname.send_keys(tran_name)
showtime.send_keys("Last 1 Month")
filter.click()
rows = browser.find_elements_by_css_selector("tr.table_row")
# print(len(rows))
for row in rows:
cells = row.find_elements_by_tag_name("td")
# row.find_elements_by_tag_name('td')
if cells[3].text == "Errors" or cells[3].text == "Completed":
downloadldss = row.find_element_by_css_selector("td.context-menu-ldss")
downloadldss.click()
else:
time.sleep(10)
i = i - 1
print("Will wait 10x" + i + "second(s)")
if i < 1:
break
print("you can check the validation result now!")
def _handle_sign_in(browser: WebDriver, email: str, password: str):
input_email = browser.find_element_by_css_selector('#loginForm input[type="email"]')
input_password = browser.find_element_by_css_selector('#loginForm input[type="password"]')
button_sign_in = browser.find_element_by_css_selector('#loginForm button')
input_email.send_keys(email)
input_password.send_keys(password)
button_sign_in.submit()
def _check_auth_code_screen(self, browser: WebDriver):
current_url = browser.current_url
is_redirect = current_url.startswith(self._callback)
try:
browser.find_element_by_css_selector("#selectAllScope")
is_scope_selection = True
except NoSuchElementException:
is_scope_selection = False
return is_redirect or is_scope_selection
def _set_endcard(driver: WebDriver):
# Add endscreen
driver.find_element_by_css_selector("#endscreens-button").click()
sleep(5)
# Select endcard type from last video or first suggestion if no prev. video
driver.find_element_by_css_selector("div.card:nth-child(1)").click()
WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, "save-button"))).click()
def watch_current_video(driver: WebDriver, max_time: int = 420) -> None:
"""Watches the YouTube video on the currently selected page.
Arguments:
driver - The webdriver, it has to be navigated to a YouTube video before calling this function.
with_progress - If true, periodically print the watch progress.
max_time - Maximum time spent watching this video before aborting.
"""
# Wait for YouTube to finish loading the player
player_div = WebDriverWait(driver, 20).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "div#player.ytd-watch-flexy")))
start_time = time.time()
logging.info("Started watching")
current_time_elem = driver.find_element_by_css_selector(
"span.ytp-time-current")
duration_time_elem = driver.find_element_by_css_selector(
"span.ytp-time-duration")
# The watch next video button gets created later I guess ¯\_(ツ)_/¯
up_next_button_elem = None
# We wiggle the virtual mouse to prevent YouTube from hiding the player controls,
# because we read the watched time from there
move_to_player = webdriver.ActionChains(driver)
move_to_player.move_to_element_with_offset(player_div, 100, 100)
wiggle_mouse = webdriver.ActionChains(driver)
wiggle_mouse.move_by_offset(10, 0)
wiggle_mouse.pause(1)
wiggle_mouse.move_by_offset(-10, 0)
move_to_player.perform()
while True:
# The buttom time bar won't update if it is not visible so move the mouse to show it
wiggle_mouse.perform()
logging.info(
f'{current_time_elem.get_attribute("textContent")} of {duration_time_elem.get_attribute("textContent")}'
)
# Resting is important
time.sleep(5)
# If the 'Up next' screen is showing, we are done watching this video
try:
if up_next_button_elem:
if up_next_button_elem.is_displayed():
break
else:
up_next_button_elem = driver.find_element_by_class_name(
"ytp-autonav-endscreen-upnext-button")
except:
# The next button is created lazily, so sometimes its missing
logging.warning("No next button found while watching video")
if time.time() - start_time >= max_time:
break
logging.info("finished watching video")
def switch_into_module(driver: WebDriver) -> None:
"""Extract the Enter Iframe function just so it can be better exported."""
# Scorm's wrapper on the modules needs to be opened first.
click_surely(driver.find_element_by_css_selector('.scf-play-button'),
False)
iframe = driver.find_element_by_css_selector('iframe[src^="/content/"]')
driver.switch_to.frame(iframe)
# Scorm has TWO layers of framing.
iframe = driver.find_element_by_css_selector('frame#ScormContent')
driver.switch_to.frame(iframe)
def login(browser_driver: WebDriver, url_link: str):
with open('.pass') as f:
credential = json.load(f)
browser_driver.get(url_link)
input_email = browser_driver.find_element_by_css_selector('input[name = "USER"]')
input_email.send_keys(credential['user_name'])
input_password = browser_driver.find_element_by_css_selector('input[name = "PASSWORD"]')
input_password.send_keys(decrypt(credential['password'], str(uuid.getnode())))
btn_login = browser_driver.find_element_by_css_selector('input[value = "Log on"]')
btn_login.click()
def login(browser: RemoteWebDriver):
browser.get(LOGIN_URL)
time.sleep(5)
ele_tel = browser.find_element_by_css_selector('input[type="tel"]')
ele_tel.send_keys(config['zhipin']['PHONE'])
ele_passwd = browser.find_element_by_css_selector('input[type="password"]')
ele_passwd.send_keys(config['zhipin']['PASSWORD'])
ele_verify = browser.find_element_by_css_selector(
'div[id*="verrify"] > div > div > span')
# todo auto press scroll bar
with open('cookie.json', 'w') as f:
f.write(json.dumps(browser.get_cookies()))
def verificar_elemento_html_hasta_no_existir_en_el_dom_html(
web_driver: WebDriver,
time=5,
id=None,
xpath=None,
link_text=None,
partial_link_text=None,
name=None,
tag_name=None,
class_name=None,
css_selector=None):
msg_selector_html_a_localizar = HtmlActions.generar_identificador_excepcion(
id, xpath, link_text, partial_link_text, name, tag_name,
class_name, css_selector)
tiempo_inicial = Temporizador.obtener_tiempo_timer()
while True:
try:
if id is not None:
web_driver.find_element_by_id(id)
elif xpath is not None:
web_driver.find_element_by_xpath(xpath)
elif link_text is not None:
web_driver.find_element_by_link_text(link_text)
elif partial_link_text is not None:
web_driver.find_element_by_partial_link_text(
partial_link_text)
elif name is not None:
web_driver.find_element_by_name(name)
elif tag_name is not None:
web_driver.find_element_by_tag_name(tag_name)
elif class_name is not None:
web_driver.find_element_by_class_name(class_name)
elif css_selector is not None:
web_driver.find_element_by_css_selector(css_selector)
segundos_transcurridos = Temporizador.obtener_tiempo_timer(
) - tiempo_inicial
if segundos_transcurridos > time:
e = TimeoutException()
e.msg = webdriver_actions_constantes.WEBDRIVER_WAIT_UNTIL_NOT_TIMEOUT_EXCEPTION.format(
time, msg_selector_html_a_localizar, e.msg)
raise e
else:
pass
except NoSuchElementException:
break
def data_mining(driver: WebDriver):
"""
Main function providing flow to the app. Next page button is different on first page then on others so when page is
not having the next page button the button's value is changed to boolean which means last article page. Program goes
through last page's articles and breaks loop.
:param driver: WebDriver
:return:
"""
driver.get("https://teonite.com/blog/")
driver.maximize_window()
next_page_button = driver.find_element_by_css_selector(
"ul.pagination-list>li.blog-button.post-pagination>a")
while True:
main_window = driver.window_handles[0]
articles = driver.find_elements_by_class_name("post-container")
for article in articles:
article_title = get_article_title(article)
open_article_in_new_tab(driver, article, article_title)
save_article_in_db(driver, article_title)
driver.close()
driver.switch_to.window(main_window)
if not isinstance(next_page_button, bool):
next_page_button.click()
try:
next_page_button = driver.find_element_by_xpath(
"//*[@id='blog-posts']/div/ul/li[2]/a")
except NoSuchElementException:
next_page_button = False
else:
driver.close()
break
def _get_auth_code(self, browser: WebDriver) -> str:
wait = WebDriverWait(browser, 120).until(lambda b: self._check_auth_code_screen(b))
if wait is not True:
raise Exception("Not found auth_code")
current_url = browser.current_url
if current_url.startswith(self._callback):
result = url_parser.urlparse(current_url)
query = url_parser.parse_qs(result.query, strict_parsing=True)
return query['code'][-1]
else:
browser.find_element_by_css_selector("#selectAllScope").click()
browser.find_element_by_css_selector('#allow-button').click()
return self._get_auth_code(browser)
def accept_all_cookies(driver: WebDriver):
from pages import common_selectors
accept = common_selectors.COOKIE_BANNER["cookie banner"][
"accept all cookies"]
banner_selector = common_selectors.COOKIE_BANNER["cookie banner"]["banner"]
if is_element_present(driver, banner_selector):
banner = driver.find_element_by_css_selector(banner_selector.value)
if banner.is_displayed():
logging.debug("Accepting all cookies")
button = driver.find_element_by_css_selector(accept.value)
button.click()
else:
logging.debug("Cookie banner is not visible")
else:
logging.debug("Cookie banner is not present")
def get_job_tran_run_id(browser: WebDriver, tran_name: str, submitter_input: str) -> str:
console = browser.find_element_by_link_text('CDS Console')
console.click()
Transactionname = browser.find_element_by_css_selector('input[id = "Filters_TranName"]')
Transactionname.send_keys(tran_name)
submitter = browser.find_element_by_id('Filters_Submitter')
submitter.clear()
submitter = browser.find_element_by_id('Filters_Submitter')
submitter.send_keys(submitter_input)
show = browser.find_element_by_id('Filters_Timefilterval')
show.send_keys('All')
Apply_Filter = browser.find_element_by_id('ApplyFilterButton')
Apply_Filter.click()
rows = browser.find_elements_by_css_selector('tr.table_row')
for row in rows:
cells = row.find_elements_by_tag_name('td')
for i, c in enumerate(cells):
if c.text == tran_name:
tran_run_id = cells[i + 10].text
return tran_run_id
def get_latest_template(browser: WebDriver, url_link):
TEMPLATE_PATH = 'template'
TEMPLATE_NAME = 'template.xlsx'
with open('config.json') as f:
config = json.load(f)
browser.get(url_link)
list = browser.find_element_by_id('ApplicationList')
list.send_keys('Standard LDSS')
core_data = browser.find_element_by_id('CoreData')
core_data.click()
download_btn = browser.find_element_by_css_selector('input[value = "Download"]')
download_btn.click()
time.sleep(10)
c_dir = os.getcwd()
template_path = os.path.join(c_dir, TEMPLATE_PATH)
file_bef = os.listdir(template_path)
if TEMPLATE_NAME in file_bef:
os.remove(template_path + os.sep + TEMPLATE_NAME)
time.sleep(3)
for a in range(len(file_bef)):
if file_bef[a] == '__init__.py':
pass
else:
os.rename(template_path + os.sep + file_bef[a], template_path + os.sep + TEMPLATE_NAME)
break
def __hole_item_id(item_name:str, driver:WebDriver.WebDriver) -> int:
# def _hole_item_id(item_name:str, driver:webdriver.Chrome):
driver.get('https://classic.wowhead.com/items/name:' + item_name)
# driver.get('https://de.classic.wowhead.com/items/name:' + item_name)
e: WebDriver.WebElement = driver.find_element_by_css_selector('table.listview-mode-default tr td div a')
item_link = e.get_attribute('href')
return __extrahiere_itemid(item_link)
def fill_out_country(driver: WebDriver, country: str):
# search using the provide country name from the test case
driver.find_element_by_css_selector("#search-input").clear()
driver.find_element_by_css_selector("#search-input").send_keys(country)
# look out for the list displayed after entering country name and select random/provided country
ul_list_element = driver.find_element_by_xpath(
"//body/div[8]/div/div/div/div/div/div[1]/div[3]/div[2]/div[2]/ul")
section_elements = ul_list_element.find_elements_by_tag_name("section")
logging.debug("length of section elements " + str(len(section_elements)))
# select random section element and within that select a country
index_random_element_to_be_selected = random.randint(
0,
len(section_elements) - 1)
logging.debug("Index of section elements " +
str(index_random_element_to_be_selected))
section_element_selected = section_elements[
index_random_element_to_be_selected]
logging.debug(section_element_selected)
div_elements = section_element_selected.find_elements_by_tag_name(
"div") # 2 has to be present
logging.debug("length of div elements " + str(len(div_elements)))
level_1_div_element = div_elements[
1] # section_element_selected.find_element_by_class_name("p-t-s expand-section open")
level_2_div_element = level_1_div_element.find_element_by_tag_name("div")
span_elements = level_2_div_element.find_elements_by_tag_name("span")
logging.debug("length of span elements " + str(len(span_elements)))
# select random span element and within that select a country
index_random_element_to_be_selected = random.randint(
0,
len(span_elements) - 1)
span_element_selected = span_elements[index_random_element_to_be_selected]
li_element = span_element_selected.find_element_by_tag_name("li")
# finally arrived at country name button(s)
buttons_elements = li_element.find_elements_by_tag_name("button")
logging.debug("length of country button elements " +
str(len(buttons_elements)))
country_name_found = False
for button_element in buttons_elements:
if str(button_element.text).lower() == country.lower():
country_name_found = True
button_element.click()
break
if country_name_found == False:
raise Exception("Country name could not be found " + str(country))
def upload_file(
driver: WebDriver,
video_path: str,
title: str,
description: str,
game: str,
kids: bool,
upload_time: datetime,
thumbnail_path: str = None,
):
WebDriverWait(driver, 20).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "ytcp-button#create-icon"))).click()
WebDriverWait(driver, 20).until(
EC.element_to_be_clickable(
(By.XPATH, '//tp-yt-paper-item[@test-id="upload-beta"]'))).click()
video_input = driver.find_element_by_xpath('//input[@type="file"]')
video_input.send_keys(video_path)
_set_basic_settings(driver, title, description, thumbnail_path)
_set_advanced_settings(driver, game, kids)
# Go to visibility settings
for i in range(3):
WebDriverWait(driver, 20).until(
EC.element_to_be_clickable((By.ID, "next-button"))).click()
_set_time(driver, upload_time)
_wait_for_processing(driver)
# Go back to endcard settings
driver.find_element_by_css_selector("#step-badge-1").click()
_set_endcard(driver)
for _ in range(2):
# Sometimes, the button is clickable but clicking it raises an error, so we add a "safety-sleep" here
sleep(5)
WebDriverWait(driver, 20).until(
EC.element_to_be_clickable((By.ID, "next-button"))).click()
sleep(5)
WebDriverWait(driver,
20).until(EC.element_to_be_clickable(
(By.ID, "done-button"))).click()
# Wait for the dialog to disappear
sleep(5)
logging.info("Upload is complete")
def get_table_column_cells(driver: WebDriver, col: int) -> List[str]:
result = []
grid = driver.find_element_by_css_selector('.grid-canvas')
rows = grid.find_elements_by_css_selector(".slick-row")
for row in rows:
elt = row.find_element_by_css_selector('.slick-cell.l%d.r%d' % (col, col))
result.append(elt.text)
return result
def get_table_selected_rows(driver: WebDriver) -> Set[int]:
result = set()
grid = driver.find_element_by_css_selector('.grid-canvas')
rows = grid.find_elements_by_css_selector(".slick-row")
for i, row in enumerate(rows):
elt = row.find_element_by_css_selector('.slick-cell.l1.r1')
if 'selected' in elt.get_attribute('class'):
result.add(i)
return result
def drag_range_slider(driver: WebDriver, css_class: str, location: str, distance: float) -> None:
el = driver.find_element_by_css_selector(css_class)
handle = el.find_element_by_css_selector('.noUi-handle-' + location)
actions = ActionChains(driver)
actions.move_to_element(handle)
actions.click_and_hold()
actions.move_by_offset(distance, 0)
actions.release()
actions.perform()
def init_from_web_driver(cls, web_driver: WebDriver):
neighborhood_component = web_driver.find_element_by_css_selector(
'.ds-neighborhood .zsg-content-component')
neighborhood_details = [
int(neighborhood_detail.get_attribute("innerText"))
for neighborhood_detail in
neighborhood_component.find_elements_by_css_selector('span.eTicsB')
]
return cls(*neighborhood_details)
def drag_slider(driver: WebDriver, css_class: str, distance: float, release: bool = True) -> None:
el = driver.find_element_by_css_selector(css_class)
handle = el.find_element_by_css_selector('.noUi-handle')
actions = ActionChains(driver)
actions.move_to_element(handle)
actions.click_and_hold()
actions.move_by_offset(distance, 0)
if release:
actions.release()
actions.perform()
def init_from_web_driver(cls, web_driver: WebDriver):
container = web_driver.find_element_by_css_selector('p.jfHfpE')
sold_date = container.find_elements_by_css_selector(
'.bvTLbK')[0].get_attribute("innerText").replace("Sold on ", "")
property_price = container.find_elements_by_css_selector(
'.bvTLbK')[1].find_element_by_css_selector(
'.flSprY').get_attribute("innerText").replace("$", "").replace(
",", "_")
property_price = int(property_price)
return cls(sold_date, property_price)
def send_tokens_to_token_bar(driver: WebDriver, element_selector: str, tokens: List[str]):
element = driver.find_element_by_css_selector(element_selector)
for token in tokens:
element.send_keys(token)
element.send_keys(Keys.ENTER)
# Tab away from element and wait
element.send_keys(Keys.TAB)
time.sleep(1)
def fill_out_product(driver: WebDriver, products: str):
product_btn = find_element(
driver, find_selector_by_name(SELECTORS, "product-btn")
)
product_btn.click()
try:
if driver.find_element_by_css_selector("body > div:nth-child(11) > div > div > button").is_displayed():
driver.find_element_by_css_selector("body > div:nth-child(11) > div > div > button").click()
except:
pass
try:
product_input_text = driver.find_element_by_xpath("//input[@id='input-commodity-name']").text
logging.debug("product_input_text -> " + product_input_text)
for i in range(len(product_input_text)):
driver.find_element_by_xpath(
"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/div[1]/input[1]").sendKeys(
Keys.BACKSPACE)
driver.find_element_by_xpath(
"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/div[1]/input[1]").send_keys("")
driver.find_element_by_xpath(
"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/div[1]/input[1]").send_keys(products)
driver.find_element_by_xpath(
"//body/div[3]/div[1]/div[1]/form[1]/div[2]/div[1]/div[1]/div[2]/button[1]/i[1]").click()
while True:
find_and_select_random_radio_and_click_next(driver)
time.sleep(1) # seconds
try:
if driver.find_element_by_xpath("//button[contains(text(),'Save product')]").is_displayed():
driver.find_element_by_xpath("//button[contains(text(),'Save product')]").click()
break
else:
continue
except:
pass
except Exception as ex:
logging.debug("Exception in product input " + str(ex))
driver.find_element_by_css_selector("#input-commodity-name").send_keys(products)
driver.find_element_by_xpath("/html/body/div[3]/div/div/form/div[2]/div/div/section/div/button").click()
def test_tabbing(browser: WebDriver, port):
id_selector = '.nbgrader-NotebookPanelWidget:not(.lm-mod-hidden) ' \
'.nbgrader-CellId input'
points_selector = '.nbgrader-NotebookPanelWidget:not(.lm-mod-hidden) ' \
'.nbgrader-CellPoints input'
_load_notebook(browser, port)
_activate_toolbar(browser)
def active_element_is(element):
def waitfor(browser):
active = browser.switch_to.active_element
return element == active
return waitfor
id_element = browser.find_element_by_css_selector(id_selector)
points_element = browser.find_element_by_css_selector(points_selector)
# make it manually graded
_select_manual(browser)
# click the id field
element = id_element
element.click()
element.send_keys(Keys.RETURN)
_wait(browser).until(active_element_is(id_element))
# press tab and check that the active element is correct
element.send_keys(Keys.TAB)
_wait(browser).until(active_element_is(points_element))
# make it autograder tests
_select_tests(browser)
# click the id field
element = id_element
element.click()
element.send_keys(Keys.RETURN)
_wait(browser).until(active_element_is(id_element))
# press tab and check that the active element is correct
element.send_keys(Keys.TAB)
_wait(browser).until(active_element_is(points_element))
def _set_endcard(driver: WebDriver):
# Add endscreen
driver.find_element_by_css_selector("#endscreens-button").click()
sleep(5)
for i in range(1, 11):
try:
# Select endcard type from last video or first suggestion if no prev. video
driver.find_element_by_css_selector(
"div.card:nth-child(1)").click()
break
except (NoSuchElementException, ElementNotInteractableException):
logging.warning(
f"Couldn't find endcard button. Retry in 5s! ({i}/10)")
sleep(5)
WebDriverWait(driver,
20).until(EC.element_to_be_clickable(
(By.ID, "save-button"))).click()
def open_any_article(driver: WebDriver) -> str:
links = extract_attributes_by_css(
driver.page_source, ARTICLE_LINKS.value, attrs=["href"]
)
selected_link = random.choice(links)
link = driver.find_element_by_css_selector(f"a[href='{selected_link['href']}']")
with wait_for_page_load_after_action(driver):
link.click()
return selected_link["text"]
def init_from_web_driver(cls, web_driver: WebDriver):
living_area_container = web_driver.find_element_by_css_selector(
'.ds-bed-bath-living-area-container')
area_details = [
int([
x.get_attribute("innerText")
for x in area_detail.find_elements_by_tag_name("span")
][0].replace(",", "_")) for area_detail in
living_area_container.find_elements_by_css_selector('.iIPyzR')
]
return cls(*area_details)
def __call__(self, driver: WebDriver):
# inject and expose javascript testing modules via window.test
bundle = open("bundle.js")
driver.execute_script(bundle.read())
bundle.close()
selector = driver.execute_script(
"return window.test.getCssSelector(arguments[0])", self.element
)
return (
driver.find_element_by_css_selector(selector + ":invalid") == self.element
)
def upload_ldss(p_browser: WebDriver, upload_file):
logger = logging.getLogger('upload_ldss')
p_browser.get('https://eit1-i.svcs.hp.com/cds/LoadLdssAsync')
p_browser.find_element_by_css_selector('input[id = "ldssfile"]').send_keys(upload_file)
validation_option = p_browser.find_element_by_css_selector('select[id = "UploadOptionList"]')
validation_option.send_keys('Validate and Release')
upload_button = p_browser.find_element_by_css_selector('input[value = "Upload"]')
upload_button.click()
time.sleep(5)
for repeat in range(9):
upload_status = p_browser.find_element_by_id('tbMontor').get_attribute('value')
if 'go to CDS Console' in upload_status and 'Load LDSS Successful:' in upload_status:
logger.info(upload_status)
return True
else:
time.sleep(5)
logger.info("DOESN'T Upload Successfully")
return False
def find_and_select_random_item_list(driver: WebDriver, element_selector_name: str):
payment_methods_btn = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(1) > div.select.m-b-l > div > div.select__placeholder.text-blue-deep-60.bg-white.radius")
payment_methods_btn.click()
payment_terms_btn = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(2) > div.select.m-b-l > div > div.select__placeholder.text-blue-deep-60.bg-white.radius")
payment_terms_btn.click()
incoterms_btn = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(3) > div.select.m-b-l > div > div.select__placeholder.text-blue-deep-60.bg-white.radius")
incoterms_btn.click()
driver.implicitly_wait(5)
# select__list body-l bg-white radius
payment_methods_element = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(1) > div.select.m-b-l > div > ul")
payment_terms_element = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(2) > div.select.m-b-l > div > ul")
incoterms_element = driver.find_element_by_css_selector(
"#getting-paid > div > div:nth-child(3) > div.select.m-b-l > div > ul")
li_elements = payment_methods_element.find_elements_by_tag_name("li")
li_elements = payment_terms_element.find_elements_by_tag_name("li")
li_elements = incoterms_element.find_elements_by_tag_name("li")
logging.debug("list elements")
logging.debug(li_elements)
random_number = 0
if len(li_elements) > 2:
random_number = random.randint(1, len(li_elements) - 1)
random_li_element = li_elements[random_number]
logging.debug(random_number)
logging.debug(random_li_element.tag_name)
logging.debug(random_li_element)
time.sleep(2)
class Browser:
name = None
capname = None
supports_alert = True
def __init__(self):
self.driver = None
self.profiledir = None
self.initialized = False
def initialSetup(self):
pass
def start(self):
if self.driver:
raise RuntimeError('%s is already running' % self.name)
caps = {}
caps.update(getattr(DesiredCapabilities, self.capname))
self.prepare_caps(caps)
self.driver = WebDriver(
'http://%s:%d/wd/hub' % (self.args.server_host, self.args.server_port),
desired_capabilities = caps
)
self.driver.implicitly_wait(2)
time.sleep(3)
for h in self.driver.window_handles[1:]:
self.driver.switch_to.window(h)
self.driver.close()
self.driver.switch_to.window(self.driver.window_handles[0])
self.driver.switch_to_default_content()
if not self.initialized:
self.initialSetup()
self.initialized = True
def quit(self):
try:
if self.driver:
self.driver.quit()
self.driver = None
except http_client.BadStatusLine:
pass
def create_profile(self):
self.profiledir = os.path.join(self.testdir, 'profile', self.name)
if os.path.exists(self.profiledir):
shutil.rmtree(self.profiledir)
os.makedirs(self.profiledir)
return self.profiledir
def set_window_size(self, width, height):
self.driver.set_window_size(width, height)
@property
def url(self):
return self.driver.current_url
def wait_page_load(self):
time.sleep(1)
self.wait_until(lambda d: self.js('return !!(window.document&&window.document.readyState==="complete")'))
def open(self, url):
self.driver.get(url)
self.wait_page_load()
def reload(self):
self.open(self.url)
def wait_until(self, callback):
wait = WebDriverWait(self.driver, 20)
return wait.until(callback)
def ac(self):
return ActionChains(self.driver)
def q(self, selector, context = None):
if context is None:
return self.driver.find_element_by_css_selector(selector)
return context.find_element_by_css_selector(selector)
def qa(self, selector, context = None):
if context is None:
return self.driver.find_elements_by_css_selector(selector)
return context.find_elements_by_css_selector(selector)
def x(self, xpath):
return self.driver.find_element_by_xpath(xpath)
def xa(self, xpath):
return self.driver.find_elements_by_xpath(xpath)
def alert_accept(self):
if self.supports_alert:
Alert(self.driver).accept()
else:
raise RuntimeError('%s not supports alert handling' % self.name)
def js(self, script, *args):
return self.driver.execute_script(script, *args)
def geom(self, element):
return self.geom2(element)[:4]
def geom2(self, element):
return tuple(map(round, self.js('''
var elem = arguments[0];
var rect = elem.getBoundingClientRect();
return [rect.left, rect.top, rect.width, rect.height,
rect.left + rect.width, rect.top + rect.height];
''', element)))
def screen_size(self):
sw, sh = self.js('''
return [document.documentElement.clientWidth,
document.documentElement.clientHeight];
''')
return sw, sh
def set_cookie(self, name, value, domain, path):
expires = ''
if value is None:
value = ''
expires = '; expires=Thu, 01 Jan 1970 00:00:00 GMT'
cookie = '%s=%s; domain=%s; path=%s%s' % (name, value, domain, path, expires)
self.js('document.cookie=%s' % json.dumps(cookie))
def screenshot(self, elem = None):
ss = self.driver.get_screenshot_as_png()
io = util.BytesIO(ss)
img = Image.open(io)
if elem is not None:
x, y, w, h = tuple(map(int, self.geom(elem)))
img = img.crop((x, y, x + w, y + h))
return img.convert('RGB')
def download(self, url, filename):
dlpath = os.path.join(self.browserdir, filename)
if not os.path.exists(dlpath) or os.stat(dlpath).st_mtime < time.time() - 60 * 60 * 24:
util.download(url, dlpath)
return dlpath
def read_file_as_base64(self, filename):
fp = open(filename, 'rb')
try:
data = fp.read()
finally:
fp.close()
data = base64.b64encode(data)
try:
data = str(data, 'ascii')
except TypeError:
pass
return data
from selenium import webdriver
from selenium.webdriver import DesiredCapabilities
from selenium.webdriver import ActionChains
from selenium.webdriver.remote.webdriver import WebDriver
from selenium.webdriver.common.keys import Keys
d = WebDriver(
'http://localhost:%d/wd/hub' % int(sys.argv[1]),
desired_capabilities = DesiredCapabilities.FIREFOX
)
d.get('file://%s/key_test.html' % os.path.abspath(os.path.dirname(__file__)))
keys = [
Keys.LEFT,
Keys.UP,
Keys.RIGHT,
Keys.DOWN,
Keys.SPACE,
Keys.ENTER,
Keys.ESCAPE,
'\x1b'
]
for key in keys:
ActionChains(d).send_keys(key).perform()
for key in keys:
d.find_element_by_css_selector('input').send_keys(key)
