Update tests, examples, benches

tests/execution/integration.rs

@@ -1,7 +1,8 @@
 //! Integration tests for end-to-end functionality
 
-use dagx::{DagResult, DagRunner, Task};
 use crate::common::task_fn;
+use dagx::{DagResult, DagRunner, Task};
+use futures::FutureExt;
 use std::time::Instant;
 use tokio::time::{sleep, Duration};
 
@@ -18,7 +19,7 @@ impl LoadValue {
 #[dagx::task]
 impl LoadValue {
     async fn run(&self) -> i32 {
-        self.value  // Read-only state: use &self
+        self.value // Read-only state: use &self
     }
 }
 
@@ -33,7 +34,7 @@ impl Multiply {
 #[dagx::task]
 impl Multiply {
     async fn run(&self, input: &i32) -> i32 {
-        input * self.factor  // Read-only state: use &self
+        input * self.factor // Read-only state: use &self
     }
 }
 
@@ -41,7 +42,7 @@ struct Add;
 #[dagx::task]
 impl Add {
     async fn run(a: &i32, b: &i32) -> i32 {
-        a + b  // Stateless: no self needed
+        a + b // Stateless: no self needed
     }
 }
 
@@ -67,7 +68,7 @@ async fn integration_test_etl_pipeline() -> DagResult<()> {
     let final_result = dag.add_task(Add).depends_on((&combine12, &transform3));
 
     // Execute pipeline
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Verify
     let result = dag.get(final_result)?;
@@ -97,7 +98,7 @@ async fn integration_test_multi_layer_dag() -> DagResult<()> {
     // Layer 4: Final result
     let final_result = dag.add_task(Add).depends_on((&double_ab, &double_bc));
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     let result = dag.get(final_result)?;
     // (1+2)*2 + (2+3)*2 = 6 + 10 = 16
@@ -118,7 +119,7 @@ async fn integration_test_multiple_sinks() -> DagResult<()> {
     let branch2 = dag.add_task(Multiply::new(3)).depends_on(&source);
     let branch3 = dag.add_task(Multiply::new(4)).depends_on(&source);
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // All branches should complete
     assert_eq!(dag.get(branch1)?, 20);
@@ -144,7 +145,7 @@ async fn integration_test_diamond_cascade() -> DagResult<()> {
     let right2 = dag.add_task(Multiply::new(3)).depends_on(sink1);
     let sink2 = dag.add_task(Add).depends_on((&left2, &right2));
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     let result = dag.get(sink2)?;
     // Diamond 1: (10*2) + (10*3) = 50
@@ -175,7 +176,7 @@ async fn integration_test_wide_and_deep() -> DagResult<()> {
         final_nodes.push(step3);
     }
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Verify each chain
     for (i, node) in final_nodes.iter().enumerate() {
@@ -194,7 +195,7 @@ async fn integration_test_error_recovery() -> DagResult<()> {
     let source = dag.add_task(LoadValue::new(42));
     let transform = dag.add_task(Multiply::new(2)).depends_on(&source);
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Should be able to access results
     assert_eq!(dag.get(transform)?, 84);
@@ -230,7 +231,7 @@ async fn integration_test_large_scale() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Verify some results
     assert_eq!(dag.get(aggregations[0])?, 1); // First two
@@ -254,7 +255,7 @@ async fn integration_test_reused_values() -> DagResult<()> {
     // Combine some of the results
     let combined = dag.add_task(Add).depends_on((&double, &triple));
 
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     assert_eq!(dag.get(double)?, 200);
     assert_eq!(dag.get(triple)?, 300);
@@ -283,7 +284,7 @@ async fn integration_test_parallel_execution_timing() -> DagResult<()> {
         .collect();
 
     let start = Instant::now();
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
     let elapsed = start.elapsed();
 
     // Verify all tasks completed
@@ -322,23 +323,29 @@ async fn integration_test_parallel_vs_sequential_timing() -> DagResult<()> {
 
     // Layer 2: Sequential chain of 3 tasks depending on the first parallel task
     // (should add ~150ms)
-    let seq1 = dag.add_task(task_fn(move |x: i32| async move {
-        sleep(sleep_duration).await;
-        x + 1
-    })).depends_on(&parallel_tasks[0]);
+    let seq1 = dag
+        .add_task(task_fn(move |x: i32| async move {
+            sleep(sleep_duration).await;
+            x + 1
+        }))
+        .depends_on(&parallel_tasks[0]);
 
-    let seq2 = dag.add_task(task_fn(move |x: i32| async move {
-        sleep(sleep_duration).await;
-        x + 1
-    })).depends_on(seq1);
+    let seq2 = dag
+        .add_task(task_fn(move |x: i32| async move {
+            sleep(sleep_duration).await;
+            x + 1
+        }))
+        .depends_on(seq1);
 
-    let seq3 = dag.add_task(task_fn(move |x: i32| async move {
-        sleep(sleep_duration).await;
-        x + 1
-    })).depends_on(seq2);
+    let seq3 = dag
+        .add_task(task_fn(move |x: i32| async move {
+            sleep(sleep_duration).await;
+            x + 1
+        }))
+        .depends_on(seq2);
 
     let start = Instant::now();
-    dag.run(|fut| { tokio::spawn(fut); }).await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
     let elapsed = start.elapsed();
 
     // Verify results
@@ -361,4 +368,4 @@ async fn integration_test_parallel_vs_sequential_timing() -> DagResult<()> {
     );
 
     Ok(())
-}
+}