chore(coverage): remove ignore-filename-regex and add inline tests

Remove the blanket --ignore-filename-regex from cargo-llvm-cov config
and add targeted tests for previously excluded code instead.

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

rsworkspace/Cargo.lock

@@ -180,3 +180,66 @@ async fn run_send_pump(
     }
     let _ = ws_sender.close().await;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::extract::State;
+    use axum::extract::ws::WebSocketUpgrade;
+    use axum::response::Response;
+    use std::time::Duration;
+    use tokio::io::AsyncReadExt;
+    use tokio::net::TcpListener;
+    use tokio_tungstenite::connect_async;
+    use tokio_tungstenite::tungstenite::Message as TungsteniteMessage;
+
+    #[derive(Clone)]
+    struct EchoState;
+
+    async fn echo_handler(ws: WebSocketUpgrade, State(_): State<EchoState>) -> Response {
+        ws.on_upgrade(|socket| async move {
+            let (ws_sender, ws_receiver) = socket.split();
+            let (duplex_write, duplex_read) = tokio::io::duplex(DUPLEX_BUFFER_SIZE);
+            let recv = run_recv_pump(ws_receiver, duplex_write);
+            let send = run_send_pump(ws_sender, duplex_read);
+            tokio::join!(recv, send);
+        })
+    }
+
+    async fn start_echo_server() -> String {
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let app = axum::Router::new()
+            .route("/ws", axum::routing::get(echo_handler))
+            .with_state(EchoState);
+        tokio::spawn(async move {
+            axum::serve(listener, app).await.unwrap();
+        });
+        format!("ws://{}/ws", addr)
+    }
+
+    #[tokio::test]
+    async fn multiple_messages_round_trip() {
+        let url = start_echo_server().await;
+        let (mut ws, _) = connect_async(&url).await.unwrap();
+
+        let messages = vec!["alpha", "beta", "gamma"];
+        for msg in &messages {
+            ws.send(TungsteniteMessage::Text((*msg).into()))
+                .await
+                .unwrap();
+        }
+
+        for expected in &messages {
+            let msg = tokio::time::timeout(Duration::from_secs(2), ws.next())
+                .await
+                .expect("timeout")
+                .expect("stream ended")
+                .unwrap();
+            match msg {
+                TungsteniteMessage::Text(t) => assert_eq!(t, *expected),
+                other => panic!("expected Text('{expected}'), got {other:?}"),
+            }
+        }
+    }
+}

rsworkspace/crates/acp-nats-ws/src/connection.rs

@@ -30,3 +30,44 @@ pub async fn handle(ws: WebSocketUpgrade, State(state): State<UpgradeState>) ->
         }
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures_util::SinkExt;
+    use std::time::Duration;
+    use tokio::net::TcpListener;
+    use tokio_tungstenite::connect_async;
+    use tokio_tungstenite::tungstenite::Message;
+
+    #[tokio::test]
+    async fn handle_sends_connection_request_through_channel() {
+        let (shutdown_tx, _shutdown_rx) = watch::channel(false);
+        let (conn_tx, mut conn_rx) = mpsc::unbounded_channel::<ConnectionRequest>();
+
+        let state = UpgradeState {
+            conn_tx,
+            shutdown_tx: shutdown_tx.clone(),
+        };
+
+        let app = axum::Router::new()
+            .route("/ws", axum::routing::get(handle))
+            .with_state(state);
+
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        tokio::spawn(async move {
+            axum::serve(listener, app).await.unwrap();
+        });
+
+        let url = format!("ws://{}/ws", addr);
+        let (_ws, _) = connect_async(&url).await.unwrap();
+
+        let req = tokio::time::timeout(Duration::from_secs(2), conn_rx.recv())
+            .await
+            .expect("timeout waiting for ConnectionRequest")
+            .expect("channel closed");
+
+        assert!(!*req.shutdown_rx.borrow());
+    }
+}

rsworkspace/crates/acp-nats-ws/src/upgrade.rs

