def test_rejects_missing_code_value(self):
with self.assertRaises(keystroke.MissingFieldErrorError):
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
})
def test_rejects_missing_alt_key_value(self):
with self.assertRaises(keystroke.MissingField):
keystroke.parse_keystroke({
'metaKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'keyCode': 1,
})
def test_rejects_missing_key_code_value(self):
with self.assertRaises(keystroke.MissingField):
keystroke.parse_keystroke({
'id': 123,
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'key': 'A',
})
def test_rejects_invalid_ctrl_modifier(self):
with self.assertRaises(keystroke.InvalidModifierKey):
keystroke.parse_keystroke({
'id': 123,
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': 'banana',
'key': 'A',
'keyCode': 65,
})
def test_rejects_too_long_code_value(self):
with self.assertRaises(keystroke.InvalidKeyCodeError):
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'code': 'A' * 31,
})
def test_rejects_float_keycode_value(self):
with self.assertRaises(keystroke.InvalidKeyCode):
keystroke.parse_keystroke({
'id': 123,
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'key': 'A',
'keyCode': 1.25,
})
def test_rejects_invalid_meta_modifier(self):
with self.assertRaises(keystroke.InvalidModifierKeyError):
keystroke.parse_keystroke({
'metaKey': 'banana',
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'code': 'KeyA',
})
def test_rejects_too_high_keycode_value(self):
with self.assertRaises(keystroke.InvalidKeyCode):
keystroke.parse_keystroke({
'id': 123,
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'keyCode': 0xff + 1,
})
def test_rejects_string_keycode_value(self):
with self.assertRaises(keystroke.InvalidKeyCode):
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'keyCode': 'banana',
'location': None,
})
def test_rejects_invalid_location_value(self):
with self.assertRaises(keystroke.InvalidLocation):
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'keyCode': 65,
'location': 12345,
})
def test_rejects_invalid_meta_modifier(self):
with self.assertRaises(keystroke.InvalidModifierKey):
keystroke.parse_keystroke({
'metaKey': 'banana',
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'altGraphKey': False,
'key': 'A',
'keyCode': 65,
'location': None,
})
def test_rejects_missing_mandatory_code_value(self):
with self.assertRaises(keystroke.MissingFieldErrorError):
keystroke.parse_keystroke({
'metaLeft': False,
'metaRight': False,
'shiftLeft': False,
'shiftRight': False,
'altLeft': False,
'altRight': False,
'ctrlLeft': False,
'ctrlRight': False,
'key': 'A',
})
def test_rejects_too_long_code_value(self):
with self.assertRaises(keystroke.InvalidKeyCodeError):
keystroke.parse_keystroke({
'metaLeft': False,
'metaRight': False,
'shiftLeft': False,
'shiftRight': False,
'altLeft': False,
'altRight': False,
'ctrlLeft': False,
'ctrlRight': False,
'key': 'A',
'code': 'A' * 31,
})
def test_rejects_invalid_ctrl_modifier(self):
with self.assertRaises(keystroke.InvalidModifierKeyError):
keystroke.parse_keystroke({
'metaLeft': False,
'metaRight': False,
'shiftLeft': False,
'shiftRight': False,
'altLeft': False,
'altRight': False,
'ctrlLeft': 'banana',
'ctrlRight': False,
'key': 'A',
'code': 'KeyA',
})
def socket_keystroke(message):
try:
keystroke = keystroke_request.parse_keystroke(message)
except keystroke_request.Error as e:
logger.error('Failed to parse keystroke request: %s', e)
return
hid_keycode = None
processing_result = {'keystrokeId': keystroke.id, 'success': False}
try:
control_keys, hid_keycode = js_to_hid.convert(keystroke)
except js_to_hid.UnrecognizedKeyCodeError:
logger.warning('Unrecognized key: %s (keycode=%d)', keystroke.key,
keystroke.key_code)
socketio.emit('keystroke-received', processing_result)
return
if hid_keycode is None:
logger.info('Ignoring %s key (keycode=%d)', keystroke.key,
keystroke.key_code)
socketio.emit('keystroke-received', processing_result)
return
try:
fake_keyboard.send_keystroke(keyboard_path, control_keys, hid_keycode)
except hid_write.WriteError as e:
logger.error('Failed to write key: %s (keycode=%d). %s', keystroke.key,
keystroke.key_code, e)
socketio.emit('keystroke-received', processing_result)
return
processing_result['success'] = True
socketio.emit('keystroke-received', processing_result)
def socket_keystroke(message):
logger.debug_sensitive('received keystroke message: %s', message)
try:
keystroke = keystroke_request.parse_keystroke(message)
except keystroke_request.Error as e:
logger.error_sensitive('Failed to parse keystroke request: %s', e)
return {'success': False}
hid_keycode = None
try:
control_keys, hid_keycode = js_to_hid.convert(keystroke)
except js_to_hid.UnrecognizedKeyCodeError:
logger.warning_sensitive('Unrecognized key: %s (keycode=%s)',
keystroke.key, keystroke.code)
return {'success': False}
if hid_keycode is None:
logger.info_sensitive('Ignoring %s key (keycode=%s)', keystroke.key,
keystroke.code)
return {'success': False}
keyboard_path = flask.current_app.config.get('KEYBOARD_PATH')
try:
fake_keyboard.send_keystroke(keyboard_path, control_keys, hid_keycode)
except hid_write.WriteError as e:
logger.error_sensitive('Failed to write key: %s (keycode=%s). %s',
keystroke.key, keystroke.code, e)
return {'success': False}
return {'success': True}
def socket_keystroke(message):
try:
keystroke = keystroke_request.parse_keystroke(message)
except keystroke_request.Error as e:
logger.error('Failed to parse keystroke request: %s', e)
return {'success': False}
hid_keycode = None
try:
control_keys, hid_keycode = js_to_hid.convert(keystroke,
keyboard_layout)
except js_to_hid.UnrecognizedKeyCodeError:
logger.warning('Unrecognized key: %s (keycode=%d)', keystroke.key,
keystroke.key_code)
return {'success': False}
if hid_keycode is None:
logger.info('Ignoring %s key (keycode=%d)', keystroke.key,
keystroke.key_code)
return {'success': False}
try:
fake_keyboard.send_keystroke(keyboard_path, control_keys, hid_keycode)
except hid_write.WriteError as e:
logger.error('Failed to write key: %s (keycode=%d). %s', keystroke.key,
keystroke.key_code, e)
return {'success': False}
return {'success': True}
def test_parses_minimal_valid_keystroke_with_defaults(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(left_meta_modifier=False,
right_meta_modifier=False,
left_alt_modifier=False,
right_alt_modifier=False,
left_shift_modifier=False,
right_shift_modifier=False,
left_ctrl_modifier=False,
right_ctrl_modifier=False,
key='',
code='KeyA'),
keystroke.parse_keystroke({
'code': 'KeyA',
}))
def test_parses_left_ctrl_key(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(left_meta_modifier=False,
left_alt_modifier=False,
left_shift_modifier=False,
left_ctrl_modifier=True,
right_alt_modifier=False,
key='Control',
code='ControlLeft'),
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': True,
'altGraphKey': False,
'key': 'Control',
'code': 'ControlLeft',
}))
def test_parses_valid_keystroke_message_with_all_modifiers_pushed(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(left_meta_modifier=True,
left_alt_modifier=True,
left_shift_modifier=True,
left_ctrl_modifier=True,
right_alt_modifier=True,
key='A',
code='KeyA'),
keystroke.parse_keystroke({
'metaKey': True,
'altKey': True,
'shiftKey': True,
'ctrlKey': True,
'altGraphKey': True,
'key': 'A',
'code': 'KeyA',
}))
def test_parses_valid_keystroke_message(self):
self.assertEqual(
keystroke.Keystroke(id=123,
meta_modifier=False,
alt_modifier=False,
shift_modifier=False,
ctrl_modifier=False,
key='A',
key_code=65),
keystroke.parse_keystroke({
'id': 123,
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': False,
'key': 'A',
'keyCode': 65,
}))
def test_parses_valid_keystroke_message_with_all_modifiers_pushed(self):
self.assertEqual(
keystroke.Keystroke(id=456,
meta_modifier=True,
alt_modifier=True,
shift_modifier=True,
ctrl_modifier=True,
key='A',
key_code=65),
keystroke.parse_keystroke({
'id': 456,
'metaKey': True,
'altKey': True,
'shiftKey': True,
'ctrlKey': True,
'key': 'A',
'keyCode': 65,
}))
def test_parses_valid_keystroke_message_with_all_modifiers_pushed(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(left_meta_modifier=True,
left_alt_modifier=True,
left_shift_modifier=True,
left_ctrl_modifier=True,
right_alt_modifier=True,
key='A',
key_code=65,
is_right_modifier=False),
keystroke.parse_keystroke({
'metaKey': True,
'altKey': True,
'shiftKey': True,
'ctrlKey': True,
'altGraphKey': True,
'key': 'A',
'keyCode': 65,
'location': None,
}))
def test_parses_and_merges_valid_keystroke_message_with_defaults(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(left_meta_modifier=True,
right_meta_modifier=False,
left_alt_modifier=True,
right_alt_modifier=False,
left_shift_modifier=False,
right_shift_modifier=True,
left_ctrl_modifier=False,
right_ctrl_modifier=False,
key='A',
code='KeyA'),
keystroke.parse_keystroke({
'metaLeft': True,
'shiftLeft': False,
'shiftRight': True,
'altLeft': True,
'ctrlRight': False,
'key': 'A',
'code': 'KeyA',
}))
def test_parses_right_ctrl_key(self):
self.assertKeystrokesEqual(
keystroke.Keystroke(
left_meta_modifier=False,
left_alt_modifier=False,
left_shift_modifier=False,
# For simplicity, we store right Ctrl modifier in
# left_ctrl_modifier since there's no right version in
# keystroke.Keystroke.
left_ctrl_modifier=True,
right_alt_modifier=False,
key='Control',
code='ControlRight'),
keystroke.parse_keystroke({
'metaKey': False,
'altKey': False,
'shiftKey': False,
'ctrlKey': True,
'altGraphKey': False,
'key': 'Control',
'code': 'ControlRight',
}))
