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_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_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_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_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) == ""