def test_lone_keyup_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_sequence_of_keydown_printable_keys_sends_events(
session, key_reporter, key_chain):
key_chain \
.key_down("a") \
.key_down("b") \
.perform()
expected = [
{
"code": "KeyA",
"key": "a",
"type": "keydown"
},
{
"code": "KeyA",
"key": "a",
"type": "keypress"
},
{
"code": "KeyB",
"key": "b",
"type": "keydown"
},
{
"code": "KeyB",
"key": "b",
"type": "keypress"
},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
assert get_keys(key_reporter) == "ab"
def test_single_printable_key_sends_correct_events(session, key_reporter,
key_chain, value, code):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
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 get_events(session)]
assert events == expected
assert get_keys(key_reporter) == value
def test_single_modifier_key_sends_correct_events(session, key_reporter,
key_chain, value, code, key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{
"code": code,
"key": key,
"type": "keydown"
},
{
"code": code,
"key": key,
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] == 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_single_nonprintable_key_sends_events(session,
key_reporter,
key_chain,
value,
code,
key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
expected = [
{"code": code, "key": key, "type": "keydown"},
{"code": code, "key": key, "type": "keypress"},
{"code": code, "key": key, "type": "keyup"},
]
all_events = get_events(session)
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] == 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_webdriver_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",
(e) => e.preventDefault());
""")
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"] == False
first_event = filter_dict(first_event, expected)
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_single_nonprintable_key_sends_events(session, key_reporter, key_chain,
value, code, key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
expected = [
{
"code": code,
"key": key,
"type": "keydown"
},
{
"code": code,
"key": key,
"type": "keypress"
},
{
"code": code,
"key": key,
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
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_webdriver_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",
(e) => e.preventDefault());
""")
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"] == False
first_event = filter_dict(first_event, expected)
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_multiple_codepoint_keys_behave_correctly(session, key_reporter,
key_chain, value):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
assert get_keys(key_reporter) == value
def test_mod_a_and_backspace_deletes_all_text(session, key_reporter,
key_chain):
key_chain.send_keys("abc d") \
.key_down(MODIFIER_KEY) \
.key_down("a") \
.key_up(MODIFIER_KEY) \
.key_up("a") \
.key_down(Keys.BACKSPACE) \
.perform()
assert get_keys(key_reporter) == ""
def test_multiple_codepoint_keys_behave_correctly(session,
key_reporter,
key_chain,
value):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
assert get_keys(key_reporter) == value
def test_single_emoji_records_correct_key(session, key_reporter, key_chain, value):
# Not using key_chain.send_keys() because we always want to treat value as
# one character here. `len(value)` varies by platform for non-BMP characters,
# so we don't want to iterate over value.
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
# events sent by major browsers are inconsistent so only check key value
assert get_keys(key_reporter) == value
def test_mod_a_mod_x_deletes_all_text(session, key_reporter, key_chain):
key_chain.send_keys("abc d") \
.key_down(MODIFIER_KEY) \
.key_down("a") \
.key_up(MODIFIER_KEY) \
.key_up("a") \
.key_down(MODIFIER_KEY) \
.key_down("x") \
.key_up(MODIFIER_KEY) \
.key_up("x") \
.perform()
assert get_keys(key_reporter) == ""
def test_sequence_of_keydown_character_keys(session, key_reporter, key_chain):
key_chain.send_keys("ef").perform()
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 get_events(session)]
assert events == expected
assert get_keys(key_reporter) == "ef"
def test_sequence_of_keydown_printable_keys_sends_events(session,
key_reporter,
key_chain):
key_chain \
.key_down("a") \
.key_down("b") \
.perform()
expected = [
{"code": "KeyA", "key": "a", "type": "keydown"},
{"code": "KeyA", "key": "a", "type": "keypress"},
{"code": "KeyB", "key": "b", "type": "keydown"},
{"code": "KeyB", "key": "b", "type": "keypress"},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
assert events == expected
assert get_keys(key_reporter) == "ab"
def test_single_printable_key_sends_correct_events(session,
key_reporter,
key_chain,
value,
code):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
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 get_events(session)]
assert events == expected
assert get_keys(key_reporter) == value
def test_sequence_of_keydown_character_keys(session, key_reporter, key_chain):
key_chain.send_keys("ef").perform()
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"},
]
all_events = get_events(session)
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] == 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_single_modifier_key_sends_correct_events(session,
key_reporter,
key_chain,
value,
code,
key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": key, "type": "keydown"},
{"code": code, "key": key, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_mod_a_mod_c_right_mod_v_pastes_text(session, key_reporter, key_chain):
initial = "abc d"
key_chain.send_keys(initial) \
.key_down(MODIFIER_KEY) \
.key_down("a") \
.key_up(MODIFIER_KEY) \
.key_up("a") \
.key_down(MODIFIER_KEY) \
.key_down("c") \
.key_up(MODIFIER_KEY) \
.key_up("c") \
.send_keys([Keys.RIGHT]) \
.key_down(MODIFIER_KEY) \
.key_down("v") \
.key_up(MODIFIER_KEY) \
.key_up("v") \
.perform()
assert get_keys(key_reporter) == initial * 2
def test_sequence_of_keydown_printable_keys_sends_events(session,
key_reporter,
key_chain):
key_chain \
.key_down("a") \
.key_down("b") \
.perform()
expected = [
{"code": "KeyA", "key": "a", "type": "keydown"},
{"code": "KeyA", "key": "a", "type": "keypress"},
{"code": "KeyB", "key": "b", "type": "keydown"},
{"code": "KeyB", "key": "b", "type": "keypress"},
]
all_events = get_events(session)
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] == 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) == "ab"
def test_single_modifier_key_sends_correct_events(session, key_reporter,
key_chain, value, code, key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{
"code": code,
"key": key,
"type": "keydown"
},
{
"code": code,
"key": key,
"type": "keyup"
},
]
events = [filter_dict(e, expected[0]) for e in all_events]
assert events == expected
assert len(get_keys(key_reporter)) == 0
def test_single_nonprintable_key_sends_events(session,
key_reporter,
key_chain,
value,
code,
key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
expected = [
{"code": code, "key": key, "type": "keydown"},
{"code": code, "key": key, "type": "keypress"},
{"code": code, "key": key, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in get_events(session)]
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_single_modifier_key_sends_correct_events(session,
key_reporter,
key_chain,
value,
code,
key):
key_chain \
.key_down(value) \
.key_up(value) \
.perform()
all_events = get_events(session)
expected = [
{"code": code, "key": key, "type": "keydown"},
{"code": code, "key": key, "type": "keyup"},
]
events = [filter_dict(e, expected[0]) for e in all_events]
if len(events) > 0 and events[0]["code"] == 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_sequence_of_keydown_character_keys(session, key_reporter, key_chain):
key_chain.send_keys("ef").perform()
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 get_events(session)]
assert events == expected
assert get_keys(key_reporter) == "ef"
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
def test_release_no_actions_sends_no_events(session, key_reporter):
session.actions.release()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
def test_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
def test_release_no_actions_sends_no_events(session, key_reporter):
session.actions.release()
assert len(get_keys(key_reporter)) == 0
assert len(get_events(session)) == 0
def test_backspace_erases_keys(session, key_reporter, key_chain):
key_chain \
.send_keys("efcd") \
.send_keys([Keys.BACKSPACE, Keys.BACKSPACE]) \
.perform()
assert get_keys(key_reporter) == "ef"
