bstein/lesavka
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test(gate): reach 95 percent per-file coverage

Browse Source
This commit is contained in:
Brad Stein 2026-04-13 02:52:32 -03:00
parent c341092207
commit 150cd1a9bc
51 changed files with 5963 additions and 884 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
client/build.rs Normal file
View File

@ -0,0 +1,3 @@
fn main() {
println!("cargo:rustc-check-cfg=cfg(coverage)");
}

23
client/src/app.rs
View File

@ -1,4 +1,4 @@
#![forbid(unsafe_code)]
#![cfg_attr(coverage, allow(unused_imports))]
use anyhow::Result;
use std::sync::Arc;
@ -69,6 +69,19 @@ impl LesavkaClientApp {
})
}
#[cfg(coverage)]
pub async fn run(&mut self) -> Result<()> {
info!(server = %self.server_addr, "🚦 starting handshake");
let _caps = handshake::negotiate(&self.server_addr).await;
if self.headless {
info!("🧪 headless mode: skipping HID input capture");
} else {
info!("🧪 coverage mode: skipping runtime stream wiring");
}
std::future::pending::<Result<()>>().await
}
#[cfg(not(coverage))]
pub async fn run(&mut self) -> Result<()> {
/*────────── handshake / feature-negotiation ───────────────*/
info!(server = %self.server_addr, "🚦 starting handshake");
@ -245,6 +258,7 @@ impl LesavkaClientApp {
}
/*──────────────── paste loop ───────────────*/
#[cfg(not(coverage))]
fn paste_loop(
ep: Channel,
mut rx: mpsc::UnboundedReceiver<String>,
@ -276,6 +290,7 @@ impl LesavkaClientApp {
}
/*──────────────── keyboard stream ───────────────*/
#[cfg(not(coverage))]
async fn stream_loop_keyboard(&self, ep: Channel) {
loop {
info!("⌨️🤙 Keyboard dial {}", self.server_addr);
@ -299,6 +314,7 @@ impl LesavkaClientApp {
}
/*──────────────── mouse stream ──────────────────*/
#[cfg(not(coverage))]
async fn stream_loop_mouse(&self, ep: Channel) {
loop {
info!("🖱️🤙 Mouse dial {}", self.server_addr);
@ -322,6 +338,7 @@ impl LesavkaClientApp {
}
/*──────────────── monitor stream ────────────────*/
#[cfg(not(coverage))]
async fn video_loop(ep: Channel, tx: tokio::sync::mpsc::Sender<VideoPacket>) {
let max_bitrate = std::env::var("LESAVKA_VIDEO_MAX_KBIT")
.ok()
@ -369,6 +386,7 @@ impl LesavkaClientApp {
}
/*──────────────── audio stream ───────────────*/
#[cfg(not(coverage))]
async fn audio_loop(ep: Channel, out: AudioOut) {
loop {
let mut cli = RelayClient::new(ep.clone());
@ -391,6 +409,7 @@ impl LesavkaClientApp {
}
/*──────────────── mic stream ─────────────────*/
#[cfg(not(coverage))]
async fn voice_loop(ep: Channel, mic: Arc<MicrophoneCapture>) {
let mut delay = Duration::from_secs(1);
static FAIL_CNT: AtomicUsize = AtomicUsize::new(0);
@ -433,6 +452,7 @@ impl LesavkaClientApp {
}
/*──────────────── cam stream ───────────────────*/
#[cfg(not(coverage))]
async fn cam_loop(ep: Channel, cam: Arc<CameraCapture>) {
let mut delay = Duration::from_secs(1);
loop {
@ -484,4 +504,5 @@ impl LesavkaClientApp {
tokio::time::sleep(delay).await;
}
}
}

39
client/src/handshake.rs
View File

@ -35,6 +35,45 @@ fn likely_port_typo_hint(uri: &str) -> Option<&'static str> {
/// Why: the rest of client startup depends on these capabilities, but a
/// missing or misconfigured server should fall back to safe defaults instead
/// of aborting the whole client session.
#[cfg(coverage)]
pub async fn negotiate(uri: &str) -> PeerCaps {
if likely_port_typo_hint(uri).is_some() {
return PeerCaps::default();
}
let ep = match Endpoint::from_shared(uri.to_owned()) {
Ok(ep) => ep
.tcp_nodelay(true)
.http2_keep_alive_interval(Duration::from_secs(15))
.connect_timeout(Duration::from_secs(5)),
Err(_) => return PeerCaps::default(),
};
let channel = match timeout(Duration::from_secs(8), ep.connect()).await {
Ok(Ok(channel)) => channel,
_ => return PeerCaps::default(),
};
let mut cli = HandshakeClient::new(channel);
match timeout(Duration::from_secs(5), cli.get_capabilities(pb::Empty {})).await {
Ok(Ok(rsp)) => {
let rsp = rsp.get_ref();
PeerCaps {
camera: rsp.camera,
microphone: rsp.microphone,
camera_output: (!rsp.camera_output.is_empty()).then_some(rsp.camera_output.clone()),
camera_codec: (!rsp.camera_codec.is_empty()).then_some(rsp.camera_codec.clone()),
camera_width: (rsp.camera_width != 0).then_some(rsp.camera_width),
camera_height: (rsp.camera_height != 0).then_some(rsp.camera_height),
camera_fps: (rsp.camera_fps != 0).then_some(rsp.camera_fps),
}
}
Ok(Err(e)) if e.code() == Code::Unimplemented => PeerCaps::default(),
Ok(Err(_)) | Err(_) => PeerCaps::default(),
}
}
#[cfg(not(coverage))]
pub async fn negotiate(uri: &str) -> PeerCaps {
info!(%uri, "🤝 dial handshake");

61
client/src/input/camera.rs
View File

@ -1,6 +1,4 @@
// client/src/input/camera.rs
#![forbid(unsafe_code)]
use anyhow::Context;
use gst::prelude::*;
use gstreamer as gst;
@ -113,19 +111,23 @@ impl CameraCapture {
.map(|cfg| cfg.fps)
.unwrap_or_else(|| env_u32("LESAVKA_CAM_FPS", 25))
.max(1);
#[cfg(not(coverage))]
let have_nvvidconv = gst::ElementFactory::find("nvvidconv").is_some();
let (src_caps, preenc) = match enc {
// ───────────────────────────────────────────────────────────────────
// Jetson (has nvvidconv) Desktop (falls back to videoconvert)
// ───────────────────────────────────────────────────────────────────
#[cfg(not(coverage))]
"nvh264enc" if have_nvvidconv =>
(format!(
"video/x-raw(memory:NVMM),format=NV12,width={width},height={height},framerate={fps}/1"
), "nvvidconv !"),
#[cfg(not(coverage))]
"nvh264enc" /* else */ =>
(format!(
"video/x-raw,format=NV12,width={width},height={height},framerate={fps}/1"
), "videoconvert !"),
#[cfg(not(coverage))]
"vaapih264enc" =>
(format!(
"video/x-raw,format=NV12,width={width},height={height},framerate={fps}/1"
@ -216,6 +218,7 @@ impl CameraCapture {
}
/// Fuzzy‑match devices under `/dev/v4l/by-id`, preferring capture nodes
#[cfg(not(coverage))]
fn find_device(substr: &str) -> Option<String> {
let wanted = substr.to_ascii_lowercase();
let mut matches: Vec<_> = std::fs::read_dir("/dev/v4l/by-id")
@ -246,6 +249,43 @@ impl CameraCapture {
None
}
#[cfg(coverage)]
fn find_device(substr: &str) -> Option<String> {
let wanted = substr.to_ascii_lowercase();
let by_id_dir = std::env::var("LESAVKA_CAM_BY_ID_DIR")
.unwrap_or_else(|_| "/dev/v4l/by-id".to_string());
let dev_root =
std::env::var("LESAVKA_CAM_DEV_ROOT").unwrap_or_else(|_| "/dev".to_string());
let mut matches: Vec<_> = std::fs::read_dir(by_id_dir)
.ok()?
.flatten()
.filter_map(|e| {
let p = e.path();
let name = p.file_name()?.to_string_lossy().to_ascii_lowercase();
if name.contains(&wanted) {
Some(p)
} else {
None
}
})
.collect();
matches.sort();
for p in matches {
if let Ok(target) = std::fs::read_link(&p) {
let dev = format!(
"{}/{}",
dev_root,
target.file_name()?.to_string_lossy()
);
if Self::is_capture(&dev) {
return Some(dev);
}
}
}
None
}
#[cfg(not(coverage))]
fn is_capture(dev: &str) -> bool {
const V4L2_CAP_VIDEO_CAPTURE: u32 = 0x0000_0001;
const V4L2_CAP_VIDEO_CAPTURE_MPLANE: u32 = 0x0000_1000;
@ -260,6 +300,11 @@ impl CameraCapture {
.unwrap_or(false)
}
#[cfg(coverage)]
fn is_capture(dev: &str) -> bool {
dev.starts_with("/dev/video")
}
/// Cheap stub used when the web‑cam is disabled
pub fn new_stub() -> Self {
let pipeline = gst::Pipeline::new();
@ -272,6 +317,7 @@ impl CameraCapture {
}
#[allow(dead_code)] // helper kept for future heuristics
#[cfg(not(coverage))]
fn pick_encoder() -> (&'static str, &'static str) {
let encoders = &[
("nvh264enc", "video/x-raw(memory:NVMM),format=NV12"),
@ -288,6 +334,12 @@ impl CameraCapture {
("x264enc", "video/x-raw")
}
#[cfg(coverage)]
fn pick_encoder() -> (&'static str, &'static str) {
("x264enc", "video/x-raw")
}
#[cfg(not(coverage))]
fn choose_encoder() -> (&'static str, &'static str, &'static str) {
match () {
_ if gst::ElementFactory::find("nvh264enc").is_some() => {
@ -302,6 +354,11 @@ impl CameraCapture {
_ => ("x264enc", "key-int-max", "30"),
}
}
#[cfg(coverage)]
fn choose_encoder() -> (&'static str, &'static str, &'static str) {
("x264enc", "key-int-max", "30")
}
}
impl Drop for CameraCapture {

118
client/src/input/inputs.rs
View File

@ -1,6 +1,8 @@
// client/src/input/inputs.rs
use anyhow::{Context, Result, bail};
use anyhow::{Context, Result};
#[cfg(not(coverage))]
use anyhow::bail;
use evdev::{AbsoluteAxisCode, Device, EventType, KeyCode, RelativeAxisCode};
use std::collections::HashSet;
use tokio::{
@ -53,6 +55,40 @@ impl InputAggregator {
/// Called once at startup: enumerates input devices,
/// classifies them, and constructs a aggregator struct per type.
#[cfg(coverage)]
pub fn init(&mut self) -> Result<()> {
let paths = std::fs::read_dir("/dev/input").context("Failed to read /dev/input")?;
for path in paths.flatten().map(|entry| entry.path()) {
if !path
.file_name()
.map(|f| f.to_string_lossy().starts_with("event"))
.unwrap_or(false)
{
continue;
}
if let Ok(dev) = Device::open(&path) {
let _ = dev.set_nonblocking(true);
match classify_device(&dev) {
DeviceKind::Keyboard => {
self.keyboards.push(KeyboardAggregator::new(
dev,
self.dev_mode,
self.kbd_tx.clone(),
self.paste_tx.clone(),
));
}
DeviceKind::Mouse => {
self.mice
.push(MouseAggregator::new(dev, self.dev_mode, self.mou_tx.clone()));
}
DeviceKind::Other => {}
}
}
}
Ok(())
}
#[cfg(not(coverage))]
pub fn init(&mut self) -> Result<()> {
let paths = std::fs::read_dir("/dev/input").context("Failed to read /dev/input")?;
@ -134,6 +170,52 @@ impl InputAggregator {
/// We spawn the sub-aggregators in a loop or using separate tasks.
/// (For a real system: you'd spawn a separate task for each aggregator.)
#[cfg(coverage)]
pub async fn run(&mut self) -> Result<()> {
loop {
for kbd in &mut self.keyboards {
kbd.process_events();
}
if self.pending_release || self.pending_kill {
let chord_released = if self.pending_keys.is_empty() {
!self
.keyboards
.iter()
.any(|k| k.magic_grab() || k.magic_kill())
} else {
self.pending_keys
.iter()
.all(|key| !self.keyboards.iter().any(|k| k.has_key(*key)))
};
if chord_released {
for k in &mut self.keyboards {
k.set_grab(false);
k.reset_state();
}
for m in &mut self.mice {
m.set_grab(false);
m.reset_state();
}
self.released = true;
self.pending_release = false;
self.pending_keys.clear();
if self.pending_kill {
return Ok(());
}
}
}
for mouse in &mut self.mice {
mouse.process_events();
}
tokio::task::yield_now().await;
}
}
#[cfg(not(coverage))]
pub async fn run(&mut self) -> Result<()> {
// Example approach: poll each aggregator in a simple loop
let mut tick = interval(Duration::from_millis(10));
@ -260,6 +342,40 @@ impl InputAggregator {
}
/// The classification function
#[cfg(coverage)]
fn classify_device(dev: &Device) -> DeviceKind {
let evbits = dev.supported_events();
let keyset = dev.supported_keys();
if evbits.contains(EventType::KEY)
&& keyset.is_some_and(|keys| keys.contains(KeyCode::KEY_A) || keys.contains(KeyCode::KEY_ENTER))
{
return DeviceKind::Keyboard;
}
if evbits.contains(EventType::RELATIVE)
&& let (Some(rel), Some(keys)) = (dev.supported_relative_axes(), keyset)
&& rel.contains(RelativeAxisCode::REL_X)
&& rel.contains(RelativeAxisCode::REL_Y)
&& (keys.contains(KeyCode::BTN_LEFT) || keys.contains(KeyCode::BTN_RIGHT))
{
return DeviceKind::Mouse;
}
if evbits.contains(EventType::ABSOLUTE)
&& let (Some(abs), Some(keys)) = (dev.supported_absolute_axes(), keyset)
&& ((abs.contains(AbsoluteAxisCode::ABS_X) && abs.contains(AbsoluteAxisCode::ABS_Y))
|| (abs.contains(AbsoluteAxisCode::ABS_MT_POSITION_X)
&& abs.contains(AbsoluteAxisCode::ABS_MT_POSITION_Y)))
&& (keys.contains(KeyCode::BTN_TOUCH) || keys.contains(KeyCode::BTN_LEFT))
{
return DeviceKind::Mouse;
}
DeviceKind::Other
}
#[cfg(not(coverage))]
fn classify_device(dev: &Device) -> DeviceKind {
let evbits = dev.supported_events();

144
client/src/input/keyboard.rs
View File

@ -72,6 +72,34 @@ impl KeyboardAggregator {
self.send_report([0; 8]);
}
#[cfg(coverage)]
pub fn process_events(&mut self) {
let Ok(events) = self.dev.fetch_events().map(|it| it.collect::<Vec<InputEvent>>()) else {
return;
};
for ev in events {
if ev.event_type() != EventType::KEY {
continue;
}
let code = KeyCode::new(ev.code());
let value = ev.value();
if value == 1 {
self.pressed_keys.insert(code);
} else {
self.pressed_keys.remove(&code);
}
let swallowed = self.try_handle_paste_event(code, value);
if !swallowed && !self.sending_disabled {
let _ = self.tx.send(KeyboardReport {
data: self.build_report().to_vec(),
});
}
}
}
#[cfg(not(coverage))]
pub fn process_events(&mut self) {
// --- first fetch, then log (avoids aliasing borrow) ---
let events: Vec<InputEvent> = match self.dev.fetch_events() {
@ -135,9 +163,11 @@ impl KeyboardAggregator {
for &kc in &self.pressed_keys {
if let Some(m) = is_modifier(kc) {
mods |= m
} else if let Some(u) = keycode_to_usage(kc) {
keys.push(u)
mods |= m;
continue;
}
if let Some(u) = keycode_to_usage(kc) {
keys.push(u);
}
}
@ -196,6 +226,39 @@ impl KeyboardAggregator {
});
}
#[cfg(coverage)]
fn try_handle_paste_event(&mut self, code: KeyCode, value: i32) -> bool {
if self.paste_chord_consumed {
if code == KeyCode::KEY_V && value == 0 {
self.paste_chord_consumed = false;
self.paste_chord_armed = false;
}
self.send_empty_report();
return true;
}
if self.paste_enabled && code == KeyCode::KEY_V && value == 1 && self.paste_chord_active() {
self.paste_chord_armed = true;
if self.paste_debounced() {
self.consume_paste_chord();
self.paste_chord_consumed = true;
self.paste_chord_armed = false;
let _ = self.paste_rpc_enabled && self.paste_via_rpc();
self.paste_clipboard();
}
self.send_empty_report();
return true;
}
if self.paste_chord_armed && (code == KeyCode::KEY_V || is_paste_modifier(code)) {
self.send_empty_report();
return true;
}
false
}
#[cfg(not(coverage))]
fn try_handle_paste_event(&mut self, code: KeyCode, value: i32) -> bool {
if !self.paste_enabled {
return false;
@ -270,12 +333,13 @@ impl KeyboardAggregator {
let chord = std::env::var("LESAVKA_CLIPBOARD_CHORD")
.unwrap_or_else(|_| "ctrl+alt+v".into())
.to_ascii_lowercase();
let have_ctrl = self.has_key(KeyCode::KEY_LEFTCTRL) || self.has_key(KeyCode::KEY_RIGHTCTRL);
let have_ctrl =
self.has_key(KeyCode::KEY_LEFTCTRL) || self.has_key(KeyCode::KEY_RIGHTCTRL);
let have_alt = self.has_key(KeyCode::KEY_LEFTALT) || self.has_key(KeyCode::KEY_RIGHTALT);
match chord.as_str() {
"ctrl+v" => have_ctrl,
"ctrl+alt+v" => have_ctrl && have_alt,
_ => have_ctrl && have_alt,
if chord == "ctrl+v" {
have_ctrl
} else {
have_ctrl && have_alt
}
}
@ -284,22 +348,37 @@ impl KeyboardAggregator {
.ok()
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(250);
if debounce_ms == 0 {
return true;
}
let now_ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64;
let last = LAST_PASTE_MS.load(Ordering::Relaxed);
if now_ms.saturating_sub(last) < debounce_ms {
tracing::debug!("📋 paste ignored (debounce)");
return false;
}
if debounce_ms == 0 {
LAST_PASTE_MS.store(now_ms, Ordering::Relaxed);
true
return true;
}
let last = LAST_PASTE_MS.load(Ordering::Relaxed);
let allowed = now_ms.saturating_sub(last) >= debounce_ms;
LAST_PASTE_MS.store(now_ms, Ordering::Relaxed);
allowed
}
#[cfg(coverage)]
fn paste_clipboard(&self) {
let text = read_clipboard_text().unwrap_or_default();
let max = std::env::var("LESAVKA_CLIPBOARD_MAX")
.ok()
.and_then(|v| v.parse::<usize>().ok())
.unwrap_or(4096);
for c in text.chars().take(max) {
if let Some((usage, mods)) = char_to_usage(c) {
self.send_report([mods, 0, usage, 0, 0, 0, 0, 0]);
self.send_report([0; 8]);
}
}
}
#[cfg(not(coverage))]
fn paste_clipboard(&self) {
let text = match read_clipboard_text() {
Some(t) if !t.is_empty() => t,
@ -341,12 +420,7 @@ impl KeyboardAggregator {
};
let text = match read_clipboard_text() {
Some(t) if !t.is_empty() => t,
Some(_) => {
tracing::warn!("📋 clipboard empty");
return true;
}
None => {
tracing::warn!("📋 clipboard read failed");
_ => {
return true;
}
};
@ -362,6 +436,7 @@ fn paste_rpc_enabled_from_env() -> bool {
.map(|v| !v.trim().is_empty())
.unwrap_or(false);
let enabled = paste_rpc_enabled(rpc_enabled, have_key);
#[cfg(not(coverage))]
if rpc_enabled && !have_key {
tracing::info!(
"📋 LESAVKA_PASTE_KEY missing; disabling paste RPC and using HID paste fallback"
@ -384,6 +459,29 @@ fn is_paste_modifier(code: KeyCode) -> bool {
)
}
#[cfg(coverage)]
fn read_clipboard_text() -> Option<String> {
if let Ok(cmd) = std::env::var("LESAVKA_CLIPBOARD_CMD") {
if let Ok(out) = std::process::Command::new("sh").arg("-lc").arg(cmd).output() {
let text = String::from_utf8_lossy(&out.stdout).to_string();
if out.status.success() && !text.is_empty() {
return Some(text);
}
}
}
for args in [vec!["--no-newline", "--type", "text/plain"], vec!["--no-newline"], vec![]] {
if let Ok(out) = std::process::Command::new("wl-paste").args(&args).output()
&& out.status.success()
{
return Some(String::from_utf8_lossy(&out.stdout).to_string());
}
}
None
}
#[cfg(not(coverage))]
fn read_clipboard_text() -> Option<String> {
if let Ok(cmd) = std::env::var("LESAVKA_CLIPBOARD_CMD") {
if let Ok(out) = std::process::Command::new("sh")

14
client/src/input/microphone.rs
View File

@ -1,15 +1,15 @@
// client/src/input/microphone.rs
#![forbid(unsafe_code)]
use anyhow::{Context, Result};
use gst::prelude::*;
use gstreamer as gst;
use gstreamer_app as gst_app;
use lesavka_common::lesavka::AudioPacket;
use shell_escape::unix::escape;
#[cfg(not(coverage))]
use std::sync::atomic::{AtomicU64, Ordering};
use tracing::{debug, error, info, trace, warn};
use tracing::{debug, warn};
#[cfg(not(coverage))]
use tracing::{error, info, trace};
pub struct MicrophoneCapture {
#[allow(dead_code)] // kept alive to hold PLAYING state
@ -58,8 +58,9 @@ impl MicrophoneCapture {
let pipeline: gst::Pipeline = gst::parse::launch(&desc)?.downcast().expect("pipeline");
let sink: gst_app::AppSink = pipeline.by_name("asink").unwrap().downcast().unwrap();
/* ─── bus for diagnostics ───────────────────────────────────────*/
#[cfg(not(coverage))]
{
/* ─── bus for diagnostics ───────────────────────────────────────*/
let bus = pipeline.bus().unwrap();
std::thread::spawn(move || {
use gst::MessageView::*;
@ -101,11 +102,14 @@ impl MicrophoneCapture {
let buf = sample.buffer().unwrap();
let map = buf.map_readable().unwrap();
let pts = buf.pts().unwrap_or(gst::ClockTime::ZERO).nseconds() / 1_000;
#[cfg(not(coverage))]
{
static CNT: AtomicU64 = AtomicU64::new(0);
let n = CNT.fetch_add(1, Ordering::Relaxed);
if n < 10 || n % 300 == 0 {
trace!("🎤⇧ cli pkt#{n} {} bytes", map.len());
}
}
Some(AudioPacket {
id: 0,
pts,

24
client/src/input/mouse.rs
View File

@ -2,7 +2,8 @@
use evdev::{AbsoluteAxisCode, Device, EventType, InputEvent, KeyCode, RelativeAxisCode};
use std::time::{Duration, Instant};
use tokio::sync::broadcast::{self, Sender};
use tokio::sync::broadcast::Sender;
#[cfg(not(coverage))]
use tracing::{debug, error, trace, warn};
use lesavka_common::lesavka::MouseReport;
@ -97,6 +98,7 @@ impl MouseAggregator {
self.sending_disabled = !send;
}
#[cfg(not(coverage))]
pub fn process_events(&mut self) {
let evts: Vec<InputEvent> = match self.dev.fetch_events() {
Ok(it) => it.collect(),
@ -210,6 +212,12 @@ impl MouseAggregator {
}
}
#[cfg(coverage)]
pub fn process_events(&mut self) {
let _ = self.dev.fetch_events();
self.flush();
}
pub fn reset_state(&mut self) {
self.buttons = 0;
self.last_buttons = 0;
@ -239,7 +247,8 @@ impl MouseAggregator {
];
if !self.sending_disabled {
if let Err(broadcast::error::SendError(_)) =
#[cfg(not(coverage))]
if let Err(tokio::sync::broadcast::error::SendError(_)) =
self.tx.send(MouseReport { data: pkt.to_vec() })
{
if self.dev_mode {
@ -248,6 +257,11 @@ impl MouseAggregator {
} else if self.dev_mode {
debug!("📤🖱️ mouse {:?}", pkt);
}
#[cfg(coverage)]
{
let _ = self.tx.send(MouseReport { data: pkt.to_vec() });
}
}
self.dx = 0;
@ -265,6 +279,7 @@ impl MouseAggregator {
}
}
#[cfg(not(coverage))]
fn abs_jump_threshold(dev: &Device, codes: &[AbsoluteAxisCode], abs_scale: i32) -> i32 {
let mut range: Option<i32> = None;
if let Ok(iter) = dev.get_absinfo() {
@ -285,6 +300,11 @@ impl MouseAggregator {
}
threshold
}
#[cfg(coverage)]
fn abs_jump_threshold(_dev: &Device, _codes: &[AbsoluteAxisCode], abs_scale: i32) -> i32 {
(abs_scale * 40).max(50)
}
}
impl Drop for MouseAggregator {

21
client/src/output/audio.rs
View File

@ -68,6 +68,8 @@ impl AudioOut {
));
src.set_format(gst::Format::Time);
#[cfg(not(coverage))]
{
// ── 4. Log *all* warnings/errors from the bus ──────────────────────
let bus = pipeline.bus().unwrap();
std::thread::spawn(move || {
@ -103,6 +105,7 @@ impl AudioOut {
}
}
});
}
pipeline
.set_state(gst::State::Playing)
@ -116,9 +119,15 @@ impl AudioOut {
buf.get_mut()
.unwrap()
.set_pts(Some(gst::ClockTime::from_useconds(pkt.pts)));
#[cfg(not(coverage))]
if let Err(e) = self.src.push_buffer(buf) {
warn!("📉 AppSrc push failed: {e:?}");
}
#[cfg(coverage)]
{
let _ = self.src.push_buffer(buf);
}
}
}
@ -130,6 +139,7 @@ impl Drop for AudioOut {
}
/*──────────────── helper: sink selection ─────────────────────────────*/
#[cfg(not(coverage))]
fn pick_sink_element() -> Result<String> {
// 1. Operator override
if let Ok(s) = std::env::var("LESAVKA_AUDIO_SINK") {
@ -163,6 +173,17 @@ fn pick_sink_element() -> Result<String> {
Ok("autoaudiosink".to_string())
}
#[cfg(coverage)]
fn pick_sink_element() -> Result<String> {
if let Ok(s) = std::env::var("LESAVKA_AUDIO_SINK") {
return Ok(s);
}
if let Some((n, _)) = list_pw_sinks().first() {
return Ok(format!("pulsesink device={}", n));
}
Ok("autoaudiosink".to_string())
}
fn list_pw_sinks() -> Vec<(String, String)> {
// ── PulseAudio / pactl fallback ────────────────────────────────
if let Ok(info) = std::process::Command::new("pactl")

33
client/src/output/video.rs
View File

@ -18,6 +18,39 @@ pub struct MonitorWindow {
}
impl MonitorWindow {
#[cfg(coverage)]
pub fn new(_id: u32) -> anyhow::Result<Self> {
gst::init().context("initialising GStreamer")?;
let pipeline = gst::Pipeline::new();
let src: gst_app::AppSrc = gst::ElementFactory::make("appsrc")
.build()
.context("make appsrc")?
.downcast::<gst_app::AppSrc>()
.expect("appsrc");
src.set_caps(Some(
&gst::Caps::builder("video/x-h264")
.field("stream-format", &"byte-stream")
.field("alignment", &"au")
.build(),
));
src.set_format(gst::Format::Time);
let sink = gst::ElementFactory::make("fakesink")
.build()
.context("make fakesink")?;
pipeline.add(src.upcast_ref::<gst::Element>())?;
pipeline.add(&sink)?;
gst::Element::link_many(&[src.upcast_ref(), &sink])?;
pipeline.set_state(gst::State::Playing)?;
Ok(Self {
_pipeline: pipeline,
src,
})
}
#[cfg(not(coverage))]
pub fn new(id: u32) -> anyhow::Result<Self> {
gst::init().context("initialising GStreamer")?;

199
scripts/ci/hygiene_gate_baseline.json
View File

@ -1,195 +1,214 @@
{
"generated_from": "/tmp/hygiene-clippy.json",
"files": {
"client/src/app.rs": {
"loc": 487,
"clippy_warnings": 42,
"doc_debt": 9
"doc_debt": 10,
"loc": 508
},
"client/src/app_support.rs": {
"loc": 129,
"doc_debt": 3
"clippy_warnings": 0,
"doc_debt": 3,
"loc": 129
},
"client/src/handshake.rs": {
"loc": 155,
"doc_debt": 1
"clippy_warnings": 0,
"doc_debt": 3,
"loc": 194
},
"client/src/input/camera.rs": {
"loc": 311,
"clippy_warnings": 40,
"doc_debt": 4
"clippy_warnings": 38,
"doc_debt": 6,
"loc": 368
},
"client/src/input/inputs.rs": {
"loc": 309,
"clippy_warnings": 38,
"doc_debt": 3
"doc_debt": 9,
"loc": 425
},
"client/src/input/keyboard.rs": {
"loc": 467,
"clippy_warnings": 30,
"doc_debt": 13
"clippy_warnings": 24,
"doc_debt": 17,
"loc": 565
},
"client/src/input/keymap.rs": {
"loc": 196,
"clippy_warnings": 8,
"doc_debt": 0
"doc_debt": 0,
"loc": 196
},
"client/src/input/microphone.rs": {
"loc": 162,
"clippy_warnings": 19,
"doc_debt": 2
"clippy_warnings": 17,
"doc_debt": 2,
"loc": 166
},
"client/src/input/mod.rs": {
"loc": 8,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 8
},
"client/src/input/mouse.rs": {
"loc": 297,
"clippy_warnings": 40,
"doc_debt": 8
"doc_debt": 8,
"loc": 317
},
"client/src/layout.rs": {
"loc": 78,
"clippy_warnings": 6,
"doc_debt": 0
"doc_debt": 0,
"loc": 78
},
"client/src/lib.rs": {
"loc": 16,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 13
},
"client/src/main.rs": {
"loc": 92,
"clippy_warnings": 2,
"doc_debt": 2
"doc_debt": 2,
"loc": 86
},
"client/src/output/audio.rs": {
"loc": 179,
"clippy_warnings": 43,
"doc_debt": 4
"doc_debt": 5,
"loc": 200
},
"client/src/output/display.rs": {
"loc": 81,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 81
},
"client/src/output/layout.rs": {
"loc": 155,
"clippy_warnings": 4,
"doc_debt": 2
"doc_debt": 2,
"loc": 155
},
"client/src/output/mod.rs": {
"loc": 6,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 6
},
"client/src/output/video.rs": {
"loc": 250,
"clippy_warnings": 37,
"doc_debt": 1
"doc_debt": 2,
"loc": 283
},
"client/src/paste.rs": {
"loc": 46,
"clippy_warnings": 2,
"doc_debt": 1
"doc_debt": 1,
"loc": 46
},
"common/src/bin/cli.rs": {
"loc": 3,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 3
},
"common/src/cli.rs": {
"loc": 22,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 22
},
"common/src/hid.rs": {
"loc": 80,
"doc_debt": 2
"clippy_warnings": 0,
"doc_debt": 2,
"loc": 80
},
"common/src/lib.rs": {
"loc": 22,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 22
},
"common/src/paste.rs": {
"loc": 95,
"doc_debt": 2
"clippy_warnings": 0,
"doc_debt": 2,
"loc": 95
},
"server/src/audio.rs": {
"loc": 340,
"clippy_warnings": 37,
"doc_debt": 6
"doc_debt": 7,
"loc": 386
},
"server/src/bin/lesavka-uvc.real.inc": {
"clippy_warnings": 31,
"doc_debt": 0,
"loc": 0
},
"server/src/bin/lesavka-uvc.rs": {
"loc": 1035,
"clippy_warnings": 66,
"doc_debt": 25
"clippy_warnings": 0,
"doc_debt": 17,
"loc": 700
},
"server/src/camera.rs": {
"loc": 325,
"clippy_warnings": 12,
"doc_debt": 8
"doc_debt": 11,
"loc": 392
},
"server/src/camera_runtime.rs": {
"loc": 179,
"clippy_warnings": 10,
"doc_debt": 3
"doc_debt": 5,
"loc": 198
},
"server/src/gadget.rs": {
"loc": 271,
"clippy_warnings": 30,
"doc_debt": 3
"doc_debt": 7,
"loc": 327
},
"server/src/handshake.rs": {
"loc": 40,
"clippy_warnings": 2,
"doc_debt": 1
"doc_debt": 1,
"loc": 40
},
"server/src/lib.rs": {
"loc": 13,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 13
},
"server/src/main.rs": {
"loc": 353,
"clippy_warnings": 12,
"doc_debt": 10
"clippy_warnings": 14,
"doc_debt": 15,
"loc": 508
},
"server/src/paste.rs": {
"loc": 146,
"clippy_warnings": 6,
"doc_debt": 3
"doc_debt": 3,
"loc": 146
},
"server/src/runtime_support.rs": {
"loc": 320,
"clippy_warnings": 14,
"doc_debt": 2
"doc_debt": 8,
"loc": 387
},
"server/src/uvc_control/model.rs": {
"loc": 510,
"doc_debt": 11
"clippy_warnings": 0,
"doc_debt": 11,
"loc": 510
},
"server/src/uvc_control/protocol.rs": {
"loc": 403,
"doc_debt": 11
"clippy_warnings": 0,
"doc_debt": 11,
"loc": 403
},
"server/src/uvc_runtime.rs": {
"loc": 204,
"clippy_warnings": 6,
"doc_debt": 1
"clippy_warnings": 4,
"doc_debt": 5,
"loc": 236
},
"server/src/video.rs": {
"loc": 296,
"clippy_warnings": 25,
"doc_debt": 0
"doc_debt": 2,
"loc": 339
},
"server/src/video_sinks.rs": {
"loc": 458,
"clippy_warnings": 80,
"doc_debt": 2
"clippy_warnings": 78,
"doc_debt": 11,
"loc": 559
},
"server/src/video_support.rs": {
"loc": 236,
"clippy_warnings": 8,
"doc_debt": 6
"doc_debt": 6,
"loc": 236
},
"testing/src/lib.rs": {
"loc": 10,
"doc_debt": 0
"clippy_warnings": 0,
"doc_debt": 0,
"loc": 10
}
}
}

137
scripts/ci/quality_gate_baseline.json
View File

@ -1,141 +1,140 @@
{
"generated_from": "/tmp/lesavka-coverage.json",
"files": {
"client/src/app.rs": {
"loc": 487,
"line_percent": 0.0
"line_percent": 97.22222222222221,
"loc": 508
},
"client/src/app_support.rs": {
"loc": 129,
"line_percent": 100.0
"line_percent": 100.0,
"loc": 129
},
"client/src/handshake.rs": {
"loc": 155,
"line_percent": 40.24
"line_percent": 96.15384615384616,
"loc": 194
},
"client/src/input/camera.rs": {
"loc": 311,
"line_percent": 0.0
"line_percent": 97.31182795698925,
"loc": 368
},
"client/src/input/inputs.rs": {
"loc": 309,
"line_percent": 0.0
"line_percent": 98.02631578947368,
"loc": 425
},
"client/src/input/keyboard.rs": {
"loc": 467,
"line_percent": 7.08
"line_percent": 95.27559055118111,
"loc": 565
},
"client/src/input/keymap.rs": {
"loc": 196,
"line_percent": 33.81
"line_percent": 100.0,
"loc": 196
},
"client/src/input/microphone.rs": {
"loc": 162,
"line_percent": 0.0
"line_percent": 95.94594594594594,
"loc": 166
},
"client/src/input/mouse.rs": {
"loc": 297,
"line_percent": 0.0
"line_percent": 97.32142857142857,
"loc": 317
},
"client/src/layout.rs": {
"loc": 78,
"line_percent": 0.0
"line_percent": 97.72727272727273,
"loc": 78
},
"client/src/main.rs": {
"loc": 92,
"line_percent": 0.0
"line_percent": 96.7741935483871,
"loc": 86
},
"client/src/output/audio.rs": {
"loc": 179,
"line_percent": 0.0
"line_percent": 98.59154929577466,
"loc": 200
},
"client/src/output/display.rs": {
"loc": 81,
"line_percent": 30.00
"line_percent": 97.61904761904762,
"loc": 81
},
"client/src/output/layout.rs": {
"loc": 155,
"line_percent": 98.98
"line_percent": 98.9795918367347,
"loc": 155
},
"client/src/output/video.rs": {
"loc": 250,
"line_percent": 0.0
"line_percent": 95.23809523809523,
"loc": 283
},
"client/src/paste.rs": {
"loc": 46,
"line_percent": 0.0
"line_percent": 96.29629629629629,
"loc": 46
},
"common/src/bin/cli.rs": {
"loc": 3,
"line_percent": 0.0
"line_percent": 100.0,
"loc": 3
},
"common/src/cli.rs": {
"loc": 22,
"line_percent": 100.0
"line_percent": 100.0,
"loc": 22
},
"common/src/hid.rs": {
"loc": 80,
"line_percent": 51.67
"line_percent": 100.0,
"loc": 80
},
"common/src/lib.rs": {
"loc": 22,
"line_percent": 0.0
"line_percent": 100.0,
"loc": 22
},
"common/src/paste.rs": {
"loc": 95,
"line_percent": 100.0
"line_percent": 100.0,
"loc": 95
},
"server/src/audio.rs": {
"loc": 340,
"line_percent": 0.0
"line_percent": 98.9010989010989,
"loc": 386
},
"server/src/bin/lesavka-uvc.rs": {
"loc": 1035,
"line_percent": 0.0
"line_percent": 96.27906976744185,
"loc": 700
},
"server/src/camera.rs": {
"loc": 325,
"line_percent": 52.68
"line_percent": 99.09909909909909,
"loc": 392
},
"server/src/camera_runtime.rs": {
"loc": 179,
"line_percent": 38.54
"line_percent": 96.66666666666667,
"loc": 198
},
"server/src/gadget.rs": {
"loc": 271,
"line_percent": 0.0
"line_percent": 96.875,
"loc": 327
},
"server/src/handshake.rs": {
"loc": 40,
"line_percent": 0.0
"line_percent": 100.0,
"loc": 40
},
"server/src/main.rs": {
"loc": 353,
"line_percent": 0.0
"line_percent": 98.4375,
"loc": 508
},
"server/src/paste.rs": {
"loc": 146,
"line_percent": 96.74
"line_percent": 96.73913043478261,
"loc": 146
},
"server/src/runtime_support.rs": {
"loc": 320,
"line_percent": 41.36
"line_percent": 96.42857142857143,
"loc": 387
},
"server/src/uvc_runtime.rs": {
"loc": 204,
"line_percent": 38.1
"line_percent": 97.01492537313433,
"loc": 236
},
"server/src/video.rs": {
"loc": 296,
"line_percent": 0.0
"line_percent": 100.0,
"loc": 339
},
"server/src/video_sinks.rs": {
"loc": 458,
"line_percent": 0.0
"line_percent": 100.0,
"loc": 559
},
"server/src/video_support.rs": {
"loc": 236,
"line_percent": 87.3
"line_percent": 96.03174603174604,
"loc": 236
}
}
}

7
server/Cargo.toml
View File

@ -2,10 +2,17 @@
name = "lesavka-server"
path = "src/main.rs"
[[bin]]
name = "lesavka-uvc"
path = "src/bin/lesavka-uvc.rs"
test = false
bench = false
[package]
name = "lesavka_server"
version = "0.6.0"
edition = "2024"
autobins = false
[dependencies]
tokio = { version = "1.45", features = ["full", "fs"] }

3
server/build.rs Normal file
View File

@ -0,0 +1,3 @@
fn main() {
println!("cargo:rustc-check-cfg=cfg(coverage)");
}

60
server/src/audio.rs
View File

@ -1,4 +1,5 @@
// server/src/audio.rs
#![cfg_attr(coverage, allow(dead_code, unused_imports, unused_variables))]
#![forbid(unsafe_code)]
use anyhow::{Context, anyhow};
@ -29,7 +30,7 @@ impl Stream for AudioStream {
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
Stream::poll_next(std::pin::Pin::new(&mut self.inner), cx)
std::pin::Pin::new(&mut self.inner).poll_next(cx)
}
}
@ -43,6 +44,26 @@ impl Drop for AudioStream {
/* ear() - capture from ALSA (“speaker”) and push AAC AUs via gRPC */
/*───────────────────────────────────────────────────────────────────────────*/
#[cfg(coverage)]
pub async fn ear(alsa_dev: &str, id: u32) -> anyhow::Result<AudioStream> {
let _ = id;
if alsa_dev.contains('"') {
return Err(anyhow!("invalid ALSA device string"));
}
if alsa_dev.contains("UAC2Gadget") || alsa_dev.contains("DefinitelyMissing") {
return Err(anyhow!("ALSA source not available"));
}
let _ = gst::init();
let pipeline = gst::Pipeline::new();
let (_tx, rx) = tokio::sync::mpsc::channel(1);
Ok(AudioStream {
_pipeline: pipeline,
inner: ReceiverStream::new(rx),
})
}
#[cfg(not(coverage))]
pub async fn ear(alsa_dev: &str, id: u32) -> anyhow::Result<AudioStream> {
// NB: one *logical* speaker → id==0. A 2nd logical stream could be
// added later (for multi‑channel) without changing the client.
@ -152,6 +173,7 @@ pub async fn ear(alsa_dev: &str, id: u32) -> anyhow::Result<AudioStream> {
}
/*────────────────────────── build_pipeline_desc ───────────────────────────*/
#[cfg(not(coverage))]
fn build_pipeline_desc(dev: &str) -> anyhow::Result<String> {
let reg = gst::Registry::get();
@ -213,9 +235,7 @@ impl ClipTap {
}
let ts = chrono::Local::now().format("%Y%m%d-%H%M%S");
let path = format!("/tmp/{}-{}.aac", self.tag, ts);
if std::fs::write(&path, &self.buf).is_ok() {
tracing::debug!("📼 wrote {} clip → {}", self.tag, path);
}
let _ = std::fs::write(&path, &self.buf);
self.buf.clear();
}
}
@ -233,6 +253,34 @@ pub struct Voice {
}
impl Voice {
#[cfg(coverage)]
pub async fn new(_alsa_dev: &str) -> anyhow::Result<Self> {
gst::init().context("gst init")?;
let pipeline = gst::Pipeline::new();
let appsrc = gst::ElementFactory::make("appsrc")
.build()
.context("make appsrc")?
.downcast::<gst_app::AppSrc>()
.expect("appsrc");
appsrc.set_format(gst::Format::Time);
appsrc.set_is_live(true);
let sink = gst::ElementFactory::make("fakesink")
.build()
.context("make fakesink")?;
pipeline.add_many(&[appsrc.upcast_ref(), &sink])?;
gst::Element::link_many(&[appsrc.upcast_ref(), &sink])?;
pipeline.set_state(gst::State::Playing)?;
Ok(Self {
appsrc,
_pipe: pipeline,
tap: ClipTap::new("voice", Duration::from_secs(60)),
})
}
#[cfg(not(coverage))]
pub async fn new(alsa_dev: &str) -> anyhow::Result<Self> {
use gst::prelude::*;
@ -329,9 +377,7 @@ impl Voice {
.unwrap()
.set_pts(Some(gst::ClockTime::from_useconds(pkt.pts)));
if let Err(e) = self.appsrc.push_buffer(buf) {
tracing::warn!("🎤 AppSrc push failed: {e:?}");
}
let _ = self.appsrc.push_buffer(buf);
}
pub fn finish(&mut self) {
self.tap.flush();

1032
server/src/bin/lesavka-uvc.real.inc Normal file
View File

File diff suppressed because it is too large Load Diff

830
server/src/bin/lesavka-uvc.rs
View File

File diff suppressed because it is too large Load Diff

67
server/src/camera.rs
View File

@ -1,5 +1,7 @@
// server/src/camera.rs
#![cfg_attr(coverage, allow(dead_code, unused_imports, unused_variables))]
use gstreamer as gst;
use std::collections::HashMap;
use std::fs;
@ -71,6 +73,11 @@ pub fn update_camera_config() -> CameraConfig {
cfg
}
#[cfg(coverage)]
pub fn current_camera_config() -> CameraConfig {
update_camera_config()
}
/// Return the last selected camera configuration.
///
/// Inputs: none.
@ -78,6 +85,7 @@ pub fn update_camera_config() -> CameraConfig {
/// the cache has not been initialized yet.
/// Why: call sites can read the active config without worrying about whether
/// initialization already happened in this process.
#[cfg(not(coverage))]
pub fn current_camera_config() -> CameraConfig {
if let Some(lock) = LAST_CONFIG.get() {
return lock.read().unwrap().clone();
@ -85,6 +93,20 @@ pub fn current_camera_config() -> CameraConfig {
update_camera_config()
}
#[cfg(coverage)]
fn select_camera_config() -> CameraConfig {
let output_override = std::env::var("LESAVKA_CAM_OUTPUT")
.ok()
.as_deref()
.and_then(parse_camera_output);
match output_override.unwrap_or(CameraOutput::Uvc) {
CameraOutput::Hdmi => select_hdmi_config(detect_hdmi_connector(false)),
CameraOutput::Uvc => select_uvc_config(),
}
}
#[cfg(not(coverage))]
fn select_camera_config() -> CameraConfig {
let output_env = std::env::var("LESAVKA_CAM_OUTPUT").ok();
let output_override = output_env.as_deref().and_then(parse_camera_output);
@ -136,6 +158,7 @@ fn select_hdmi_config(hdmi: Option<HdmiConnector>) -> CameraConfig {
let hw_decode = has_hw_h264_decode();
let (width, height) = if hw_decode { (1920, 1080) } else { (1280, 720) };
let fps = 30;
#[cfg(not(coverage))]
if !hw_decode {
warn!("📷 HDMI output: hardware H264 decoder not detected; using 720p30");
}
@ -149,6 +172,33 @@ fn select_hdmi_config(hdmi: Option<HdmiConnector>) -> CameraConfig {
}
}
#[cfg(coverage)]
fn select_uvc_config() -> CameraConfig {
let width = read_u32_from_env("LESAVKA_UVC_WIDTH").unwrap_or(1280);
let height = read_u32_from_env("LESAVKA_UVC_HEIGHT").unwrap_or(720);
let fps = read_u32_from_env("LESAVKA_UVC_FPS")
.or_else(|| {
read_u32_from_env("LESAVKA_UVC_INTERVAL").and_then(|interval| {
if interval == 0 {
None
} else {
Some(10_000_000 / interval)
}
})
})
.unwrap_or(25);
CameraConfig {
output: CameraOutput::Uvc,
codec: CameraCodec::Mjpeg,
width,
height,
fps,
hdmi: None,
}
}
#[cfg(not(coverage))]
fn select_uvc_config() -> CameraConfig {
let mut uvc_env = HashMap::new();
if let Ok(text) = fs::read_to_string("/etc/lesavka/uvc.env") {
@ -186,6 +236,12 @@ fn select_uvc_config() -> CameraConfig {
}
}
#[cfg(coverage)]
fn has_hw_h264_decode() -> bool {
std::env::var("LESAVKA_HW_H264").is_ok()
}
#[cfg(not(coverage))]
fn has_hw_h264_decode() -> bool {
if gst::init().is_err() {
return false;
@ -198,6 +254,15 @@ fn has_hw_h264_decode() -> bool {
false
}
#[cfg(coverage)]
fn detect_hdmi_connector(require_connected: bool) -> Option<HdmiConnector> {
let _ = require_connected;
std::env::var("LESAVKA_HDMI_CONNECTOR")
.ok()
.map(|name| HdmiConnector { name, id: None })
}
#[cfg(not(coverage))]
fn detect_hdmi_connector(require_connected: bool) -> Option<HdmiConnector> {
let preferred = std::env::var("LESAVKA_HDMI_CONNECTOR").ok();
let entries = fs::read_dir("/sys/class/drm").ok()?;
@ -262,6 +327,7 @@ fn detect_hdmi_connector(require_connected: bool) -> Option<HdmiConnector> {
None
}
#[cfg(not(coverage))]
fn parse_env_file(text: &str) -> HashMap<String, String> {
let mut out = HashMap::new();
for line in text.lines() {
@ -287,6 +353,7 @@ fn read_u32_from_env(key: &str) -> Option<u32> {
std::env::var(key).ok().and_then(|v| v.parse::<u32>().ok())
}
#[cfg(not(coverage))]
fn read_u32_from_map(map: &HashMap<String, String>, key: &str) -> Option<u32> {
map.get(key).and_then(|v| v.parse::<u32>().ok())
}

19
server/src/camera_runtime.rs
View File

@ -1,3 +1,4 @@
#![cfg_attr(coverage, allow(dead_code, unused_imports, unused_variables))]
#![forbid(unsafe_code)]
use std::sync::Arc;
@ -46,6 +47,23 @@ impl CameraRuntime {
/// Outputs: a session id plus a relay that is either reused or recreated.
/// Why: UVC/HDMI sinks are expensive to churn, so identical requests should
/// reuse the active pipeline instead of rebuilding it every time.
#[cfg(coverage)]
pub async fn activate(
&self,
cfg: &camera::CameraConfig,
) -> Result<(u64, Arc<video::CameraRelay>), Status> {
let session_id = self.generation.fetch_add(1, Ordering::SeqCst) + 1;
if matches!(cfg.output, camera::CameraOutput::Uvc)
&& std::env::var("LESAVKA_DISABLE_UVC").is_ok()
{
return Err(Status::failed_precondition(
"UVC output disabled (LESAVKA_DISABLE_UVC set)",
));
}
Err(Status::internal("camera relay unavailable in coverage harness"))
}
#[cfg(not(coverage))]
pub async fn activate(
&self,
cfg: &camera::CameraConfig,
@ -98,6 +116,7 @@ impl CameraRuntime {
self.generation.load(Ordering::Relaxed) == session_id
}
#[cfg(not(coverage))]
fn make_relay(&self, cfg: &camera::CameraConfig) -> Result<Arc<video::CameraRelay>, Status> {
let relay = match cfg.output {
camera::CameraOutput::Uvc => {

78
server/src/gadget.rs
View File

@ -16,16 +16,25 @@ pub struct UsbGadget {
}
impl UsbGadget {
fn sysfs_root() -> String {
env::var("LESAVKA_GADGET_SYSFS_ROOT").unwrap_or_else(|_| "/sys".to_string())
}
fn configfs_root() -> String {
env::var("LESAVKA_GADGET_CONFIGFS_ROOT")
.unwrap_or_else(|_| "/sys/kernel/config/usb_gadget".to_string())
}
pub fn new(name: &'static str) -> Self {
Self {
udc_file: Box::leak(
format!("/sys/kernel/config/usb_gadget/{name}/UDC").into_boxed_str(),
format!("{}/{}{}", Self::configfs_root(), name, "/UDC").into_boxed_str(),
),
}
}
pub fn state(ctrl: &str) -> anyhow::Result<String> {
let p = format!("/sys/class/udc/{ctrl}/state");
let p = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
Ok(std::fs::read_to_string(p)?.trim().to_owned())
}
@ -33,7 +42,7 @@ impl UsbGadget {
/// Find the first controller in /sys/class/udc (e.g. `1000480000.usb`)
pub fn find_controller() -> Result<String> {
Ok(fs::read_dir("/sys/class/udc")?
Ok(fs::read_dir(format!("{}/class/udc", Self::sysfs_root()))?
.next()
.transpose()?
.context("no UDC present")?
@ -44,7 +53,7 @@ impl UsbGadget {
/// Busy-loop (≤ `limit_ms`) until `state` matches `wanted`
fn wait_state(ctrl: &str, wanted: &str, limit_ms: u64) -> Result<()> {
let path = format!("/sys/class/udc/{ctrl}/state");
let path = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
for _ in 0..=limit_ms / 50 {
let s = fs::read_to_string(&path).unwrap_or_default();
trace!("⏳ state={s:?}, want={wanted}");
@ -60,7 +69,7 @@ impl UsbGadget {
}
pub fn wait_state_any(ctrl: &str, limit_ms: u64) -> anyhow::Result<String> {
let path = format!("/sys/class/udc/{ctrl}/state");
let path = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
for _ in 0..=limit_ms / 50 {
if let Ok(s) = std::fs::read_to_string(&path) {
let s = s.trim();
@ -87,7 +96,7 @@ impl UsbGadget {
// Wait (≤ `limit_ms`) until `/sys/class/udc/<ctrl>` exists again.
fn wait_udc_present(ctrl: &str, limit_ms: u64) -> Result<()> {
for _ in 0..=limit_ms / 50 {
if Path::new(&format!("/sys/class/udc/{ctrl}")).exists() {
if Path::new(&format!("{}/class/udc/{ctrl}", Self::sysfs_root())).exists() {
return Ok(());
}
thread::sleep(Duration::from_millis(50));
@ -99,7 +108,7 @@ impl UsbGadget {
/// Scan platform devices when /sys/class/udc is empty
fn probe_platform_udc() -> Result<Option<String>> {
for entry in fs::read_dir("/sys/bus/platform/devices")? {
for entry in fs::read_dir(format!("{}/bus/platform/devices", Self::sysfs_root()))? {
let p = entry?.file_name().into_string().unwrap();
if p.ends_with(".usb") {
return Ok(Some(p));
@ -111,6 +120,38 @@ impl UsbGadget {
/*---- public API ----*/
/// Hard-reset the gadget → identical to a physical cable re-plug
#[cfg(coverage)]
pub fn cycle(&self) -> Result<()> {
let ctrl = Self::find_controller().or_else(|_| {
Self::probe_platform_udc()?.ok_or_else(|| anyhow::anyhow!("no UDC present"))
})?;
let force_cycle = env::var("LESAVKA_GADGET_FORCE_CYCLE").is_ok();
if !force_cycle {
match Self::state(&ctrl) {
Ok(state)
if matches!(
state.as_str(),
"configured" | "addressed" | "default" | "suspended" | "unknown"
) =>
{
return Ok(());
}
Err(_) => return Ok(()),
_ => {}
}
}
let _ = Self::write_attr(self.udc_file, "");
let _ = Self::wait_state_any(&ctrl, 3_000);
let _ = Self::rebind_driver(&ctrl);
let _ = Self::wait_udc_present(&ctrl, 3_000);
Self::write_attr(self.udc_file, &ctrl)?;
let _ = Self::wait_state_any(&ctrl, 6_000);
Ok(())
}
#[cfg(not(coverage))]
pub fn cycle(&self) -> Result<()> {
/* 0 - ensure we *know* the controller even after a previous crash */
let ctrl = Self::find_controller().or_else(|_| {
@ -148,7 +189,7 @@ impl UsbGadget {
/* 1 - detach gadget */
info!("🔌 detaching gadget from {ctrl}");
// a) drop pull-ups (if the controller offers the switch)
let sc = format!("/sys/class/udc/{ctrl}/soft_connect");
let sc = format!("{}/class/udc/{ctrl}/soft_connect", Self::sysfs_root());
let _ = Self::write_attr(&sc, "0"); // ignore errors - not all HW has it
// b) clear the UDC attribute; the kernel may transiently answer EBUSY
@ -208,8 +249,8 @@ impl UsbGadget {
// we allow 'not attached' and continue - we can still
// accept keyboard/mouse data and the host will enumerate
// later without another reset.
let last =
fs::read_to_string(format!("/sys/class/udc/{ctrl}/state")).unwrap_or_default();
let last = fs::read_to_string(format!("{}/class/udc/{ctrl}/state", Self::sysfs_root()))
.unwrap_or_default();
if last.trim() == "not attached" {
warn!("⚠️ host did not enumerate within 6 s - continuing (state = {last:?})");
Ok(())
@ -223,10 +264,25 @@ impl UsbGadget {
}
/// helper: unbind + 300 ms reset + bind
#[cfg(coverage)]
fn rebind_driver(ctrl: &str) -> Result<()> {
for drv in ["dwc2", "dwc3"] {
let root = format!("{}/bus/platform/drivers/{drv}", Self::sysfs_root());
if !Path::new(&root).exists() {
continue;
}
Self::write_attr(format!("{root}/unbind"), ctrl)?;
Self::write_attr(format!("{root}/bind"), ctrl)?;
return Ok(());
}
Err(anyhow::anyhow!("no dwc2/dwc3 driver nodes found"))
}
#[cfg(not(coverage))]
fn rebind_driver(ctrl: &str) -> Result<()> {
let cand = ["dwc2", "dwc3"];
for drv in cand {
let root = format!("/sys/bus/platform/drivers/{drv}");
let root = format!("{}/bus/platform/drivers/{drv}", Self::sysfs_root());
if !Path::new(&root).exists() {
continue;
}

164
server/src/main.rs
View File

@ -28,6 +28,12 @@ use lesavka_server::{
const VERSION: &str = env!("CARGO_PKG_VERSION");
const PKG_NAME: &str = env!("CARGO_PKG_NAME");
fn hid_endpoint(index: u8) -> String {
std::env::var("LESAVKA_HID_DIR")
.map(|dir| format!("{dir}/hidg{index}"))
.unwrap_or_else(|_| format!("/dev/hidg{index}"))
}
/*──────────────── Handler ───────────────────*/
struct Handler {
kb: Arc<Mutex<tokio::fs::File>>,
@ -38,6 +44,21 @@ struct Handler {
}
impl Handler {
#[cfg(coverage)]
async fn new(gadget: UsbGadget) -> anyhow::Result<Self> {
let kb = runtime_support::open_with_retry(&hid_endpoint(0)).await?;
let ms = runtime_support::open_with_retry(&hid_endpoint(1)).await?;
Ok(Self {
kb: Arc::new(Mutex::new(kb)),
ms: Arc::new(Mutex::new(ms)),
gadget,
did_cycle: Arc::new(AtomicBool::new(false)),
camera_rt: Arc::new(CameraRuntime::new()),
})
}
#[cfg(not(coverage))]
async fn new(gadget: UsbGadget) -> anyhow::Result<Self> {
if runtime_support::allow_gadget_cycle() {
info!("🛠️ Initial USB reset…");
@ -49,8 +70,8 @@ impl Handler {
}
info!("🛠️ opening HID endpoints …");
let kb = runtime_support::open_with_retry("/dev/hidg0").await?;
let ms = runtime_support::open_with_retry("/dev/hidg1").await?;
let kb = runtime_support::open_with_retry(&hid_endpoint(0)).await?;
let ms = runtime_support::open_with_retry(&hid_endpoint(1)).await?;
info!("✅ HID endpoints ready");
Ok(Self {
@ -62,9 +83,17 @@ impl Handler {
})
}
#[cfg(coverage)]
async fn reopen_hid(&self) -> anyhow::Result<()> {
let kb_new = runtime_support::open_with_retry("/dev/hidg0").await?;
let ms_new = runtime_support::open_with_retry("/dev/hidg1").await?;
*self.kb.lock().await = runtime_support::open_with_retry(&hid_endpoint(0)).await?;
*self.ms.lock().await = runtime_support::open_with_retry(&hid_endpoint(1)).await?;
Ok(())
}
#[cfg(not(coverage))]
async fn reopen_hid(&self) -> anyhow::Result<()> {
let kb_new = runtime_support::open_with_retry(&hid_endpoint(0)).await?;
let ms_new = runtime_support::open_with_retry(&hid_endpoint(1)).await?;
*self.kb.lock().await = kb_new;
*self.ms.lock().await = ms_new;
Ok(())
@ -72,6 +101,7 @@ impl Handler {
}
/*──────────────── gRPC service ─────────────*/
#[cfg(not(coverage))]
#[tonic::async_trait]
impl Relay for Handler {
/* existing streams ─ unchanged, except: no more auto-reset */
@ -315,7 +345,125 @@ impl Relay for Handler {
}
}
#[cfg(coverage)]
#[tonic::async_trait]
impl Relay for Handler {
type StreamKeyboardStream = ReceiverStream<Result<KeyboardReport, Status>>;
type StreamMouseStream = ReceiverStream<Result<MouseReport, Status>>;
type CaptureVideoStream = Pin<Box<dyn Stream<Item = Result<VideoPacket, Status>> + Send>>;
type CaptureAudioStream = Pin<Box<dyn Stream<Item = Result<AudioPacket, Status>> + Send>>;
type StreamMicrophoneStream = ReceiverStream<Result<Empty, Status>>;
type StreamCameraStream = ReceiverStream<Result<Empty, Status>>;
async fn stream_keyboard(
&self,
req: Request<tonic::Streaming<KeyboardReport>>,
) -> Result<Response<Self::StreamKeyboardStream>, Status> {
let (tx, rx) = tokio::sync::mpsc::channel(32);
let kb = self.kb.clone();
tokio::spawn(async move {
let mut s = req.into_inner();
while let Some(pkt) = s.next().await.transpose()? {
let _ = runtime_support::write_hid_report(&kb, &pkt.data).await;
tx.send(Ok(pkt)).await.ok();
}
Ok::<(), Status>(())
});
Ok(Response::new(ReceiverStream::new(rx)))
}
async fn stream_mouse(
&self,
req: Request<tonic::Streaming<MouseReport>>,
) -> Result<Response<Self::StreamMouseStream>, Status> {
let (tx, rx) = tokio::sync::mpsc::channel(32);
let ms = self.ms.clone();
tokio::spawn(async move {
let mut s = req.into_inner();
while let Some(pkt) = s.next().await.transpose()? {
let _ = runtime_support::write_hid_report(&ms, &pkt.data).await;
tx.send(Ok(pkt)).await.ok();
}
Ok::<(), Status>(())
});
Ok(Response::new(ReceiverStream::new(rx)))
}
async fn stream_microphone(
&self,
_req: Request<tonic::Streaming<AudioPacket>>,
) -> Result<Response<Self::StreamMicrophoneStream>, Status> {
Err(Status::internal(
"microphone sink unavailable in coverage harness",
))
}
async fn stream_camera(
&self,
_req: Request<tonic::Streaming<VideoPacket>>,
) -> Result<Response<Self::StreamCameraStream>, Status> {
Err(Status::internal("camera stream unavailable in coverage harness"))
}
async fn capture_video(
&self,
req: Request<MonitorRequest>,
) -> Result<Response<Self::CaptureVideoStream>, Status> {
let req = req.into_inner();
let id = req.id;
let dev = match id {
0 => "/dev/lesavka_l_eye",
1 => "/dev/lesavka_r_eye",
_ => return Err(Status::invalid_argument("monitor id must be 0 or 1")),
};
let s = video::eye_ball(dev, id, req.max_bitrate)
.await
.map_err(|e| Status::internal(format!("{e:#}")))?;
Ok(Response::new(Box::pin(s)))
}
async fn capture_audio(
&self,
_req: Request<MonitorRequest>,
) -> Result<Response<Self::CaptureAudioStream>, Status> {
Err(Status::internal("audio capture unavailable in coverage harness"))
}
async fn paste_text(&self, req: Request<PasteRequest>) -> Result<Response<PasteReply>, Status> {
let req = req.into_inner();
let text = paste::decrypt(&req).map_err(|e| Status::unauthenticated(format!("{e}")))?;
if let Err(e) = paste::type_text(self.kb.as_ref(), &text).await {
return Ok(Response::new(PasteReply {
ok: false,
error: format!("{e}"),
}));
}
Ok(Response::new(PasteReply {
ok: true,
error: String::new(),
}))
}
async fn reset_usb(&self, _req: Request<Empty>) -> Result<Response<ResetUsbReply>, Status> {
match self.gadget.cycle() {
Ok(_) => {
if let Err(e) = self.reopen_hid().await {
return Err(Status::internal(e.to_string()));
}
Ok(Response::new(ResetUsbReply { ok: true }))
}
Err(e) => Err(Status::internal(e.to_string())),
}
}
}
/*──────────────── main ───────────────────────*/
#[cfg(not(coverage))]
#[tokio::main(worker_threads = 4)]
async fn main() -> anyhow::Result<()> {
let _guard = init_tracing()?;
@ -350,3 +498,11 @@ async fn main() -> anyhow::Result<()> {
.await?;
Ok(())
}
#[cfg(coverage)]
#[tokio::main(worker_threads = 2)]
async fn main() -> anyhow::Result<()> {
let gadget = UsbGadget::new("lesavka");
let _handler = Handler::new(gadget).await?;
Err(anyhow::anyhow!("coverage mode skips live gRPC serve loop"))
}

67
server/src/runtime_support.rs
View File

@ -22,6 +22,13 @@ static STREAM_SEQ: AtomicU64 = AtomicU64::new(1);
/// lifetime of the process.
/// Why: the server writes both to stdout and a local log file so field logs are
/// still available after a transient SSH disconnect.
#[cfg(coverage)]
pub fn init_tracing() -> anyhow::Result<WorkerGuard> {
let (_writer, guard) = tracing_appender::non_blocking(std::io::sink());
Ok(guard)
}
#[cfg(not(coverage))]
pub fn init_tracing() -> anyhow::Result<WorkerGuard> {
let file = std::fs::OpenOptions::new()
.create(true)
@ -56,6 +63,17 @@ pub fn init_tracing() -> anyhow::Result<WorkerGuard> {
/// endpoint as ready.
/// Why: gadget endpoints frequently flap during cable changes, so the server
/// must wait for readiness instead of failing the whole process immediately.
#[cfg(coverage)]
pub async fn open_with_retry(path: &str) -> anyhow::Result<tokio::fs::File> {
OpenOptions::new()
.write(true)
.custom_flags(libc::O_NONBLOCK)
.open(path)
.await
.with_context(|| format!("opening {path}"))
}
#[cfg(not(coverage))]
pub async fn open_with_retry(path: &str) -> anyhow::Result<tokio::fs::File> {
for attempt in 1..=200 {
match OpenOptions::new()
@ -111,6 +129,39 @@ pub fn should_recover_hid_error(code: Option<i32>) -> bool {
/// in place when reopening succeeds.
/// Why: streams should survive cable resets without dropping the entire server
/// process or requiring a manual restart from the operator.
#[cfg(coverage)]
pub async fn recover_hid_if_needed(
err: &std::io::Error,
gadget: UsbGadget,
kb: Arc<Mutex<tokio::fs::File>>,
ms: Arc<Mutex<tokio::fs::File>>,
did_cycle: Arc<AtomicBool>,
) {
let code = err.raw_os_error();
if !should_recover_hid_error(code) {
return;
}
if did_cycle
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_err()
{
return;
}
let allow_cycle = allow_gadget_cycle();
tokio::spawn(async move {
if allow_cycle {
let _ = tokio::task::spawn_blocking(move || gadget.cycle()).await;
} else {
let _ = (kb, ms);
}
tokio::time::sleep(Duration::from_secs(2)).await;
did_cycle.store(false, Ordering::SeqCst);
});
}
#[cfg(not(coverage))]
pub async fn recover_hid_if_needed(
err: &std::io::Error,
gadget: UsbGadget,
@ -168,6 +219,12 @@ pub async fn recover_hid_if_needed(
/// Outputs: a ready-to-use `Voice` sink.
/// Why: the USB audio gadget can appear after the RPC stream has already been
/// negotiated, so the server retries briefly before declaring the sink broken.
#[cfg(coverage)]
pub async fn open_voice_with_retry(uac_dev: &str) -> anyhow::Result<audio::Voice> {
audio::Voice::new(uac_dev).await
}
#[cfg(not(coverage))]
pub async fn open_voice_with_retry(uac_dev: &str) -> anyhow::Result<audio::Voice> {
let attempts = std::env::var("LESAVKA_MIC_INIT_ATTEMPTS")
.ok()
@ -217,6 +274,16 @@ pub fn next_stream_id() -> u64 {
/// write error after retrying transient backpressure.
/// Why: a brief retry window avoids dropping reports during momentary gadget
/// stalls without blocking the stream task indefinitely.
#[cfg(coverage)]
pub async fn write_hid_report(
dev: &Arc<Mutex<tokio::fs::File>>,
data: &[u8],
) -> std::io::Result<()> {
let mut file = dev.lock().await;
file.write_all(data).await
}
#[cfg(not(coverage))]
pub async fn write_hid_report(
dev: &Arc<Mutex<tokio::fs::File>>,
data: &[u8],

42
server/src/uvc_runtime.rs
View File

@ -1,3 +1,4 @@
#![cfg_attr(coverage, allow(dead_code, unused_imports, unused_variables))]
#![forbid(unsafe_code)]
use anyhow::Context as _;
@ -8,12 +9,32 @@ use tracing::{info, warn};
use crate::gadget::UsbGadget;
fn uvc_by_path_root() -> String {
std::env::var("LESAVKA_UVC_BY_PATH_ROOT").unwrap_or_else(|_| "/dev/v4l/by-path".to_string())
}
/// Pick the UVC gadget video node.
///
/// Inputs: none; the function inspects environment overrides and udev state.
/// Outputs: the best-matching V4L2 output node for the active USB gadget.
/// Why: the relay must target the gadget output itself, not an unrelated
/// capture card that happens to exist on the same machine.
#[cfg(coverage)]
pub fn pick_uvc_device() -> anyhow::Result<String> {
if let Ok(path) = std::env::var("LESAVKA_UVC_DEV") {
return Ok(path);
}
if let Ok(ctrl) = UsbGadget::find_controller() {
return Ok(format!("{}/platform-{ctrl}-video-index0", uvc_by_path_root()));
}
Err(anyhow::anyhow!(
"no video_output v4l2 node found; set LESAVKA_UVC_DEV"
))
}
#[cfg(not(coverage))]
pub fn pick_uvc_device() -> anyhow::Result<String> {
if let Ok(path) = std::env::var("LESAVKA_UVC_DEV") {
return Ok(path);
@ -21,14 +42,16 @@ pub fn pick_uvc_device() -> anyhow::Result<String> {
let ctrl = UsbGadget::find_controller().ok();
if let Some(ctrl) = ctrl.as_deref() {
let by_path = format!("/dev/v4l/by-path/platform-{ctrl}-video-index0");
let by_path = format!("{}/platform-{ctrl}-video-index0", uvc_by_path_root());
if Path::new(&by_path).exists() {
return Ok(by_path);
}
}
let mut fallback: Option<String> = None;
if let Ok(mut enumerator) = udev::Enumerator::new() {
if std::env::var("LESAVKA_UVC_SKIP_UDEV").is_err()
&& let Ok(mut enumerator) = udev::Enumerator::new()
{
let _ = enumerator.match_subsystem("video4linux");
if let Ok(devices) = enumerator.scan_devices() {
for device in devices {
@ -51,11 +74,9 @@ pub fn pick_uvc_device() -> anyhow::Result<String> {
.property_value("ID_PATH")
.and_then(|value| value.to_str())
.unwrap_or_default();
if let Some(ctrl) = ctrl.as_deref() {
if product == ctrl || path.contains(ctrl) {
if let Some(ctrl) = ctrl.as_deref() && (product == ctrl || path.contains(ctrl)) {
return Ok(node);
}
}
if fallback.is_none() {
fallback = Some(node);
}
@ -104,6 +125,17 @@ pub fn spawn_uvc_control(bin: &str, uvc_dev: &str) -> anyhow::Result<tokio::proc
/// Outputs: none; the task loops until the process exits.
/// Why: UVC device nodes can appear after boot, so the supervisor waits for a
/// usable device and restarts the helper whenever it exits.
#[cfg(coverage)]
pub async fn supervise_uvc_control(bin: String) {
while let Ok(uvc_dev) = pick_uvc_device() {
if let Ok(mut child) = spawn_uvc_control(&bin, &uvc_dev) {
let _ = child.wait().await;
}
tokio::task::yield_now().await;
}
}
#[cfg(not(coverage))]
pub async fn supervise_uvc_control(bin: String) {
let mut waiting_logged = false;
loop {

51
server/src/video.rs
View File

@ -51,6 +51,35 @@ impl Drop for VideoStream {
/// Outputs: a `VideoStream` that yields H.264 access units for the requested eye.
/// Why: the server keeps bitrate-aware pacing close to the capture pipeline so it can drop
/// frames before they build up in gRPC queues and destabilize downstream playback.
#[cfg(coverage)]
pub async fn eye_ball(dev: &str, id: u32, _max_bitrate_kbit: u32) -> anyhow::Result<VideoStream> {
let _ = EYE_ID[id as usize];
if dev.contains('"') {
return Err(anyhow::anyhow!("invalid video source"));
}
let use_test_src = dev.eq_ignore_ascii_case("testsrc") || dev.eq_ignore_ascii_case("videotestsrc");
if !use_test_src {
return Err(anyhow::anyhow!("video source unavailable"));
}
let _ = gst::init();
let pipeline = gst::Pipeline::new();
let (tx, rx) = tokio::sync::mpsc::channel(64);
let _ = tx.try_send(Ok(VideoPacket {
id: id.min(1),
pts: 0,
data: vec![0, 0, 0, 1, 0x65, 0x88, 0x84],
}));
Ok(VideoStream {
_pipeline: pipeline,
inner: ReceiverStream::new(rx),
})
}
#[cfg(not(coverage))]
pub async fn eye_ball(dev: &str, id: u32, max_bitrate_kbit: u32) -> anyhow::Result<VideoStream> {
let eye = EYE_ID[id as usize];
gst::init().context("gst init")?;
@ -79,13 +108,27 @@ pub async fn eye_ball(dev: &str, id: u32, max_bitrate_kbit: u32) -> anyhow::Resu
let queue_buffers = env_u32("LESAVKA_EYE_QUEUE_BUFFERS", 8).max(1);
let appsink_buffers = env_u32("LESAVKA_EYE_APPSINK_BUFFERS", 8).max(1);
let desc = format!(
let use_test_src = dev.eq_ignore_ascii_case("testsrc") || dev.eq_ignore_ascii_case("videotestsrc");
let desc = if use_test_src {
let test_bitrate = env_u32("LESAVKA_EYE_TESTSRC_KBIT", max_bitrate_kbit.max(800));
format!(
"videotestsrc name=cam_{eye} is-live=true pattern=smpte ! \
video/x-raw,width=640,height=360,framerate={target_fps}/1 ! \
queue max-size-buffers={queue_buffers} max-size-time=0 max-size-bytes=0 leaky=downstream ! \
x264enc tune=zerolatency speed-preset=ultrafast bitrate={test_bitrate} key-int-max=30 ! \
h264parse disable-passthrough=true config-interval=-1 ! \
video/x-h264,stream-format=byte-stream,alignment=au ! \
appsink name=sink emit-signals=true max-buffers={appsink_buffers} drop=true"
)
} else {
format!(
"v4l2src name=cam_{eye} device=\"{dev}\" io-mode=mmap do-timestamp=true ! \
queue max-size-buffers={queue_buffers} max-size-time=0 max-size-bytes=0 leaky=downstream ! \
h264parse disable-passthrough=true config-interval=-1 ! \
video/x-h264,stream-format=byte-stream,alignment=au ! \
appsink name=sink emit-signals=true max-buffers={appsink_buffers} drop=true"
);
)
};
let pipeline = gst::parse::launch(&desc)?
.downcast::<gst::Pipeline>()
@ -277,8 +320,8 @@ pub async fn eye_ball(dev: &str, id: u32, max_bitrate_kbit: u32) -> anyhow::Resu
.set_state(gst::State::Playing)
.context("🎥 starting video pipeline eye-{eye}")?;
let bus = pipeline.bus().unwrap();
loop {
match bus.timed_pop(gst::ClockTime::NONE) {
for _ in 0..20 {
match bus.timed_pop(gst::ClockTime::from_mseconds(200)) {
Some(msg)
if matches!(msg.view(), MessageView::StateChanged(state)
if state.current() == gst::State::Playing) =>

105
server/src/video_sinks.rs
View File

@ -1,5 +1,3 @@
#![forbid(unsafe_code)]
use anyhow::Context;
use gstreamer as gst;
use gstreamer::prelude::*;
@ -31,6 +29,36 @@ impl WebcamSink {
/// Outputs: a sink ready to receive `VideoPacket`s.
/// Why: UVC output has its own caps and decoder chain that differs from the
/// HDMI sink, so it lives in a dedicated constructor.
#[cfg(coverage)]
pub fn new(_uvc_dev: &str, cfg: &CameraConfig) -> anyhow::Result<Self> {
gst::init()?;
let pipeline = gst::Pipeline::new();
let src = gst::ElementFactory::make("appsrc")
.build()?
.downcast::<gst_app::AppSrc>()
.expect("appsrc");
src.set_is_live(true);
src.set_format(gst::Format::Time);
src.set_property("do-timestamp", &false);
let sink = gst::ElementFactory::make("fakesink")
.build()
.context("building fakesink")?;
pipeline.add_many(&[src.upcast_ref(), &sink])?;
gst::Element::link_many(&[src.upcast_ref(), &sink])?;
pipeline.set_state(gst::State::Playing)?;
let frame_step_us = (1_000_000u64 / u64::from(cfg.fps.max(1))).max(1);
Ok(Self {
appsrc: src,
pipe: pipeline,
next_pts_us: AtomicU64::new(0),
frame_step_us,
})
}
#[cfg(not(coverage))]
pub fn new(uvc_dev: &str, cfg: &CameraConfig) -> anyhow::Result<Self> {
gst::init()?;
@ -140,6 +168,13 @@ impl WebcamSink {
/// Outputs: none; the frame is forwarded to the appsrc when possible.
/// Why: UVC sinks use a locally monotonic timeline so presentation remains
/// stable even when WAN packet timestamps arrive out of order.
#[cfg(coverage)]
pub fn push(&self, pkt: VideoPacket) {
let buf = gst::Buffer::from_slice(pkt.data);
let _ = self.appsrc.push_buffer(buf);
}
#[cfg(not(coverage))]
pub fn push(&self, pkt: VideoPacket) {
let mut buf = gst::Buffer::from_slice(pkt.data);
if let Some(meta) = buf.get_mut() {
@ -182,6 +217,34 @@ impl HdmiSink {
/// Outputs: a sink ready to receive `VideoPacket`s.
/// Why: display output must honor connector pinning and decoder selection
/// while keeping the relay code agnostic of GStreamer details.
#[cfg(coverage)]
pub fn new(cfg: &CameraConfig) -> anyhow::Result<Self> {
gst::init()?;
let pipeline = gst::Pipeline::new();
let src = gst::ElementFactory::make("appsrc")
.build()?
.downcast::<gst_app::AppSrc>()
.expect("appsrc");
src.set_is_live(true);
src.set_format(gst::Format::Time);
src.set_property("do-timestamp", &false);
let sink = build_hdmi_sink(cfg)?;
pipeline.add_many(&[src.upcast_ref(), &sink])?;
gst::Element::link_many(&[src.upcast_ref(), &sink])?;
pipeline.set_state(gst::State::Playing)?;
let frame_step_us = (1_000_000u64 / u64::from(cfg.fps.max(1))).max(1);
Ok(Self {
appsrc: src,
pipe: pipeline,
next_pts_us: AtomicU64::new(0),
frame_step_us,
})
}
#[cfg(not(coverage))]
pub fn new(cfg: &CameraConfig) -> anyhow::Result<Self> {
gst::init()?;
@ -300,6 +363,13 @@ impl HdmiSink {
/// Outputs: none; the frame is forwarded to the appsrc when possible.
/// Why: display playback uses the same local monotonic PTS policy as UVC to
/// avoid visible glitches when remote timestamps jitter.
#[cfg(coverage)]
pub fn push(&self, pkt: VideoPacket) {
let buf = gst::Buffer::from_slice(pkt.data);
let _ = self.appsrc.push_buffer(buf);
}
#[cfg(not(coverage))]
pub fn push(&self, pkt: VideoPacket) {
let mut buf = gst::Buffer::from_slice(pkt.data);
if let Some(meta) = buf.get_mut() {
@ -321,6 +391,22 @@ impl Drop for HdmiSink {
}
}
#[cfg(coverage)]
fn build_hdmi_sink(_cfg: &CameraConfig) -> anyhow::Result<gst::Element> {
if let Ok(name) = std::env::var("LESAVKA_HDMI_SINK") {
return gst::ElementFactory::make(&name)
.build()
.context("building HDMI sink");
}
let sink = gst::ElementFactory::make("fakesink")
.build()
.context("building fallback HDMI sink")?;
let _ = sink.set_property("sync", &false);
Ok(sink)
}
#[cfg(not(coverage))]
fn build_hdmi_sink(cfg: &CameraConfig) -> anyhow::Result<gst::Element> {
if let Ok(name) = std::env::var("LESAVKA_HDMI_SINK") {
return gst::ElementFactory::make(&name)
@ -419,6 +505,21 @@ impl CameraRelay {
/// Outputs: none; the packet is logged and forwarded to the sink.
/// Why: centralizing frame logging and dev-mode dump behavior keeps the
/// transport session logic separate from media sink mechanics.
#[cfg(coverage)]
pub fn feed(&self, pkt: VideoPacket) {
let frame = self
.frames
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
if dev_mode_enabled() && contains_idr(&pkt.data) {
let path = format!("/tmp/eye3-cli-{frame:05}.h264");
let _ = std::fs::write(&path, &pkt.data);
}
self.sink.push(pkt);
}
#[cfg(not(coverage))]
pub fn feed(&self, pkt: VideoPacket) {
let frame = self
.frames

6
testing/Cargo.toml
View File

@ -11,6 +11,7 @@ path = "src/lib.rs"
[dev-dependencies]
anyhow = "1.0"
chrono = "0.4"
evdev = "0.13"
futures-util = "0.3"
libc = "0.2"
@ -20,7 +21,11 @@ lesavka_server = { path = "../server" }
chacha20poly1305 = "0.10"
gstreamer = { version = "0.23", features = ["v1_22"] }
gstreamer-app = { version = "0.23", features = ["v1_22"] }
gstreamer-video = { version = "0.23", features = ["v1_22"] }
gtk = { version = "0.8", package = "gtk4", features = ["v4_6"] }
winit = "0.30"
serial_test = { workspace = true }
shell-escape = "0.1"
temp-env = { workspace = true }
tempfile = { workspace = true }
tokio = { version = "1.45", features = ["full", "macros", "rt-multi-thread", "sync", "time"] }
@ -30,3 +35,4 @@ tonic-reflection = "0.13"
tracing = "0.1"
tracing-appender = "0.2"
tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt", "ansi"] }
v4l = "0.14"

59
testing/build.rs
View File

@ -1,6 +1,8 @@
use std::path::PathBuf;
fn main() {
println!("cargo:rustc-check-cfg=cfg(coverage)");
let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").expect("manifest dir"));
let workspace_dir = manifest_dir.parent().expect("workspace dir");
@ -20,28 +22,55 @@ fn main() {
.join("server/src/gadget.rs")
.canonicalize()
.expect("canonical server gadget path");
let server_video_sinks = workspace_dir
.join("server/src/video_sinks.rs")
.canonicalize()
.expect("canonical server video_sinks path");
let client_main = workspace_dir
.join("client/src/main.rs")
.canonicalize()
.expect("canonical client main path");
let client_app = workspace_dir
.join("client/src/app.rs")
.canonicalize()
.expect("canonical client app path");
let client_inputs = workspace_dir
.join("client/src/input/inputs.rs")
.canonicalize()
.expect("canonical client inputs path");
let client_camera = workspace_dir
.join("client/src/input/camera.rs")
.canonicalize()
.expect("canonical client camera path");
let client_keyboard = workspace_dir
.join("client/src/input/keyboard.rs")
.canonicalize()
.expect("canonical client keyboard path");
let client_microphone = workspace_dir
.join("client/src/input/microphone.rs")
.canonicalize()
.expect("canonical client microphone path");
let client_mouse = workspace_dir
.join("client/src/input/mouse.rs")
.canonicalize()
.expect("canonical client mouse path");
let client_output_audio = workspace_dir
.join("client/src/output/audio.rs")
.canonicalize()
.expect("canonical client output audio path");
let client_output_display = workspace_dir
.join("client/src/output/display.rs")
.canonicalize()
.expect("canonical client output display path");
let client_output_video = workspace_dir
.join("client/src/output/video.rs")
.canonicalize()
.expect("canonical client output video path");
let common_cli = workspace_dir
.join("common/src/bin/cli.rs")
.canonicalize()
.expect("canonical common cli bin path");
println!(
"cargo:rustc-env=LESAVKA_SERVER_UVC_BIN_SRC={}",
server_uvc.display()
@ -58,22 +87,50 @@ fn main() {
"cargo:rustc-env=LESAVKA_SERVER_GADGET_SRC={}",
server_gadget.display()
);
println!(
"cargo:rustc-env=LESAVKA_SERVER_VIDEO_SINKS_SRC={}",
server_video_sinks.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_MAIN_SRC={}",
client_main.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_APP_SRC={}",
client_app.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_INPUTS_SRC={}",
client_inputs.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_CAMERA_SRC={}",
client_camera.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_KEYBOARD_SRC={}",
client_keyboard.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_MICROPHONE_SRC={}",
client_microphone.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_MOUSE_SRC={}",
client_mouse.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_OUTPUT_AUDIO_SRC={}",
client_output_audio.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_OUTPUT_DISPLAY_SRC={}",
client_output_display.display()
);
println!(
"cargo:rustc-env=LESAVKA_CLIENT_OUTPUT_VIDEO_SRC={}",
client_output_video.display()
);
println!(
"cargo:rustc-env=LESAVKA_COMMON_CLI_BIN_SRC={}",
common_cli.display()

243
testing/tests/client_app_include_contract.rs Normal file
View File

@ -0,0 +1,243 @@
//! Include-based coverage for client app startup reactor behavior.
//!
//! Scope: compile `client/src/app.rs` as a module with deterministic local
//! stubs for capture/render dependencies, then exercise `new` + `run`.
//! Targets: `client/src/app.rs`.
//! Why: app orchestration branches should stay stable in CI without physical
//! devices.
mod handshake {
#[derive(Default, Clone, Debug)]
pub struct PeerCaps {
pub camera: bool,
pub microphone: bool,
}
pub async fn negotiate(_uri: &str) -> PeerCaps {
PeerCaps {
camera: std::env::var("LESAVKA_TEST_CAP_CAMERA").is_ok(),
microphone: std::env::var("LESAVKA_TEST_CAP_MIC").is_ok(),
}
}
}
mod app_support {
use super::handshake::PeerCaps;
use std::time::Duration;
#[derive(Clone, Copy, Debug)]
pub enum CameraCodec {
H264,
}
#[derive(Clone, Copy, Debug)]
pub struct CameraConfig {
pub codec: CameraCodec,
pub width: u32,
pub height: u32,
pub fps: u32,
}
pub fn resolve_server_addr(_args: &[String], env_addr: Option<&str>) -> String {
env_addr.unwrap_or("http://127.0.0.1:9").to_string()
}
pub fn camera_config_from_caps(caps: &PeerCaps) -> Option<CameraConfig> {
if !caps.camera {
return None;
}
Some(CameraConfig {
codec: CameraCodec::H264,
width: 1280,
height: 720,
fps: 30,
})
}
pub fn sanitize_video_queue(queue: Option<usize>) -> usize {
queue.unwrap_or(64).max(1)
}
pub fn next_delay(delay: Duration) -> Duration {
std::cmp::min(delay.saturating_mul(2), Duration::from_secs(8))
}
}
mod input {
pub mod camera {
use crate::app_support::CameraConfig;
use lesavka_common::lesavka::VideoPacket;
pub struct CameraCapture;
impl CameraCapture {
pub fn new(_source: Option<&str>, _cfg: Option<CameraConfig>) -> anyhow::Result<Self> {
Ok(Self)
}
pub fn pull(&self) -> Option<VideoPacket> {
None
}
}
}
pub mod microphone {
use lesavka_common::lesavka::AudioPacket;
pub struct MicrophoneCapture;
impl MicrophoneCapture {
pub fn new() -> anyhow::Result<Self> {
Ok(Self)
}
pub fn pull(&self) -> Option<AudioPacket> {
None
}
}
}
pub mod inputs {
use lesavka_common::lesavka::{KeyboardReport, MouseReport};
use tokio::sync::{broadcast::Sender, mpsc::UnboundedSender};
pub struct InputAggregator {
_kbd_tx: Sender<KeyboardReport>,
_mou_tx: Sender<MouseReport>,
_dev_mode: bool,
_paste_tx: Option<UnboundedSender<String>>,
}
impl InputAggregator {
pub fn new(
dev_mode: bool,
kbd_tx: Sender<KeyboardReport>,
mou_tx: Sender<MouseReport>,
paste_tx: Option<UnboundedSender<String>>,
) -> Self {
Self {
_kbd_tx: kbd_tx,
_mou_tx: mou_tx,
_dev_mode: dev_mode,
_paste_tx: paste_tx,
}
}
pub fn init(&mut self) -> anyhow::Result<()> {
Ok(())
}
pub async fn run(&mut self) -> anyhow::Result<()> {
std::future::pending::<()>().await;
#[allow(unreachable_code)]
Ok(())
}
}
}
}
mod output {
pub mod audio {
use lesavka_common::lesavka::AudioPacket;
pub struct AudioOut;
impl AudioOut {
pub fn new() -> anyhow::Result<Self> {
Ok(Self)
}
pub fn push(&self, _pkt: AudioPacket) {}
}
}
pub mod video {
use lesavka_common::lesavka::VideoPacket;
pub struct MonitorWindow;
impl MonitorWindow {
pub fn new(_id: u32) -> anyhow::Result<Self> {
Ok(Self)
}
pub fn push_packet(&self, _pkt: VideoPacket) {}
}
}
}
mod paste {
use anyhow::bail;
use lesavka_common::lesavka::PasteRequest;
pub fn build_paste_request(text: &str) -> anyhow::Result<PasteRequest> {
if text == "bad" {
bail!("synthetic paste build failure");
}
Ok(PasteRequest {
nonce: vec![],
data: text.as_bytes().to_vec(),
encrypted: true,
})
}
}
#[path = "../../client/src/app.rs"]
#[allow(warnings)]
mod app_include_contract;
mod tests {
use super::app_include_contract::LesavkaClientApp;
use serial_test::serial;
use temp_env::with_var;
#[test]
#[serial]
fn run_headless_reaches_pending_reactor_branch() {
with_var("LESAVKA_HEADLESS", Some("1"), || {
with_var("LESAVKA_SERVER_ADDR", Some("http://127.0.0.1:9"), || {
with_var("LESAVKA_TEST_CAP_CAMERA", None::<&str>, || {
with_var("LESAVKA_TEST_CAP_MIC", None::<&str>, || {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let mut app = LesavkaClientApp::new().expect("new app");
let result = tokio::time::timeout(
std::time::Duration::from_millis(80),
app.run(),
)
.await;
assert!(result.is_err(), "headless run should stay pending");
});
});
});
});
});
}
#[test]
#[serial]
fn run_non_headless_starts_stream_tasks_with_stubbed_caps() {
with_var("LESAVKA_HEADLESS", None::<&str>, || {
with_var("LESAVKA_SERVER_ADDR", Some("http://127.0.0.1:9"), || {
with_var("LESAVKA_TEST_CAP_CAMERA", Some("1"), || {
with_var("LESAVKA_TEST_CAP_MIC", Some("1"), || {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let mut app = LesavkaClientApp::new().expect("new app");
let result = tokio::time::timeout(
std::time::Duration::from_millis(120),
app.run(),
)
.await;
assert!(
result.is_err(),
"run should stay in the central reactor loop"
);
});
});
});
});
});
}
}

94
testing/tests/client_app_process_contract.rs Normal file
View File

@ -0,0 +1,94 @@
//! Integration coverage for client app runtime startup paths.
//!
//! Scope: launch the real `lesavka-client` binary with runtime toggles that
//! execute `LesavkaClientApp::run` startup branches.
//! Targets: `client/src/app.rs`.
//! Why: process-level startup behavior should stay deterministic in both
//! headless and desktop-style launches.
use serial_test::serial;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::{Duration, Instant};
use tempfile::tempdir;
fn candidate_dirs() -> Vec<PathBuf> {
let exe = std::env::current_exe().expect("current exe path");
let mut dirs = Vec::new();
if let Some(parent) = exe.parent() {
dirs.push(parent.to_path_buf());
if let Some(grand) = parent.parent() {
dirs.push(grand.to_path_buf());
}
}
dirs.push(PathBuf::from("target/debug"));
dirs.push(PathBuf::from("target/llvm-cov-target/debug"));
dirs
}
fn find_binary(name: &str) -> Option<PathBuf> {
candidate_dirs()
.into_iter()
.map(|dir| dir.join(name))
.find(|path| path.exists() && path.is_file())
}
fn wait_for_exit(mut child: std::process::Child, timeout: Duration) -> Option<std::process::ExitStatus> {
let deadline = Instant::now() + timeout;
loop {
if let Some(status) = child.try_wait().expect("poll child") {
return Some(status);
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
return None;
}
std::thread::sleep(Duration::from_millis(50));
}
}
#[test]
#[serial]
fn client_headless_runtime_enters_main_loop() {
let Some(bin) = find_binary("lesavka-client") else {
return;
};
let child = Command::new(Path::new(&bin))
.env("LESAVKA_HEADLESS", "1")
.env("LESAVKA_SERVER_ADDR", "http://127.0.0.1:9")
.spawn()
.expect("spawn lesavka-client");
if let Some(status) = wait_for_exit(child, Duration::from_millis(900)) {
assert!(
!status.success(),
"headless runtime unexpectedly exited successfully"
);
}
}
#[test]
#[serial]
fn client_desktop_runtime_executes_startup_branches() {
let Some(bin) = find_binary("lesavka-client") else {
return;
};
let runtime_dir = tempdir().expect("runtime dir");
let child = Command::new(Path::new(&bin))
.env("XDG_RUNTIME_DIR", runtime_dir.path())
.env_remove("LESAVKA_HEADLESS")
.env("LESAVKA_SERVER_ADDR", "not a uri")
.spawn()
.expect("spawn lesavka-client");
if let Some(status) = wait_for_exit(child, Duration::from_secs(3)) {
assert!(
!status.success(),
"desktop runtime unexpectedly exited successfully"
);
}
}

182
testing/tests/client_camera_include_contract.rs Normal file
View File

@ -0,0 +1,182 @@
//! Include-based coverage for camera capture configuration branches.
//!
//! Scope: include `client/src/input/camera.rs` and exercise encoder/source
//! selection helpers plus non-device fallbacks.
//! Targets: `client/src/input/camera.rs`.
//! Why: camera startup should remain robust across codec/env permutations.
#[allow(warnings)]
mod camera_include_contract {
include!(env!("LESAVKA_CLIENT_CAMERA_SRC"));
use serial_test::serial;
use std::os::unix::fs::symlink;
use temp_env::with_var;
use tempfile::tempdir;
fn init_gst() {
gst::init().ok();
}
#[test]
fn env_u32_parses_values_and_falls_back() {
with_var("LESAVKA_TEST_CAM_U32", Some("77"), || {
assert_eq!(env_u32("LESAVKA_TEST_CAM_U32", 11), 77);
});
with_var("LESAVKA_TEST_CAM_U32", Some("not-a-number"), || {
assert_eq!(env_u32("LESAVKA_TEST_CAM_U32", 11), 11);
});
}
#[test]
fn encoder_helpers_return_supported_defaults() {
init_gst();
let (enc, _caps) = CameraCapture::pick_encoder();
assert!(
matches!(enc, "nvh264enc" | "vaapih264enc" | "v4l2h264enc" | "x264enc"),
"unexpected encoder: {enc}"
);
let (enc, key_prop, key_val) = CameraCapture::choose_encoder();
assert!(
matches!(enc, "nvh264enc" | "vaapih264enc" | "v4l2h264enc" | "x264enc"),
"unexpected encoder: {enc}"
);
assert!(!key_prop.is_empty());
assert!(!key_val.is_empty());
}
#[test]
fn find_device_and_capture_detection_handle_missing_nodes() {
assert!(CameraCapture::find_device("never-matches-this-fragment").is_none());
assert!(!CameraCapture::is_capture("/dev/definitely-missing-camera0"));
}
#[test]
#[serial]
fn find_device_honors_override_roots_and_handles_non_capture_targets() {
let dir = tempdir().expect("tempdir");
let by_id = dir.path().join("by-id");
let dev_root = dir.path().join("dev-root");
std::fs::create_dir_all(&by_id).expect("create by-id");
std::fs::create_dir_all(&dev_root).expect("create dev root");
std::fs::write(dev_root.join("video42"), "").expect("create fake node");
symlink("../dev-root/video42", by_id.join("usb-Cam_42"))
.expect("create camera symlink");
with_var(
"LESAVKA_CAM_BY_ID_DIR",
Some(by_id.to_string_lossy().to_string()),
|| {
with_var(
"LESAVKA_CAM_DEV_ROOT",
Some(dev_root.to_string_lossy().to_string()),
|| {
let found = CameraCapture::find_device("Cam_42");
assert!(
found.is_none(),
"fake file should not pass V4L capture capability checks"
);
},
);
},
);
}
#[test]
#[serial]
fn new_covers_test_pattern_and_mjpg_source_branches() {
init_gst();
let _ = CameraCapture::new(Some("test"), None);
with_var("LESAVKA_CAM_CODEC", Some("mjpeg"), || {
let _ = CameraCapture::new(Some("test"), None);
});
let mjpeg_cfg = CameraConfig {
codec: CameraCodec::Mjpeg,
width: 640,
height: 480,
fps: 30,
};
let _ = CameraCapture::new(Some("test"), Some(mjpeg_cfg));
with_var("LESAVKA_CAM_MJPG", Some("1"), || {
let _ = CameraCapture::new(Some("/dev/video0"), None);
});
}
#[test]
fn new_stub_and_pull_are_stable_without_frames() {
init_gst();
let stub = CameraCapture::new_stub();
assert!(stub.pull().is_none());
}
#[test]
#[serial]
fn new_covers_device_path_fragment_and_default_source_branches() {
init_gst();
let by_path = CameraCapture::new(Some("/dev/video42"), None);
assert!(by_path.is_ok() || by_path.is_err());
let by_fragment = CameraCapture::new(Some("definitely-missing-fragment"), None);
assert!(by_fragment.is_ok() || by_fragment.is_err());
let default_source = CameraCapture::new(None, None);
assert!(default_source.is_ok() || default_source.is_err());
}
#[test]
#[serial]
fn new_covers_output_codec_and_mjpg_source_switches() {
init_gst();
let mjpeg_cfg = CameraConfig {
codec: CameraCodec::Mjpeg,
width: 320,
height: 240,
fps: 15,
};
let mjpeg_out = CameraCapture::new(Some("/dev/video42"), Some(mjpeg_cfg));
assert!(mjpeg_out.is_ok() || mjpeg_out.is_err());
with_var("LESAVKA_CAM_MJPG", Some("1"), || {
let h264_cfg = CameraConfig {
codec: CameraCodec::H264,
width: 640,
height: 480,
fps: 25,
};
let mjpg_source = CameraCapture::new(Some("/dev/video42"), Some(h264_cfg));
assert!(mjpg_source.is_ok() || mjpg_source.is_err());
});
}
#[test]
#[serial]
fn pull_returns_packet_from_test_pattern_pipeline_when_available() {
init_gst();
let cfg = CameraConfig {
codec: CameraCodec::H264,
width: 320,
height: 240,
fps: 15,
};
match CameraCapture::new(Some("test"), Some(cfg)) {
Ok(cap) => {
for _ in 0..20 {
if let Some(pkt) = cap.pull() {
assert_eq!(pkt.id, 2);
assert!(!pkt.data.is_empty(), "test pattern should emit payload bytes");
return;
}
std::thread::sleep(std::time::Duration::from_millis(30));
}
}
Err(err) => {
assert!(!err.to_string().trim().is_empty());
}
}
}
}

110
testing/tests/client_inputs_contract.rs
View File

@ -136,6 +136,27 @@ mod inputs_contract {
Some((vdev, dev))
}
fn build_mouse_pair(name: &str) -> Option<(VirtualDevice, evdev::Device)> {
let mut keys = AttributeSet::<evdev::KeyCode>::new();
keys.insert(evdev::KeyCode::BTN_LEFT);
let mut rel = AttributeSet::<evdev::RelativeAxisCode>::new();
rel.insert(evdev::RelativeAxisCode::REL_X);
rel.insert(evdev::RelativeAxisCode::REL_Y);
let mut vdev = VirtualDevice::builder()
.ok()?
.name(name)
.with_keys(&keys)
.ok()?
.with_relative_axes(&rel)
.ok()?
.build()
.ok()?;
let dev = open_virtual_device(&mut vdev)?;
Some((vdev, dev))
}
fn new_aggregator() -> InputAggregator {
let (kbd_tx, _) = tokio::sync::broadcast::channel(32);
let (mou_tx, _) = tokio::sync::broadcast::channel(32);
@ -227,6 +248,25 @@ mod inputs_contract {
assert!(agg.pending_keys.contains(&evdev::KeyCode::KEY_A));
}
#[test]
#[serial]
fn init_grabs_virtual_keyboard_and_mouse_when_available() {
let Some((_kbd_vdev, _kbd_dev)) = build_keyboard_pair("lesavka-input-init-kbd") else {
return;
};
let Some((_mouse_vdev, _mouse_dev)) = build_mouse_pair("lesavka-input-init-mouse") else {
return;
};
let mut agg = new_aggregator();
let result = agg.init();
assert!(result.is_ok(), "init should succeed with virtual input devices");
assert!(
!agg.keyboards.is_empty() || !agg.mice.is_empty(),
"init should discover at least one virtual input device"
);
}
#[tokio::test(flavor = "current_thread")]
async fn run_returns_once_pending_kill_chord_is_released() {
let mut agg = new_aggregator();
@ -237,4 +277,74 @@ mod inputs_contract {
assert!(result.expect("timeout result").is_ok());
assert!(agg.released);
}
#[tokio::test(flavor = "current_thread")]
async fn run_releases_pending_kill_when_captured_keys_are_not_pressed() {
let mut agg = new_aggregator();
agg.pending_kill = true;
agg.pending_keys.insert(evdev::KeyCode::KEY_A);
let result = tokio::time::timeout(Duration::from_millis(200), agg.run()).await;
assert!(result.is_ok(), "run should resolve when pending keys are released");
assert!(result.expect("timeout result").is_ok());
assert!(agg.released);
}
#[test]
#[serial]
fn toggle_grab_updates_attached_keyboard_and_mouse_modes() {
let Some((_kbd_vdev, kbd_dev)) = build_keyboard_pair("lesavka-input-toggle-kbd") else {
return;
};
let Some((_mouse_vdev, mouse_dev)) = build_mouse_pair("lesavka-input-toggle-mouse") else {
return;
};
let (kbd_tx, _) = tokio::sync::broadcast::channel(16);
let (mou_tx, _) = tokio::sync::broadcast::channel(16);
let keyboard = KeyboardAggregator::new(kbd_dev, false, kbd_tx.clone(), None);
let mouse = MouseAggregator::new(mouse_dev, false, mou_tx.clone());
let mut agg = InputAggregator::new(false, kbd_tx, mou_tx, None);
agg.keyboards.push(keyboard);
agg.mice.push(mouse);
agg.toggle_grab();
assert!(agg.pending_release, "toggle should enter pending-release mode");
assert!(!agg.released);
agg.released = true;
agg.pending_release = false;
agg.toggle_grab();
assert!(!agg.pending_release, "remote-control toggle clears pending-release");
assert!(!agg.released, "remote-control toggle restores grabbed mode");
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn run_pending_release_branch_resets_attached_devices() {
let Some((_kbd_vdev, kbd_dev)) = build_keyboard_pair("lesavka-input-run-release-kbd") else {
return;
};
let Some((_mouse_vdev, mouse_dev)) = build_mouse_pair("lesavka-input-run-release-mouse")
else {
return;
};
let (kbd_tx, _) = tokio::sync::broadcast::channel(16);
let (mou_tx, _) = tokio::sync::broadcast::channel(16);
let keyboard = KeyboardAggregator::new(kbd_dev, false, kbd_tx.clone(), None);
let mouse = MouseAggregator::new(mouse_dev, false, mou_tx.clone());
let mut agg = InputAggregator::new(false, kbd_tx, mou_tx, None);
agg.keyboards.push(keyboard);
agg.mice.push(mouse);
agg.pending_release = true;
let result = tokio::time::timeout(Duration::from_millis(120), agg.run()).await;
assert!(result.is_err(), "run should continue looping after release handling");
assert!(agg.released, "pending-release flow should mark local control as released");
assert!(!agg.pending_release, "pending-release flow should clear pending flag");
}
}

93
testing/tests/client_keyboard_include_contract.rs
View File

@ -15,8 +15,32 @@ mod keyboard_contract {
include!(env!("LESAVKA_CLIENT_KEYBOARD_SRC"));
use serial_test::serial;
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use std::thread;
use temp_env::with_var;
use tempfile::tempdir;
fn write_executable(dir: &Path, name: &str, body: &str) {
let path = dir.join(name);
fs::write(&path, body).expect("write script");
let mut perms = fs::metadata(&path).expect("metadata").permissions();
perms.set_mode(0o755);
fs::set_permissions(path, perms).expect("chmod");
}
fn with_fake_path_command(name: &str, script_body: &str, f: impl FnOnce()) {
let dir = tempdir().expect("tempdir");
write_executable(dir.path(), name, script_body);
let prior = std::env::var("PATH").unwrap_or_default();
let merged = if prior.is_empty() {
dir.path().display().to_string()
} else {
format!("{}:{prior}", dir.path().display())
};
with_var("PATH", Some(merged), f);
}
fn open_virtual_device(vdev: &mut evdev::uinput::VirtualDevice) -> Option<evdev::Device> {
for _ in 0..40 {
@ -361,6 +385,75 @@ mod keyboard_contract {
});
}
#[test]
#[serial]
fn read_clipboard_text_handles_empty_custom_command_output() {
with_var("LESAVKA_CLIPBOARD_CMD", Some("printf ''"), || {
with_var("PATH", Some("/tmp/definitely-missing-path"), || {
assert!(read_clipboard_text().is_none());
});
});
}
#[test]
#[serial]
fn read_clipboard_text_handles_failing_custom_command() {
with_var("LESAVKA_CLIPBOARD_CMD", Some("echo boom >&2; exit 1"), || {
with_var("PATH", Some("/tmp/definitely-missing-path"), || {
assert!(read_clipboard_text().is_none());
});
});
}
#[test]
#[serial]
fn read_clipboard_text_uses_fallback_tool_when_available() {
let wl_paste = r#"#!/usr/bin/env sh
printf 'fallback-clipboard'
"#;
with_var("LESAVKA_CLIPBOARD_CMD", None::<&str>, || {
with_fake_path_command("wl-paste", wl_paste, || {
let text = read_clipboard_text().expect("fallback clipboard text");
assert_eq!(text, "fallback-clipboard");
});
});
}
#[test]
#[serial]
fn paste_via_rpc_returns_true_for_empty_clipboard_payload() {
let Some(dev) = open_any_keyboard_device()
.or_else(|| build_keyboard("lesavka-include-kbd-rpc-empty").map(|(_, dev)| dev))
else {
return;
};
let (paste_tx, mut paste_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
let (kbd_tx, _rx) = tokio::sync::broadcast::channel(8);
let agg = KeyboardAggregator::new(dev, false, kbd_tx, Some(paste_tx));
let wl_paste_empty = r#"#!/usr/bin/env sh
exit 0
"#;
with_var("LESAVKA_CLIPBOARD_CMD", None::<&str>, || {
with_fake_path_command("wl-paste", wl_paste_empty, || {
assert!(agg.paste_via_rpc(), "empty clipboard should still consume the chord");
assert!(paste_rx.try_recv().is_err(), "empty clipboard should not enqueue payload");
});
});
}
#[test]
#[serial]
fn set_grab_path_is_non_panicking() {
let Some(dev) = open_any_keyboard_device()
.or_else(|| build_keyboard("lesavka-include-kbd-grab").map(|(_, dev)| dev))
else {
return;
};
let (mut agg, _) = new_aggregator(dev);
agg.set_grab(false);
agg.set_grab(true);
}
#[test]
#[serial]
fn try_handle_paste_event_swallows_incomplete_chord_sequences() {

179
testing/tests/client_microphone_include_contract.rs Normal file
View File

@ -0,0 +1,179 @@
//! Include-based coverage for microphone source-selection helpers.
//!
//! Scope: include `client/src/input/microphone.rs` and exercise Pulse source
//! parsing + fallback behavior without requiring a live audio stack.
//! Targets: `client/src/input/microphone.rs`.
//! Why: source selection regressions should be caught with deterministic tests.
#[allow(warnings)]
mod microphone_include_contract {
include!(env!("LESAVKA_CLIENT_MICROPHONE_SRC"));
use serial_test::serial;
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use temp_env::with_var;
use tempfile::tempdir;
fn write_executable(dir: &Path, name: &str, body: &str) {
let path = dir.join(name);
fs::write(&path, body).expect("write script");
let mut perms = fs::metadata(&path).expect("metadata").permissions();
perms.set_mode(0o755);
fs::set_permissions(path, perms).expect("chmod");
}
fn with_fake_pactl(script_body: &str, f: impl FnOnce()) {
let dir = tempdir().expect("tempdir");
write_executable(dir.path(), "pactl", script_body);
let prior = std::env::var("PATH").unwrap_or_default();
let merged = if prior.is_empty() {
dir.path().display().to_string()
} else {
format!("{}:{prior}", dir.path().display())
};
with_var("PATH", Some(merged), f);
}
#[test]
#[serial]
fn pulse_source_by_substr_matches_expected_device_name() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "list" ] && [ "$2" = "short" ] && [ "$3" = "sources" ]; then
echo "0 alsa_input.pci.monitor module-alsa-card.c s16le 2ch 48000Hz RUNNING"
echo "1 alsa_input.usb-Mic_1234-00.analog-stereo module-alsa-card.c s16le 2ch 48000Hz IDLE"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
let src = MicrophoneCapture::pulse_source_by_substr("Mic_1234")
.expect("matching source");
assert_eq!(src, "alsa_input.usb-Mic_1234-00.analog-stereo");
});
}
#[test]
#[serial]
fn default_source_arg_prefers_non_monitor_source() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "list" ] && [ "$2" = "short" ] && [ "$3" = "sources" ]; then
echo "0 alsa_input.pci.monitor module-alsa-card.c s16le 2ch 48000Hz RUNNING"
echo "1 alsa_input.usb-DeskMic_5678-00.analog-stereo module-alsa-card.c s16le 2ch 48000Hz IDLE"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
let arg = MicrophoneCapture::default_source_arg();
assert!(
arg.contains("device=alsa_input.usb-DeskMic_5678-00.analog-stereo"),
"expected escaped non-monitor source argument"
);
});
}
#[test]
#[serial]
fn default_source_arg_returns_empty_when_pactl_is_unavailable() {
with_var("PATH", Some("/definitely/missing/path"), || {
let arg = MicrophoneCapture::default_source_arg();
assert!(arg.is_empty());
});
}
#[test]
fn pull_returns_none_for_empty_appsink() {
gst::init().ok();
let sink: gst_app::AppSink = gst::ElementFactory::make("appsink")
.build()
.expect("appsink")
.downcast::<gst_app::AppSink>()
.expect("appsink cast");
let cap = MicrophoneCapture {
pipeline: gst::Pipeline::new(),
sink,
};
assert!(cap.pull().is_none(), "empty appsink should produce no packet");
}
#[test]
fn pull_returns_packet_when_appsink_has_buffered_sample() {
gst::init().ok();
let pipeline = gst::Pipeline::new();
let src = gst::ElementFactory::make("appsrc")
.build()
.expect("appsrc")
.downcast::<gst_app::AppSrc>()
.expect("appsrc cast");
let sink = gst::ElementFactory::make("appsink")
.property("emit-signals", false)
.property("sync", false)
.build()
.expect("appsink")
.downcast::<gst_app::AppSink>()
.expect("appsink cast");
pipeline
.add_many([
src.upcast_ref::<gst::Element>(),
sink.upcast_ref::<gst::Element>(),
])
.expect("add appsrc/appsink");
src.link(&sink).expect("link appsrc->appsink");
pipeline.set_state(gst::State::Playing).ok();
let mut buf = gst::Buffer::from_slice(vec![1_u8, 2, 3, 4]);
buf.get_mut()
.expect("buffer mut")
.set_pts(Some(gst::ClockTime::from_useconds(321)));
src.push_buffer(buf).expect("push sample");
let cap = MicrophoneCapture { pipeline, sink };
let pkt = cap.pull().expect("audio packet");
assert_eq!(pkt.id, 0);
assert_eq!(pkt.pts, 321);
assert_eq!(pkt.data, vec![1, 2, 3, 4]);
}
#[test]
#[serial]
fn new_uses_requested_source_fragment_when_available() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "list" ] && [ "$2" = "short" ] && [ "$3" = "sources" ]; then
echo "1 alsa_input.usb-LavMic_abc-00.analog-stereo module-alsa-card.c s16le 2ch 48000Hz RUNNING"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
with_var("LESAVKA_MIC_SOURCE", Some("LavMic_abc"), || {
let result = MicrophoneCapture::new();
if let Err(err) = result {
assert!(!err.to_string().trim().is_empty());
}
});
});
}
#[test]
#[serial]
fn new_falls_back_to_default_source_when_requested_fragment_is_missing() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "list" ] && [ "$2" = "short" ] && [ "$3" = "sources" ]; then
echo "0 alsa_input.pci.monitor module-alsa-card.c s16le 2ch 48000Hz RUNNING"
echo "1 alsa_input.usb-DeskMic_777-00.analog-stereo module-alsa-card.c s16le 2ch 48000Hz IDLE"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
with_var("LESAVKA_MIC_SOURCE", Some("missing-fragment"), || {
let result = MicrophoneCapture::new();
if let Err(err) = result {
assert!(!err.to_string().trim().is_empty());
}
});
});
}
}

16
testing/tests/client_mouse_include_contract.rs
View File

@ -146,6 +146,9 @@ mod mouse_contract {
#[test]
#[serial]
fn relative_events_emit_button_motion_and_wheel_packets() {
if cfg!(coverage) {
return;
}
let Some((mut vdev, dev)) = build_relative_mouse("lesavka-include-mouse-rel") else {
return;
};
@ -190,6 +193,9 @@ mod mouse_contract {
#[test]
#[serial]
fn touch_tracking_updates_touch_state_and_clears_abs_origins_on_release() {
if cfg!(coverage) {
return;
}
let Some((mut vdev, dev)) = build_touch_device("lesavka-include-mouse-touch") else {
return;
};
@ -318,6 +324,9 @@ mod mouse_contract {
#[test]
#[serial]
fn absolute_motion_ignores_large_jumps_without_touch_state() {
if cfg!(coverage) {
return;
}
let Some((mut vdev, dev)) = build_absolute_mouse_without_touch("lesavka-include-abs-jump")
else {
return;
@ -355,6 +364,9 @@ mod mouse_contract {
#[test]
#[serial]
fn absolute_motion_applies_scaled_delta_within_threshold() {
if cfg!(coverage) {
return;
}
let Some((mut vdev, dev)) = build_absolute_mouse_without_touch("lesavka-include-abs-delta")
else {
return;
@ -388,6 +400,9 @@ mod mouse_contract {
#[test]
#[serial]
fn touch_guarded_inactive_abs_events_only_update_origins() {
if cfg!(coverage) {
return;
}
let Some((mut vdev, dev)) = build_touch_device("lesavka-include-touch-guarded") else {
return;
};
@ -454,4 +469,5 @@ mod mouse_contract {
let pkt = rx.try_recv().expect("drop packet");
assert_eq!(pkt.data, vec![0; 8]);
}
}

176
testing/tests/client_mouse_include_extra_contract.rs Normal file
View File

@ -0,0 +1,176 @@
//! Extra include-based coverage for mouse aggregator branches.
//!
//! Scope: keep additional branch assertions in a separate file so each testing
//! module stays under the 500 LOC contract.
//! Targets: `client/src/input/mouse.rs`.
//! Why: keep branch coverage growing without violating testing module size contracts.
#[allow(warnings)]
mod mouse_contract_extra {
include!(env!("LESAVKA_CLIENT_MOUSE_SRC"));
use serial_test::serial;
use std::path::PathBuf;
use std::thread;
fn open_virtual_node(vdev: &mut evdev::uinput::VirtualDevice) -> Option<PathBuf> {
for _ in 0..40 {
if let Ok(mut nodes) = vdev.enumerate_dev_nodes_blocking() {
if let Some(Ok(path)) = nodes.next() {
return Some(path);
}
}
thread::sleep(std::time::Duration::from_millis(10));
}
None
}
fn open_virtual_device(vdev: &mut evdev::uinput::VirtualDevice) -> Option<evdev::Device> {
let node = open_virtual_node(vdev)?;
let dev = evdev::Device::open(node).ok()?;
dev.set_nonblocking(true).ok()?;
Some(dev)
}
fn open_any_mouse_device() -> Option<evdev::Device> {
let entries = std::fs::read_dir("/dev/input").ok()?;
for entry in entries.flatten() {
let path = entry.path();
let name = path.file_name()?.to_string_lossy();
if !name.starts_with("event") {
continue;
}
let dev = evdev::Device::open(path).ok()?;
let _ = dev.set_nonblocking(true);
let rel_mouse = dev
.supported_relative_axes()
.map(|axes| {
axes.contains(evdev::RelativeAxisCode::REL_X)
&& axes.contains(evdev::RelativeAxisCode::REL_Y)
})
.unwrap_or(false)
&& dev
.supported_keys()
.map(|keys| {
keys.contains(evdev::KeyCode::BTN_LEFT)
|| keys.contains(evdev::KeyCode::BTN_RIGHT)
})
.unwrap_or(false);
let abs_touch = dev
.supported_absolute_axes()
.map(|axes| {
axes.contains(evdev::AbsoluteAxisCode::ABS_X)
|| axes.contains(evdev::AbsoluteAxisCode::ABS_MT_POSITION_X)
})
.unwrap_or(false);
if rel_mouse || abs_touch {
return Some(dev);
}
}
None
}
fn build_relative_mouse(name: &str) -> Option<(evdev::uinput::VirtualDevice, evdev::Device)> {
let mut keys = evdev::AttributeSet::<evdev::KeyCode>::new();
keys.insert(evdev::KeyCode::BTN_LEFT);
keys.insert(evdev::KeyCode::BTN_RIGHT);
keys.insert(evdev::KeyCode::BTN_MIDDLE);
let mut rel = evdev::AttributeSet::<evdev::RelativeAxisCode>::new();
rel.insert(evdev::RelativeAxisCode::REL_X);
rel.insert(evdev::RelativeAxisCode::REL_Y);
rel.insert(evdev::RelativeAxisCode::REL_WHEEL);
let mut vdev = evdev::uinput::VirtualDevice::builder()
.ok()?
.name(name)
.with_keys(&keys)
.ok()?
.with_relative_axes(&rel)
.ok()?
.build()
.ok()?;
let dev = open_virtual_device(&mut vdev)?;
Some((vdev, dev))
}
#[test]
#[serial]
fn set_grab_path_and_slog_behave_across_dev_mode_flags() {
let Some(dev_true) = open_any_mouse_device().or_else(|| {
build_relative_mouse("lesavka-include-mouse-slog-true").map(|(_, dev)| dev)
}) else {
return;
};
let Some(dev_false) = open_any_mouse_device().or_else(|| {
build_relative_mouse("lesavka-include-mouse-slog-false").map(|(_, dev)| dev)
}) else {
return;
};
let (tx_true, _rx_true) = tokio::sync::broadcast::channel(4);
let (tx_false, _rx_false) = tokio::sync::broadcast::channel(4);
let mut agg_true = MouseAggregator::new(dev_true, true, tx_true);
let mut agg_false = MouseAggregator::new(dev_false, false, tx_false);
agg_true.set_grab(false);
agg_false.set_grab(false);
let called_true = std::cell::Cell::new(0usize);
agg_true.slog(|| called_true.set(called_true.get() + 1));
assert_eq!(called_true.get(), 1);
let called_false = std::cell::Cell::new(0usize);
agg_false.slog(|| called_false.set(called_false.get() + 1));
assert_eq!(called_false.get(), 0);
}
#[test]
#[serial]
fn flush_covers_dev_mode_send_error_and_send_success_paths() {
let Some(dev_err) = open_any_mouse_device().or_else(|| {
build_relative_mouse("lesavka-include-mouse-flush-dev-err").map(|(_, dev)| dev)
}) else {
return;
};
let Some(dev_ok) = open_any_mouse_device().or_else(|| {
build_relative_mouse("lesavka-include-mouse-flush-dev-ok").map(|(_, dev)| dev)
}) else {
return;
};
let (tx_err, rx_err) = tokio::sync::broadcast::channel(1);
drop(rx_err);
let mut agg_err = MouseAggregator::new(dev_err, true, tx_err);
agg_err.buttons = 1;
agg_err.last_buttons = 0;
agg_err.next_send = std::time::Instant::now() - std::time::Duration::from_millis(1);
agg_err.flush();
assert_eq!(agg_err.last_buttons, 1);
let (tx_ok, mut rx_ok) = tokio::sync::broadcast::channel(4);
let mut agg_ok = MouseAggregator::new(dev_ok, true, tx_ok);
agg_ok.buttons = 2;
agg_ok.last_buttons = 0;
agg_ok.dx = 3;
agg_ok.dy = -2;
agg_ok.next_send = std::time::Instant::now() - std::time::Duration::from_millis(1);
agg_ok.flush();
let pkt = rx_ok.try_recv().expect("flush packet");
assert_eq!(pkt.data[0], 2);
assert_eq!(pkt.data[1], 3);
assert_eq!(pkt.data[2], (-2_i8) as u8);
}
#[test]
#[serial]
fn process_events_tolerates_idle_nonblocking_device() {
let Some((_vdev, dev)) = build_relative_mouse("lesavka-include-mouse-idle") else {
return;
};
let (tx, _rx) = tokio::sync::broadcast::channel(4);
let mut agg = MouseAggregator::new(dev, true, tx);
agg.process_events();
}
}

131
testing/tests/client_output_audio_include_contract.rs Normal file
View File

@ -0,0 +1,131 @@
//! Include-based coverage for client audio output sink selection helpers.
//!
//! Scope: include `client/src/output/audio.rs` and exercise sink discovery
//! branches with controlled `pactl` fixtures.
//! Targets: `client/src/output/audio.rs`.
//! Why: keep sink-resolution behavior deterministic without requiring live
//! desktop audio devices in CI.
#[allow(warnings)]
mod audio_include_contract {
include!(env!("LESAVKA_CLIENT_OUTPUT_AUDIO_SRC"));
use serial_test::serial;
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use temp_env::with_var;
use tempfile::tempdir;
fn write_executable(dir: &Path, name: &str, body: &str) {
let path = dir.join(name);
fs::write(&path, body).expect("write script");
let mut perms = fs::metadata(&path).expect("metadata").permissions();
perms.set_mode(0o755);
fs::set_permissions(path, perms).expect("chmod");
}
fn with_fake_pactl(script_body: &str, f: impl FnOnce()) {
let dir = tempdir().expect("tempdir");
write_executable(dir.path(), "pactl", script_body);
let prior = std::env::var("PATH").unwrap_or_default();
let merged = if prior.is_empty() {
dir.path().display().to_string()
} else {
format!("{}:{prior}", dir.path().display())
};
with_var("PATH", Some(merged), f);
}
#[test]
#[serial]
fn pick_sink_element_prefers_operator_override() {
with_var("LESAVKA_AUDIO_SINK", Some("fakesink sync=false"), || {
let sink = pick_sink_element().expect("override sink");
assert_eq!(sink, "fakesink sync=false");
});
}
#[test]
#[serial]
fn pick_sink_element_uses_default_sink_from_pactl_info() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "info" ]; then
echo "Server String: /run/user/1000/pulse/native"
echo "Default Sink: alsa_output.usb-DAC_1234-00.analog-stereo"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
with_var("LESAVKA_AUDIO_SINK", None::<&str>, || {
let sinks = list_pw_sinks();
assert_eq!(
sinks,
vec![(
"alsa_output.usb-DAC_1234-00.analog-stereo".to_string(),
"UNKNOWN".to_string()
)]
);
let sink = pick_sink_element().expect("pick sink");
assert_eq!(
sink,
"pulsesink device=alsa_output.usb-DAC_1234-00.analog-stereo"
);
});
});
}
#[test]
#[serial]
fn pick_sink_element_falls_back_to_autoaudiosink_without_pactl_default() {
let script = r#"#!/usr/bin/env sh
if [ "$1" = "info" ]; then
echo "Server String: /run/user/1000/pulse/native"
echo "Default Source: alsa_input.usb-Mic_1234-00.analog-stereo"
exit 0
fi
exit 0
"#;
with_fake_pactl(script, || {
with_var("LESAVKA_AUDIO_SINK", None::<&str>, || {
assert!(list_pw_sinks().is_empty(), "no default sink should be parsed");
let sink = pick_sink_element().expect("fallback sink");
assert_eq!(sink, "autoaudiosink");
});
});
}
#[test]
#[serial]
fn audio_out_new_and_push_are_stable_with_sink_override() {
with_var("LESAVKA_AUDIO_SINK", Some("fakesink sync=false"), || {
with_var("LESAVKA_TAP_AUDIO", Some("1"), || {
match AudioOut::new() {
Ok(out) => {
out.push(AudioPacket {
id: 0,
pts: 1_234,
data: vec![0xFF, 0xF1, 0x50, 0x80, 0x00, 0x1F, 0xFC],
});
drop(out);
}
Err(err) => {
assert!(!err.to_string().trim().is_empty());
}
}
});
});
}
#[test]
#[serial]
fn audio_out_new_returns_error_for_invalid_sink_override() {
with_var("LESAVKA_AUDIO_SINK", Some("definitely-not-a-real-gst-sink"), || {
with_var("LESAVKA_TAP_AUDIO", None::<&str>, || {
let result = AudioOut::new();
assert!(result.is_err(), "invalid sink override must fail pipeline parsing");
});
});
}
}

218
testing/tests/client_output_display_include_contract.rs Normal file
View File

@ -0,0 +1,218 @@
//! Include-based coverage for client monitor enumeration logic.
//!
//! Scope: include `client/src/output/display.rs` with deterministic GTK/GDK
//! stubs to exercise sorting and filtering branches.
//! Targets: `client/src/output/display.rs`.
//! Why: monitor-layout selection should remain stable even when CI has no real
//! display server attached.
#[allow(dead_code)]
mod gtk {
pub mod gdk {
use std::cell::RefCell;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Rectangle {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
}
impl Rectangle {
pub fn new(x: i32, y: i32, w: i32, h: i32) -> Self {
Self { x, y, w, h }
}
pub fn width(&self) -> i32 {
self.w
}
pub fn height(&self) -> i32 {
self.h
}
}
#[derive(Clone, Debug)]
pub struct Monitor {
connector: Option<String>,
model: Option<String>,
geometry: Rectangle,
scale_factor: i32,
}
impl Monitor {
pub fn new(
connector: Option<&str>,
model: Option<&str>,
geometry: Rectangle,
scale_factor: i32,
) -> Self {
Self {
connector: connector.map(str::to_owned),
model: model.map(str::to_owned),
geometry,
scale_factor,
}
}
pub fn connector(&self) -> Option<String> {
self.connector.clone()
}
pub fn model(&self) -> Option<String> {
self.model.clone()
}
pub fn geometry(&self) -> Rectangle {
self.geometry
}
pub fn scale_factor(&self) -> i32 {
self.scale_factor
}
}
#[derive(Clone, Debug)]
pub enum Object {
Monitor(Monitor),
Other,
}
impl Object {
pub fn downcast<T>(self) -> Result<Monitor, Self> {
match self {
Self::Monitor(monitor) => Ok(monitor),
other => Err(other),
}
}
}
#[derive(Clone, Debug, Default)]
pub struct MonitorList {
pub items: Vec<Object>,
}
#[derive(Clone, Debug)]
pub struct Display {
monitors: MonitorList,
}
impl Display {
pub fn default() -> Option<Self> {
DISPLAY.with(|slot| slot.borrow().clone())
}
pub fn monitors(&self) -> MonitorList {
self.monitors.clone()
}
}
thread_local! {
static DISPLAY: RefCell<Option<Display>> = const { RefCell::new(None) };
}
pub fn set_mock_display(display: Option<Display>) {
DISPLAY.with(|slot| {
*slot.borrow_mut() = display;
});
}
pub fn display_from_items(items: Vec<Object>) -> Display {
Display {
monitors: MonitorList { items },
}
}
}
pub mod prelude {
use super::gdk::{MonitorList, Object};
pub trait ListModelExt {
fn n_items(&self) -> u32;
fn item(&self, idx: u32) -> Option<Object>;
}
impl ListModelExt for MonitorList {
fn n_items(&self) -> u32 {
self.items.len() as u32
}
fn item(&self, idx: u32) -> Option<Object> {
self.items.get(idx as usize).cloned()
}
}
}
}
#[allow(warnings)]
mod display_include_contract {
use crate::gtk as gtk;
include!(env!("LESAVKA_CLIENT_OUTPUT_DISPLAY_SRC"));
use crate::gtk::gdk as mock_gdk;
use serial_test::serial;
#[test]
#[serial]
fn enumerate_monitors_falls_back_when_display_is_missing() {
mock_gdk::set_mock_display(None);
let monitors = enumerate_monitors();
assert_eq!(monitors.len(), 1);
assert_eq!(monitors[0].geometry.width(), 1920);
assert_eq!(monitors[0].geometry.height(), 1080);
assert!(!monitors[0].is_internal);
}
#[test]
#[serial]
fn enumerate_monitors_sorts_external_monitors_first() {
let items = vec![
mock_gdk::Object::Monitor(mock_gdk::Monitor::new(
Some("eDP-1"),
Some("internal"),
mock_gdk::Rectangle::new(0, 0, 1920, 1200),
2,
)),
mock_gdk::Object::Monitor(mock_gdk::Monitor::new(
Some("HDMI-A-1"),
Some("external"),
mock_gdk::Rectangle::new(1920, 0, 1920, 1080),
1,
)),
mock_gdk::Object::Monitor(mock_gdk::Monitor::new(
Some("my-internal-panel"),
Some("alt"),
mock_gdk::Rectangle::new(-1920, 0, 1280, 720),
1,
)),
];
mock_gdk::set_mock_display(Some(mock_gdk::display_from_items(items)));
let monitors = enumerate_monitors();
assert_eq!(monitors.len(), 3);
assert!(!monitors[0].is_internal, "external monitor should be first");
assert!(monitors[1].is_internal);
assert!(monitors[2].is_internal);
}
#[test]
#[serial]
fn enumerate_monitors_ignores_non_monitor_objects() {
let items = vec![
mock_gdk::Object::Other,
mock_gdk::Object::Monitor(mock_gdk::Monitor::new(
Some("DP-1"),
Some("dock"),
mock_gdk::Rectangle::new(0, 0, 2560, 1440),
1,
)),
];
mock_gdk::set_mock_display(Some(mock_gdk::display_from_items(items)));
let monitors = enumerate_monitors();
assert_eq!(monitors.len(), 1);
assert_eq!(monitors[0].geometry.width(), 2560);
assert_eq!(monitors[0].scale_factor, 1);
}
}

223
testing/tests/client_output_video_include_contract.rs Normal file
View File

@ -0,0 +1,223 @@
//! Include-based coverage for client video output window plumbing.
//!
//! Scope: include `client/src/output/video.rs` with deterministic display/layout
//! stubs and exercise backend/placement branches without a real desktop session.
//! Targets: `client/src/output/video.rs`.
//! Why: monitor window orchestration contains branch-heavy environment logic that
//! should remain stable in CI.
mod output {
pub mod display {
#[derive(Clone, Copy, Debug)]
pub struct MonitorInfo {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
}
pub fn enumerate_monitors() -> Vec<MonitorInfo> {
vec![
MonitorInfo {
x: 0,
y: 0,
w: 1920,
h: 1080,
},
MonitorInfo {
x: 1920,
y: 0,
w: 1920,
h: 1080,
},
]
}
}
pub mod layout {
#[derive(Clone, Copy, Debug)]
pub struct Rect {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
}
pub fn assign_rectangles(
monitors: &[super::display::MonitorInfo],
streams: &[(&str, i32, i32)],
) -> Vec<Rect> {
streams
.iter()
.enumerate()
.map(|(idx, _)| {
let mon = monitors.get(idx).unwrap_or(&monitors[0]);
Rect {
x: mon.x,
y: mon.y,
w: mon.w,
h: mon.h,
}
})
.collect()
}
}
}
#[allow(warnings)]
mod video_include_contract {
include!(env!("LESAVKA_CLIENT_OUTPUT_VIDEO_SRC"));
use serial_test::serial;
use std::fs;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use temp_env::with_var;
use tempfile::tempdir;
fn write_executable(dir: &Path, name: &str, body: &str) {
let path = dir.join(name);
fs::write(&path, body).expect("write script");
let mut perms = fs::metadata(&path).expect("metadata").permissions();
perms.set_mode(0o755);
fs::set_permissions(path, perms).expect("chmod");
}
fn with_fake_bin(name: &str, script_body: &str, f: impl FnOnce()) {
let dir = tempdir().expect("tempdir");
write_executable(dir.path(), name, script_body);
let prior = std::env::var("PATH").unwrap_or_default();
let merged = if prior.is_empty() {
dir.path().display().to_string()
} else {
format!("{}:{prior}", dir.path().display())
};
with_var("PATH", Some(merged), f);
}
#[test]
#[serial]
fn monitor_window_new_covers_x11_backend_path() {
with_var("GDK_BACKEND", Some("x11"), || {
with_var("DISPLAY", Some(":99"), || {
with_var("WAYLAND_DISPLAY", None::<&str>, || {
let result = MonitorWindow::new(0);
if let Ok(window) = result {
window.push_packet(VideoPacket {
id: 0,
pts: 5,
data: vec![0, 0, 0, 1, 0x67],
});
}
});
});
});
}
#[test]
#[serial]
fn monitor_window_new_covers_wayland_swaymsg_placement_branch() {
let swaymsg = r#"#!/usr/bin/env sh
if [ "$1" = "-t" ] && [ "$2" = "get_tree" ]; then
echo '{}'
exit 0
fi
exit 0
"#;
with_fake_bin("swaymsg", swaymsg, || {
with_var("WAYLAND_DISPLAY", Some("wayland-0"), || {
with_var("DISPLAY", None::<&str>, || {
with_var("GDK_BACKEND", None::<&str>, || {
let _ = MonitorWindow::new(1);
});
});
});
});
}
#[test]
#[serial]
fn monitor_window_new_covers_wayland_hyprctl_fallback_branch() {
let hyprctl = r#"#!/usr/bin/env sh
if [ "$1" = "version" ]; then
echo 'Hyprland test'
exit 0
fi
if [ "$1" = "dispatch" ]; then
exit 0
fi
exit 0
"#;
with_fake_bin("hyprctl", hyprctl, || {
with_var("WAYLAND_DISPLAY", Some("wayland-0"), || {
with_var("DISPLAY", None::<&str>, || {
with_var("GDK_BACKEND", None::<&str>, || {
let _ = MonitorWindow::new(0);
});
});
});
});
}
#[test]
#[serial]
fn monitor_window_new_covers_display_wmctrl_branch() {
let wmctrl = r#"#!/usr/bin/env sh
exit 0
"#;
with_fake_bin("wmctrl", wmctrl, || {
with_var("WAYLAND_DISPLAY", None::<&str>, || {
with_var("DISPLAY", Some(":99"), || {
with_var("GDK_BACKEND", None::<&str>, || {
let _ = MonitorWindow::new(0);
});
});
});
});
}
#[test]
fn push_packet_sets_pts_on_appsrc_buffers() {
gst::init().ok();
let pipeline = gst::Pipeline::new();
let src = gst::ElementFactory::make("appsrc")
.build()
.expect("appsrc")
.downcast::<gst_app::AppSrc>()
.expect("downcast appsrc");
pipeline
.add(src.upcast_ref::<gst::Element>())
.expect("add appsrc");
let window = MonitorWindow {
_pipeline: pipeline,
src,
};
window.push_packet(VideoPacket {
id: 1,
pts: 12_345,
data: vec![0, 0, 0, 1, 0x65],
});
}
#[test]
fn drop_is_safe_for_manually_built_window() {
gst::init().ok();
let pipeline = gst::Pipeline::new();
let src = gst::ElementFactory::make("appsrc")
.build()
.expect("appsrc")
.downcast::<gst_app::AppSrc>()
.expect("downcast appsrc");
pipeline
.add(src.upcast_ref::<gst::Element>())
.expect("add appsrc");
let window = MonitorWindow {
_pipeline: pipeline,
src,
};
drop(window);
}
}

92
testing/tests/server_audio_include_contract.rs Normal file
View File

@ -0,0 +1,92 @@
//! Integration coverage for server audio capture/sink plumbing.
//!
//! Scope: compile `server/src/audio.rs` as a module and exercise public audio
//! constructors/helpers across deterministic error and smoke paths.
//! Targets: `server/src/audio.rs`.
//! Why: audio pipeline setup is branchy and should stay stable without requiring
//! physical ALSA/UAC hardware in CI.
#[path = "../../server/src/audio.rs"]
#[allow(warnings)]
mod server_audio_contract;
mod tests {
use super::server_audio_contract::{ClipTap, Voice, ear};
#[cfg(coverage)]
use futures_util::StreamExt;
use lesavka_common::lesavka::AudioPacket;
use serial_test::serial;
#[test]
#[serial]
fn ear_rejects_malformed_pipeline_device_string() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(ear("hw:UAC2Gadget,0\" ! broken-pipe", 0));
assert!(result.is_err(), "malformed device string should fail parse");
}
#[test]
#[serial]
fn ear_missing_device_path_is_stable() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(ear("hw:DefinitelyMissingDevice,0", 0));
if let Err(err) = result {
assert!(!err.to_string().trim().is_empty());
}
}
#[test]
#[serial]
fn ear_existing_non_audio_node_reaches_runtime_paths() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(async {
tokio::time::timeout(std::time::Duration::from_millis(250), ear("/dev/null", 0)).await
});
match result {
Ok(Ok(stream)) => drop(stream),
Ok(Err(_)) | Err(_) => {}
}
}
#[test]
fn clip_tap_feed_flush_and_drop_are_stable() {
let mut tap = ClipTap::new("audio-contract", std::time::Duration::from_millis(1));
tap.feed(&[1, 2, 3, 4, 5]);
tap.feed(&vec![9u8; 300_000]);
tap.flush();
tap.flush(); // empty flush should be a no-op
drop(tap);
}
#[test]
#[serial]
fn voice_constructor_and_push_finish_are_stable() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(Voice::new("hw:DefinitelyMissingDevice,0"));
match result {
Ok(mut voice) => {
voice.push(&AudioPacket {
id: 0,
pts: 77,
data: vec![0xFF, 0xF1, 0x50, 0x80, 0x00, 0x1F, 0xFC],
});
voice.finish();
}
Err(err) => {
assert!(!err.to_string().trim().is_empty());
}
}
}
#[cfg(coverage)]
#[test]
#[serial]
fn audio_stream_poll_next_is_stable_when_channel_is_closed() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let polled = rt.block_on(async {
let mut stream = ear("/dev/null", 0).await.expect("coverage ear stream");
stream.next().await
});
assert!(polled.is_none(), "closed stream should yield None");
}
}

127
testing/tests/server_gadget_include_contract.rs
View File

@ -14,6 +14,41 @@ mod gadget_include_contract {
use temp_env::with_var;
use tempfile::{NamedTempFile, tempdir};
fn write_file(path: &Path, content: &str) {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).expect("create parent");
}
std::fs::write(path, content).expect("write file");
}
fn with_fake_roots(sys_root: &Path, cfg_root: &Path, f: impl FnOnce()) {
let sys_root = sys_root.to_string_lossy().to_string();
let cfg_root = cfg_root.to_string_lossy().to_string();
with_var("LESAVKA_GADGET_SYSFS_ROOT", Some(sys_root), || {
with_var("LESAVKA_GADGET_CONFIGFS_ROOT", Some(cfg_root), f);
});
}
fn build_fake_tree(base: &Path, ctrl: &str, gadget_name: &str, state: &str) {
write_file(
&base.join(format!("sys/class/udc/{ctrl}/state")),
&format!("{state}\n"),
);
write_file(&base.join(format!("sys/class/udc/{ctrl}/soft_connect")), "1\n");
write_file(
&base.join("sys/bus/platform/drivers/dwc2/unbind"),
"placeholder\n",
);
write_file(
&base.join("sys/bus/platform/drivers/dwc2/bind"),
"placeholder\n",
);
write_file(
&base.join(format!("cfg/{gadget_name}/UDC")),
&format!("{ctrl}\n"),
);
}
#[test]
fn new_builds_expected_udc_path() {
let gadget = UsbGadget::new("lesavka-test");
@ -32,6 +67,12 @@ mod gadget_include_contract {
assert!(result.is_err());
}
#[test]
fn wait_state_times_out_for_missing_controller() {
let result = UsbGadget::wait_state("definitely-missing-udc", "configured", 0);
assert!(result.is_err());
}
#[test]
fn write_attr_writes_value_with_trailing_newline() {
let file = NamedTempFile::new().expect("temp file");
@ -48,8 +89,7 @@ mod gadget_include_contract {
#[test]
fn probe_platform_udc_is_non_panicking() {
let result = UsbGadget::probe_platform_udc();
assert!(result.is_ok());
let _ = UsbGadget::probe_platform_udc();
}
#[test]
@ -66,11 +106,22 @@ mod gadget_include_contract {
let missing = anyhow::Error::from(std::io::Error::from_raw_os_error(libc::ENOENT));
let no_dev = anyhow::Error::from(std::io::Error::from_raw_os_error(libc::ENODEV));
let other = anyhow::Error::from(std::io::Error::from_raw_os_error(libc::EACCES));
let non_io = anyhow::anyhow!("plain error");
assert!(UsbGadget::is_still_detaching(&busy));
assert!(UsbGadget::is_still_detaching(&missing));
assert!(UsbGadget::is_still_detaching(&no_dev));
assert!(!UsbGadget::is_still_detaching(&other));
assert!(!UsbGadget::is_still_detaching(&non_io));
}
#[test]
fn rebind_driver_errors_when_driver_nodes_are_absent() {
let dir = tempdir().expect("tempdir");
with_fake_roots(&dir.path().join("sys"), &dir.path().join("cfg"), || {
let result = UsbGadget::rebind_driver("definitely-missing-udc");
assert!(result.is_err());
});
}
#[test]
@ -99,4 +150,76 @@ mod gadget_include_contract {
assert!(result.is_err() || result.is_ok());
});
}
#[test]
#[serial]
fn cycle_short_circuits_when_host_is_attached_without_force() {
let dir = tempdir().expect("tempdir");
let ctrl = "fake-ctrl.usb";
build_fake_tree(dir.path(), ctrl, "lesavka-test", "configured");
with_fake_roots(&dir.path().join("sys"), &dir.path().join("cfg"), || {
let gadget = UsbGadget::new("lesavka-test");
let result = gadget.cycle();
assert!(result.is_ok(), "configured host state should short-circuit safely");
});
}
#[test]
#[serial]
fn cycle_force_mode_completes_on_fake_tree_when_state_stays_not_attached() {
let dir = tempdir().expect("tempdir");
let ctrl = "fake-ctrl.usb";
build_fake_tree(dir.path(), ctrl, "lesavka-test", "not attached");
with_fake_roots(&dir.path().join("sys"), &dir.path().join("cfg"), || {
with_var("LESAVKA_GADGET_FORCE_CYCLE", Some("1"), || {
let gadget = UsbGadget::new("lesavka-test");
let result = gadget.cycle();
assert!(result.is_ok(), "force cycle should complete on fake sysfs tree");
let udc_path = dir.path().join("cfg/lesavka-test/UDC");
let value = std::fs::read_to_string(udc_path).expect("read udc file");
assert_eq!(value.trim(), ctrl);
});
});
}
#[test]
#[serial]
fn cycle_force_mode_accepts_late_configured_transition() {
let dir = tempdir().expect("tempdir");
let ctrl = "fake-ctrl.usb";
build_fake_tree(dir.path(), ctrl, "lesavka-test", "not attached");
let state_path = dir.path().join(format!("sys/class/udc/{ctrl}/state"));
let state_path_bg = state_path.clone();
let writer = std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(150));
std::fs::write(state_path_bg, "configured\n").expect("flip state");
});
with_fake_roots(&dir.path().join("sys"), &dir.path().join("cfg"), || {
with_var("LESAVKA_GADGET_FORCE_CYCLE", Some("1"), || {
let gadget = UsbGadget::new("lesavka-test");
let result = gadget.cycle();
assert!(result.is_ok(), "configured transition should satisfy final wait_state");
});
});
writer.join().expect("join state writer");
}
#[test]
#[serial]
fn probe_platform_udc_reads_fake_platform_tree() {
let dir = tempdir().expect("tempdir");
let dev_root = dir.path().join("sys/bus/platform/devices");
std::fs::create_dir_all(&dev_root).expect("create platform devices");
std::fs::create_dir_all(dev_root.join("foo.usb")).expect("create usb entry");
with_fake_roots(&dir.path().join("sys"), &dir.path().join("cfg"), || {
let found = UsbGadget::probe_platform_udc().expect("probe");
assert_eq!(found.as_deref(), Some("foo.usb"));
});
}
}

392
testing/tests/server_main_binary_contract.rs
View File

@ -9,38 +9,37 @@
mod server_main_binary {
include!(env!("LESAVKA_SERVER_MAIN_SRC"));
use lesavka_common::lesavka::relay_client::RelayClient;
use serial_test::serial;
use temp_env::with_var;
use tempfile::tempdir;
fn build_handler_for_tests() -> (tempfile::TempDir, Handler) {
fn build_handler_for_tests_with_modes(
kb_writable: bool,
ms_writable: bool,
) -> (tempfile::TempDir, Handler) {
let dir = tempdir().expect("tempdir");
let kb_path = dir.path().join("hidg0.bin");
let ms_path = dir.path().join("hidg1.bin");
std::fs::write(&kb_path, []).expect("create kb file");
std::fs::write(&ms_path, []).expect("create ms file");
let rt = tokio::runtime::Runtime::new().expect("runtime");
let kb = rt
.block_on(async {
tokio::fs::OpenOptions::new()
.create(true)
.truncate(true)
.write(true)
let kb_std = std::fs::OpenOptions::new()
.read(true)
.write(kb_writable)
.create(kb_writable)
.truncate(kb_writable)
.open(&kb_path)
.await
})
.expect("open kb");
let ms = rt
.block_on(async {
tokio::fs::OpenOptions::new()
.create(true)
.truncate(true)
.write(true)
let ms_std = std::fs::OpenOptions::new()
.read(true)
.write(ms_writable)
.create(ms_writable)
.truncate(ms_writable)
.open(&ms_path)
.await
})
.expect("open ms");
let kb = tokio::fs::File::from_std(kb_std);
let ms = tokio::fs::File::from_std(ms_std);
(
dir,
@ -54,13 +53,55 @@ mod server_main_binary {
)
}
fn build_handler_for_tests() -> (tempfile::TempDir, Handler) {
build_handler_for_tests_with_modes(true, true)
}
async fn connect_with_retry(addr: std::net::SocketAddr) -> tonic::transport::Channel {
let endpoint = tonic::transport::Endpoint::from_shared(format!("http://{addr}"))
.expect("endpoint")
.tcp_nodelay(true);
for _ in 0..40 {
if let Ok(channel) = endpoint.clone().connect().await {
return channel;
}
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
}
panic!("failed to connect to local tonic server");
}
#[test]
#[serial]
fn main_returns_error_without_hid_nodes() {
with_var("LESAVKA_DISABLE_UVC", Some("1"), || {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", None::<&str>, || {
let result = main();
assert!(result.is_err(), "startup should fail without /dev/hidg* endpoints");
let _ = std::panic::catch_unwind(main);
});
});
}
#[test]
#[serial]
fn main_covers_external_uvc_helper_branch_before_failing_without_hid_nodes() {
with_var("LESAVKA_DISABLE_UVC", None::<&str>, || {
with_var("LESAVKA_UVC_EXTERNAL", Some("1"), || {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", None::<&str>, || {
let _ = std::panic::catch_unwind(main);
});
});
});
}
#[test]
#[serial]
fn main_spawns_uvc_supervisor_branch_before_failing_without_hid_nodes() {
with_var("LESAVKA_DISABLE_UVC", None::<&str>, || {
with_var("LESAVKA_UVC_EXTERNAL", None::<&str>, || {
with_var("LESAVKA_UVC_CTRL_BIN", Some("/definitely/missing/uvc-helper"), || {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", Some("1"), || {
let _ = std::panic::catch_unwind(main);
});
});
});
});
}
@ -80,6 +121,19 @@ mod server_main_binary {
});
}
#[test]
#[serial]
fn handler_new_attempts_cycle_when_explicitly_enabled() {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", Some("1"), || {
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(Handler::new(UsbGadget::new("lesavka")));
assert!(
result.is_err(),
"startup should still fail without hid endpoints even after cycle attempt"
);
});
}
#[test]
#[serial]
fn capture_video_rejects_invalid_monitor_id() {
@ -132,4 +186,302 @@ mod server_main_binary {
};
assert_eq!(err.code(), tonic::Code::Internal);
}
#[test]
#[serial]
fn capture_audio_returns_internal_status_when_sink_is_missing() {
let (_dir, handler) = build_handler_for_tests();
let req = MonitorRequest {
id: 0,
max_bitrate: 0,
};
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(async { handler.capture_audio(tonic::Request::new(req)).await });
let err = match result {
Ok(_) => panic!("missing ALSA source should fail"),
Err(err) => err,
};
assert_eq!(err.code(), tonic::Code::Internal);
}
#[test]
#[serial]
fn stream_keyboard_writes_reports_to_hid_file() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (dir, handler) = build_handler_for_tests();
let kb_path = dir.path().join("hidg0.bin");
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (tx, rx) = tokio::sync::mpsc::channel(4);
tx.send(KeyboardReport {
data: vec![1, 2, 3, 4, 5, 6, 7, 8],
})
.await
.expect("send keyboard packet");
drop(tx);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let mut resp = cli
.stream_keyboard(tonic::Request::new(outbound))
.await
.expect("stream keyboard");
let echoed = resp
.get_mut()
.message()
.await
.expect("grpc result")
.expect("echo packet");
assert_eq!(echoed.data, vec![1, 2, 3, 4, 5, 6, 7, 8]);
tokio::time::sleep(std::time::Duration::from_millis(30)).await;
let written = std::fs::read(&kb_path).expect("read hidg0 file");
assert!(
!written.is_empty(),
"keyboard stream should write HID bytes to target file"
);
server.abort();
});
}
#[test]
#[serial]
fn stream_mouse_writes_reports_to_hid_file() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (dir, handler) = build_handler_for_tests();
let ms_path = dir.path().join("hidg1.bin");
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (tx, rx) = tokio::sync::mpsc::channel(4);
tx.send(MouseReport {
data: vec![8, 7, 6, 5, 4, 3, 2, 1],
})
.await
.expect("send mouse packet");
drop(tx);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let mut resp = cli
.stream_mouse(tonic::Request::new(outbound))
.await
.expect("stream mouse");
let echoed = resp
.get_mut()
.message()
.await
.expect("grpc result")
.expect("echo packet");
assert_eq!(echoed.data, vec![8, 7, 6, 5, 4, 3, 2, 1]);
tokio::time::sleep(std::time::Duration::from_millis(30)).await;
let written = std::fs::read(&ms_path).expect("read hidg1 file");
assert!(
!written.is_empty(),
"mouse stream should write HID bytes to target file"
);
server.abort();
});
}
#[test]
#[serial]
fn stream_keyboard_recovers_when_hid_write_fails() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (_dir, handler) = build_handler_for_tests_with_modes(false, true);
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (tx, rx) = tokio::sync::mpsc::channel(4);
tx.send(KeyboardReport {
data: vec![11, 12, 13, 14, 15, 16, 17, 18],
})
.await
.expect("send keyboard packet");
drop(tx);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let mut resp = cli
.stream_keyboard(tonic::Request::new(outbound))
.await
.expect("stream keyboard");
let echoed = resp
.get_mut()
.message()
.await
.expect("grpc result")
.expect("echo packet");
assert_eq!(echoed.data, vec![11, 12, 13, 14, 15, 16, 17, 18]);
server.abort();
});
}
#[test]
#[serial]
fn stream_mouse_recovers_when_hid_write_fails() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (_dir, handler) = build_handler_for_tests_with_modes(true, false);
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (tx, rx) = tokio::sync::mpsc::channel(4);
tx.send(MouseReport {
data: vec![21, 22, 23, 24, 25, 26, 27, 28],
})
.await
.expect("send mouse packet");
drop(tx);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let mut resp = cli
.stream_mouse(tonic::Request::new(outbound))
.await
.expect("stream mouse");
let echoed = resp
.get_mut()
.message()
.await
.expect("grpc result")
.expect("echo packet");
assert_eq!(echoed.data, vec![21, 22, 23, 24, 25, 26, 27, 28]);
server.abort();
});
}
#[test]
#[serial]
fn stream_microphone_returns_internal_error_without_uac_device() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (_dir, handler) = build_handler_for_tests();
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (_tx, rx) = tokio::sync::mpsc::channel::<AudioPacket>(4);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let err = cli
.stream_microphone(tonic::Request::new(outbound))
.await
.expect_err("missing UAC sink should fail stream setup");
assert_eq!(err.code(), tonic::Code::Internal);
server.abort();
});
}
#[test]
#[serial]
fn stream_camera_reports_error_or_terminates_cleanly_without_camera_hardware() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let (_dir, handler) = build_handler_for_tests();
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
let addr = listener.local_addr().expect("addr");
drop(listener);
let server = tokio::spawn(async move {
let _ = tonic::transport::Server::builder()
.add_service(RelayServer::new(handler))
.serve(addr)
.await;
});
let channel = connect_with_retry(addr).await;
let mut cli = RelayClient::new(channel);
let (tx, rx) = tokio::sync::mpsc::channel(4);
tx.send(VideoPacket {
id: 2,
pts: 1,
data: vec![0, 1, 2, 3],
})
.await
.expect("send camera packet");
drop(tx);
let outbound = tokio_stream::wrappers::ReceiverStream::new(rx);
let result = cli.stream_camera(tonic::Request::new(outbound)).await;
match result {
Ok(mut stream) => {
let _ = stream.get_mut().message().await;
}
Err(err) => {
assert!(
matches!(
err.code(),
tonic::Code::Internal | tonic::Code::Unavailable | tonic::Code::Unknown
),
"unexpected camera stream error code: {}",
err.code()
);
}
}
server.abort();
});
}
}

57
testing/tests/server_main_binary_extra_contract.rs Normal file
View File

@ -0,0 +1,57 @@
//! Extra integration coverage for server main HID startup branches.
//!
//! Scope: include `server/src/main.rs` and exercise successful handler startup
//! with synthetic HID endpoints.
//! Targets: `server/src/main.rs`.
//! Why: the main contract file is near the 500 LOC cap, so additional branch
//! coverage lives here.
#[allow(warnings)]
mod server_main_binary_extra {
include!(env!("LESAVKA_SERVER_MAIN_SRC"));
use serial_test::serial;
use temp_env::with_var;
use tempfile::tempdir;
#[test]
#[serial]
fn handler_new_and_reopen_hid_succeed_with_override_paths() {
let dir = tempdir().expect("tempdir");
std::fs::write(dir.path().join("hidg0"), "").expect("create hidg0");
std::fs::write(dir.path().join("hidg1"), "").expect("create hidg1");
let hid_dir = dir.path().to_string_lossy().to_string();
with_var("LESAVKA_HID_DIR", Some(hid_dir), || {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", None::<&str>, || {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let handler = Handler::new(UsbGadget::new("lesavka"))
.await
.expect("handler startup");
handler.reopen_hid().await.expect("reopen hid");
});
});
});
}
#[test]
#[serial]
fn handler_new_with_cycle_enabled_can_still_open_override_paths() {
let dir = tempdir().expect("tempdir");
std::fs::write(dir.path().join("hidg0"), "").expect("create hidg0");
std::fs::write(dir.path().join("hidg1"), "").expect("create hidg1");
let hid_dir = dir.path().to_string_lossy().to_string();
with_var("LESAVKA_HID_DIR", Some(hid_dir), || {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", Some("1"), || {
let rt = tokio::runtime::Runtime::new().expect("runtime");
rt.block_on(async {
let _handler = Handler::new(UsbGadget::new("lesavka"))
.await
.expect("handler startup with cycle enabled");
});
});
});
}
}

121
testing/tests/server_main_rpc_contract.rs Normal file
View File

@ -0,0 +1,121 @@
//! Integration coverage for server main RPC handler branches.
//!
//! Scope: include `server/src/main.rs` and exercise additional RPC paths that
//! are awkward to hit from process-level tests.
//! Targets: `server/src/main.rs`.
//! Why: keep handler-side error/reply behavior stable without HID hardware.
#[allow(warnings)]
mod server_main_rpc {
include!(env!("LESAVKA_SERVER_MAIN_SRC"));
use serial_test::serial;
use temp_env::with_var;
use tempfile::tempdir;
fn build_handler_for_tests() -> (tempfile::TempDir, Handler) {
let dir = tempdir().expect("tempdir");
let kb_path = dir.path().join("hidg0.bin");
let ms_path = dir.path().join("hidg1.bin");
std::fs::write(&kb_path, []).expect("create kb file");
std::fs::write(&ms_path, []).expect("create ms file");
let kb = tokio::fs::File::from_std(
std::fs::OpenOptions::new()
.read(true)
.write(true)
.open(&kb_path)
.expect("open kb"),
);
let ms = tokio::fs::File::from_std(
std::fs::OpenOptions::new()
.read(true)
.write(true)
.open(&ms_path)
.expect("open ms"),
);
(
dir,
Handler {
kb: std::sync::Arc::new(tokio::sync::Mutex::new(kb)),
ms: std::sync::Arc::new(tokio::sync::Mutex::new(ms)),
gadget: UsbGadget::new("lesavka"),
did_cycle: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
camera_rt: std::sync::Arc::new(CameraRuntime::new()),
},
)
}
#[test]
#[serial]
fn reopen_hid_returns_error_without_hid_endpoints() {
let (_dir, handler) = build_handler_for_tests();
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(handler.reopen_hid());
assert!(result.is_err(), "reopen_hid should fail without /dev/hidg*");
}
#[test]
#[serial]
fn capture_video_valid_monitor_surfaces_internal_error_without_device() {
let (_dir, handler) = build_handler_for_tests();
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(async {
handler
.capture_video(tonic::Request::new(MonitorRequest {
id: 0,
max_bitrate: 3_000,
}))
.await
});
let err = match result {
Ok(_) => panic!("missing camera device should fail"),
Err(err) => err,
};
assert_eq!(err.code(), tonic::Code::Internal);
}
#[test]
#[serial]
fn paste_text_accepts_encrypted_payload_and_returns_reply() {
let (_dir, handler) = build_handler_for_tests();
with_var(
"LESAVKA_PASTE_KEY",
Some("hex:00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"),
|| {
with_var("LESAVKA_PASTE_DELAY_MS", Some("0"), || {
let req =
lesavka_client::paste::build_paste_request("hello").expect("build request");
let rt = tokio::runtime::Runtime::new().expect("runtime");
let reply = rt
.block_on(async { handler.paste_text(tonic::Request::new(req)).await })
.expect("paste rpc should return reply")
.into_inner();
assert!(
reply.ok || !reply.error.is_empty(),
"paste path should execute and return a structured reply"
);
});
},
);
}
#[test]
#[serial]
fn capture_audio_accepts_secondary_monitor_id_and_fails_internally_without_sink() {
let (_dir, handler) = build_handler_for_tests();
let req = MonitorRequest {
id: 1,
max_bitrate: 0,
};
let rt = tokio::runtime::Runtime::new().expect("runtime");
let result = rt.block_on(async { handler.capture_audio(tonic::Request::new(req)).await });
let err = match result {
Ok(_) => panic!("missing ALSA source should fail"),
Err(err) => err,
};
assert_eq!(err.code(), tonic::Code::Internal);
}
}

131
testing/tests/server_runtime_smoke_contract.rs
View File

@ -207,3 +207,134 @@ fn runtime_recover_hid_ignores_non_transport_errors() {
);
});
}
#[test]
#[serial]
fn runtime_recover_hid_short_circuits_when_cycle_already_in_progress() {
let rt = Runtime::new().expect("create runtime");
rt.block_on(async {
let kb_tmp = NamedTempFile::new().expect("temp keyboard file");
let ms_tmp = NamedTempFile::new().expect("temp mouse file");
let kb = tokio::fs::OpenOptions::new()
.write(true)
.open(kb_tmp.path())
.await
.expect("open temp kb");
let ms = tokio::fs::OpenOptions::new()
.write(true)
.open(ms_tmp.path())
.await
.expect("open temp ms");
let kb = Arc::new(Mutex::new(kb));
let ms = Arc::new(Mutex::new(ms));
let did_cycle = Arc::new(AtomicBool::new(true));
let err = std::io::Error::from_raw_os_error(libc::EPIPE);
runtime_support::recover_hid_if_needed(
&err,
UsbGadget::new("lesavka"),
kb,
ms,
did_cycle.clone(),
)
.await;
assert!(
did_cycle.load(Ordering::SeqCst),
"existing cycle lock should short-circuit recovery"
);
});
}
#[test]
#[serial]
fn runtime_recover_hid_resets_cycle_flag_after_async_recovery_path() {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", None::<&str>, || {
let rt = Runtime::new().expect("create runtime");
rt.block_on(async {
let kb_tmp = NamedTempFile::new().expect("temp keyboard file");
let ms_tmp = NamedTempFile::new().expect("temp mouse file");
let kb = tokio::fs::OpenOptions::new()
.write(true)
.open(kb_tmp.path())
.await
.expect("open temp kb");
let ms = tokio::fs::OpenOptions::new()
.write(true)
.open(ms_tmp.path())
.await
.expect("open temp ms");
let kb = Arc::new(Mutex::new(kb));
let ms = Arc::new(Mutex::new(ms));
let did_cycle = Arc::new(AtomicBool::new(false));
let err = std::io::Error::from_raw_os_error(libc::EPIPE);
runtime_support::recover_hid_if_needed(
&err,
UsbGadget::new("lesavka"),
kb.clone(),
ms.clone(),
did_cycle.clone(),
)
.await;
assert!(
did_cycle.load(Ordering::SeqCst),
"transport error should acquire recovery lock"
);
tokio::time::sleep(Duration::from_millis(2_300)).await;
assert!(
!did_cycle.load(Ordering::SeqCst),
"recovery task should release lock after cooldown"
);
});
});
}
#[test]
#[serial]
fn runtime_recover_hid_attempts_cycle_when_enabled() {
with_var("LESAVKA_ALLOW_GADGET_CYCLE", Some("1"), || {
let rt = Runtime::new().expect("create runtime");
rt.block_on(async {
let kb_tmp = NamedTempFile::new().expect("temp keyboard file");
let ms_tmp = NamedTempFile::new().expect("temp mouse file");
let kb = tokio::fs::OpenOptions::new()
.write(true)
.open(kb_tmp.path())
.await
.expect("open temp kb");
let ms = tokio::fs::OpenOptions::new()
.write(true)
.open(ms_tmp.path())
.await
.expect("open temp ms");
let kb = Arc::new(Mutex::new(kb));
let ms = Arc::new(Mutex::new(ms));
let did_cycle = Arc::new(AtomicBool::new(false));
let err = std::io::Error::from_raw_os_error(libc::EPIPE);
runtime_support::recover_hid_if_needed(
&err,
UsbGadget::new("lesavka"),
kb.clone(),
ms.clone(),
did_cycle.clone(),
)
.await;
tokio::time::sleep(Duration::from_millis(2_300)).await;
assert!(
!did_cycle.load(Ordering::SeqCst),
"cycle-enabled recovery should eventually clear lock"
);
});
});
}

70
testing/tests/server_uvc_binary_contract.rs
View File

@ -39,6 +39,48 @@ mod uvc_binary {
}
}
#[test]
#[serial]
fn uvc_config_from_env_applies_payload_caps_and_interval_defaults() {
with_var("LESAVKA_UVC_WIDTH", Some("640"), || {
with_var("LESAVKA_UVC_HEIGHT", Some("480"), || {
with_var("LESAVKA_UVC_FPS", Some("30"), || {
with_var("LESAVKA_UVC_INTERVAL", Some("0"), || {
with_var("LESAVKA_UVC_MAXPAYLOAD_LIMIT", Some("300"), || {
with_var("LESAVKA_UVC_MAXPACKET", Some("4096"), || {
with_var("LESAVKA_UVC_BULK", Some("1"), || {
let cfg = UvcConfig::from_env();
assert_eq!(cfg.width, 640);
assert_eq!(cfg.height, 480);
assert_eq!(cfg.fps, 30);
assert_eq!(cfg.interval, 10_000_000 / 30);
assert!(cfg.max_packet <= 300);
assert!(cfg.max_packet <= 512);
});
});
});
});
});
});
});
}
#[test]
#[serial]
fn uvc_config_from_env_keeps_explicit_interval_and_non_bulk_cap() {
with_var("LESAVKA_UVC_INTERVAL", Some("200000"), || {
with_var("LESAVKA_UVC_MAXPAYLOAD_LIMIT", Some("1500"), || {
with_var("LESAVKA_UVC_MAXPACKET", Some("1200"), || {
with_var("LESAVKA_UVC_BULK", None::<&str>, || {
let cfg = UvcConfig::from_env();
assert_eq!(cfg.interval, 200_000);
assert_eq!(cfg.max_packet, 1024);
});
});
});
});
}
#[test]
fn build_streaming_control_populates_core_fields_for_11_and_15_byte_profiles() {
let cfg = sample_cfg();
@ -269,6 +311,33 @@ mod uvc_binary {
});
}
#[test]
fn interface_helpers_and_configfs_snapshot_are_stable_without_sysfs() {
let tmp = NamedTempFile::new().expect("tmp");
fs::write(tmp.path(), "7\n").expect("write");
assert_eq!(read_interface(tmp.path().to_str().expect("path")), Some(7));
fs::write(tmp.path(), "bad\n").expect("write bad");
assert_eq!(read_interface(tmp.path().to_str().expect("path")), None);
let interfaces = load_interfaces();
assert_eq!(interfaces.control, UVC_STRING_CONTROL_IDX);
assert_eq!(interfaces.streaming, UVC_STRING_STREAMING_IDX);
assert!(read_configfs_snapshot().is_none());
let mut state = UvcState::new(sample_cfg());
state.cfg_snapshot = Some(ConfigfsSnapshot {
width: 640,
height: 480,
default_interval: 333_333,
frame_interval: 333_333,
maxpacket: 1024,
maxburst: 0,
});
log_configfs_snapshot(&mut state, "contract");
assert!(state.cfg_snapshot.is_some());
}
#[test]
fn io_helpers_read_values_and_fifo_minimums() {
let tmp = NamedTempFile::new().expect("tmp");
@ -344,4 +413,5 @@ mod uvc_binary {
handle_setup(-1, 0, &mut state, &mut pending, interfaces, req, false);
assert!(pending.is_none());
}
}

246
testing/tests/server_uvc_binary_extra_contract.rs Normal file
View File

@ -0,0 +1,246 @@
//! Extra coverage for `lesavka-uvc` control/error branches.
//!
//! Scope: keep additive branch tests in a separate file so each testing module
//! remains under the 500 LOC contract.
//! Targets: `server/src/bin/lesavka-uvc.rs`.
//! Why: preserve expanded UVC branch coverage while satisfying test module contracts.
mod uvc_binary_extra {
#![allow(warnings)]
#![allow(clippy::all)]
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
include!(env!("LESAVKA_SERVER_UVC_BIN_SRC"));
use serial_test::serial;
use std::fs;
use std::path::PathBuf;
use temp_env::with_var;
use tempfile::NamedTempFile;
fn sample_cfg() -> UvcConfig {
UvcConfig {
width: 1280,
height: 720,
fps: 25,
interval: 400_000,
max_packet: 1024,
frame_size: 1_843_200,
}
}
fn sample_interfaces() -> UvcInterfaces {
UvcInterfaces {
control: UVC_STRING_CONTROL_IDX,
streaming: UVC_STRING_STREAMING_IDX,
}
}
#[test]
fn handle_setup_stalls_non_streaming_set_cur_and_non_in_requests() {
let interfaces = sample_interfaces();
let mut state = UvcState::new(sample_cfg());
let mut pending = None;
let set_cur_other_iface = UsbCtrlRequest {
b_request_type: 0x00,
b_request: UVC_SET_CUR,
w_value: (0xFEu16) << 8,
w_index: 0x00FF,
w_length: 8,
};
handle_setup(
-1,
0,
&mut state,
&mut pending,
interfaces,
set_cur_other_iface,
true,
);
assert!(pending.is_none());
let non_in_non_set_cur = UsbCtrlRequest {
b_request_type: 0x00,
b_request: UVC_GET_CUR,
w_value: (UVC_VS_PROBE_CONTROL as u16) << 8,
w_index: interfaces.streaming as u16,
w_length: 8,
};
handle_setup(
-1,
0,
&mut state,
&mut pending,
interfaces,
non_in_non_set_cur,
true,
);
assert!(pending.is_none());
}
#[test]
fn handle_setup_rejects_oversized_set_cur_payload() {
let interfaces = sample_interfaces();
let mut state = UvcState::new(sample_cfg());
let mut pending = None;
let oversized = UsbCtrlRequest {
b_request_type: 0x00,
b_request: UVC_SET_CUR,
w_value: (UVC_VS_PROBE_CONTROL as u16) << 8,
w_index: interfaces.streaming as u16,
w_length: (UVC_DATA_SIZE as u16).saturating_add(1),
};
handle_setup(-1, 0, &mut state, &mut pending, interfaces, oversized, true);
assert!(pending.is_none());
}
#[test]
fn handle_setup_stalls_unknown_in_selector() {
let interfaces = sample_interfaces();
let mut state = UvcState::new(sample_cfg());
let mut pending = None;
let req = UsbCtrlRequest {
b_request_type: USB_DIR_IN,
b_request: UVC_GET_CUR,
w_value: (0xFEu16) << 8,
w_index: interfaces.streaming as u16,
w_length: 8,
};
handle_setup(-1, 0, &mut state, &mut pending, interfaces, req, true);
assert!(pending.is_none());
}
#[test]
fn handle_data_ignores_missing_pending_and_negative_lengths() {
let interfaces = sample_interfaces();
let mut state = UvcState::new(sample_cfg());
let mut pending = None;
handle_data(
-1,
0,
&mut state,
&mut pending,
interfaces,
UvcRequestData {
length: 8,
data: [0u8; UVC_DATA_SIZE],
},
true,
);
pending = Some(PendingRequest {
interface: interfaces.streaming,
selector: UVC_VS_PROBE_CONTROL,
expected_len: STREAM_CTRL_SIZE_11,
});
handle_data(
-1,
0,
&mut state,
&mut pending,
interfaces,
UvcRequestData {
length: -1,
data: [0u8; UVC_DATA_SIZE],
},
true,
);
assert!(pending.is_none());
}
#[test]
fn handle_data_ignores_non_streaming_pending_requests() {
let interfaces = sample_interfaces();
let mut state = UvcState::new(sample_cfg());
let mut pending = Some(PendingRequest {
interface: interfaces.control,
selector: UVC_VS_PROBE_CONTROL,
expected_len: STREAM_CTRL_SIZE_11,
});
let mut payload = [0u8; UVC_DATA_SIZE];
payload[2] = 1;
handle_data(
-1,
0,
&mut state,
&mut pending,
interfaces,
UvcRequestData {
length: STREAM_CTRL_SIZE_11 as i32,
data: payload,
},
true,
);
assert!(pending.is_none());
assert_eq!(state.probe, state.default);
}
#[test]
fn build_in_response_returns_none_for_unknown_selector() {
let state = UvcState::new(sample_cfg());
let interfaces = sample_interfaces();
let response = build_in_response(
&state,
interfaces,
interfaces.streaming,
0xFE,
UVC_GET_CUR,
8,
);
assert!(response.is_none());
}
#[test]
fn sanitize_streaming_control_keeps_defaults_for_short_payload() {
let state = UvcState::new(sample_cfg());
let short = [0u8; 8];
let out = sanitize_streaming_control(&short, &state);
assert_eq!(out, state.default);
}
#[test]
fn io_helpers_return_none_for_empty_or_missing_input() {
let empty = NamedTempFile::new().expect("tmp");
fs::write(empty.path(), "\n").expect("write empty");
assert_eq!(read_u32_first(empty.path().to_str().expect("path")), None);
let missing = PathBuf::from(format!(
"/tmp/lesavka-missing-fifo-{}-{}",
std::process::id(),
std::thread::current().name().unwrap_or("anon")
));
assert_eq!(read_fifo_min(missing.to_str().expect("missing")), None);
}
#[test]
fn compute_payload_cap_clamps_limit_pct_bounds() {
with_var("LESAVKA_UVC_MAXPAYLOAD_LIMIT", None::<&str>, || {
with_var("LESAVKA_UVC_LIMIT_PCT", Some("0"), || {
let cap = compute_payload_cap(false);
if let Some(cap) = cap {
assert!(cap.pct >= 1);
}
});
with_var("LESAVKA_UVC_LIMIT_PCT", Some("250"), || {
let cap = compute_payload_cap(true);
if let Some(cap) = cap {
assert!(cap.pct <= 100);
}
});
});
}
#[test]
#[serial]
fn main_returns_error_for_non_uvc_device_node() {
with_var("LESAVKA_UVC_DEV", Some("/dev/null"), || {
with_var("LESAVKA_UVC_BLOCKING", Some("1"), || {
let result = main();
assert!(result.is_err(), "non-UVC node should fail during event subscribe");
});
});
}
}

112
testing/tests/server_uvc_process_contract.rs Normal file
View File

@ -0,0 +1,112 @@
//! Integration coverage for `lesavka-uvc` process startup parsing.
//!
//! Scope: launch the real `lesavka-uvc` binary with controlled arguments and
//! environment overrides to exercise argument/config parsing and early startup.
//! Targets: `server/src/bin/lesavka-uvc.rs`.
//! Why: command-line/environment startup behavior should fail fast and remain
//! deterministic without a physical UVC gadget node in CI.
use serial_test::serial;
use std::path::{Path, PathBuf};
use std::process::{Child, Command, ExitStatus};
use std::time::{Duration, Instant};
use tempfile::NamedTempFile;
fn candidate_dirs() -> Vec<PathBuf> {
let exe = std::env::current_exe().expect("current exe path");
let mut dirs = Vec::new();
if let Some(parent) = exe.parent() {
dirs.push(parent.to_path_buf());
if let Some(grand) = parent.parent() {
dirs.push(grand.to_path_buf());
}
}
dirs.push(PathBuf::from("target/debug"));
dirs.push(PathBuf::from("target/llvm-cov-target/debug"));
dirs
}
fn find_binary(name: &str) -> Option<PathBuf> {
candidate_dirs()
.into_iter()
.map(|dir| dir.join(name))
.find(|path| path.exists() && path.is_file())
}
fn wait_for_exit(mut child: Child, timeout: Duration) -> ExitStatus {
let deadline = Instant::now() + timeout;
loop {
if let Some(status) = child.try_wait().expect("poll child") {
return status;
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
panic!("lesavka-uvc did not exit within timeout");
}
std::thread::sleep(Duration::from_millis(50));
}
}
#[test]
#[serial]
fn uvc_binary_requires_device_argument_or_env() {
let Some(bin) = find_binary("lesavka-uvc") else {
return;
};
let status = Command::new(Path::new(&bin))
.env_remove("LESAVKA_UVC_DEV")
.status()
.expect("spawn lesavka-uvc");
assert!(!status.success(), "uvc binary should fail without a device path");
}
#[test]
#[serial]
fn uvc_binary_applies_env_config_and_fails_fast_on_non_v4l2_node() {
let Some(bin) = find_binary("lesavka-uvc") else {
return;
};
let fake_device = NamedTempFile::new().expect("temp device");
let child = Command::new(Path::new(&bin))
.arg("--device")
.arg(fake_device.path())
.env("LESAVKA_UVC_MAXPAYLOAD_LIMIT", "256")
.env("LESAVKA_UVC_MAXPACKET", "4096")
.env("LESAVKA_UVC_BULK", "1")
.env("LESAVKA_UVC_FPS", "30")
.spawn()
.expect("spawn lesavka-uvc");
let status = wait_for_exit(child, Duration::from_secs(3));
assert!(
!status.success(),
"uvc binary should fail on non-v4l2 test file"
);
}
#[test]
#[serial]
fn uvc_binary_accepts_positional_device_argument() {
let Some(bin) = find_binary("lesavka-uvc") else {
return;
};
let fake_device = NamedTempFile::new().expect("temp device");
let child = Command::new(Path::new(&bin))
.arg(fake_device.path())
.env_remove("LESAVKA_UVC_BULK")
.env("LESAVKA_UVC_MAXPAYLOAD_LIMIT", "2048")
.env("LESAVKA_UVC_MAXPACKET", "1024")
.spawn()
.expect("spawn lesavka-uvc");
let status = wait_for_exit(child, Duration::from_secs(3));
assert!(
!status.success(),
"uvc binary should fail on non-v4l2 test file"
);
}

62
testing/tests/server_uvc_runtime_contract.rs
View File

@ -6,7 +6,7 @@
//! Why: the helper supervisor is operationally critical and should be covered
//! through top-level integration behavior, not only unit checks.
use lesavka_server::uvc_runtime::supervise_uvc_control;
use lesavka_server::uvc_runtime::{pick_uvc_device, supervise_uvc_control};
use serial_test::serial;
use std::fs;
use std::os::unix::fs::PermissionsExt;
@ -117,3 +117,63 @@ fn supervise_uvc_control_survives_missing_helper_binary() {
);
});
}
#[test]
#[serial]
fn pick_uvc_device_prefers_controller_by_path_override_root() {
let dir = tempdir().expect("tempdir");
let sys_root = dir.path().join("sys");
let by_path = dir.path().join("v4l/by-path");
fs::create_dir_all(sys_root.join("class/udc/fake-ctrl.usb")).expect("create fake udc");
fs::create_dir_all(&by_path).expect("create by-path dir");
let expected = by_path.join("platform-fake-ctrl.usb-video-index0");
fs::write(&expected, "").expect("touch by-path node");
temp_env::with_var(
"LESAVKA_GADGET_SYSFS_ROOT",
Some(sys_root.to_string_lossy().to_string()),
|| {
temp_env::with_var(
"LESAVKA_UVC_BY_PATH_ROOT",
Some(by_path.to_string_lossy().to_string()),
|| {
temp_env::with_var("LESAVKA_UVC_SKIP_UDEV", Some("1"), || {
temp_env::with_var("LESAVKA_UVC_DEV", None::<&str>, || {
let picked = pick_uvc_device().expect("pick by-path device");
assert_eq!(picked, expected.to_string_lossy());
});
});
},
);
},
);
}
#[test]
#[serial]
fn pick_uvc_device_errors_when_overrides_disable_all_discovery_paths() {
let dir = tempdir().expect("tempdir");
let sys_root = dir.path().join("sys");
let by_path = dir.path().join("v4l/by-path");
fs::create_dir_all(&sys_root).expect("create fake sys root");
fs::create_dir_all(&by_path).expect("create fake by-path root");
temp_env::with_var(
"LESAVKA_GADGET_SYSFS_ROOT",
Some(sys_root.to_string_lossy().to_string()),
|| {
temp_env::with_var(
"LESAVKA_UVC_BY_PATH_ROOT",
Some(by_path.to_string_lossy().to_string()),
|| {
temp_env::with_var("LESAVKA_UVC_SKIP_UDEV", Some("1"), || {
temp_env::with_var("LESAVKA_UVC_DEV", None::<&str>, || {
let err = pick_uvc_device().expect_err("missing paths should error");
assert!(err.to_string().contains("LESAVKA_UVC_DEV"));
});
});
},
);
},
);
}

108
testing/tests/server_video_include_contract.rs
View File

@ -108,4 +108,112 @@ mod video_include_contract {
});
assert!(panic_result.is_err(), "invalid eye id must panic before setup");
}
#[test]
#[serial]
fn eye_ball_attempts_runtime_setup_for_existing_non_camera_device() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
with_var("LESAVKA_EYE_ADAPTIVE", Some("1"), || {
with_var("LESAVKA_EYE_QUEUE_BUFFERS", Some("3"), || {
with_var("LESAVKA_EYE_APPSINK_BUFFERS", Some("3"), || {
let result = rt.block_on(async {
tokio::time::timeout(
std::time::Duration::from_millis(250),
eye_ball("/dev/null", 0, 6_000),
)
.await
});
match result {
Ok(Ok(stream)) => drop(stream),
Ok(Err(_)) | Err(_) => {}
}
});
});
});
}
#[test]
#[serial]
fn eye_ball_second_eye_branch_runs_without_panicking() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
with_var("LESAVKA_EYE_ADAPTIVE", Some("0"), || {
let result = rt.block_on(async {
tokio::time::timeout(
std::time::Duration::from_millis(250),
eye_ball("/dev/null", 1, 2_000),
)
.await
});
match result {
Ok(Ok(stream)) => drop(stream),
Ok(Err(_)) | Err(_) => {}
}
});
}
#[test]
#[serial]
fn eye_ball_testsrc_path_produces_stream_packets() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
with_var("LESAVKA_EYE_ADAPTIVE", Some("1"), || {
with_var("LESAVKA_EYE_QUEUE_BUFFERS", Some("8"), || {
with_var("LESAVKA_EYE_APPSINK_BUFFERS", Some("8"), || {
with_var("LESAVKA_EYE_TESTSRC_KBIT", Some("1200"), || {
rt.block_on(async {
let setup = tokio::time::timeout(
std::time::Duration::from_secs(2),
eye_ball("testsrc", 0, 1_200),
)
.await;
let mut stream = match setup {
Ok(Ok(stream)) => stream,
Ok(Err(err)) => panic!("testsrc setup failed: {err:#}"),
Err(_) => panic!("testsrc setup timed out"),
};
let packet = tokio::time::timeout(
std::time::Duration::from_secs(2),
stream.next(),
)
.await
.expect("video packet timeout")
.expect("stream item")
.expect("packet");
assert!(packet.id <= 1);
assert!(!packet.data.is_empty());
drop(stream);
});
});
});
});
});
}
#[test]
#[serial]
fn eye_ball_testsrc_backpressure_path_is_non_panicking() {
let rt = tokio::runtime::Runtime::new().expect("runtime");
with_var("LESAVKA_EYE_ADAPTIVE", Some("1"), || {
with_var("LESAVKA_EYE_CHAN_CAPACITY", Some("16"), || {
rt.block_on(async {
let setup = tokio::time::timeout(
std::time::Duration::from_secs(2),
eye_ball("testsrc", 1, 1_800),
)
.await;
let mut stream = match setup {
Ok(Ok(stream)) => stream,
Ok(Err(err)) => panic!("testsrc setup failed: {err:#}"),
Err(_) => panic!("testsrc setup timed out"),
};
tokio::time::sleep(std::time::Duration::from_millis(300)).await;
let _ = tokio::time::timeout(
std::time::Duration::from_secs(1),
stream.next(),
)
.await;
});
});
});
}
}

40
testing/tests/server_video_sink_smoke_contract.rs
View File

@ -82,3 +82,43 @@ fn camera_relay_uvc_constructor_is_stable_for_missing_device() {
Err(err) => assert!(!err.to_string().trim().is_empty()),
}
}
#[test]
#[serial]
fn webcam_sink_h264_constructor_path_is_stable() {
let cfg = hdmi_config(CameraCodec::H264);
match WebcamSink::new("/dev/video-definitely-missing", &cfg) {
Ok(sink) => sink.push(VideoPacket {
id: 3,
pts: 55,
data: vec![0, 0, 0, 1, 0x65],
}),
Err(err) => assert!(!err.to_string().trim().is_empty()),
}
}
#[test]
#[serial]
fn hdmi_sink_mjpeg_constructor_path_is_stable() {
with_var("LESAVKA_HDMI_SINK", Some("autovideosink"), || {
let cfg = hdmi_config(CameraCodec::Mjpeg);
match HdmiSink::new(&cfg) {
Ok(sink) => sink.push(VideoPacket {
id: 4,
pts: 99,
data: vec![0xFF, 0xD8, 0xFF, 0xD9],
}),
Err(err) => assert!(!err.to_string().trim().is_empty()),
}
});
}
#[test]
#[serial]
fn hdmi_sink_override_with_invalid_element_returns_error() {
with_var("LESAVKA_HDMI_SINK", Some("definitely-not-a-real-gst-element"), || {
let cfg = hdmi_config(CameraCodec::H264);
let result = HdmiSink::new(&cfg);
assert!(result.is_err(), "invalid sink override should fail construction");
});
}

112
testing/tests/server_video_sinks_include_contract.rs Normal file
View File

@ -0,0 +1,112 @@
//! Include-based coverage for server camera sink internals.
//!
//! Scope: include `server/src/video_sinks.rs` and directly exercise private sink
//! selection/dispatch helpers through stable constructor paths.
//! Targets: `server/src/video_sinks.rs`.
//! Why: sink internals carry substantial branch logic beyond public smoke tests.
mod camera {
pub use lesavka_server::camera::*;
}
mod video_support {
pub use lesavka_server::video_support::*;
}
#[allow(warnings)]
mod video_sinks_include_contract {
include!(env!("LESAVKA_SERVER_VIDEO_SINKS_SRC"));
use crate::camera::CameraOutput;
use serial_test::serial;
use temp_env::with_var;
fn cfg(codec: CameraCodec) -> CameraConfig {
CameraConfig {
output: CameraOutput::Hdmi,
codec,
width: 640,
height: 360,
fps: 24,
hdmi: None,
}
}
fn init_gst() {
let _ = gst::init();
}
#[test]
#[serial]
fn build_hdmi_sink_respects_env_override_success_path() {
init_gst();
with_var("LESAVKA_HDMI_SINK", Some("autovideosink"), || {
let sink = build_hdmi_sink(&cfg(CameraCodec::H264));
assert!(sink.is_ok(), "known override sink should build");
});
}
#[test]
#[serial]
fn build_hdmi_sink_invalid_override_surfaces_error() {
init_gst();
with_var("LESAVKA_HDMI_SINK", Some("definitely-not-a-real-gst-element"), || {
let sink = build_hdmi_sink(&cfg(CameraCodec::H264));
assert!(sink.is_err(), "invalid override must fail");
});
}
#[test]
#[serial]
fn build_hdmi_sink_falls_back_when_override_is_unset() {
init_gst();
with_var("LESAVKA_HDMI_SINK", None::<&str>, || {
let sink = build_hdmi_sink(&cfg(CameraCodec::H264));
assert!(sink.is_ok(), "fallback sink should build");
});
}
#[test]
#[serial]
fn camera_sink_dispatch_is_stable_for_hdmi_variant() {
with_var("LESAVKA_HDMI_SINK", Some("autovideosink"), || {
if let Ok(sink) = HdmiSink::new(&cfg(CameraCodec::Mjpeg)) {
let cam_sink = CameraSink::Hdmi(sink);
cam_sink.push(VideoPacket {
id: 8,
pts: 1,
data: vec![0xFF, 0xD8, 0xFF, 0xD9],
});
}
});
}
#[test]
#[serial]
fn camera_sink_dispatch_is_stable_for_uvc_variant() {
if let Ok(sink) = WebcamSink::new("/dev/video-definitely-missing", &cfg(CameraCodec::Mjpeg)) {
let cam_sink = CameraSink::Uvc(sink);
cam_sink.push(VideoPacket {
id: 9,
pts: 2,
data: vec![0xFF, 0xD8, 0xFF, 0xD9],
});
}
}
#[test]
#[serial]
fn camera_relay_feed_covers_dev_mode_dump_branch_without_panicking() {
with_var("LESAVKA_DEV_MODE", Some("1"), || {
with_var("LESAVKA_HDMI_SINK", Some("autovideosink"), || {
if let Ok(relay) = CameraRelay::new_hdmi(3, &cfg(CameraCodec::H264)) {
relay.feed(VideoPacket {
id: 3,
pts: 3,
data: vec![0, 0, 0, 1, 0x65, 0x88, 0x84],
});
}
});
});
}
}