hone-recipes 0.1.0

YAML recipe system for Hone
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::sync::{Arc, Mutex};

use hone_recipes::{Recipe, RecipeError, RecipeRunner, RecipeStep};

fn make_recipe(steps: Vec<RecipeStep>, test_cmd: Option<&str>) -> Recipe {
    Recipe {
        name: "test-recipe".to_string(),
        description: None,
        steps,
        test_cmd: test_cmd.map(str::to_string),
    }
}

fn make_step(name: &str, prompt: &str, when: Option<bool>) -> RecipeStep {
    RecipeStep {
        name: name.to_string(),
        prompt: prompt.to_string(),
        when,
    }
}

#[tokio::test]
async fn test_step_with_condition_skips_when_false() {
    let executed: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
    let executed_clone = Arc::clone(&executed);

    let recipe = make_recipe(
        vec![
            make_step("step-a", "prompt a", None),
            make_step("step-b", "prompt b", Some(false)),
            make_step("step-c", "prompt c", None),
        ],
        None,
    );

    let runner = RecipeRunner::new(recipe, move |_idx, step: &RecipeStep| {
        let name = step.name.clone();
        let executed = Arc::clone(&executed_clone);
        async move {
            executed.lock().unwrap().push(name);
            Ok("done".to_string())
        }
    });

    let report = runner.run().await.expect("recipe should succeed");

    let names = executed.lock().unwrap().clone();
    assert_eq!(names, vec!["step-a", "step-c"]);

    let skipped: Vec<_> = report.steps.iter().filter(|s| s.skipped).collect();
    assert_eq!(skipped.len(), 1);
    assert_eq!(skipped[0].step_name, "step-b");
}

#[tokio::test]
async fn test_recipe_runner_executes_steps_in_order() {
    let recorded: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
    let recorded_clone = Arc::clone(&recorded);

    let recipe = make_recipe(
        vec![
            make_step("first", "do first", None),
            make_step("second", "do second", None),
        ],
        None,
    );

    let runner = RecipeRunner::new(recipe, move |_idx, step: &RecipeStep| {
        let name = step.name.clone();
        let recorded = Arc::clone(&recorded_clone);
        async move {
            recorded.lock().unwrap().push(name);
            Ok("ok".to_string())
        }
    });

    runner.run().await.expect("recipe should succeed");

    let names = recorded.lock().unwrap().clone();
    assert_eq!(names, vec!["first", "second"]);
}

#[tokio::test]
async fn test_tdd_recipe_runs_tests_between_steps_success() {
    let recipe = make_recipe(
        vec![
            make_step("step-a", "prompt a", None),
            make_step("step-b", "prompt b", None),
        ],
        Some("true"),
    );

    let runner = RecipeRunner::new(recipe, |_idx, _step: &RecipeStep| async move {
        Ok("done".to_string())
    });

    runner
        .run()
        .await
        .expect("recipe with passing test_cmd should succeed");
}

#[tokio::test]
async fn test_tdd_recipe_runs_tests_between_steps_failure() {
    let recipe = make_recipe(
        vec![
            make_step("step-a", "prompt a", None),
            make_step("step-b", "prompt b", None),
        ],
        Some("false"),
    );

    let runner = RecipeRunner::new(recipe, |_idx, _step: &RecipeStep| async move {
        Ok("done".to_string())
    });

    let result = runner.run().await;
    assert!(result.is_err(), "recipe with failing test_cmd should fail");

    match result.unwrap_err() {
        RecipeError::TestFailed { step, .. } => {
            assert_eq!(step, "step-a", "first step triggers the test failure");
        }
        other => panic!("expected TestFailed, got: {other:?}"),
    }
}