feat: dagrunner, initial version

tests/dependencies/mod.rs

@@ -0,0 +1,5 @@
+//! Dependency tests module
+
+pub mod resolution;
+pub mod single;
+pub mod tuples;

tests/dependencies/resolution.rs

@@ -0,0 +1,176 @@
+//! Tests for dependency resolution order and transitive dependencies
+
+use crate::common::task_fn;
+use dagx::{DagResult, DagRunner};
+use std::sync::{Arc, Mutex};
+
+#[tokio::test]
+async fn test_dependency_resolution_order() -> DagResult<()> {
+    // Test that dependencies are resolved in the correct order
+    let dag = DagRunner::new();
+
+    let execution_log = Arc::new(Mutex::new(Vec::new()));
+
+    // Create a chain: A -> B -> C -> D -> E
+    let a = {
+        let log = execution_log.clone();
+        dag.add_task(task_fn(move |_: ()| {
+            let log = log.clone();
+            async move {
+                log.lock().unwrap().push(("A_start", 0));
+                tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+                log.lock().unwrap().push(("A_end", 1));
+                1
+            }
+        }))
+    };
+
+    let b = {
+        let log = execution_log.clone();
+        dag.add_task(task_fn(move |x: i32| {
+            let log = log.clone();
+            async move {
+                log.lock().unwrap().push(("B_start", x));
+                assert_eq!(x, 1, "B should receive 1 from A");
+                log.lock().unwrap().push(("B_end", x + 1));
+                x + 1
+            }
+        }))
+        .depends_on(&a)
+    };
+
+    let c = {
+        let log = execution_log.clone();
+        dag.add_task(task_fn(move |x: i32| {
+            let log = log.clone();
+            async move {
+                log.lock().unwrap().push(("C_start", x));
+                assert_eq!(x, 2, "C should receive 2 from B");
+                log.lock().unwrap().push(("C_end", x + 1));
+                x + 1
+            }
+        }))
+        .depends_on(b)
+    };
+
+    let d = {
+        let log = execution_log.clone();
+        dag.add_task(task_fn(move |x: i32| {
+            let log = log.clone();
+            async move {
+                log.lock().unwrap().push(("D_start", x));
+                assert_eq!(x, 3, "D should receive 3 from C");
+                log.lock().unwrap().push(("D_end", x + 1));
+                x + 1
+            }
+        }))
+        .depends_on(c)
+    };
+
+    let e = {
+        let log = execution_log.clone();
+        dag.add_task(task_fn(move |x: i32| {
+            let log = log.clone();
+            async move {
+                log.lock().unwrap().push(("E_start", x));
+                assert_eq!(x, 4, "E should receive 4 from D");
+                log.lock().unwrap().push(("E_end", x + 1));
+                x + 1
+            }
+        }))
+        .depends_on(d)
+    };
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(e)?, 5);
+
+    // Verify execution order
+    let log = execution_log.lock().unwrap();
+    let order: Vec<String> = log.iter().map(|(name, _)| name.to_string()).collect();
+
+    // Each task should start after the previous one ends
+    let a_end_pos = order.iter().position(|x| x == "A_end").unwrap();
+    let b_start_pos = order.iter().position(|x| x == "B_start").unwrap();
+    assert!(b_start_pos > a_end_pos, "B should start after A ends");
+
+    let b_end_pos = order.iter().position(|x| x == "B_end").unwrap();
+    let c_start_pos = order.iter().position(|x| x == "C_start").unwrap();
+    assert!(c_start_pos > b_end_pos, "C should start after B ends");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_transitive_dependencies() -> DagResult<()> {
+    // Test that transitive dependencies work correctly
+    // A -> B -> C (creates transitive A -> C relationship)
+    let dag = DagRunner::new();
+
+    let a = dag.add_task(task_fn(|_: ()| async { 10 }));
+    let b = dag
+        .add_task(task_fn(|x: i32| async move { x * 2 }))
+        .depends_on(&a);
+    let c = dag
+        .add_task(task_fn(|x: i32| async move { x + 5 }))
+        .depends_on(b);
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(&a)?, 10);
+    assert_eq!(dag.get(b)?, 20);
+    assert_eq!(dag.get(c)?, 25); // 20 + 5
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_deep_chain_50_levels() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let first = dag.add_task(task_fn(|_: ()| async { 0 }));
+    let mut handles = vec![(&first).into()];
+
+    for _i in 1..=50 {
+        let next = dag
+            .add_task(task_fn(move |x: i32| async move { x + 1 }))
+            .depends_on(handles.last().unwrap());
+        handles.push(next);
+    }
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(handles.last().unwrap())?, 50);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_deep_chain_200_levels() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let first = dag.add_task(task_fn(|_: ()| async { 1 }));
+    let mut current = (&first).into();
+
+    for _ in 0..200 {
+        current = dag
+            .add_task(task_fn(|x: i32| async move { x + 1 }))
+            .depends_on(current);
+    }
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(current)?, 201);
+    Ok(())
+}

tests/dependencies/single.rs

