Depend on futures-util instead of futures

tests/dependencies/resolution.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{task, DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::sync::{Arc, Mutex};
 
 #[tokio::test]
@@ -79,7 +79,7 @@ async fn test_dependency_resolution_order() -> DagResult<()> {
         .depends_on(d)
     };
 
-    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(e)?, 5);
 
@@ -113,7 +113,7 @@ async fn test_transitive_dependencies() -> DagResult<()> {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
         .depends_on(b);
 
-    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(a)?, 10);
     assert_eq!(dag.get(b)?, 20);
@@ -136,7 +136,7 @@ async fn test_deep_chain_50_levels() -> DagResult<()> {
         handles.push(next);
     }
 
-    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(handles.last().unwrap())?, 50);
     Ok(())
@@ -155,7 +155,7 @@ async fn test_deep_chain_200_levels() -> DagResult<()> {
             .depends_on(current);
     }
 
-    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(current)?, 201);
     Ok(())

tests/dependencies/single.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 
 #[tokio::test]
 async fn test_single_dependency() -> DagResult<()> {
@@ -13,7 +13,7 @@ async fn test_single_dependency() -> DagResult<()> {
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
         .depends_on(source);
 
-    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(dependent)?, 43);
     Ok(())
@@ -44,7 +44,7 @@ async fn test_dependency_data_flow() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(s, p): (&i32, &i32)| s + p))
         .depends_on((&sum, &product));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Note: sum and product are not sinks (final_result depends on them)
     // Only final_result is a sink and can be retrieved
@@ -68,7 +68,7 @@ async fn test_dependencies_with_different_types() -> DagResult<()> {
         ))
         .depends_on((int_source, string_source, bool_source));
 
-    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(combined)?, "hello: 42 (true)");
     Ok(())
@@ -89,7 +89,7 @@ async fn test_shared_dependencies() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Verify all dependents got the correct value from shared
     for (i, handle) in dependents.iter().enumerate() {
@@ -108,7 +108,7 @@ async fn test_multiple_source_nodes() -> DagResult<()> {
         .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 10)))
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     for (i, source) in sources.into_iter().enumerate() {
         assert_eq!(dag.get(source)?, i as i32 * 10);

tests/dependencies/tuples.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner};
-use futures::FutureExt;
+
 
 #[tokio::test]
 async fn test_two_dependencies() -> DagResult<()> {
@@ -14,7 +14,7 @@ async fn test_two_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
         .depends_on((a, b));
 
-    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(sum)?, 30);
     Ok(())
@@ -33,7 +33,7 @@ async fn test_three_dependencies() -> DagResult<()> {
         ))
         .depends_on((a, b, c));
 
-    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(sum)?, 6);
     Ok(())
@@ -53,7 +53,7 @@ async fn test_four_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3]));
 
-    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(sum)?, 10); // 1+2+3+4
     Ok(())
@@ -73,7 +73,7 @@ async fn test_five_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4]));
 
-    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(sum)?, 15); // 1+2+3+4+5
     Ok(())
@@ -93,7 +93,7 @@ async fn test_six_dependencies() -> DagResult<()> {
         ))
         .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]));
 
-    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(sum)?, 21); // 1+2+3+4+5+6
     Ok(())
@@ -117,7 +117,7 @@ async fn test_seven_dependencies() -> DagResult<()> {
             &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6],
         ));
 
-    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(sum)?, 28); // 1+2+3+4+5+6+7
     Ok(())
@@ -141,7 +141,7 @@ async fn test_eight_dependencies() -> DagResult<()> {
             &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6], &deps[7],
         ));
 
-    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(sum)?, 36); // Sum of 1..=8
     Ok(())