Improve test coverage

Cargo.toml

@@ -46,7 +46,10 @@ miette = { version = "5.10.0", features = ["fancy"] }
 
 # Logging
 tracing-subscriber = "0.3.17"
-tracing-test = "0.2.4"
+tracing-test = { version = "0.2.4", features = [
+    "no-env-filter",
+    "llvm-cov-compat",
+], branch = "fix_coverage", git = "https://github.com/Finomnis/tracing-test.git" }
 
 # Tokio
 tokio = { version = "1.32.0", features = ["full"] }

src/error_action.rs

@@ -29,6 +29,7 @@ pub enum ErrorAction {
 mod tests {
     use super::*;
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn derive_traits() {
         let x = ErrorAction::CatchAndLocalShutdown;
         #[allow(clippy::clone_on_copy)]

src/errors.rs

@@ -132,6 +132,7 @@ mod tests {
 
     use super::*;
 
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn examine_report(report: miette::Report) {
         println!("{}", report);
         println!("{:?}", report);
@@ -142,6 +143,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn errors_can_be_converted_to_diagnostic() {
         examine_report(GracefulShutdownError::ShutdownTimeout::<BoxedError>(Box::new([])).into());
         examine_report(GracefulShutdownError::SubsystemsFailed::<BoxedError>(Box::new([])).into());
@@ -154,6 +156,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn extract_related_from_graceful_shutdown_error() {
         let related = || {
             Box::new([
@@ -185,6 +188,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn extract_contained_error_from_convert_subsystem_failure() {
         let msg = "MyFailure".to_string();
         let failure = SubsystemFailure(msg.clone());

src/lib.rs

@@ -91,6 +91,8 @@
     test(no_crate_inject, attr(deny(warnings))),
     test(attr(allow(dead_code)))
 )]
+// Required for test coverage
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
 
 type BoxedError = Box<dyn std::error::Error + Send + Sync + 'static>;
 

src/runner/alive_guard.rs

@@ -62,10 +62,13 @@ impl Drop for Inner {
 mod tests {
 
     use std::sync::atomic::{AtomicU32, Ordering};
+    use tracing_test::traced_test;
 
     use super::*;
 
     #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn finished_callback() {
         let alive_guard = AliveGuard::new();
 
@@ -82,6 +85,8 @@ mod tests {
     }
 
     #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn cancel_callback() {
         let alive_guard = AliveGuard::new();
 
@@ -99,6 +104,8 @@ mod tests {
     }
 
     #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn both_callbacks() {
         let alive_guard = AliveGuard::new();
 
@@ -117,4 +124,14 @@ mod tests {
 
         assert_eq!(counter.load(Ordering::Relaxed), 2);
     }
+
+    #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
+    fn no_callback() {
+        let alive_guard = AliveGuard::new();
+        drop(alive_guard);
+
+        assert!(logs_contain("No `finished` callback was registered in AliveGuard! This should not happen, please report this at https://github.com/Finomnis/tokio-graceful-shutdown/issues."));
+    }
 }

src/subsystem/error_collector.rs

@@ -41,3 +41,79 @@ impl<ErrType: ErrTypeTraits> Drop for ErrorCollector<ErrType> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use tracing_test::traced_test;
+
+    use super::*;
+
+    #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
+    fn normal() {
+        let (sender, receiver) = mpsc::unbounded_channel();
+        let mut error_collector = ErrorCollector::<String>::new(receiver);
+
+        sender
+            .send(SubsystemError::Panicked(Arc::from("ABC")))
+            .unwrap();
+        sender
+            .send(SubsystemError::Panicked(Arc::from("def")))
+            .unwrap();
+
+        let received = error_collector.finish();
+        assert_eq!(
+            received.iter().map(|e| e.name()).collect::<Vec<_>>(),
+            vec!["ABC", "def"]
+        );
+    }
+
+    #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
+    fn double_finish() {
+        let (sender, receiver) = mpsc::unbounded_channel();
+        let mut error_collector = ErrorCollector::<String>::new(receiver);
+
+        sender
+            .send(SubsystemError::Panicked(Arc::from("ABC")))
+            .unwrap();
+        sender
+            .send(SubsystemError::Panicked(Arc::from("def")))
+            .unwrap();
+
+        let received = error_collector.finish();
+        assert_eq!(
+            received.iter().map(|e| e.name()).collect::<Vec<_>>(),
+            vec!["ABC", "def"]
+        );
+
+        let received = error_collector.finish();
+        assert_eq!(
+            received.iter().map(|e| e.name()).collect::<Vec<_>>(),
+            vec!["ABC", "def"]
+        );
+    }
+
+    #[test]
+    #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
+    fn no_finish() {
+        let (sender, receiver) = mpsc::unbounded_channel();
+        let error_collector = ErrorCollector::<String>::new(receiver);
+
+        sender
+            .send(SubsystemError::Panicked(Arc::from("ABC")))
+            .unwrap();
+        sender
+            .send(SubsystemError::Panicked(Arc::from("def")))
+            .unwrap();
+
+        drop(error_collector);
+
+        assert!(logs_contain("An error got dropped: Panicked(\"ABC\")"));
+        assert!(logs_contain("An error got dropped: Panicked(\"def\")"));
+    }
+}

src/subsystem/subsystem_handle.rs

@@ -362,6 +362,7 @@ mod tests {
     use crate::subsystem::SubsystemBuilder;
 
     #[tokio::test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     async fn recursive_cancellation() {
         let root_handle = root_handle::<BoxedError>(|_| {});
 
@@ -388,6 +389,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     async fn recursive_cancellation_2() {
         let root_handle = root_handle(|_| {});
 

src/utils/joiner_token.rs

@@ -187,6 +187,7 @@ mod tests {
 
     #[test]
     #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn counters() {
         let (root, _) = JoinerToken::<BoxedError>::new(|_| None);
         assert_eq!(0, root.count());
@@ -221,6 +222,7 @@ mod tests {
 
     #[test]
     #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn counters_weak() {
         let (root, weak_root) = JoinerToken::<BoxedError>::new(|_| None);
         assert_eq!(0, weak_root.count());
@@ -293,6 +295,7 @@ mod tests {
 
     #[tokio::test]
     #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     async fn join() {
         let (superroot, _) = JoinerToken::<BoxedError>::new(|_| None);
 
@@ -335,6 +338,7 @@ mod tests {
 
     #[tokio::test]
     #[traced_test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     async fn join_through_ref() {
         let (root, joiner) = JoinerToken::<BoxedError>::new(|_| None);
 
@@ -372,6 +376,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn debug_print() {
         let (root, _) = JoinerToken::<BoxedError>::new(|_| None);
         assert_eq!(format!("{:?}", root), "JoinerToken(children = 0)");
@@ -384,6 +389,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn debug_print_ref() {
         let (root, root_ref) = JoinerToken::<BoxedError>::new(|_| None);
         assert_eq!(

src/utils/remote_drop_collection.rs

@@ -86,6 +86,7 @@ mod tests {
     use crate::{utils::JoinerToken, BoxedError};
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn insert_and_drop() {
         let items = RemotelyDroppableItems::new();
 
@@ -109,6 +110,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn drop_token() {
         let items = RemotelyDroppableItems::new();
 

tests/cancel_on_shutdown.rs

@@ -1,3 +1,6 @@
+// Required for test coverage
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
 use tokio::time::{sleep, Duration};
 use tokio_graceful_shutdown::{
     errors::CancelledByShutdown, FutureExt, SubsystemBuilder, SubsystemHandle, Toplevel,

tests/integration_test.rs

@@ -1,3 +1,6 @@
+// Required for test coverage
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
 use anyhow::anyhow;
 use tokio::time::{sleep, timeout, Duration};
 use tokio_graceful_shutdown::{

tests/integration_test_2.rs

@@ -0,0 +1,23 @@
+// Required for test coverage
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
+use anyhow::anyhow;
+use tokio::time::{sleep, timeout, Duration};
+use tokio_graceful_shutdown::{
+    errors::{GracefulShutdownError, SubsystemError, SubsystemJoinError},
+    ErrorAction, IntoSubsystem, SubsystemBuilder, SubsystemHandle, Toplevel,
+};
+use tracing_test::traced_test;
+
+pub mod common;
+use common::Event;
+
+use std::error::Error;
+
+/// Wrapper function to simplify lambdas
+type BoxedError = Box<dyn Error + Sync + Send>;
+type BoxedResult = Result<(), BoxedError>;
+
+#[tokio::test]
+#[traced_test]
+async fn dummy() {}