capsula-capture-command 0.12.1

A Capsula hook that captures command execution output.
Documentation 
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#![expect(clippy::unwrap_used, reason = "unwrap is acceptable in test code")]

use capsula_capture_command::CommandHook;
use capsula_core::captured::Captured;
use capsula_core::hook::{Hook, PreRun, RuntimeParams};
use capsula_core::run::PreparedRun;
use serde_json::json;
use std::path::PathBuf;
use ulid::Ulid;

#[test]
fn command_hook_executes_successful_command() {
    // Arrange
    let config = json!({
        "command": ["echo", "hello world"],
        "abort_on_failure": false
    });
    let hook = <CommandHook as Hook<PreRun>>::from_config(&config, &PathBuf::from("."))
        .expect("from_config ok");

    let run_metadata = PreparedRun {
        id: Ulid::new(),
        name: "test-run".to_string(),
        command: vec![],
        run_dir: PathBuf::from("."),
        project_root: PathBuf::from("."),
    };
    let params = RuntimeParams::<PreRun>::default();

    // Act
    let captured = hook.run(&run_metadata, &params).expect("run ok");
    let json = captured
        .serialize_json()
        .expect("serialization should succeed");

    // Assert
    assert_eq!(
        json.get("status").and_then(serde_json::Value::as_i64),
        Some(0)
    );
    let stdout = json.get("stdout").and_then(|v| v.as_str()).unwrap();
    assert!(
        stdout.contains("hello world"),
        "stdout should contain output"
    );
    assert!(!captured.abort_requested(), "Should not request abort");
}

#[test]
fn command_hook_captures_failing_command() {
    // Arrange - use 'false' command which always exits with code 1
    let config = json!({
        "command": ["false"],
        "abort_on_failure": false
    });
    let hook = <CommandHook as Hook<PreRun>>::from_config(&config, &PathBuf::from("."))
        .expect("from_config ok");

    let run_metadata = PreparedRun {
        id: Ulid::new(),
        name: "test-run".to_string(),
        command: vec![],
        run_dir: PathBuf::from("."),
        project_root: PathBuf::from("."),
    };
    let params = RuntimeParams::<PreRun>::default();

    // Act
    let captured = hook.run(&run_metadata, &params).expect("run ok");
    let json = captured
        .serialize_json()
        .expect("serialization should succeed");

    // Assert
    assert_ne!(
        json.get("status").and_then(serde_json::Value::as_i64),
        Some(0)
    );
    assert!(
        !captured.abort_requested(),
        "Should not request abort when abort_on_failure is false"
    );
}

#[test]
fn command_hook_aborts_on_failure_when_configured() {
    // Arrange
    let config = json!({
        "command": ["false"],
        "abort_on_failure": true
    });
    let hook = <CommandHook as Hook<PreRun>>::from_config(&config, &PathBuf::from("."))
        .expect("from_config ok");

    let run_metadata = PreparedRun {
        id: Ulid::new(),
        name: "test-run".to_string(),
        command: vec![],
        run_dir: PathBuf::from("."),
        project_root: PathBuf::from("."),
    };
    let params = RuntimeParams::<PreRun>::default();

    // Act
    let captured = hook.run(&run_metadata, &params).expect("run ok");

    // Assert
    assert!(
        captured.abort_requested(),
        "Should request abort when command fails and abort_on_failure is true"
    );
}

#[test]
fn command_hook_captures_stderr() {
    // Arrange - use a command that writes to stderr
    let config = json!({
        "command": ["sh", "-c", "echo 'error message' >&2"],
        "abort_on_failure": false
    });
    let hook = <CommandHook as Hook<PreRun>>::from_config(&config, &PathBuf::from("."))
        .expect("from_config ok");

    let run_metadata = PreparedRun {
        id: Ulid::new(),
        name: "test-run".to_string(),
        command: vec![],
        run_dir: PathBuf::from("."),
        project_root: PathBuf::from("."),
    };
    let params = RuntimeParams::<PreRun>::default();

    // Act
    let captured = hook.run(&run_metadata, &params).expect("run ok");
    let json = captured
        .serialize_json()
        .expect("serialization should succeed");

    // Assert
    let stderr = json.get("stderr").and_then(|v| v.as_str()).unwrap();
    assert!(
        stderr.contains("error message"),
        "stderr should contain error message"
    );
}