feat: dagrunner, initial version

tests/execution/results.rs

@@ -0,0 +1,127 @@
+// Result and error handling tests for DagRunner
+use crate::common::task_fn;
+
+use crate::common::tasks::Counter;
+use dagx::*;
+
+#[tokio::test]
+async fn test_result_type() {
+    let dag = DagRunner::new();
+
+    let success_task = dag.add_task(task_fn(|_: ()| async { Ok::<i32, String>(42) }));
+    let error_task = dag.add_task(task_fn(|_: ()| async {
+        Err::<i32, String>("error".to_string())
+    }));
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await
+    .unwrap();
+
+    assert_eq!(dag.get(success_task).unwrap(), Ok(42));
+    assert_eq!(dag.get(error_task).unwrap(), Err("error".to_string()));
+}
+
+#[tokio::test]
+async fn test_dag_result_type_works() {
+    let dag = DagRunner::new();
+    let task = dag.add_task(task_fn(|_: ()| async { 100 }));
+
+    // Test that DagResult<()> works with ? operator pattern
+    async fn run_dag(dag: &DagRunner) -> DagResult<()> {
+        dag.run(|fut| {
+            tokio::spawn(fut);
+        })
+        .await?;
+        Ok(())
+    }
+
+    let result = run_dag(&dag).await;
+    assert!(result.is_ok());
+    assert_eq!(dag.get(task).unwrap(), 100);
+}
+
+#[tokio::test]
+async fn test_task_not_executed_error() {
+    let dag = DagRunner::new();
+    let task = dag.add_task(task_fn(|_: ()| async { 42 }));
+
+    // Try to get result before running - should error
+    let result = dag.get(task);
+    assert!(result.is_err());
+    match result {
+        Err(DagError::ResultNotFound { task_id }) => {
+            assert_eq!(task_id, 0); // First task has ID 0
+        }
+        _ => panic!("Expected ResultNotFound error"),
+    }
+}
+
+#[tokio::test]
+async fn test_error_messages_are_helpful() {
+    // Test ResultNotFound error message
+    let dag = DagRunner::new();
+    let task = dag.add_task(task_fn(|_: ()| async { 42 }));
+    let result = dag.get(task);
+    assert!(result.is_err());
+    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()"));
+}
+
+#[tokio::test]
+async fn test_successful_execution_returns_ok() {
+    let dag = DagRunner::new();
+    let task = dag.add_task(task_fn(|_: ()| async { 42 }));
+
+    // Should return Ok(())
+    let result = dag
+        .run(|fut| {
+            tokio::spawn(fut);
+        })
+        .await;
+    assert!(result.is_ok());
+
+    // Should be able to get value
+    assert_eq!(dag.get(task).unwrap(), 42);
+}
+
+#[tokio::test]
+async fn test_stateful_tasks() {
+    let dag = DagRunner::new();
+
+    let input = dag.add_task(task_fn(|_: ()| async { 5 }));
+    let counter = dag.add_task(Counter::new(10)).depends_on(&input);
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await
+    .unwrap();
+
+    assert_eq!(dag.get(counter).unwrap(), 15); // 10 + 5
+}
+
+// Cycle detection test removed - it required access to private fields
+// The public API correctly prevents creating cycles, so this is tested implicitly
+
+#[tokio::test]
+async fn test_task_fn_with_captured_state() {
+    let dag = DagRunner::new();
+
+    let multiplier = 7;
+    let base = dag.add_task(task_fn(|_: ()| async { 5 }));
+    let scaled = dag
+        .add_task(task_fn(move |x: i32| async move { x * multiplier }))
+        .depends_on(&base);
+
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await
+    .unwrap();
+
+    assert_eq!(dag.get(scaled).unwrap(), 35);
+}