feat(input-server): add InputServer<D: InputDevice> with protocol, mock + UART adapters, and tests

crates/servers/input-server/src/tests/mod.rs

@@ -0,0 +1,2 @@
+mod protocol;
+mod server;

crates/servers/input-server/src/tests/protocol.rs

@@ -0,0 +1,46 @@
+use crate::protocol::*;
+use server_framework::{Decode, Encode};
+
+#[test]
+fn poll_request_roundtrip() {
+    let words = InputRequest::PollEvent.encode();
+    assert_eq!(InputRequest::decode(words), Some(InputRequest::PollEvent));
+}
+
+#[test]
+fn wait_request_roundtrip() {
+    let words = InputRequest::WaitEvent.encode();
+    assert_eq!(InputRequest::decode(words), Some(InputRequest::WaitEvent));
+}
+
+#[test]
+fn key_down_response_roundtrip() {
+    let resp = InputResponse::Event(InputEvent::KeyDown(Key::Up));
+    let words = resp.encode();
+    assert_eq!(InputResponse::decode(words), Some(resp));
+}
+
+#[test]
+fn key_up_response_roundtrip() {
+    let resp = InputResponse::Event(InputEvent::KeyUp(Key::Left));
+    let words = resp.encode();
+    assert_eq!(InputResponse::decode(words), Some(resp));
+}
+
+#[test]
+fn char_key_roundtrip() {
+    let resp = InputResponse::Event(InputEvent::KeyDown(Key::Char(b'x')));
+    let words = resp.encode();
+    assert_eq!(InputResponse::decode(words), Some(resp));
+}
+
+#[test]
+fn no_event_roundtrip() {
+    let words = InputResponse::NoEvent.encode();
+    assert_eq!(InputResponse::decode(words), Some(InputResponse::NoEvent));
+}
+
+#[test]
+fn invalid_request_returns_none() {
+    assert!(InputRequest::decode([99, 0, 0, 0]).is_none());
+}

crates/servers/input-server/src/tests/server.rs

@@ -0,0 +1,51 @@
+use crate::adapters::mock::MockInputDevice;
+use crate::protocol::*;
+use crate::server::InputServer;
+use server_framework::Server;
+
+fn test_server() -> InputServer<MockInputDevice> {
+    InputServer::new(MockInputDevice::new())
+}
+
+#[test]
+fn poll_with_no_events_returns_no_event() {
+    let mut server = test_server();
+    let resp = server.handle(InputRequest::PollEvent);
+    assert_eq!(resp, InputResponse::NoEvent);
+}
+
+#[test]
+fn poll_returns_queued_event() {
+    let mut device = MockInputDevice::new();
+    device.push_event(InputEvent::KeyDown(Key::Up));
+    let mut server = InputServer::new(device);
+
+    let resp = server.handle(InputRequest::PollEvent);
+    assert_eq!(resp, InputResponse::Event(InputEvent::KeyDown(Key::Up)));
+}
+
+#[test]
+fn poll_drains_events_in_order() {
+    let mut device = MockInputDevice::new();
+    device.push_event(InputEvent::KeyDown(Key::Left));
+    device.push_event(InputEvent::KeyDown(Key::Right));
+    let mut server = InputServer::new(device);
+
+    let r1 = server.handle(InputRequest::PollEvent);
+    let r2 = server.handle(InputRequest::PollEvent);
+    let r3 = server.handle(InputRequest::PollEvent);
+
+    assert_eq!(r1, InputResponse::Event(InputEvent::KeyDown(Key::Left)));
+    assert_eq!(r2, InputResponse::Event(InputEvent::KeyDown(Key::Right)));
+    assert_eq!(r3, InputResponse::NoEvent);
+}
+
+#[test]
+fn char_event_preserved() {
+    let mut device = MockInputDevice::new();
+    device.push_event(InputEvent::KeyDown(Key::Char(b'z')));
+    let mut server = InputServer::new(device);
+
+    let resp = server.handle(InputRequest::PollEvent);
+    assert_eq!(resp, InputResponse::Event(InputEvent::KeyDown(Key::Char(b'z'))));
+}