def take_screenshot():
screen_name = Screenshooter.get_screen_file_name()
save_screen_path = os.path.join(Screenshooter.__session_dir, screen_name)
Logger.info("Screenshot capture to file " + screen_name)
Browser.get_browser().get_driver().save_screenshot(save_screen_path)
result_image = Image.open(save_screen_path)
Logger.info(VisualRecord(screen_name, result_image))
def do_text_bold(self):
"""
method to do text bold
"""
Browser().switch_to_frame_by_locator(*self.__IFRAME)
element = self.__TEXT_FIELD.find_element()
element.send_keys(Keys.CONTROL + self.settings['KEY_a'])
Browser().switch_to_default_content()
self.__BOLD_BUTTON.click()
def send_text(self, text):
"""
method to send random text
"""
Browser().switch_to_frame_by_locator(*self.__IFRAME)
element = self.__TEXT_FIELD
element.selenium_clear()
element.send_keys(text)
Browser().switch_to_default_content()
def get_text(self):
"""
method to get text
:return: text
"""
Browser().switch_to_frame_by_locator(*self.__IFRAME)
text = self.__TEXT_FIELD.find_element().text
Browser().switch_to_default_content()
return text
def create_browser(request):
with allure.step("Creating a browser session"):
browser = request.config.getoption('--browser')
selenoid = request.config.getoption('--selenoid')
lang = request.config.getoption('--lang')
Browser.get_browser().set_up_driver(browser_key=browser, selenoid=selenoid, lang=lang)
yield
with allure.step("Close sessions of all browsers"):
for browser_key in list(Browser.get_browser().get_driver_names()):
Browser.get_browser().quit(browser_key=browser_key)
class CookieTool:
def __init__(self):
self.driver = Browser().get_driver()
def add_cookie(self, cookie):
for c in cookie:
self.driver.add_cookie(c)
def get_cookies(self):
return self.driver.get_cookies()
def delete_cookie(self, name):
self.driver.delete_cookie(name)
def delete_all_cookies(self):
self.driver.delete_all_cookies()
def update_cookie(self, cookie):
cookie_for_update = self.driver.get_cookie(cookie['name'])
self.delete_cookie(cookie_for_update['name'])
cookie_for_update['value'] = cookie['value']
self.add_cookie([cookie_for_update])
def is_cookies_match(self, cookies):
get_cookies = CookieTool().get_cookies()
get_cookies_keys = get_cookies.keys()
for key in cookies.keys():
if key in get_cookies_keys:
if cookies.get(key) != get_cookies.get(key):
return False
return False
return True
def get_displayed_elements(condition, locator):
element_size = len(Browser.get_browser().get_driver().find_elements(condition, locator))
result_elements = []
try:
for ele_number in range(1, element_size + 1):
element_locator = "({locator})[{number}]".format(locator=locator, number=ele_number)
Logger.info("Search for an item with a locator " + element_locator)
element = WebDriverWait(Browser.get_browser().get_driver(), Waits.EXPLICITLY_WAIT_SEC).until(
ec.visibility_of_element_located((condition, element_locator)))
result_elements.append(element)
except TimeoutException:
error_msg = "item with locator was not found"
Logger.error(error_msg)
raise TimeoutException(error_msg)
return result_elements
def create_browser(request):
with allure.step("Creating a browser session"):
browser = request.config.getoption('--browser')
selenoid = request.config.getoption('--selenoid')
lang = request.config.getoption('--lang')
Browser.get_browser().set_up_driver(browser_key=browser,
selenoid=selenoid,
lang=lang)
cloudinary.config(cloud_name=CloudinaryConfig.CLOUD_NAME,
api_key=CloudinaryConfig.API_KEY,
api_secret=CloudinaryConfig.API_SECRET)
yield
with allure.step("Close sessions of all browsers"):
for browser_key in list(Browser.get_browser().get_driver_names()):
Browser.get_browser().quit(browser_key=browser_key)
def wait_for_check_by_condition(self, method_to_check, message,
wait_time_sec=Waits.EXPLICITLY_WAIT_SEC, use_default_msg=True):
try:
element = WebDriverWait(Browser.get_browser().get_driver(), wait_time_sec).until(method=method_to_check)
except TimeoutException:
result_message = ("item '" + self.get_name() + "' with locator " + self.get_locator() + message
if use_default_msg else message)
Logger.warning(result_message)
raise TimeoutException(result_message)
return element
def wait_for(self, condition, *args, **kwargs):
def func(driver):
try:
value = condition(*args, **kwargs)
return value
except StaleElementReferenceException:
return False
return WebDriverWait(Browser.get_browser().get_driver(), Waits.EXPLICITLY_WAIT_SEC,
ignored_exceptions=[StaleElementReferenceException]).until(func)
def is_text_bold(self):
"""
method to check text is bold
:return: if the text is bold then return true or not return false
"""
Browser().switch_to_frame_by_locator(*self.__IFRAME)
if self.__BOLD_TEXT.find_element():
return True
else:
return False
def scroll_by_script(self):
self.wait_for_is_visible()
Logger.info("Scroll to item '" + self.get_name() + "'")
Browser.get_browser().execute_script(scripts_js.SCROLL_INTO_VIEW, self.find_element())
def get_text_content(self):
self.wait_for_is_visible()
return Browser.get_browser().get_driver().\
execute_script("return arguments[0].textContent;", self.find_element())
def send_keys_to_element(self, keys):
actions = ActionChains(Browser.get_browser().get_driver())
actions.send_keys_to_element(self.find_element(), keys)
actions.perform()
def wait_for_page_closed(self):
self.wait_page_to_load()
return Browser.get_browser().is_wait_successful(
Label(self.search_condition, self.locator,
self.page_name).wait_for_is_absent)
def __init__(self):
self._browser = Browser.get_instance()
def get_elements(self):
return Browser.get_browser().get_driver().find_elements(self.__search_condition, self.__locator)
def js_click(self):
element = self.wait_for_clickable()
Browser.get_browser().get_driver().execute_script("arguments[0].click();", element)
def start_browser():
browser = Browser.get_instance()
browser.maximize_window()
yield browser
browser.quit()
def wait_page_to_load(self):
Logger.info("Waiting for page to load " + self.page_name + " using js")
Browser.get_browser().wait_for_page_to_load()
def is_opened(self):
Logger.info("Check if the page is open " + self.page_name)
self.wait_page_to_load()
return Browser.get_browser().is_wait_successful(
Label(self.search_condition, self.locator,
self.page_name).wait_for_is_visible)
def double_click(self):
self.wait_for_is_visible()
Logger.info("double_click: Double click on an item '" + self.get_name() + "'")
ActionChains(Browser.get_browser().get_driver()).double_click(self.find_element()).perform()
def wait_for_is_displayed(self):
Browser.get_browser().wait_for_true(self.is_displayed)
def get_alert_text():
return Browser().get_alert_text()
def actions_click_with_key(self, key):
actions = ActionChains(Browser.get_browser().get_driver())
actions.key_down(value=key).click(self.find_element()).key_up(value=key).perform()
def key_up(self, key):
actions = ActionChains(Browser.get_browser().get_driver())
actions.key_up(value=key, element=self.find_element())
actions.perform()
def get_elements_count(self):
elements_count = len(Browser.get_browser().get_driver().find_elements(self.__search_condition, self.__locator))
return elements_count
def actions_send_keys(self, keys):
actions = ActionChains(Browser.get_browser().get_driver())
actions.move_to_element(self.find_element()).send_keys(keys)
actions.perform()
def actions_click(self):
actions = ActionChains(Browser.get_browser().get_driver())
actions.click(on_element=self.find_element())
actions.perform()
def refresh_page(self):
Logger.info("Page Refresh " + self.page_name)
Browser.get_browser().refresh_page()
