import imghdr
from base64 import decodebytes
from webdriver import NoSuchAlertException, WebDriverException, WebElement
# WebDriver specification ID: dfn-error-response-data
errors = {
"detached shadow root": 404,
"element click intercepted": 400,
"element not selectable": 400,
"element not interactable": 400,
"insecure certificate": 400,
"invalid argument": 400,
"invalid cookie domain": 400,
"invalid coordinates": 400,
"invalid element state": 400,
"invalid selector": 400,
"invalid session id": 404,
"javascript error": 500,
"move target out of bounds": 500,
"no such alert": 404,
"no such cookie": 404,
"no such element": 404,
"no such frame": 404,
"no such shadow root": 404,
"no such window": 404,
"script timeout": 500,
"session not created": 500,
"stale element reference": 404,
"timeout": 500,
"unable to set cookie": 500,
"unable to capture screen": 500,
"unexpected alert open": 500,
"unknown command": 404,
"unknown error": 500,
"unknown method": 405,
"unsupported operation": 500,
}
def assert_error(response, error_code):
"""
Verify that the provided webdriver.Response instance described
a valid error response as defined by `dfn-send-an-error` and
the provided error code.
:param response: ``webdriver.Response`` instance.
:param error_code: String value of the expected error code
"""
assert response.status == errors[error_code]
assert "value" in response.body
assert response.body["value"]["error"] == error_code
assert isinstance(response.body["value"]["message"], str)
assert isinstance(response.body["value"]["stacktrace"], str)
assert_response_headers(response.headers)
def assert_success(response, value=None):
"""
Verify that the provided webdriver.Response instance described
a valid success response as defined by `dfn-send-a-response` and
the provided response value.
:param response: ``webdriver.Response`` instance.
:param value: Expected value of the response body, if any.
"""
assert response.status == 200, str(response.error)
if value is not None:
assert response.body["value"] == value
assert_response_headers(response.headers)
return response.body.get("value")
def assert_response_headers(headers):
"""
Method to assert response headers for WebDriver requests
:param headers: dict with header data
"""
assert 'cache-control' in headers
assert 'no-cache' == headers['cache-control']
assert 'content-type' in headers
assert 'application/json; charset=utf-8' == headers['content-type']
def assert_dialog_handled(session, expected_text, expected_retval):
# If there were any existing dialogs prior to the creation of this
# fixture's dialog, then the "Get Alert Text" command will return
# successfully. In that case, the text must be different than that
# of this fixture's dialog.
try:
assert session.alert.text != expected_text, (
"User prompt with text '{}' was not handled.".format(expected_text))
except NoSuchAlertException:
# If dialog has been closed and no other one is open, check its return value
prompt_retval = session.execute_script(" return window.dialog_return_value;")
assert prompt_retval == expected_retval
def assert_files_uploaded(session, element, files):
def get_file_contents(file_index):
return session.execute_async_script("""
let files = arguments[0].files;
let index = arguments[1];
let resolve = arguments[2];
var reader = new FileReader();
reader.onload = function(event) {
resolve(reader.result);
};
reader.readAsText(files[index]);
""", (element, file_index))
def get_uploaded_file_names():
return session.execute_script("""
let fileList = arguments[0].files;
let files = [];
for (var i = 0; i < fileList.length; i++) {
files.push(fileList[i].name);
}
return files;
""", args=(element,))
expected_file_names = [str(f.basename) for f in files]
assert get_uploaded_file_names() == expected_file_names
for index, f in enumerate(files):
assert get_file_contents(index) == f.read()
def assert_is_active_element(session, element):
"""Verify that element reference is the active element."""
from_js = session.execute_script("return document.activeElement")
if element is None:
assert from_js is None
else:
assert_same_element(session, element, from_js)
def assert_same_element(session, a, b):
"""Verify that two element references describe the same element."""
if isinstance(a, dict):
assert WebElement.identifier in a, "Actual value does not describe an element"
a_id = a[WebElement.identifier]
elif isinstance(a, WebElement):
a_id = a.id
else:
raise AssertionError("Actual value is not a dictionary or web element")
if isinstance(b, dict):
assert WebElement.identifier in b, "Expected value does not describe an element"
b_id = b[WebElement.identifier]
elif isinstance(b, WebElement):
b_id = b.id
else:
raise AssertionError("Expected value is not a dictionary or web element")
if a_id == b_id:
return
message = ("Expected element references to describe the same element, " +
"but they did not.")
# Attempt to provide more information, accounting for possible errors such
# as stale element references or not visible elements.
try:
a_markup = session.execute_script("return arguments[0].outerHTML;", args=(a,))
b_markup = session.execute_script("return arguments[0].outerHTML;", args=(b,))
message += " Actual: `%s`. Expected: `%s`." % (a_markup, b_markup)
except WebDriverException:
pass
raise AssertionError(message)
def assert_in_events(session, expected_events):
actual_events = session.execute_script("return window.events")
for expected_event in expected_events:
assert expected_event in actual_events
def assert_events_equal(session, expected_events):
actual_events = session.execute_script("return window.events")
assert actual_events == expected_events
def assert_element_has_focus(target_element):
session = target_element.session
active_element = session.execute_script("return document.activeElement")
active_tag = active_element.property("localName")
target_tag = target_element.property("localName")
assert active_element == target_element, (
"Focussed element is <%s>, not <%s>" % (active_tag, target_tag))
def assert_move_to_coordinates(point, target, events):
for e in events:
if e["type"] != "mousemove":
assert e["pageX"] == point["x"]
assert e["pageY"] == point["y"]
assert e["target"] == target
def assert_pdf(value):
data = decodebytes(value.encode())
assert data.startswith(b"%PDF-"), "Decoded data starts with the PDF signature"
assert data.endswith(b"%%EOF\n"), "Decoded data ends with the EOF flag"
def assert_png(screenshot):
"""Test that screenshot is a Base64 encoded PNG file, or a bytestring representing a PNG.
Returns the bytestring for the PNG, if the assert passes
"""
if type(screenshot) is str:
image = decodebytes(screenshot.encode())
else:
image = screenshot
mime_type = imghdr.what("", image)
assert mime_type == "png", "Expected image to be PNG, but it was {}".format(mime_type)
return image
Codebase Browser
chromium