@@ -0,0 +1,128 @@
+//! Tests for single dependencies and basic dependency data flow
+
+use crate::common::task_fn;
+use dagx::{DagResult, DagRunner};
+
+#[tokio::test]
+async fn test_single_dependency() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let source = dag.add_task(task_fn(|_: ()| async { 42 }));
+    let dependent = dag
+        .add_task(task_fn(|x: i32| async move { x + 1 }))
+        .depends_on(&source);
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(dependent)?, 43);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_dependency_data_flow() -> DagResult<()> {
+    // Test that data flows correctly through dependencies
+    let dag = DagRunner::new();
+
+    let source = dag.add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }));
+
+    let sum = dag
+        .add_task(task_fn(|v: Vec<i32>| async move { v.iter().sum::<i32>() }))
+        .depends_on(&source);
+
+    let product = dag
+        .add_task(task_fn(
+            |v: Vec<i32>| async move { v.iter().product::<i32>() },
+        ))
+        .depends_on(&source);
+
+    let final_result = dag
+        .add_task(task_fn(|(s, p): (i32, i32)| async move { s + p }))
+        .depends_on((&sum, &product));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    // Note: sum and product are not sinks (final_result depends on them)
+    // Only final_result is a sink and can be retrieved
+    assert_eq!(dag.get(final_result)?, 135); // 15+120
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_dependencies_with_different_types() -> DagResult<()> {
+    // Test that dependencies with different types work correctly
+    let dag = DagRunner::new();
+
+    let int_source = dag.add_task(task_fn(|_: ()| async { 42 }));
+    let string_source = dag.add_task(task_fn(|_: ()| async { "hello".to_string() }));
+    let bool_source = dag.add_task(task_fn(|_: ()| async { true }));
+
+    let combined = dag
+        .add_task(task_fn(|(i, s, b): (i32, String, bool)| async move {
+            format!("{}: {} ({})", s, i, b)
+        }))
+        .depends_on((&int_source, &string_source, &bool_source));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(combined)?, "hello: 42 (true)");
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_shared_dependencies() -> DagResult<()> {
+    // Test that a single node can be a dependency for multiple downstream nodes
+    let dag = DagRunner::new();
+
+    let shared = dag.add_task(task_fn(|_: ()| async { 42 }));
+
+    // Create 10 tasks that all depend on the shared node
+    let dependents: Vec<_> = (0..10)
+        .map(|i| {
+            dag.add_task(task_fn(move |x: i32| async move { x * (i + 1) }))
+                .depends_on(&shared)
+        })
+        .collect();
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    // Verify all dependents got the correct value from shared
+    for (i, handle) in dependents.iter().enumerate() {
+        assert_eq!(dag.get(handle)?, 42 * (i as i32 + 1));
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_multiple_source_nodes() -> DagResult<()> {
+    // Test DAG with multiple source nodes (no dependencies)
+    let dag = DagRunner::new();
+
+    let sources: Vec<_> = (0..20)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 10 })))
+        .collect();
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    for (i, source) in sources.iter().enumerate() {
+        assert_eq!(dag.get(source)?, i as i32 * 10);
+    }
+
+    Ok(())
+}

tests/dependencies/tuples.rs

@@ -0,0 +1,170 @@
+//! Tests for tuple dependencies (2-8 dependencies)
+
+use crate::common::task_fn;
+use dagx::{DagResult, DagRunner};
+
+#[tokio::test]
+async fn test_two_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let a = dag.add_task(task_fn(|_: ()| async { 10 }));
+    let b = dag.add_task(task_fn(|_: ()| async { 20 }));
+    let sum = dag
+        .add_task(task_fn(|(x, y): (i32, i32)| async move { x + y }))
+        .depends_on((&a, &b));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 30);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_three_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let a = dag.add_task(task_fn(|_: ()| async { 1 }));
+    let b = dag.add_task(task_fn(|_: ()| async { 2 }));
+    let c = dag.add_task(task_fn(|_: ()| async { 3 }));
+    let sum = dag
+        .add_task(task_fn(
+            |(x, y, z): (i32, i32, i32)| async move { x + y + z },
+        ))
+        .depends_on((&a, &b, &c));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 6);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_four_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let deps: Vec<_> = (1..=4)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .collect();
+
+    let sum = dag
+        .add_task(task_fn(|(a, b, c, d): (i32, i32, i32, i32)| async move {
+            a + b + c + d
+        }))
+        .depends_on((&deps[0], &deps[1], &deps[2], &deps[3]));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 10); // 1+2+3+4
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_five_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let deps: Vec<_> = (1..=5)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .collect();
+
+    let sum = dag
+        .add_task(task_fn(
+            |(a, b, c, d, e): (i32, i32, i32, i32, i32)| async move { a + b + c + d + e },
+        ))
+        .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4]));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 15); // 1+2+3+4+5
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_six_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let deps: Vec<_> = (1..=6)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .collect();
+
+    let sum = dag.add_task(task_fn(
+        |(a, b, c, d, e, f): (i32, i32, i32, i32, i32, i32)| async move {
+            a + b + c + d + e + f
+        }
+    )).depends_on((
+        &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]
+    ));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 21); // 1+2+3+4+5+6
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_seven_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let deps: Vec<_> = (1..=7)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .collect();
+
+    let sum = dag
+        .add_task(task_fn(
+            |(a, b, c, d, e, f, g): (i32, i32, i32, i32, i32, i32, i32)| async move {
+                a + b + c + d + e + f + g
+            },
+        ))
+        .depends_on((
+            &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6],
+        ));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 28); // 1+2+3+4+5+6+7
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_eight_dependencies() -> DagResult<()> {
+    let dag = DagRunner::new();
+
+    let deps: Vec<_> = (1..=8)
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .collect();
+
+    let sum = dag
+        .add_task(task_fn(
+            |(a, b, c, d, e, f, g, h): (i32, i32, i32, i32, i32, i32, i32, i32)| async move {
+                a + b + c + d + e + f + g + h
+            },
+        ))
+        .depends_on((
+            &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6], &deps[7],
+        ));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+
+    assert_eq!(dag.get(sum)?, 36); // Sum of 1..=8
+    Ok(())
+}