288 lines
8.8 KiB
Python
288 lines
8.8 KiB
Python
"""
|
|
Unit tests for gesture event system.
|
|
|
|
Tests TouchEvent, GestureType, GestureResponse, and HAL integration.
|
|
"""
|
|
|
|
import unittest
|
|
from dreader.gesture import (
|
|
GestureType,
|
|
TouchEvent,
|
|
GestureResponse,
|
|
ActionType
|
|
)
|
|
|
|
|
|
class TestGestureType(unittest.TestCase):
|
|
"""Test GestureType enum"""
|
|
|
|
def test_gesture_types_exist(self):
|
|
"""Test all gesture types are defined"""
|
|
self.assertEqual(GestureType.TAP.value, "tap")
|
|
self.assertEqual(GestureType.LONG_PRESS.value, "long_press")
|
|
self.assertEqual(GestureType.SWIPE_LEFT.value, "swipe_left")
|
|
self.assertEqual(GestureType.SWIPE_RIGHT.value, "swipe_right")
|
|
self.assertEqual(GestureType.SWIPE_UP.value, "swipe_up")
|
|
self.assertEqual(GestureType.SWIPE_DOWN.value, "swipe_down")
|
|
self.assertEqual(GestureType.PINCH_IN.value, "pinch_in")
|
|
self.assertEqual(GestureType.PINCH_OUT.value, "pinch_out")
|
|
self.assertEqual(GestureType.DRAG_START.value, "drag_start")
|
|
self.assertEqual(GestureType.DRAG_MOVE.value, "drag_move")
|
|
self.assertEqual(GestureType.DRAG_END.value, "drag_end")
|
|
|
|
|
|
class TestTouchEvent(unittest.TestCase):
|
|
"""Test TouchEvent dataclass"""
|
|
|
|
def test_init_basic(self):
|
|
"""Test basic TouchEvent creation"""
|
|
event = TouchEvent(
|
|
gesture=GestureType.TAP,
|
|
x=450,
|
|
y=320
|
|
)
|
|
|
|
self.assertEqual(event.gesture, GestureType.TAP)
|
|
self.assertEqual(event.x, 450)
|
|
self.assertEqual(event.y, 320)
|
|
self.assertIsNone(event.x2)
|
|
self.assertIsNone(event.y2)
|
|
self.assertEqual(event.timestamp_ms, 0)
|
|
|
|
def test_init_with_secondary_point(self):
|
|
"""Test TouchEvent with secondary point (pinch/drag)"""
|
|
event = TouchEvent(
|
|
gesture=GestureType.PINCH_OUT,
|
|
x=400,
|
|
y=300,
|
|
x2=450,
|
|
y2=350,
|
|
timestamp_ms=12345.678
|
|
)
|
|
|
|
self.assertEqual(event.gesture, GestureType.PINCH_OUT)
|
|
self.assertEqual(event.x, 400)
|
|
self.assertEqual(event.y, 300)
|
|
self.assertEqual(event.x2, 450)
|
|
self.assertEqual(event.y2, 350)
|
|
self.assertEqual(event.timestamp_ms, 12345.678)
|
|
|
|
def test_from_hal_basic(self):
|
|
"""Test parsing TouchEvent from HAL format"""
|
|
hal_data = {
|
|
'gesture': 'tap',
|
|
'x': 450,
|
|
'y': 320
|
|
}
|
|
|
|
event = TouchEvent.from_hal(hal_data)
|
|
|
|
self.assertEqual(event.gesture, GestureType.TAP)
|
|
self.assertEqual(event.x, 450)
|
|
self.assertEqual(event.y, 320)
|
|
|
|
def test_from_hal_complete(self):
|
|
"""Test parsing TouchEvent with all fields from HAL"""
|
|
hal_data = {
|
|
'gesture': 'pinch_out',
|
|
'x': 400,
|
|
'y': 300,
|
|
'x2': 450,
|
|
'y2': 350,
|
|
'timestamp': 12345.678
|
|
}
|
|
|
|
event = TouchEvent.from_hal(hal_data)
|
|
|
|
self.assertEqual(event.gesture, GestureType.PINCH_OUT)
|
|
self.assertEqual(event.x, 400)
|
|
self.assertEqual(event.y, 300)
|
|
self.assertEqual(event.x2, 450)
|
|
self.assertEqual(event.y2, 350)
|
|
self.assertEqual(event.timestamp_ms, 12345.678)
|
|
|
|
def test_to_dict(self):
|
|
"""Test TouchEvent serialization"""
|
|
event = TouchEvent(
|
|
gesture=GestureType.SWIPE_LEFT,
|
|
x=600,
|
|
y=400,
|
|
timestamp_ms=12345.0
|
|
)
|
|
|
|
d = event.to_dict()
|
|
|
|
self.assertEqual(d['gesture'], 'swipe_left')
|
|
self.assertEqual(d['x'], 600)
|
|
self.assertEqual(d['y'], 400)
|
|
self.assertIsNone(d['x2'])
|
|
self.assertIsNone(d['y2'])
|
|
self.assertEqual(d['timestamp_ms'], 12345.0)
|
|
|
|
|
|
class TestGestureResponse(unittest.TestCase):
|
|
"""Test GestureResponse dataclass"""
|
|
|
|
def test_init(self):
|
|
"""Test GestureResponse creation"""
|
|
response = GestureResponse(
|
|
action="page_turn",
|
|
data={"direction": "forward", "progress": 0.42}
|
|
)
|
|
|
|
self.assertEqual(response.action, "page_turn")
|
|
self.assertEqual(response.data['direction'], "forward")
|
|
self.assertEqual(response.data['progress'], 0.42)
|
|
|
|
def test_to_dict(self):
|
|
"""Test GestureResponse serialization"""
|
|
response = GestureResponse(
|
|
action="define",
|
|
data={"word": "ephemeral", "bounds": (100, 200, 50, 20)}
|
|
)
|
|
|
|
d = response.to_dict()
|
|
|
|
self.assertEqual(d['action'], "define")
|
|
self.assertEqual(d['data']['word'], "ephemeral")
|
|
self.assertEqual(d['data']['bounds'], (100, 200, 50, 20))
|
|
|
|
def test_to_dict_empty_data(self):
|
|
"""Test GestureResponse with empty data"""
|
|
response = GestureResponse(action="none", data={})
|
|
|
|
d = response.to_dict()
|
|
|
|
self.assertEqual(d['action'], "none")
|
|
self.assertEqual(d['data'], {})
|
|
|
|
|
|
class TestActionType(unittest.TestCase):
|
|
"""Test ActionType constants"""
|
|
|
|
def test_action_types_defined(self):
|
|
"""Test all action type constants are defined"""
|
|
self.assertEqual(ActionType.NONE, "none")
|
|
self.assertEqual(ActionType.PAGE_TURN, "page_turn")
|
|
self.assertEqual(ActionType.NAVIGATE, "navigate")
|
|
self.assertEqual(ActionType.DEFINE, "define")
|
|
self.assertEqual(ActionType.SELECT, "select")
|
|
self.assertEqual(ActionType.ZOOM, "zoom")
|
|
self.assertEqual(ActionType.BOOK_LOADED, "book_loaded")
|
|
self.assertEqual(ActionType.WORD_SELECTED, "word_selected")
|
|
self.assertEqual(ActionType.SHOW_MENU, "show_menu")
|
|
self.assertEqual(ActionType.SELECTION_START, "selection_start")
|
|
self.assertEqual(ActionType.SELECTION_UPDATE, "selection_update")
|
|
self.assertEqual(ActionType.SELECTION_COMPLETE, "selection_complete")
|
|
self.assertEqual(ActionType.AT_START, "at_start")
|
|
self.assertEqual(ActionType.AT_END, "at_end")
|
|
self.assertEqual(ActionType.ERROR, "error")
|
|
|
|
|
|
class TestHALIntegration(unittest.TestCase):
|
|
"""Test HAL integration scenarios"""
|
|
|
|
def test_hal_tap_flow(self):
|
|
"""Test complete HAL tap event flow"""
|
|
# Simulate HAL sending tap event
|
|
hal_data = {
|
|
'gesture': 'tap',
|
|
'x': 450,
|
|
'y': 320,
|
|
'timestamp': 1234567890.123
|
|
}
|
|
|
|
# Parse event
|
|
event = TouchEvent.from_hal(hal_data)
|
|
|
|
# Verify event
|
|
self.assertEqual(event.gesture, GestureType.TAP)
|
|
self.assertEqual(event.x, 450)
|
|
self.assertEqual(event.y, 320)
|
|
|
|
# Simulate business logic response
|
|
response = GestureResponse(
|
|
action=ActionType.WORD_SELECTED,
|
|
data={"word": "hello", "bounds": (440, 310, 50, 20)}
|
|
)
|
|
|
|
# Serialize for Flask
|
|
response_dict = response.to_dict()
|
|
|
|
self.assertEqual(response_dict['action'], "word_selected")
|
|
self.assertEqual(response_dict['data']['word'], "hello")
|
|
|
|
def test_hal_pinch_flow(self):
|
|
"""Test complete HAL pinch event flow"""
|
|
# Simulate HAL sending pinch event with two touch points
|
|
hal_data = {
|
|
'gesture': 'pinch_out',
|
|
'x': 400,
|
|
'y': 500,
|
|
'x2': 500,
|
|
'y2': 500,
|
|
'timestamp': 1234567891.456
|
|
}
|
|
|
|
event = TouchEvent.from_hal(hal_data)
|
|
|
|
self.assertEqual(event.gesture, GestureType.PINCH_OUT)
|
|
self.assertEqual(event.x, 400)
|
|
self.assertEqual(event.x2, 500)
|
|
|
|
def test_hal_swipe_flow(self):
|
|
"""Test complete HAL swipe event flow"""
|
|
hal_data = {
|
|
'gesture': 'swipe_left',
|
|
'x': 600,
|
|
'y': 400
|
|
}
|
|
|
|
event = TouchEvent.from_hal(hal_data)
|
|
|
|
self.assertEqual(event.gesture, GestureType.SWIPE_LEFT)
|
|
|
|
# Expected response
|
|
response = GestureResponse(
|
|
action=ActionType.PAGE_TURN,
|
|
data={"direction": "forward", "progress": 0.25}
|
|
)
|
|
|
|
self.assertEqual(response.action, "page_turn")
|
|
|
|
def test_hal_drag_selection_flow(self):
|
|
"""Test complete drag selection flow"""
|
|
# Drag start
|
|
start_data = {
|
|
'gesture': 'drag_start',
|
|
'x': 100,
|
|
'y': 200
|
|
}
|
|
|
|
start_event = TouchEvent.from_hal(start_data)
|
|
self.assertEqual(start_event.gesture, GestureType.DRAG_START)
|
|
|
|
# Drag move
|
|
move_data = {
|
|
'gesture': 'drag_move',
|
|
'x': 300,
|
|
'y': 250
|
|
}
|
|
|
|
move_event = TouchEvent.from_hal(move_data)
|
|
self.assertEqual(move_event.gesture, GestureType.DRAG_MOVE)
|
|
|
|
# Drag end
|
|
end_data = {
|
|
'gesture': 'drag_end',
|
|
'x': 500,
|
|
'y': 300
|
|
}
|
|
|
|
end_event = TouchEvent.from_hal(end_data)
|
|
self.assertEqual(end_event.gesture, GestureType.DRAG_END)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|