def sendKeys(self,
el: WebElement,
keys,
clearBefore: bool = False,
assertText: str = None,
assertAttempts: int = 3,
assertTime: float = 1,
timeSleep: float = 0) -> bool:
"""
-> Send keys to an element and optionally assert for a text on page after the send
:return: True/False. True if send keys and then page has the text, False otherwise
"""
if el is None:
return False #1
try:
if clearBefore:
el.click()
el.clear()
if isinstance(keys, str): #->2
el.send_keys(keys)
elif isinstance(keys, tuple): #->3
for k in keys:
el.send_keys(k)
else:
return False #4
except:
return False #5
time.sleep(timeSleep)
return self.assertText(assertText, assertAttempts,
assertTime) #2 and 3
def fill_input_with_value(input_el: WebElement, value: InputValue) -> None:
try:
# If element is user-editable, clear input.
input_el.clear()
except InvalidElementStateException:
pass
input_el.send_keys(value)
def send_keys_slowly(element: WebElement, keys: str):
logging_info(
f'Simulate human entering keys speed into WebElement: {element}')
for key in keys:
element.send_keys(key)
sleep(0.3)
sleep(1)
def send_keys_human_like(element: WebElement, value: str):
""" Typing value with human like """
# todo: get value is list and string
for character in value:
element.send_keys(character)
sleep(random.uniform(0.2, 0.4))
sleep(random.uniform(0.5, 1.1))
def input(self, target: WebElement, value) -> WebElement:
try:
if type(target) == WebElement:
target.send_keys(value)
self.__DEBUG(target=target, value=value)
except ElementNotInteractableException:
return target
return target
def click_and_wait_for_load(self, element: WebElement):
"""Click an offscreen element and wait for title to load.
Clicks the given element, even if it is offscreen, by sending the ENTER
key. Returns after loading the last element (title) of the page).
"""
title_before_click = self.page_title
element.send_keys(Keys.ENTER)
self.wait.until(lambda _: title_before_click != (self.page_title))
def write_into_element(self,
data: str,
locator_type: By = None,
locator_value: str = None,
element: WebElement = None,
from_element: WebElement = None,
time_to_wait: int = TIME_TO_WAIT,
should_clear_element: bool = True):
if not element:
element = self.find_element_by(locator_type, locator_value,
from_element, time_to_wait)
if should_clear_element:
self.clear_element(element=element)
element.send_keys(data)
def type_login_info(browser: WebDriver, uname_form: WebElement,
pword_form: WebElement) -> None:
"""Sends username and password to login form."""
try:
from bfetch.modules.secretss import username, password
except:
message_u = "Please enter your blackboard username."
message_p = "Please enter you blackboard password."
prompt = "> "
username = input(message_u + "\n" + prompt)
password = getpass.getpass(prompt=f"{message_p}\n{prompt}",
stream=None)
uname_form.send_keys(username)
pword_form.send_keys(password)
def set_current_time_use_element(element: WebElement) -> None:
"""
设置当前时间到时间输入框
:param element: 时间输入框对象
:return: WebElement
"""
return element.send_keys(DateTime.current_date_time())
def send_keys_delay_random(self,
element: WebElement,
keys: Union[str, int, float, List[str],
List[int], List[float]],
min_delay: float = 0.025,
max_delay: float = 0.25) -> bool:
_keys = copy.deepcopy(keys)
if type(_keys) in [int, float]:
_keys = str(_keys)
for key in _keys:
if type(key) in [int, float]:
key = str(key)
element.send_keys(key)
time.sleep(random.uniform(min_delay, max_delay))
return True
def send_keys(self, # pylint: disable=no-self-use
element: WebElement,
value: str,
retries: int = 10) -> None:
'''Helper to _really_ send keys to an element.
For some yet unexplained reason when running in non-headless mode, the
interactions with text elements do not always register by the browser.
This causes input elements to remain empty even after sending the keys.
This method sends the keys and then ensures that the value of the
element is the expected string, retrying if necessary.
'''
for _ in range(retries):
element.clear()
element.send_keys(value)
if element.get_attribute('value') == value:
return
logging.error('Failed to send keys to the element')
def action_on_elem(self,
web_elem: WebElement,
action: str,
content: str = ""):
log_client = LogsClient(output_file=self.log_output_file,
project_dir=project_dir,
file_name=file_name,
log_run_uuid=self.log_run_uuid)
log_client.set_msg(
log_type="info",
log_msg=f"action: {action} on web element: {web_elem}")
try:
if action == "click":
web_elem.click()
elif action == "send_keys":
web_elem.send_keys(content)
sleep(2)
except NoSuchElementException:
log_client.set_msg(
log_type="error",
log_msg=
f"error while trying to perform action: {action} at web element: {web_elem}"
)
except Exception as e:
log_client.set_msg(
log_type="error",
log_msg=f"the following error occurred with args: {e.args}")
def _do_script_step(self, step: list, parent: WebElement = None) -> list:
"""
单步执行操作
@param {list} step - 要执行操作的步骤参数
['find', op, para1, ...] # 忽略此前步骤查找到的元素，重新全局搜索元素并设置为当前元素, 数组后面为查找指令和对应的参数，参考find_elements
['find_child', op, para1, ...] # 搜索此前元素的子元素并设置为当前元素，数组后面为查找指令和对应的参数，参考find_elements
['click'] # 点击元素
['send_str', '要输入的文本'] # 元素输入文本
['send_keys', 'Keys.CONTROL', 'Keys.SHIFT', 'a', ...] # 输入按键，传入多个代表同时按下
# 特殊按键定义参考 selenium.webdriver.common.keys.Keys
@param {WebElement} parent=None - 父节点，如果不传代表全局搜索
@returns {list} - 如果是执行操作，直接返回包含parent的数组；如果是查询操作，返回查询到的元素清单
"""
_elements = [
parent,
]
_op = step[0]
if _op == 'find':
# 忽略此前步骤查找到的元素，重新全局搜索元素并设置为当前元素
return self.find_elements([step[1:]], parent=None)
elif _op == 'find_child':
return self.find_elements([step[1:]], parent=parent)
elif _op == 'click':
parent.click()
elif _op == 'send_str':
parent.send_keys(step[1])
elif _op == 'send_keys':
# 输入快捷键
_keys = [
eval(_key) if _key.startswith('Keys.') else _key
for _key in step[1:]
]
parent.send_keys(*_keys)
return _elements
def robust_input(self,
ele: WebElement,
text: str,
use_paste=False,
ensure_value=False) -> bool:
ele.clear()
if use_paste:
import os
os.system("echo {}|clip".format(text))
ele.send_keys(Keys.CONTROL, "v")
else:
ele.send_keys(text)
if ensure_value:
if ele.get_attribute("value") == text:
return True
else:
logger_driver.warning({
"target input": text,
"inputted": ele.get_attribute("value")
})
return False
else:
return True
def search_indexer(
self,
browser: DriverType,
search_bar: WebElement,
query: str,
locator_type: str,
locator_value: str,
) -> List:
"""
Searches via indexer. Will return a list of Elements for results;
if there are no results then it will return an empty List.
Behaviour to `search_chapter_title` is pretty much identical, but
this also sends a `<RETURN>` key to trigger search-by-text rather than
by-title.
"""
self.slow_send_keys(search_bar, query)
search_bar.send_keys(Keys.RETURN)
try:
counter = WebDriverWait(browser, 10).until(
EC.presence_of_element_located((
By.XPATH,
"//div[contains(@class, 'UI Tab is-active')]//i[number(text()) = number(text())]",
)))
if int(counter.text) == 0:
return []
else:
elements = browser.find_elements(locator_type, locator_value)
return elements if elements else []
except BaseException:
# Note we want to return an empty list if it does time out, as that
# indicates nothing loaded.
# It's up to the test to handle this and work out if that's a failure/success.
return []
def perform_action(driver, action):
try:
if action.id == 'noop':
pass
elif action.id == 'click':
id = action.args[0]
element = WebElement(driver, id)
ActionChains(driver).move_to_element(element).click(
element).perform()
elif action.id == 'doubleClick':
id = action.args[0]
element = WebElement(driver, id)
ActionChains(driver).move_to_element(
element).double_click(element).perform()
elif action.id == 'focus':
id = action.args[0]
element = WebElement(driver, id)
element.send_keys("")
elif action.id == 'keyPress':
char = action.args[0]
element = driver.switch_to.active_element
element.send_keys(char)
elif action.id == 'enterText':
element = driver.switch_to.active_element
element.send_keys(action.args[0])
elif action.id == 'enterTextInto':
id = action.args[1]
element = WebElement(driver, id)
element.send_keys(action.args[0])
elif action.id == 'clear':
id = action.args[0]
element = WebElement(driver, id)
element.clear()
else:
raise UnsupportedActionError(action)
except Exception as e:
raise PerformActionError(action, e)
def set_val(self,
element: WebElement,
val: Any,
send_enter: bool = False,
send_keys: bool = False,
**kw) -> None:
"""Set input box value by send_keys or exec script
- Need id to set by script
Parameters
----------
element : WebElement
val : Any
send_enter : bool, optional
press enter after sending, default False
send_keys : bool, optional
default False
"""
driver = self.driver
val = str(val).replace("'", "\\'").replace('"',
'\\"').replace('\n', '\\n')
try:
if send_keys:
element.send_keys(val)
else:
driver.execute_script(
"document.getElementById('{}').value='{}'".format(
element.get_attribute('id'), val))
if send_enter:
element.send_keys(
Keys.ENTER
) # date fields need an ENTER to set val properly
except:
log.warning(f'couldn\'t set value: {val}')
if self.suppress_errors:
return
element.send_keys(val)
def _send_keys_like_human(elem: WebElement, keys: str):
for key in keys:
elem.send_keys(key)
_human_wait(mu=0.03)
def enter_text_to_elem(self, text: str, elem: WebElement):
if elem != None:
elem.send_keys(text)
return True
return False
def input_text(self, element: WebElement, text: str) -> None:
if element.is_displayed():
element.send_keys(text)
def clear_and_type(self, web_element: WebElement, text: str):
self.webdriver_client.execute_js('arguments[0].focus()', web_element)
self.webdriver_client.execute_js('arguments[0].value = ""',
web_element)
web_element.send_keys(text)
def send_keys(element: WebElement, s: str):
element.send_keys(s[0:-1])
sleep(0.5)
element.send_keys(s[-1])
sleep(0.5)
def input_value(self, element: WebElement, text: str):
"""
Проверка на то, что заполняем поля не типом None
"""
if text is not None:
element.send_keys(text)
def send_keys(el: WebElement, keys: str):
for i in range(len(keys)):
el.send_keys(keys[i])
def set_element_value(self, element: WebElement, key):
element.clear()
element.click()
element.send_keys(key)
def send_comment(comment_input: WebElement, content: Any):
comment_input.send_keys(str(content))
comment_input.send_keys(Keys.ENTER)
sleep(15)
def send_keys(element: WebElement, keys: Any) -> None:
for char in keys:
element.send_keys(char)
