128 lines
3.3 KiB
Rust
128 lines
3.3 KiB
Rust
// 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);
|
|
}
|