Depend on futures-util instead of futures

tests/execution/basic.rs

@@ -1,13 +1,12 @@
 // Basic execution tests for DagRunner
 use crate::common::task_fn;
-use futures::FutureExt;
 
 use dagx::*;
 
 #[tokio::test]
 async fn test_empty_dag() {
     let dag = DagRunner::new();
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap(); // Should complete without error
 }
@@ -16,7 +15,7 @@ async fn test_empty_dag() {
 async fn test_single_task() {
     let dag = DagRunner::new();
     let task = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
     assert_eq!(dag.get(task).unwrap(), 42);
@@ -40,7 +39,7 @@ async fn test_deep_chain() {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
         .depends_on(d);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -57,7 +56,7 @@ async fn test_wide_parallel() {
         .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 2)))
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -81,7 +80,7 @@ async fn test_diamond_dependency() {
         .add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
         .depends_on((&b, &c));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -107,7 +106,7 @@ async fn test_different_output_types() {
         age: 30,
     }));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -140,7 +139,7 @@ async fn test_multiple_sinks() {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
         .depends_on(branch2);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap(); // Should wait for both sinks
 
@@ -162,7 +161,7 @@ async fn test_single_task_inline_path() {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
         .depends_on(t2);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -187,7 +186,7 @@ async fn test_multi_task_spawn_path() {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 3))
         .depends_on(source);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -213,7 +212,7 @@ async fn test_producer_consumer_channels() {
         }))
         .depends_on(producer);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -238,7 +237,7 @@ async fn test_multi_consumer_fanout() {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x - 5))
         .depends_on(producer);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -266,7 +265,7 @@ async fn test_compute_layers_with_dependents_tracking() {
         .add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
         .depends_on((&left, &right));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -308,7 +307,7 @@ async fn test_layer_execution_order() {
         }))
         .depends_on(t2);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 

tests/execution/integration.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, Task};
-use futures::FutureExt;
+
 use std::time::Instant;
 use tokio::time::{sleep, Duration};
 
@@ -68,7 +68,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify
     let result = dag.get(final_result)?;
@@ -98,7 +99,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     let result = dag.get(final_result)?;
     // (1+2)*2 + (2+3)*2 = 6 + 10 = 16
@@ -119,7 +121,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // All branches should complete
     assert_eq!(dag.get(branch1)?, 20);
@@ -145,7 +148,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     let result = dag.get(sink2)?;
     // Diamond 1: (10*2) + (10*3) = 50
@@ -176,7 +180,8 @@ async fn integration_test_wide_and_deep() -> DagResult<()> {
         final_nodes.push(step3);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify each chain
     for (i, node) in final_nodes.iter().enumerate() {
@@ -195,7 +200,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Should be able to access results
     assert_eq!(dag.get(transform)?, 84);
@@ -231,7 +237,8 @@ async fn integration_test_large_scale() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify some results
     assert_eq!(dag.get(aggregations[0])?, 1); // First two
@@ -255,7 +262,8 @@ 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).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     assert_eq!(dag.get(double)?, 200);
     assert_eq!(dag.get(triple)?, 300);
@@ -284,7 +292,8 @@ async fn integration_test_parallel_execution_timing() -> DagResult<()> {
         .collect();
 
     let start = Instant::now();
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
     let elapsed = start.elapsed();
 
     // Verify all tasks completed
@@ -345,7 +354,8 @@ async fn integration_test_parallel_vs_sequential_timing() -> DagResult<()> {
         .depends_on(seq2);
 
     let start = Instant::now();
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
     let elapsed = start.elapsed();
 
     // Verify results

tests/execution/results.rs

@@ -3,7 +3,6 @@ use crate::common::task_fn;
 
 use crate::common::tasks::Counter;
 use dagx::*;
-use futures::FutureExt;
 
 #[tokio::test]
 async fn test_result_type() {
@@ -14,7 +13,7 @@ async fn test_result_type() {
         Err::<i32, String>("error".to_string())
     }));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -29,7 +28,8 @@ async fn test_dag_result_type_works() {
 
     // Test that DagResult<()> works with ? operator pattern
     async fn run_dag(dag: &DagRunner) -> DagResult<()> {
-        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+            .await?;
         Ok(())
     }
 
@@ -64,7 +64,7 @@ async fn test_error_messages_are_helpful() {
     let err_msg = format!("{}", result.unwrap_err());
     assert!(err_msg.contains("Result not found"));
     assert!(err_msg.contains("task #0")); // Task ID
-    assert!(err_msg.contains("Call dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))"));
+    assert!(err_msg.contains("Call dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })"));
 }
 
 #[tokio::test]
@@ -73,7 +73,9 @@ async fn test_successful_execution_returns_ok() {
     let task = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
 
     // Should return Ok(())
-    let result = dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await;
+    let result = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await;
     assert!(result.is_ok());
 
     // Should be able to get value
@@ -87,7 +89,7 @@ async fn test_stateful_tasks() {
     let input = dag.add_task(task_fn::<(), _, _>(|_: ()| 5));
     let counter = dag.add_task(Counter::new(10)).depends_on(input);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -107,7 +109,7 @@ async fn test_task_fn_with_captured_state() {
         .add_task(task_fn::<i32, _, _>(move |&x: &i32| x * multiplier))
         .depends_on(base);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();