def run_keyword(self, name, args, kwargs):
# list of keyword which need to be highlighted
commandsTohighlight = [
'element_should_be_enabled', 'element_should_be_focused',
'element_should_be_visible', 'get_text', 'click_button',
'click_image', 'click_link', 'click_element',
'double_click_element', 'scroll_element_into_view',
'get_list_items', 'get_selected_list_value',
'select_from_list_by_value', 'select_from_list_by_label',
'select_checkbox', 'select_radio_button', 'input_password',
'input_text'
]
if name in commandsTohighlight:
element1 = _find_element(self, args[:1])
self.highlight(element1)
return SeleniumLibrary.run_keyword(self, name, args, kwargs)
def run_keyword(self, name, args, kwargs):
logger.warn("run_keyword: {} {} {}".format(name, args, kwargs))
if name == "click_element":
self.wait_for_testability_ready()
SeleniumLibrary.run_keyword(self, name, args, kwargs)
class TestProjectLibrary:
# CONSTANTS #
ACCEPT = "ACCEPT"
ROBOT_LIBRARY_SCOPE = "GLOBAL"
ROBOT_LISTENER_API_VERSION = 3
CHROME_NAMES = ["googlechrome", "chrome", "gc"]
FIREFOX_NAMES = ["firefox", "ff"]
IE_NAMES = ["internetexplorer", "ie"]
# CONSTANTS END #
def __init__(self):
self.ROBOT_LIBRARY_LISTENER = self
self.__default_screenshot_name = f'TestProject-{datetime.date.today().strftime("%Y_%m_%d_%H_%M_%S")}.png'
self.__reporter = None
self.library = SeleniumLibrary()
os.environ["RFW_SUPPRESS_WARNINGS"] = "true"
# TESTPROJECT #
@keyword
def init_testproject_driver(
self,
browser: str = "firefox",
url: Optional[str] = None,
timeout: Optional[int] = 5000,
project_name: Optional[str] = "TestProject Robot",
job_name: Optional[str] = "Robot Job",
desired_capabilities: Union[str, dict, None] = None,
disabled_reports: Optional[bool] = False,
dev_token: Optional[str] = os.getenv("TP_DEV_TOKEN"),
):
logger.console(f"Initializing TestProject Library for Robot v{definitions.get_lib_version()}...")
# # Make sure development token is set
# if not dev_token:
# BuiltIn().fatal_error(
# "******************************************************************************\n"
# "* TestProject Development token not set! *\n"
# "* Please use the 'dev_token' argument of the 'init_testproject_driver' *\n"
# "* keyword, or set the 'TP_DEV_TOKEN' environment variable. *\n"
# "******************************************************************************"
# )
driver = None
# Check if instance of Options to pass to the driver.
if not isinstance(desired_capabilities, (ChromeOptions, FirefoxOptions, IeOptions)):
desired_capabilities = self._build_capabilities(
WebDriverCreator(os.getcwd())._parse_capabilities(capabilities=desired_capabilities, browser=browser), browser
)
# If headless, override and start a clean headless session.
if "headless" in browser:
type = browser.split("headless", 1)[1]
if type == "chrome":
desired_capabilities = ChromeOptions()
elif type == "firefox":
desired_capabilities = FirefoxOptions()
else:
raise ValueError("Headless is supported for FireFox and Chrome only")
desired_capabilities.add_argument("--headless")
browser = type
if browser in self.FIREFOX_NAMES:
driver = webdriver.Firefox(
firefox_options=desired_capabilities,
token=dev_token,
projectname=project_name,
jobname=job_name,
disable_reports=disabled_reports,
)
elif browser in self.CHROME_NAMES:
driver = webdriver.Chrome(
chrome_options=desired_capabilities,
token=dev_token,
projectname=project_name,
jobname=job_name,
disable_reports=disabled_reports,
)
elif browser in self.IE_NAMES:
driver = webdriver.Ie(
ie_options=desired_capabilities,
token=dev_token,
projectname=project_name,
jobname=job_name,
disable_reports=disabled_reports,
)
elif browser == "edge":
driver = webdriver.Edge(
edge_options=desired_capabilities,
token=dev_token,
projectname=project_name,
jobname=job_name,
disable_reports=disabled_reports,
)
elif browser == "safari":
driver = webdriver.Safari(
desired_capabilities=desired_capabilities,
token=dev_token,
projectname=project_name,
jobname=job_name,
disable_reports=disabled_reports,
)
else:
raise ValueError("Unsupported Browser, please look at the official TestProject library documentation")
driver.report().disable_command_reports(True)
driver.set_script_timeout(timeout)
driver.report().step(message="Set timeout", description=f"Time out was set to {timeout}", passed=True)
try:
driver.get(url)
driver.report().step(message=f"Navigated to {url}", description=f"Successfully navigated to {url}", passed=True)
except Exception:
driver.report().step(message=f"Failed to open {url}", description=f"Failed to open {url}", passed=True)
raise
self.library.register_driver(driver=driver, alias="testproject_driver")
self.__reporter = driver.report()
self.__reporter.exclude_test_names(["run_cli", "main"])
def _build_capabilities(self, caps, browser_name):
options = None
if caps:
_, value = caps.popitem()
try:
browser = value["browserName"]
except Exception as e:
logger.console("No browser name capability was set")
raise e
if browser in self.FIREFOX_NAMES:
options = FirefoxOptions()
elif browser in self.CHROME_NAMES:
options = ChromeOptions()
elif browser in self.IE_NAMES:
options = IeOptions()
elif browser == "edge":
options = Options()
elif browser == "safari":
options = DesiredCapabilities.SAFARI.copy()
for k, v in value.items():
options.set_capability(k, v)
else:
if browser_name in self.FIREFOX_NAMES:
caps = DesiredCapabilities.FIREFOX.copy()
options = FirefoxOptions()
elif browser_name in self.CHROME_NAMES:
caps = DesiredCapabilities.CHROME.copy()
options = ChromeOptions()
elif browser_name in self.IE_NAMES:
caps = DesiredCapabilities.INTERNETEXPLORER.copy()
options = IeOptions()
elif browser_name == "edge":
caps = DesiredCapabilities.EDGE.copy()
options = Options()
elif browser_name == "safari":
options = DesiredCapabilities.SAFARI.copy()
for k, v in caps.items():
options.set_capability(k, v)
return options
# TESTPROJECT END #
# SELECT/UNSELECT #
@keyword
def select_from_list_by_value(self, xpath, *values):
self.base(xpath, f'Values selected: "{values}"', f' Values:"{xpath}", List: "{values}"', *values)
@keyword
def select_all_from_list(self, locator):
self.base(locator, f'Selected all values from "{locator}"', f'"{locator}"')
@keyword
def select_from_list_by_label(self, locator, *labels):
self.base(locator, f'Selected labels "{labels}"', f'Labels:"{locator}", List: "{labels}"', *labels)
@keyword
def unselect_all_from_list(self, locator):
self.base(locator, f'Unselected all from "{locator}"', f'"{locator}"')
@keyword
def unselect_from_list_by_index(self, locator, *indexes):
self.base(locator, f'Unselected "{indexes}" from "{locator}"', f"Indexes: {indexes}, List: {locator}", *indexes)
@keyword
def unselect_from_list_by_value(self, locator, *values):
self.base(locator, f'Unselected "{values}" from "{locator}"', f"Values: {values}, List: {locator}", *values)
@keyword
def unselect_from_list_by_label(self, locator, *labels):
self.base(locator, f'Unselected "{labels}" from "{locator}"', f"Labels: {labels}, List: {locator}", *labels)
@keyword
def get_selected_list_label(self, locator):
return self.base(locator, "label", f"List: {locator}")
@keyword
def get_selected_list_labels(self, locator):
return self.base(locator, "labels", f"List: {locator}")
@keyword
def get_selected_list_value(self, locator):
return self.base(locator, "value", f"List: {locator}")
@keyword
def get_selected_list_values(self, locator):
return self.base(locator, "values", f"List: {locator}")
@keyword
def get_list_items(self, locator, values=False):
return self.base(locator, "list items", f"List: {locator}", values)
@keyword
def list_selection_should_be(self, locator, *expected):
self.base(locator, f'Selection is "{expected}"', f"List: {locator}", *expected)
@keyword
def list_should_have_no_selections(self, locator):
self.base(locator, f'List "{locator}" has no selections', f"List: {locator}")
@keyword
def page_should_not_contain_list(self, locator, message=None, loglevel="TRACE"):
self.base(locator, "List is not in page", f"List: {locator}", message, loglevel)
@keyword
def page_should_contain_list(self, locator, message=None, loglevel="TRACE"):
self.base(locator, "List is in page", f"List: {locator}", message, loglevel)
# SELECT/UNSELECT END #
# SCREENSHOTS #
@keyword
def capture_page_screenshot(self, filename=None):
if not filename: # Generate default file name with time stamp
filename = self.__default_screenshot_name
return self.base("", "Screenshot captured file", f" {filename}", filename)
@keyword
def set_screenshot_directory(self, path):
self.base("", "previous set directory", f" {path}", path)
@keyword
def capture_element_screenshot(self, locator, filename=None):
if not filename:
filename = self.__default_screenshot_name
return self.base(locator, "element screenshot file", f"{filename}", filename)
# SCREENSHOTS END #
# ELEMENTS #
@keyword(name="Get WebElement")
def get_webelement(self, locator):
return self.base(locator, "first web element by the given locator", f" {locator}")
@keyword(name="Get WebElements")
def get_webelements(self, locator):
return self.base(locator, "list of web elements by the given locator", f" {locator}")
@keyword
def element_should_contain(self, locator, expected, message=None, ignore_case=False):
self.base(locator, f'Element contains "{expected}"', f" {locator}", expected, message, ignore_case)
@keyword
def element_should_not_contain(self, locator, expected, message=None, ignore_case=False):
self.base(locator, f'Element does not contain "{expected}"', f" {locator}", expected, message, ignore_case)
@keyword
def page_should_contain_element(self, locator, message=None, loglevel="TRACE", limit=None):
return self.base(locator, f'Page contains "{locator}"', f" {locator}", message, loglevel, limit)
@keyword
def page_should_contain(self, text, loglevel="TRACE"):
self.base("", f'Page contains "{text}"', f" {text}", text, loglevel)
@keyword
def locator_should_match_x_times(self, locator, x, message=None, loglevel="TRACE"):
self.base(locator, f'"{locator}" matched "{x}"', f"Locator: {locator}, X: {x}", x, message, loglevel)
@keyword
def page_should_not_contain(self, text, loglevel="TRACE"):
self.base("", f'Page did not contain "{text}"', f" {text}", text, loglevel)
@keyword
def page_should_not_contain_element(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f'Page did not contain "{locator}"', f" {locator}", message, loglevel)
@keyword
def assign_id_to_element(self, locator, id):
self.base(locator, f'ID was assigned to "{id}"', f" {locator}", id)
@keyword
def element_should_be_disabled(self, locator):
self.base(locator, "Element is disabled", f" {locator}")
@keyword
def element_should_be_enabled(self, locator):
self.base(locator, "Element is enabled", f" {locator}")
@keyword
def element_should_be_focused(self, locator):
self.base(locator, "Element is focused", f" {locator}")
@keyword
def element_should_be_visible(self, locator, message=None):
self.base(locator, "Element is visible", f" {locator}", message)
@keyword
def element_should_not_be_visible(self, locator, message=None):
self.base(locator, "Element is not visible", f" {locator}", message)
@keyword
def element_text_should_be(self, locator, expected, message=None, ignore_case=False):
self.base(locator, f'Text is "{expected}"', f"Element: {locator}, Text: {expected}", expected, message, ignore_case)
@keyword
def element_text_should_not_be(self, locator, not_expected, message=None, ignore_case=False):
self.base(
locator,
f'Text is not "{not_expected}"',
f"Element: {locator}, Text: {not_expected}",
not_expected,
message,
ignore_case,
)
@keyword
def get_element_attribute(self, locator, attribute):
return self.base(locator, "attribute", f"Element: {locator}", attribute)
@keyword
def element_attribute_value_should_be(self, locator, attribute, expected, message=None):
self.base(
locator,
f'Attribute "{attribute}" contains {expected}',
f"Element: {locator}, Attribute: {expected}",
attribute,
expected,
message,
)
@keyword
def get_horizontal_position(self, locator):
return self.base(locator, "Horizontal position", f" {locator}")
@keyword
def get_element_size(self, locator):
return self.base(locator, "size", f"Element: {locator}")
@keyword
def cover_element(self, locator):
self.base(locator, f'Element Covered "{locator}"', f" {locator}")
@keyword
def get_value(self, locator):
return self.base(locator, "value", f" {locator}")
@keyword
def get_text(self, locator):
return self.base(locator, "Text", f" {locator}")
@keyword
def clear_element_text(self, locator):
self.base(locator, "Text cleared", f" {locator}")
@keyword
def get_vertical_position(self, locator):
return self.base(locator, "vertical position", f" {locator}")
@keyword
def click_button(self, locator, modifier=False):
self.base(locator, f'Clicked button "{locator}"', f" {locator}", modifier)
@keyword
def click_image(self, locator, modifier=False):
self.base(locator, f'Clicked image "{locator}"', f" {locator}", modifier)
@keyword
def click_link(self, locator, modifier=False):
self.base(locator, f'Clicked link "{locator}"', f" {locator}", modifier)
@keyword
def click_element(self, locator, modifier=False, action_chain=False):
self.base(locator, f'Clicked "{locator}"', f" {locator}", modifier, action_chain)
@keyword
def click_element_at_coordinates(self, locator, xoffset, yoffset):
self.base(locator, f'Clicked "{locator}" at X:{xoffset} , Y:{yoffset}', f" {locator}", xoffset, yoffset)
@keyword
def double_click_element(self, locator):
self.base(self, f'Double clicked "{locator}"', f" {locator}")
@keyword
def set_focus_to_element(self, locator):
self.base(locator, f'Element "{locator}" was is focused', f" {locator}")
@keyword
def scroll_element_into_view(self, locator):
self.base(locator, f'Element "{locator}" was scrolled into view', f" {locator}")
@keyword
def drag_and_drop(self, locator, target):
self.base(locator, f'Element "{locator}" was dragged to "{target}"', f"Origin: {locator}, Target: {target}", target)
@keyword
def drag_and_drop_by_offset(self, locator, xoffset, yoffset):
self.base(locator, f'Element "{locator}" was dragged to X:{xoffset} , Y:{yoffset}', f" {locator}", xoffset, yoffset)
@keyword
def mouse_down(self, locator):
self.base(locator, f'Mouse down on: "{locator}"', f" {locator}")
@keyword
def mouse_out(self, locator):
self.base(locator, f'Mouse out on: "{locator}"', f" {locator}")
@keyword
def mouse_over(self, locator):
self.base(locator, f'Mouse over on: "{locator}"', f" {locator}")
@keyword
def mouse_up(self, locator):
self.base(locator, f'Mouse up on: "{locator}"', f" {locator}")
@keyword
def open_context_menu(self, locator):
self.base(locator, f'Context menu opened on: "{locator}"', f" {locator}")
@keyword
def simulate_event(self, locator, event):
self.base(locator, f'Event: "{event}" was simulated on {locator}', f"Element: {locator}, Event: {event}", event)
@keyword
def press_key(self, locator, key):
self.base(locator, f'Key pressed: "{key}"', f"Locator: {locator}, Key: {key}", key)
@keyword
def press_keys(self, locator=None, *keys):
self.base(locator, f'Keys pressed: "{keys}"\non element found at "{locator}"', f"{keys}", keys)
@keyword
def get_all_links(self):
return self.base("", "links", "")
@keyword
def mouse_down_on_link(self, locator):
self.base(locator, f'Mouse was pressed on "{locator}"', f" {locator}")
@keyword
def page_should_contain_link(self, locator, message=None, loglevel="TRACE"):
self.base(locator, 'Page did contain link in "{}"', f" {locator}", message, loglevel)
@keyword
def page_should_not_contain_link(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f'Page did not contain link in "{locator}"', f" {locator}", message, loglevel)
@keyword
def mouse_down_on_image(self, locator):
self.base(locator, f'Mouse was down on image found at "{locator}"', f" {locator}")
@keyword
def page_should_contain_image(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f'Page did contain "{locator}"', f" {locator}", message, loglevel)
@keyword
def page_should_not_contain_image(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f'Page did not contain "{locator}"', f" {locator}", message, loglevel)
@keyword
def get_element_count(self, locator):
return self.base(locator, f'element "{locator}" count', f"Element: {locator}")
@keyword
def add_location_strategy(self, strategy_name, strategy_keyword, persist=False):
self.base("", f"Strategy '{strategy_name} was added'", strategy_name, strategy_keyword, persist)
@keyword
def remove_location_strategy(self, strategy_name):
self.base("", f"Strategy '{strategy_name}' was removed", f"Removed {strategy_name}", strategy_name)
# ELEMENTS END #
# ALERTS #
@keyword
def input_text_into_alert(self, text, action=ACCEPT, timeout=None):
self.base("", f"Typed {text} into alert\nAction used: {action}", f"Text: {text}", text, action, timeout)
@keyword
def alert_should_be_present(self, text="", action=ACCEPT, timeout=None):
self.base("", f"Action used: {action}", "", text, action, timeout)
@keyword
def alert_should_not_be_present(self, action=ACCEPT, timeout=0):
self.base("", f"Action used: {action}", "", action, timeout)
@keyword
def handle_alert(self, action=ACCEPT, timeout=None):
return self.base("", f"Alert handled with action: {action}", "", action, timeout)
# ALERTS END #
# COOKIES #
@keyword
def delete_all_cookies(self):
self.base("", "Deleted all cookies", "")
@keyword
def delete_cookie(self, name):
self.base("", "Deleted all cookies", f"{name}", name)
@keyword
def get_cookies(self, as_dict=False):
return self.base("", "Cookies", "", as_dict)
@keyword
def get_cookie(self, name):
return self.base("", "Cookie", f"{name}", name)
@keyword
def add_cookie(self, name, value, path=None, domain=None, secure=None, expiry=None):
self.base("", f"Added cookie: {name} with value: {value}", f"{name}", name, value, path, domain, secure, expiry)
# COOKIES END #
# JAVASCRIPT #
@keyword
def execute_javascript(self, *code):
return self.base("", f"Executed {code}", f"{code}", *code)
@keyword
def execute_async_javascript(self, *code):
return self.base("", f"Executed {code} Asynchronously", f"{code}", *code)
# JAVASCRIPT END #
# RUN ON FAILURE #
@keyword
def register_keyword_to_run_on_failure(self, keyword):
return self.base("", "Previous keyword", f"{keyword}", keyword)
# RUN ON FAILURE END #
# TABLE ELEMENT #
@keyword
def get_table_cell(self, locator, row, column, loglevel="TRACE"):
return self.base(locator, "Cell text", f"{locator} at Row: {row}, Col: {column}", row, column, loglevel)
@keyword
def table_cell_should_contain(self, locator, row, column, expected, loglevel="TRACE"):
self.base(
locator,
f"Cell at row: {row} and column {column} contained {expected}",
f"{locator} at Row: {row}, Col: {column}",
row,
column,
expected,
loglevel,
)
@keyword
def table_column_should_contain(self, locator, column, expected, loglevel="TRACE"):
self.base(locator, f"Column {column} contained {expected}", f"{locator} Col: {column}", column, expected, loglevel)
@keyword
def table_footer_should_contain(self, locator, expected, loglevel="TRACE"):
self.base(locator, f"Footer contained {expected}", f"Footer: {locator}, Expected: {expected}", expected, loglevel)
@keyword
def table_header_should_contain(self, locator, expected, loglevel="TRACE"):
self.base(locator, f"Header contained {expected}", f"Header: {locator}, Expected: {expected}", expected, loglevel)
@keyword
def table_row_should_contain(self, locator, row, expected, loglevel="TRACE"):
self.base(locator, f"Row {row} contained {expected}", f"{locator} Row: {row}", row, expected, loglevel)
@keyword
def table_should_contain(self, locator, expected, loglevel="TRACE"):
self.base(locator, f"Table contained {expected}", f"Table: {locator}, Expected: {expected}", expected, loglevel)
# TABLE ELEMENT END #
# WAITING #
@keyword
def wait_for_condition(self, condition, timeout=None, error=None):
message = self._set_message(timeout)
self.base("", f"Condition: '{condition}' was met {message}", f"{condition}", condition, timeout, error)
@keyword
def wait_until_location_is(self, expected, timeout=None, message=None):
message = self._set_message(timeout)
self.base("", f"Location was '{expected}' {message}", f"{expected}", expected, timeout, message)
@keyword
def wait_until_location_is_not(self, location, timeout=None, message=None):
message = self._set_message(timeout)
self.base("", f"Location was not '{location}' {message}", f"{location}", location, timeout, message)
@keyword
def wait_until_location_contains(self, expected, timeout=None, message=None):
message = self._set_message(timeout)
self.base("", f"Location contained '{expected}' {message}", f"{expected}", expected, timeout, message)
@keyword
def wait_until_location_does_not_contain(self, location, timeout=None, message=None):
message = self._set_message(timeout)
self.base("", f"Location does not contain '{location}' {message}", f"{location}", location, timeout, message)
@keyword
def wait_until_page_contains(self, text, timeout=None, error=None):
message = self._set_message(timeout)
self.base("", f"Page contained '{text}' {message}", f" {text}", text, timeout, error)
@keyword
def wait_until_page_does_not_contain(self, text, timeout=None, error=None):
message = self._set_message(timeout)
self.base("", f"Page does not contain '{text}' {message}", f" {text}", text, timeout, error)
@keyword
def wait_until_page_contains_element(self, locator, timeout=None, error=None, limit=None):
message = self._set_message(timeout)
self.base(locator, f"Page contained '{locator}' {message}", f" {locator}", timeout, error, limit)
@keyword
def wait_until_page_does_not_contain_element(self, locator, timeout=None, error=None, limit=None):
message = self._set_message(timeout)
self.base(locator, f"Page does not contain '{locator}' {message}", f" {locator}", timeout, error, limit)
@keyword
def wait_until_element_is_visible(self, locator, timeout=None, error=None):
message = self._set_message(timeout)
self.base(locator, f"Element '{locator}' was visible {message}", f" {locator}", timeout, error)
@keyword
def wait_until_element_is_not_visible(self, locator, timeout=None, error=None):
message = self._set_message(timeout)
self.base(locator, f"Element '{locator}' was not visible {message}", f" {locator}", timeout, error)
@keyword
def wait_until_element_is_enabled(self, locator, timeout=None, error=None):
message = self._set_message(timeout)
self.base(locator, f"Element '{locator}' was enabled {message}", f" {locator}", timeout, error)
@keyword
def wait_until_element_contains(self, locator, text, timeout=None, error=None):
message = self._set_message(timeout)
self.base(locator, f"Element '{locator}' contained {text} {message}", f" {text}", text, timeout, error)
@keyword
def wait_until_element_does_not_contain(self, locator, text, timeout=None, error=None):
message = self._set_message(timeout)
self.base(locator, f"Element '{locator}' does not contain {text} {message}", f" {text}", text, timeout, error)
def _set_message(self, timeout):
return "" if timeout is None else f"(timeout: {timeout} seconds)"
# WAITING END #
# WINDOW #
@keyword
def select_window(self, locator="MAIN", timeout=None):
return self.base(locator, f"Switched to {locator}", "", timeout)
@keyword
def switch_window(self, locator="MAIN", timeout=None, browser="CURRENT"):
return self.base(locator, f"Switched to {locator}", f"{browser}", timeout, browser)
@keyword
def close_window(self):
self.base("", "Window closed", "")
@keyword
def get_window_handles(self, browser="CURRENT"):
return self.base("", "Window Handles", "", browser)
@keyword
def get_window_identifiers(self, browser="CURRENT"):
return self.base("", "Window Identifiers", "", browser)
@keyword
def get_window_names(self, browser="CURRENT"):
return self.base("", "Window Names", "", browser)
@keyword
def get_window_titles(self, browser="CURRENT"):
return self.base("", "Window Titles", "", browser)
@keyword
def get_locations(self, browser="CURRENT"):
return self.base("", "All Locations", "", browser)
@keyword
def maximize_browser_window(self):
self.base("", "Window Maximized", "")
@keyword
def get_window_size(self, inner=False):
return self.base("", "Window size", "", inner)
@keyword
def set_window_size(self, width, height, inner=False):
self.base("", f"Size set to {width}, {height}", f"Width: {width}, Height: {height}", width, height, inner)
@keyword
def get_window_position(self):
return self.base("", "Window position", "")
@keyword
def set_window_position(self, x, y):
self.base("", f"Position set to {x}, {y}", f"X: {x}, Y: {y}", x, y)
# WINDOW END #
# FRAMES #
@keyword
def select_frame(self, locator):
self.base(locator, f"Switched from to {locator}", f"{locator}")
@keyword
def unselect_frame(self):
self.base("", "Returned to main frame", "")
@keyword
def current_frame_should_contain(self, text, loglevel="TRACE"):
self.base("", f"Current frame contains {text}", f"{text}", text, loglevel)
@keyword
def current_frame_should_not_contain(self, text, loglevel="TRACE"):
self.base("", f"Current frame does not contain {text}", f"{text}", text, loglevel)
@keyword
def frame_should_contain(self, locator, text, loglevel="TRACE"):
self.base(locator, f"{locator} contains {text}", f"Frame: {locator}, Text: {text}", text, loglevel)
# FRAMES END #
# FORM ELEMENT #
@keyword
def submit_form(self, locator=None):
self.base(locator, "Form submitted", f"{locator}")
@keyword
def checkbox_should_be_selected(self, locator):
self.base(locator, f"Checked box {locator} is selected", f"{locator}")
@keyword
def checkbox_should_not_be_selected(self, locator):
self.base(locator, f"Checked box {locator} is not selected", f"{locator}")
@keyword
def page_should_contain_checkbox(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page contains checkbox {locator}", f"{locator}", message, loglevel)
@keyword
def page_should_not_contain_checkbox(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page does not contain checkbox {locator}", f"{locator}", message, loglevel)
@keyword
def select_checkbox(self, locator):
self.base(locator, "Checkbox selected", f"{locator}")
@keyword
def unselect_checkbox(self, locator):
self.base(locator, "Checkbox unselected", f"{locator}")
@keyword
def page_should_contain_radio_button(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page contains radio button {locator}", f"{locator}", message, loglevel)
@keyword
def page_should_not_contain_radio_button(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page does not contain radio button {locator}", f"{locator}", message, loglevel)
@keyword
def radio_button_should_be_set_to(self, group_name, value):
self.base("", f"{group_name} was set to {value}", f"{value}", group_name, value)
@keyword
def radio_button_should_not_be_selected(self, group_name):
self.base("", f"{group_name} was not selected", f"{group_name}", group_name)
@keyword
def select_radio_button(self, group_name, value):
self.base("", f"{group_name} was set to {value}", f"{value}", group_name, value)
@keyword
def choose_file(self, locator, file_path):
self.base(locator, f"File {file_path} was uploaded", f"{locator}", file_path)
@keyword
def input_password(self, locator, password, clear=True):
self.base(locator, f"Typed {password} to {locator}", f"{password}", password, clear)
@keyword
def input_text(self, locator, text, clear=True):
self.base(locator, f"Typed {text} to {locator}", f"{text}", text, clear)
@keyword
def page_should_contain_textfield(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page contains TextField {locator}", f"{locator}", message, loglevel)
@keyword
def page_should_not_contain_textfield(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page does not contain TextField {locator}", f"{locator}", message, loglevel)
@keyword
def textfield_should_contain(self, locator, expected, message=None):
self.base(locator, f"TextField {locator} contains {expected}", f"{expected}", expected, message)
@keyword
def textfield_value_should_be(self, locator, expected, message=None):
self.base(locator, f"TextField {locator} value is {expected}", f"{expected}", expected, message)
@keyword
def textarea_should_contain(self, locator, expected, message=None):
self.base(locator, f"TextArea {locator} contains {expected}", f"{expected}", expected, message)
@keyword
def textarea_value_should_be(self, locator, expected, message=None):
self.base(locator, f"TextArea {locator} value is {expected}", f"{expected}", expected, message)
@keyword
def page_should_contain_button(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page contains button {locator}", f"{locator}", message, loglevel)
@keyword
def page_should_not_contain_button(self, locator, message=None, loglevel="TRACE"):
self.base(locator, f"Page does not contain button {locator}", f"{locator}", message, loglevel)
# FORM ELEMENT END #
# BROWSER MANAGEMENT #
@keyword
def open_browser(self, url=None):
if not self.__reporter:
self.__reporter.step(
description="Open Browser",
message="This step is deprecated using TestProject library",
passed=True,
screenshot=False,
)
warnings.warn(
"This is deprecated using TestProject Library, please look at the official documentation for examples.",
DeprecationWarning,
stacklevel=2,
)
logger.console("'Open Browser' is deprecated using TestProject Library, please see official documentation.")
@keyword
def switch_browser(self, index_or_alias):
self.base("", f"Switched to {index_or_alias}", f"{index_or_alias}", index_or_alias)
@keyword
def get_browser_ids(self):
return self.base("", "Browser Ids", "")
@keyword
def get_browser_aliases(self):
return self.base("", "Browser Aliases", "")
@keyword
def get_session_id(self):
return self.base("", "Session ID", "")
@keyword
def get_source(self):
return self.base("", "Page Source", "")
@keyword
def get_title(self):
return self.base("", "Page Title", "")
@keyword
def get_location(self):
return self.base("", "Window URL", "")
@keyword
def location_should_be(self, url, message=None):
self.base("", f"URL is: {url}", f"{url}", url, message)
@keyword
def location_should_contain(self, expected, message=None):
self.base("", f"URL contains: {expected}", f"{expected}", expected, message)
@keyword
def log_location(self):
return self.base("", "Location and logged it", "")
@keyword
def log_source(self, loglevel="INFO"):
return self.base("", "Source and logged it", "", loglevel)
@keyword
def log_title(self):
return self.base("", "Title and logged it", "")
@keyword
def title_should_be(self, title, message=None):
return self.base("", f"Title is {title}", f"{title}", title, message)
@keyword
def go_back(self):
self.base("", "Navigated Back", "")
@keyword
def go_to(self, url):
self.base("", f"Navigated to {url}", f"{url}", url)
@keyword
def reload_page(self):
self.base("", "Reloaded page", "")
@keyword
def get_selenium_speed(self):
return self.base("", "Delay between each selenium command", "")
@keyword
def get_selenium_timeout(self):
return self.base("", "Timeout between variuos keywords", "")
@keyword
def get_selenium_implicit_wait(self):
return self.base("", "Implicit wait value", "")
@keyword
def set_selenium_speed(self, value):
return self.base("", f"Selenium Speed set to {value}", f"{value}", value)
@keyword
def set_selenium_timeout(self, value):
return self.base("", f"Timeout was set to {value}", f"{value}", value)
@keyword
def set_selenium_implicit_wait(self, value):
return self.base("", f"Implicit wait set to {value}", f"{value}", value)
@keyword
def set_browser_implicit_wait(self, value):
self.base("", f"Browser implicit wait set to {value}", f"{value}", value)
@keyword
def close_all_browsers(self):
self.base("", "Closed all open browsers", "")
@keyword
def create_webdriver(self, driver_name, alias=None, kwargs={}, **init_kwargs):
if not self.__reporter:
self.__reporter.step(
description="Create Webdriver",
message="This step is deprecated using TestProject library",
passed=True,
screenshot=False,
)
warnings.warn(
"This is deprecated using TestProject Library, please look at the offical documentation for examples.",
DeprecationWarning,
stacklevel=2,
)
logger.console("'Create WebDriver' is deprecated using TestProject Library, please see offical documentation.")
# BROWSER MANAGEMENT END #
# UTIL METHODS #
def base(self, *args):
func_name = inspect.stack()[1].function
locator, message, description = "N/A"
try:
locator = args[0] # Get the locator of the element
message = args[1] # Get the message for the __reporter
description = args[2] # Get the description for the __reporter
# Remove message,description and locator
args_as_list = list(args)
args = tuple(args_as_list[3:])
value = self.base_keyword_action(locator, *args, func_name=func_name)
if not value:
self.base_report(True, message=message, func_name=func_name, description=description)
else:
self.base_report(True, message=f"Returned value: {value}", func_name=func_name, description=description)
return value
except Exception as e:
self.base_report(success=False, exception=e, func_name=func_name, description=description)
raise
def build_values(self, locator, *values):
result_list = []
if locator:
result_list.append(locator)
result_list = result_list + list(values)
return result_list
def convert(self, word):
return " ".join(x.capitalize() for x in word.split("_"))
def base_report(self, success, message="", func_name="", screenshot=False, exception=None, description=None):
if self.__reporter is None:
return
if not func_name:
func_name = inspect.stack()[1].function
func_name = self.convert(func_name)
if success:
self.__reporter.step(
description=f"{func_name}: {description}", message=message, passed=True, screenshot=True
)
else:
if not message:
message += f"Failure reason:\n'{exception}'"
self.__reporter.step(description=f"{func_name}: {description}", message=message, passed=False, screenshot=True)
def base_keyword_action(self, locator, *values, func_name=""):
try:
ret_value = ""
if not func_name: # Get name of calling Keyword
func_name = inspect.stack()[1].function
if not locator and not values:
ret_value = self.library.run_keyword(func_name, (), {})
elif not locator:
ret_value = self.library.run_keyword(func_name, self.build_values(None, *values), {})
elif not values:
if func_name == "get_webelements":
func_name = "Get WebElements"
if func_name == "get_webelement":
func_name = "Get WebElement"
ret_value = self.library.run_keyword(func_name, [locator], {})
else:
ret_value = self.library.run_keyword(func_name, self.build_values(locator, *values), {})
return ret_value
except Exception as e:
raise e
# UTIL METHODS END #
# LISTENERS #
def _end_test(self, data, result):
if self.__reporter is None:
return
self.__reporter.test(name=result.name, passed=result.passed)
