def test_keyup_only_sends_no_events(session, key_reporter, key_chain):
key_chain.key_up("a").perform()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
session.actions.release()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
def test_keyup_only_sends_no_events(session, key_reporter, key_chain):
key_chain.key_up("a").perform()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
session.actions.release()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
def test_drag_and_drop(session,
test_actions_page,
mouse_chain,
dx,
dy,
drag_duration):
drag_target = session.find.css("#dragTarget", all=False)
initial_rect = drag_target.rect
initial_center = get_inview_center(initial_rect, get_viewport_rect(session))
# Conclude chain with extra move to allow time for last queued
# coordinate-update of drag_target and to test that drag_target is "dropped".
mouse_chain \
.pointer_move(0, 0, origin=drag_target) \
.pointer_down() \
.pointer_move(dx, dy, duration=drag_duration, origin="pointer") \
.pointer_up() \
.pointer_move(80, 50, duration=100, origin="pointer") \
.perform()
# mouseup that ends the drag is at the expected destination
e = get_events(session)[1]
assert e["type"] == "mouseup"
assert e["pageX"] == pytest.approx(initial_center["x"] + dx, abs = 1.0)
assert e["pageY"] == pytest.approx(initial_center["y"] + dy, abs = 1.0)
# check resulting location of the dragged element
final_rect = drag_target.rect
assert initial_rect["x"] + dx == final_rect["x"]
assert initial_rect["y"] + dy == final_rect["y"]
def test_printable_key_sends_correct_events(session, key_reporter, key_chain,
value, code):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{
"code": code,
"key": value,
"type": "keydown"
},
{
"code": code,
"key": value,
"type": "keypress"
},
{
"code": code,
"key": value,
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert get_keys(key_reporter) == value
def test_drag_and_drop_with_draggable_element(session,
test_actions_page,
mouse_chain,
drag_duration):
drag_target = session.find.css("#draggable", all=False)
drop_target = session.find.css("#droppable", all=False)
# Conclude chain with extra move to allow time for last queued
# coordinate-update of drag_target and to test that drag_target is "dropped".
mouse_chain \
.pointer_move(0, 0, origin=drag_target) \
.pointer_down() \
.pointer_move(50,
25,
duration=drag_duration,
origin=drop_target) \
.pointer_up() \
.pointer_move(80, 50, duration=100, origin="pointer") \
.perform()
# mouseup that ends the drag is at the expected destination
e = get_events(session)
assert e[1]["type"] == "dragstart", "Events captured were {}".format(e)
assert e[2]["type"] == "dragover", "Events captured were {}".format(e)
drag_events_captured = [ev["type"] for ev in e if ev["type"].startswith("drag") or ev["type"].startswith("drop")]
assert "dragend" in drag_events_captured
assert "dragenter" in drag_events_captured
assert "dragleave" in drag_events_captured
assert "drop" in drag_events_captured
def test_modifier_click(session, test_actions_page, key_chain, mouse_chain, modifier, prop):
key_chain \
.pause(200) \
.key_down(modifier) \
.pause(200) \
.key_up(modifier)
outer = session.find.css("#outer", all=False)
mouse_chain.click(element=outer)
session.actions.perform([key_chain.dict, mouse_chain.dict])
expected = [
{"type": "mousemove"},
{"type": "mousedown"},
{"type": "mouseup"},
{"type": "click"},
]
defaults = {
"altKey": False,
"metaKey": False,
"shiftKey": False,
"ctrlKey": False
}
for e in expected:
e.update(defaults)
if e["type"] != "mousemove":
e[prop] = True
filtered_events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert expected == filtered_events
def test_modifier_click(session, test_actions_page, key_chain, mouse_chain, modifier, prop):
key_chain \
.pause(200) \
.key_down(modifier) \
.pause(200) \
.key_up(modifier)
outer = session.find.css("#outer", all=False)
mouse_chain.click(element=outer)
session.actions.perform([key_chain.dict, mouse_chain.dict])
expected = [
{"type": "mousemove"},
{"type": "mousedown"},
{"type": "mouseup"},
{"type": "click"},
]
defaults = {
"altKey": False,
"metaKey": False,
"shiftKey": False,
"ctrlKey": False
}
for e in expected:
e.update(defaults)
if e["type"] != "mousemove":
e[prop] = True
filtered_events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert expected == filtered_events
def test_release_control_click(session, key_reporter, key_chain, mouse_chain):
# The context menu stays visible during subsequent tests so let's not
# display it in the first place.
session.execute_script("""
var keyReporter = document.getElementById("keys");
document.addEventListener("contextmenu", function(e) {
e.preventDefault();
});
""")
key_chain \
.pause(0) \
.key_down(Keys.CONTROL)
mouse_chain \
.pointer_move(0, 0, origin=key_reporter) \
.pointer_down()
session.actions.perform([key_chain.dict, mouse_chain.dict])
session.execute_script("""
var keyReporter = document.getElementById("keys");
keyReporter.addEventListener("mousedown", recordPointerEvent);
keyReporter.addEventListener("mouseup", recordPointerEvent);
resetEvents();
""")
session.actions.release()
expected = [
{
"type": "mouseup"
},
{
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
def test_special_key_sends_keydown(session, key_reporter, key_chain, name, expected):
if name.startswith("F"):
# Prevent default behavior for F1, etc., but only after keydown
# bubbles up to body. (Otherwise activated browser menus/functions
# may interfere with subsequent tests.)
session.execute_script("""
document.body.addEventListener("keydown",
function(e) { e.preventDefault() });
""")
if (session.capabilities["browserName"] == 'internet explorer'):
key_reporter.click()
session.execute_script("resetEvents();")
key_chain.key_down(getattr(Keys, name)).perform()
# only interested in keydown
first_event = get_events(session)[0]
# make a copy so we can throw out irrelevant keys and compare to events
expected = dict(expected)
del expected["value"]
# check and remove keys that aren't in expected
assert first_event["type"] == "keydown"
assert first_event["repeat"] is False
first_event = filter_dict(first_event, expected)
if first_event["code"] is None:
del first_event["code"]
del expected["code"]
assert first_event == expected
# only printable characters should be recorded in input field
entered_keys = get_keys(key_reporter)
if len(expected["key"]) == 1:
assert entered_keys == expected["key"]
else:
assert len(entered_keys) == 0
def test_non_printable_key_sends_events(session, key_reporter, key_chain, key, event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keypress"},
{"code": code, "key": value, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
if len(events) == 2:
# most browsers don't send a keypress for non-printable keys
assert events == [expected[0], expected[2]]
else:
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_release_control_click(session, key_reporter, key_chain, mouse_chain):
# The context menu stays visible during subsequent tests so let's not
# display it in the first place.
session.execute_script("""
var keyReporter = document.getElementById("keys");
document.addEventListener("contextmenu", function(e) {
e.preventDefault();
});
""")
key_chain \
.pause(0) \
.key_down(Keys.CONTROL)
mouse_chain \
.pointer_move(0, 0, origin=key_reporter) \
.pointer_down()
session.actions.perform([key_chain.dict, mouse_chain.dict])
session.execute_script("""
var keyReporter = document.getElementById("keys");
keyReporter.addEventListener("mousedown", recordPointerEvent);
keyReporter.addEventListener("mouseup", recordPointerEvent);
resetEvents();
""")
session.actions.release()
expected = [
{"type": "mouseup"},
{"type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
def test_drag_and_drop(session,
test_actions_page,
mouse_chain,
dx,
dy,
drag_duration):
drag_target = session.find.css("#dragTarget", all=False)
initial_rect = drag_target.rect
initial_center = get_inview_center(initial_rect, get_viewport_rect(session))
# Conclude chain with extra move to allow time for last queued
# coordinate-update of drag_target and to test that drag_target is "dropped".
mouse_chain \
.pointer_move(0, 0, origin=drag_target) \
.pointer_down() \
.pointer_move(dx, dy, duration=drag_duration, origin="pointer") \
.pointer_up() \
.pointer_move(80, 50, duration=100, origin="pointer") \
.perform()
# mouseup that ends the drag is at the expected destination
e = get_events(session)[1]
assert e["type"] == "mouseup"
assert pytest.approx(e["pageX"], initial_center["x"] + dx)
assert pytest.approx(e["pageY"], initial_center["y"] + dy)
# check resulting location of the dragged element
final_rect = drag_target.rect
assert initial_rect["x"] + dx == final_rect["x"]
assert initial_rect["y"] + dy == final_rect["y"]
def test_modifier_key_sends_correct_events(session, key_reporter, key_chain, key, event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
if session.capabilities["browserName"] == "internet explorer":
key_reporter.click()
session.execute_script("resetEvents();")
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_context_menu_at_coordinates(session, test_actions_page, mouse_chain):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"]) \
.pointer_down(button=2) \
.pointer_up(button=2) \
.perform()
events = get_events(session)
expected = [
{
"type": "mousedown",
"button": 2
},
{
"type": "contextmenu",
"button": 2
},
]
assert len(events) == 4
filtered_events = [filter_dict(e, expected[0]) for e in events]
mousedown_contextmenu_events = [
x for x in filtered_events
if x["type"] in ["mousedown", "contextmenu"]
]
assert expected == mousedown_contextmenu_events
def test_click_at_coordinates(session, test_actions_page, mouse_chain):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"], duration=1000) \
.click() \
.perform()
events = get_events(session)
assert len(events) == 4
assert_move_to_coordinates(div_point, "outer", events)
for e in events:
if e["type"] != "mousedown":
assert e["buttons"] == 0
assert e["button"] == 0
expected = [
{
"type": "mousedown",
"buttons": 1
},
{
"type": "mouseup",
"buttons": 0
},
{
"type": "click",
"buttons": 0
},
]
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_dblclick_at_coordinates(session, test_actions_page, mouse_chain, click_pause):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"]) \
.click() \
.pause(click_pause) \
.click() \
.perform()
events = get_events(session)
assert_move_to_coordinates(div_point, "outer", events)
expected = [
{"type": "mousedown", "button": 0},
{"type": "mouseup", "button": 0},
{"type": "click", "button": 0},
{"type": "mousedown", "button": 0},
{"type": "mouseup", "button": 0},
{"type": "click", "button": 0},
{"type": "dblclick", "button": 0},
]
assert len(events) == 8
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_modifier_key_sends_correct_events(session, key_reporter, key_chain, key, event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
if session.capabilities["browserName"] == "internet explorer":
key_reporter.click()
session.execute_script("resetEvents();")
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_non_printable_key_sends_events(session, key_reporter, key_chain, key,
event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{
"code": code,
"key": value,
"type": "keydown"
},
{
"code": code,
"key": value,
"type": "keypress"
},
{
"code": code,
"key": value,
"type": "keyup"
},
]
# Make a copy for alternate key property values
# Note: only keydown and keyup are affected by alternate key names
alt_expected = copy.deepcopy(expected)
if event in ALTERNATIVE_KEY_NAMES:
alt_expected[0]["key"] = ALTERNATIVE_KEY_NAMES[event]
alt_expected[2]["key"] = ALTERNATIVE_KEY_NAMES[event]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
alt_expected = [
filter_dict(e, {
"key": "",
"type": ""
}) for e in alt_expected
]
events = [filter_dict(e, expected[0]) for e in events]
if len(events) == 2:
# most browsers don't send a keypress for non-printable keys
assert events == [expected[0], expected[2]
] or events == [alt_expected[0], alt_expected[2]]
else:
assert events == expected or events == alt_expected
assert len(get_keys(key_reporter)) == 0
def test_wheel_scroll_iframe(session, test_actions_scroll_page, wheel_chain):
session.execute_script("document.scrollingElement.scrollTop = 0")
subframe = session.find.css("#subframe", all=False)
wheel_chain.scroll(0, 0, 5, 10, origin=subframe).perform()
events = get_events(session)
assert len(events) == 1
assert events[0]["type"] == "wheel"
assert events[0]["deltaX"] >= 5
assert events[0]["deltaY"] >= 10
assert events[0]["deltaZ"] == 0
assert events[0]["target"] == "iframeContent"
def test_many_modifiers_click(session, test_actions_page, key_chain,
mouse_chain):
outer = session.find.css("#outer", all=False)
dblclick_timeout = 800
key_chain \
.pause(0) \
.key_down(Keys.ALT) \
.key_down(Keys.SHIFT) \
.pause(dblclick_timeout) \
.key_up(Keys.ALT) \
.key_up(Keys.SHIFT)
mouse_chain \
.pointer_move(0, 0, origin=outer) \
.pause(0) \
.pointer_down() \
.pointer_up() \
.pause(0) \
.pause(0) \
.pointer_down()
session.actions.perform([key_chain.dict, mouse_chain.dict])
expected = [
{
"type": "mousemove"
},
# shift and alt pressed
{
"type": "mousedown"
},
{
"type": "mouseup"
},
{
"type": "click"
},
# no modifiers pressed
{
"type": "mousedown"
},
]
defaults = {
"altKey": False,
"metaKey": False,
"shiftKey": False,
"ctrlKey": False
}
for e in expected:
e.update(defaults)
for e in expected[1:4]:
e["shiftKey"] = True
e["altKey"] = True
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
def test_click_element_center(session, test_actions_page, mouse_chain):
outer = session.find.css("#outer", all=False)
center = get_inview_center(outer.rect, get_viewport_rect(session))
mouse_chain.click(element=outer).perform()
events = get_events(session)
assert len(events) == 4
event_types = [e["type"] for e in events]
assert ["mousemove", "mousedown", "mouseup", "click"] == event_types
for e in events:
if e["type"] != "mousemove":
assert pytest.approx(e["pageX"], center["x"])
assert pytest.approx(e["pageY"], center["y"])
assert e["target"] == "outer"
def test_click_element_center(session, test_actions_page, mouse_chain):
outer = session.find.css("#outer", all=False)
center = get_inview_center(outer.rect, get_viewport_rect(session))
mouse_chain.click(element=outer).perform()
events = get_events(session)
assert len(events) == 4
event_types = [e["type"] for e in events]
assert ["mousemove", "mousedown", "mouseup", "click"] == event_types
for e in events:
if e["type"] != "mousemove":
assert e["pageX"] == pytest.approx(center["x"], abs = 1.0)
assert e["pageY"] == pytest.approx(center["y"], abs = 1.0)
assert e["target"] == "outer"
def test_space_char_equals_pua(session, key_reporter, key_chain):
key_chain \
.key_down(Keys.SPACE) \
.key_up(Keys.SPACE) \
.key_down(" ") \
.key_up(" ") \
.perform()
all_events = get_events(session)
by_type = defaultdict(list)
for event in all_events:
by_type[event["type"]].append(event)
for event_type in by_type:
events = by_type[event_type]
assert len(events) == 2
assert events[0] == events[1]
def test_dblclick_at_coordinates(session, test_actions_page, mouse_chain,
click_pause):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"]) \
.click() \
.pause(click_pause) \
.click() \
.perform()
events = get_events(session)
assert_move_to_coordinates(div_point, "outer", events)
expected = [
{
"type": "mousedown",
"button": 0
},
{
"type": "mouseup",
"button": 0
},
{
"type": "click",
"button": 0
},
{
"type": "mousedown",
"button": 0
},
{
"type": "mouseup",
"button": 0
},
{
"type": "click",
"button": 0
},
{
"type": "dblclick",
"button": 0
},
]
assert len(events) == 8
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_sequence_of_keydown_printable_characters_sends_events(
session, key_reporter, key_chain):
key_chain.send_keys("ef").perform()
all_events = get_events(session)
expected = [
{
"code": "KeyE",
"key": "e",
"type": "keydown"
},
{
"code": "KeyE",
"key": "e",
"type": "keypress"
},
{
"code": "KeyE",
"key": "e",
"type": "keyup"
},
{
"code": "KeyF",
"key": "f",
"type": "keydown"
},
{
"code": "KeyF",
"key": "f",
"type": "keypress"
},
{
"code": "KeyF",
"key": "f",
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert get_keys(key_reporter) == "ef"
def test_dblclick_with_pause_after_second_pointerdown(session,
test_actions_page,
mouse_chain):
outer = session.find.css("#outer", all=False)
center = get_inview_center(outer.rect, get_viewport_rect(session))
mouse_chain \
.pointer_move(int(center["x"]), int(center["y"])) \
.click() \
.pointer_down() \
.pause(_DBLCLICK_INTERVAL + 10) \
.pointer_up() \
.perform()
events = get_events(session)
expected = [
{
"type": "mousedown",
"button": 0
},
{
"type": "mouseup",
"button": 0
},
{
"type": "click",
"button": 0
},
{
"type": "mousedown",
"button": 0
},
{
"type": "mouseup",
"button": 0
},
{
"type": "click",
"button": 0
},
{
"type": "dblclick",
"button": 0
},
]
assert len(events) == 8
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_special_key_sends_keydown(session, key_reporter, key_chain, name,
expected):
if name.startswith("F"):
# Prevent default behavior for F1, etc., but only after keydown
# bubbles up to body. (Otherwise activated browser menus/functions
# may interfere with subsequent tests.)
session.execute_script("""
document.body.addEventListener("keydown",
function(e) { e.preventDefault() });
""")
if session.capabilities["browserName"] == "internet explorer":
key_reporter.click()
session.execute_script("resetEvents();")
key_chain.key_down(getattr(Keys, name)).perform()
# only interested in keydown
first_event = get_events(session)[0]
# make a copy so we can throw out irrelevant keys and compare to events
expected = dict(expected)
del expected["value"]
# make another copy for alternative key names
alt_expected = copy.deepcopy(expected)
if name in ALTERNATIVE_KEY_NAMES:
alt_expected["key"] = ALTERNATIVE_KEY_NAMES[name]
# check and remove keys that aren't in expected
assert first_event["type"] == "keydown"
assert first_event["repeat"] is False
first_event = filter_dict(first_event, expected)
if first_event["code"] is None:
del first_event["code"]
del expected["code"]
del alt_expected["code"]
assert first_event == expected or first_event == alt_expected
# only printable characters should be recorded in input field
entered_keys = get_keys(key_reporter)
if len(expected["key"]) == 1:
assert entered_keys == expected["key"]
else:
assert len(entered_keys) == 0
def test_many_modifiers_click(session, test_actions_page, key_chain, mouse_chain):
outer = session.find.css("#outer", all=False)
dblclick_timeout = 800
key_chain \
.pause(0) \
.key_down(Keys.ALT) \
.key_down(Keys.SHIFT) \
.pause(dblclick_timeout) \
.key_up(Keys.ALT) \
.key_up(Keys.SHIFT)
mouse_chain \
.pointer_move(0, 0, origin=outer) \
.pause(0) \
.pointer_down() \
.pointer_up() \
.pause(0) \
.pause(0) \
.pointer_down()
session.actions.perform([key_chain.dict, mouse_chain.dict])
expected = [
{"type": "mousemove"},
# shift and alt pressed
{"type": "mousedown"},
{"type": "mouseup"},
{"type": "click"},
# no modifiers pressed
{"type": "mousedown"},
]
defaults = {
"altKey": False,
"metaKey": False,
"shiftKey": False,
"ctrlKey": False
}
for e in expected:
e.update(defaults)
for e in expected[1:4]:
e["shiftKey"] = True
e["altKey"] = True
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
def test_pen_pointer_properties(session, test_actions_pointer_page, pen_chain):
pointerArea = session.find.css("#pointerArea", all=False)
center = get_inview_center(pointerArea.rect, get_viewport_rect(session))
pen_chain.pointer_move(0, 0, origin=pointerArea) \
.pointer_down(pressure=0.36, tilt_x=-72, tilt_y=9, twist=86) \
.pointer_move(10, 10, origin=pointerArea) \
.pointer_up() \
.pointer_move(80, 50, origin=pointerArea) \
.perform()
events = get_events(session)
assert len(events) == 10
event_types = [e["type"] for e in events]
assert [
"pointerover", "pointerenter", "pointermove", "pointerdown",
"pointerover", "pointerenter", "pointermove", "pointerup",
"pointerout", "pointerleave"
] == event_types
assert events[3]["type"] == "pointerdown"
assert events[3]["pageX"] == pytest.approx(center["x"], abs=1.0)
assert events[3]["pageY"] == pytest.approx(center["y"], abs=1.0)
assert events[3]["target"] == "pointerArea"
assert events[3]["pointerType"] == "pen"
# The default value of width and height for mouse and pen inputs is 1
assert round(events[3]["width"], 2) == 1
assert round(events[3]["height"], 2) == 1
assert round(events[3]["pressure"], 2) == 0.36
assert events[3]["tiltX"] == -72
assert events[3]["tiltY"] == 9
assert events[3]["twist"] == 86
assert events[6]["type"] == "pointermove"
assert events[6]["pageX"] == pytest.approx(center["x"] + 10, abs=1.0)
assert events[6]["pageY"] == pytest.approx(center["y"] + 10, abs=1.0)
assert events[6]["target"] == "pointerArea"
assert events[6]["pointerType"] == "pen"
assert round(events[6]["width"], 2) == 1
assert round(events[6]["height"], 2) == 1
# The default value of pressure for all inputs is 0.5, other properties are 0
assert round(events[6]["pressure"], 2) == 0.5
assert events[6]["tiltX"] == 0
assert events[6]["tiltY"] == 0
assert events[6]["twist"] == 0
def test_sequence_of_keydown_printable_characters_sends_events(session, key_reporter, key_chain):
key_chain.send_keys("ef").perform()
all_events = get_events(session)
expected = [
{"code": "KeyE", "key": "e", "type": "keydown"},
{"code": "KeyE", "key": "e", "type": "keypress"},
{"code": "KeyE", "key": "e", "type": "keyup"},
{"code": "KeyF", "key": "f", "type": "keydown"},
{"code": "KeyF", "key": "f", "type": "keypress"},
{"code": "KeyF", "key": "f", "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert get_keys(key_reporter) == "ef"
def test_no_dblclick(session, test_actions_page, mouse_chain):
outer = session.find.css("#outer", all=False)
center = get_inview_center(outer.rect, get_viewport_rect(session))
mouse_chain \
.pointer_move(int(center["x"]), int(center["y"])) \
.click() \
.pause(_DBLCLICK_INTERVAL + 10) \
.click() \
.perform()
events = get_events(session)
expected = [
{"type": "mousedown", "button": 0},
{"type": "mouseup", "button": 0},
{"type": "click", "button": 0},
{"type": "mousedown", "button": 0},
{"type": "mouseup", "button": 0},
{"type": "click", "button": 0},
]
assert len(events) == 7
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_printable_key_sends_correct_events(session, key_reporter, key_chain, value, code):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keypress"},
{"code": code, "key": value, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert get_keys(key_reporter) == value
def test_touch_pointer_properties(session, test_actions_pointer_page,
touch_chain):
pointerArea = session.find.css("#pointerArea", all=False)
center = get_inview_center(pointerArea.rect, get_viewport_rect(session))
touch_chain.pointer_move(0, 0, origin=pointerArea) \
.pointer_down(width=23, height=31, pressure=0.78, tilt_x=21, tilt_y=-8, twist=355) \
.pointer_move(10, 10, origin=pointerArea, width=39, height=35, pressure=0.91, tilt_x=-19, tilt_y=62, twist=345) \
.pointer_up() \
.pointer_move(80, 50, origin=pointerArea) \
.perform()
events = get_events(session)
assert len(events) == 7
event_types = [e["type"] for e in events]
assert [
"pointerover", "pointerenter", "pointerdown", "pointermove",
"pointerup", "pointerout", "pointerleave"
] == event_types
assert events[2]["type"] == "pointerdown"
assert events[2]["pageX"] == pytest.approx(center["x"], abs=1.0)
assert events[2]["pageY"] == pytest.approx(center["y"], abs=1.0)
assert events[2]["target"] == "pointerArea"
assert events[2]["pointerType"] == "touch"
assert round(events[2]["width"], 2) == 23
assert round(events[2]["height"], 2) == 31
assert round(events[2]["pressure"], 2) == 0.78
assert events[2]["tiltX"] == 21
assert events[2]["tiltY"] == -8
assert events[2]["twist"] == 355
assert events[3]["type"] == "pointermove"
assert events[3]["pageX"] == pytest.approx(center["x"] + 10, abs=1.0)
assert events[3]["pageY"] == pytest.approx(center["y"] + 10, abs=1.0)
assert events[3]["target"] == "pointerArea"
assert events[3]["pointerType"] == "touch"
assert round(events[3]["width"], 2) == 39
assert round(events[3]["height"], 2) == 35
assert round(events[3]["pressure"], 2) == 0.91
assert events[3]["tiltX"] == -19
assert events[3]["tiltY"] == 62
assert events[3]["twist"] == 345
def test_context_menu_at_coordinates(session, test_actions_page, mouse_chain):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"]) \
.pointer_down(button=2) \
.pointer_up(button=2) \
.perform()
events = get_events(session)
expected = [
{"type": "mousedown", "button": 2},
{"type": "contextmenu", "button": 2},
]
assert len(events) == 4
filtered_events = [filter_dict(e, expected[0]) for e in events]
mousedown_contextmenu_events = [
x for x in filtered_events
if x["type"] in ["mousedown", "contextmenu"]
]
assert expected == mousedown_contextmenu_events
def test_click_at_coordinates(session, test_actions_page, mouse_chain):
div_point = {
"x": 82,
"y": 187,
}
mouse_chain \
.pointer_move(div_point["x"], div_point["y"], duration=1000) \
.click() \
.perform()
events = get_events(session)
assert len(events) == 4
assert_move_to_coordinates(div_point, "outer", events)
for e in events:
if e["type"] != "mousedown":
assert e["buttons"] == 0
assert e["button"] == 0
expected = [
{"type": "mousedown", "buttons": 1},
{"type": "mouseup", "buttons": 0},
{"type": "click", "buttons": 0},
]
filtered_events = [filter_dict(e, expected[0]) for e in events]
assert expected == filtered_events[1:]
def test_modifier_key_sends_correct_events(session, key_reporter, key_chain, key, event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
events = [filter_dict(e, expected[0]) for e in events]
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_non_printable_key_sends_events(session, key_reporter, key_chain, key, event):
code = ALL_EVENTS[event]["code"]
value = ALL_EVENTS[event]["key"]
key_chain \
.key_down(key) \
.key_up(key) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": value, "type": "keydown"},
{"code": code, "key": value, "type": "keypress"},
{"code": code, "key": value, "type": "keyup"},
]
# Make a copy for alternate key property values
# Note: only keydown and keyup are affected by alternate key names
alt_expected = copy.deepcopy(expected)
if event in ALTERNATIVE_KEY_NAMES:
alt_expected[0]["key"] = ALTERNATIVE_KEY_NAMES[event]
alt_expected[2]["key"] = ALTERNATIVE_KEY_NAMES[event]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] is None:
# Remove 'code' entry if browser doesn't support it
expected = [filter_dict(e, {"key": "", "type": ""}) for e in expected]
alt_expected = [filter_dict(e, {"key": "", "type": ""}) for e in alt_expected]
events = [filter_dict(e, expected[0]) for e in events]
if len(events) == 2:
# most browsers don't send a keypress for non-printable keys
assert events == [expected[0], expected[2]] or events == [alt_expected[0], alt_expected[2]]
else:
assert events == expected or events == alt_expected
assert len(get_keys(key_reporter)) == 0
def test_perform_no_actions_send_no_events(session, key_reporter, key_chain):
key_chain.perform()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