@@ -15,4 +15,6 @@ tracing-subscriber = { version = "0.3.22", features = ["env-filter", "fmt", "jso
 trogon-std = { path = "../trogon-std" }
 
 [dev-dependencies]
+libc = "0.2"
+tokio = { version = "1.49.0", features = ["rt", "macros", "signal"] }
 trogon-std = { path = "../trogon-std", features = ["test-support"] }

rsworkspace/crates/acp-telemetry/Cargo.toml

@@ -208,4 +208,21 @@ mod tests {
         assert_eq!(ServiceName::AcpNatsStdio.as_str(), "acp-nats-stdio");
         assert_eq!(ServiceName::AcpNatsWs.as_str(), "acp-nats-ws");
     }
+
+    #[test]
+    fn otel_lifecycle() {
+        let _ = try_init_otel(ServiceName::AcpNatsStdio, "test");
+        let m = meter("test-meter");
+        let _ = m.u64_counter("test_counter").build();
+        shutdown_otel();
+    }
+
+    #[test]
+    fn init_logger_without_otel_does_not_panic() {
+        let env = InMemoryEnv::new();
+        env.set("ACP_LOG_DIR", "/tmp/test-init-logger");
+        let fs = MemFs::new();
+
+        init_logger(ServiceName::AcpNatsStdio, "test", &env, &fs);
+    }
 }

rsworkspace/crates/acp-telemetry/src/lib.rs

@@ -81,6 +81,7 @@ fn platform_log_dir(service_name: ServiceName) -> Result<PathBuf, Box<dyn std::e
 #[cfg(test)]
 mod tests {
     use super::*;
+    use opentelemetry::KeyValue;
     use trogon_std::env::InMemoryEnv;
     use trogon_std::fs::MemFs;
 
@@ -109,4 +110,17 @@ mod tests {
         let dir = platform_log_dir(ServiceName::AcpNatsWs).unwrap();
         assert!(dir.ends_with(ServiceName::AcpNatsWs.as_str()));
     }
+
+    #[test]
+    fn init_provider_lifecycle() {
+        let resource = opentelemetry_sdk::Resource::builder()
+            .with_service_name("test-log")
+            .with_attributes(vec![KeyValue::new("test", "true")])
+            .build();
+
+        let provider = init_provider(&resource);
+        assert!(provider.is_ok());
+        force_flush();
+        shutdown();
+    }
 }

rsworkspace/crates/acp-telemetry/src/log.rs

@@ -42,3 +42,23 @@ pub(crate) fn shutdown() {
         eprintln!("Failed to shutdown meter provider: {e}");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use opentelemetry::KeyValue;
+    use opentelemetry_sdk::Resource;
+
+    #[test]
+    fn init_provider_returns_valid_provider() {
+        let resource = Resource::builder()
+            .with_service_name("test-metric")
+            .with_attributes(vec![KeyValue::new("test", "true")])
+            .build();
+
+        let provider = init_provider(&resource);
+        assert!(provider.is_ok());
+        force_flush();
+        shutdown();
+    }
+}

rsworkspace/crates/acp-telemetry/src/metric.rs

@@ -33,3 +33,22 @@ pub async fn shutdown_signal() {
         _ = terminate => {}
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn shutdown_signal_completes_on_sigterm() {
+        let handle = tokio::spawn(shutdown_signal());
+
+        tokio::task::yield_now().await;
+
+        unsafe {
+            libc::kill(libc::getpid(), libc::SIGTERM);
+        }
+
+        let result = tokio::time::timeout(std::time::Duration::from_secs(2), handle).await;
+        assert!(result.is_ok());
+    }
+}

rsworkspace/crates/acp-telemetry/src/signal.rs

@@ -32,3 +32,23 @@ pub(crate) fn shutdown() {
         eprintln!("Failed to shutdown tracer provider: {e}");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use opentelemetry::KeyValue;
+    use opentelemetry_sdk::Resource;
+
+    #[test]
+    fn init_provider_returns_valid_provider() {
+        let resource = Resource::builder()
+            .with_service_name("test-trace")
+            .with_attributes(vec![KeyValue::new("test", "true")])
+            .build();
+
+        let provider = init_provider(&resource);
+        assert!(provider.is_ok());
+        force_flush();
+        shutdown();
+    }
+}