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_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_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"
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_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_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_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_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 check_user_prompt_not_closed_but_exception(dialog_type):
create_dialog(dialog_type, text=dialog_type)
response = perform_actions(session, actions)
assert_error(response, "unexpected alert open")
assert session.alert.text == dialog_type
session.alert.dismiss()
assert get_keys(key_reporter) == ""
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_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_codepoint_keys_behave_correctly(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 check_user_prompt_closed_with_exception(dialog_type, retval):
create_dialog(dialog_type, text=dialog_type)
response = perform_actions(session, actions)
assert_error(response, "unexpected alert open")
assert_dialog_handled(session,
expected_text=dialog_type,
expected_retval=retval)
assert get_keys(key_reporter) == ""
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_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_codepoint_keys_behave_correctly(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_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_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_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_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_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_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_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
def test_element_not_focused(session, test_actions_page, key_chain):
key_reporter = session.find.css("#keys", all=False)
key_chain.key_down("a").key_up("a").perform()
assert get_keys(key_reporter) == ""
