mxsh 0.2.0

Embeddable POSIX-style shell parser and runtime
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

#![cfg(all(feature = "embed", feature = "test-support"))]

use mxsh::ShellBuilder;
use mxsh::ast::Program;
use mxsh::embed::{DeferredWorkKind, StdioConfig, TraceEvent, VariableAttributes};
use mxsh::runtime::testing::{InMemoryRuntime, StringStdioOut};

#[test]
fn runtime_owning_shell_runs_and_collects_trace() {
    let stdout = StringStdioOut::new();
    let mut shell = ShellBuilder::new()
        .env("GREETING", "hello", VariableAttributes::EXPORT)
        .stdio(StdioConfig {
            stdout: stdout.fd(),
            ..StdioConfig::default()
        })
        .build(InMemoryRuntime::new())
        .expect("shell should build");

    let outcome = shell.run("echo \"$GREETING world\"");

    assert_eq!(outcome.status, 0);
    assert!(outcome.diagnostics.is_empty());
    assert_eq!(stdout.collect(), "hello world\n");
    assert_eq!(outcome.trace.len(), 2);
    assert!(matches!(
        &outcome.trace[0],
        TraceEvent::RunStarted {
            raw_command: Some(command),
            ..
        } if command == "echo \"$GREETING world\""
    ));
    assert!(matches!(
        &outcome.trace[1],
        TraceEvent::RunFinished { status: 0, .. }
    ));
}

#[test]
fn embedded_run_trace_uses_exit_trap_status() {
    let mut shell = ShellBuilder::new()
        .build(InMemoryRuntime::new())
        .expect("shell should build");

    let outcome = shell.run("trap 'exit 7' EXIT; exit 3");

    assert_eq!(outcome.status, 7);
    assert_eq!(outcome.exit_code, Some(7));
    assert!(matches!(
        outcome.trace.last(),
        Some(TraceEvent::RunFinished { status: 7, .. })
    ));
}

#[test]
fn prepared_run_trace_uses_exit_trap_status() {
    let mut shell = ShellBuilder::new()
        .build(InMemoryRuntime::new())
        .expect("shell should build");
    let program = Program::parse("trap 'exit 9' EXIT; exit 2").expect("program should parse");
    let prepared = shell.prepare(&program);

    let outcome = shell.run_prepared(&prepared);

    assert_eq!(outcome.status, 9);
    assert_eq!(outcome.exit_code, Some(9));
    assert!(matches!(
        outcome.trace.last(),
        Some(TraceEvent::RunFinished { status: 9, .. })
    ));
}

#[test]
fn run_outcome_collects_deferred_work_trace_without_manual_sinks() {
    let stdout = StringStdioOut::new();
    let mut runtime = InMemoryRuntime::new();
    runtime.register_command("cat", |_argv, _env, _cwd, stdio| {
        let input = stdio.stdin_fd.dup().expect("dup cat stdin").read_all();
        let _ = stdio.stdout_fd.write_str(&input);
        0
    });
    let mut shell = ShellBuilder::new()
        .stdio(StdioConfig {
            stdout: stdout.fd(),
            ..StdioConfig::default()
        })
        .build(runtime)
        .expect("shell should build");

    let outcome = shell.run("unset X; echo ${X:=hi} | cat");

    assert_eq!(outcome.status, 0);
    assert_eq!(stdout.collect(), "hi\n");
    assert!(outcome.diagnostics.is_empty());
    assert!(outcome.trace.iter().any(|event| {
        matches!(
            event,
            TraceEvent::DeferredWorkStarted {
                kind: DeferredWorkKind::ParameterExpansion,
                ..
            }
        )
    }));
    assert!(outcome.trace.iter().any(|event| {
        matches!(
            event,
            TraceEvent::DeferredWorkFinished {
                kind: DeferredWorkKind::ParameterExpansion,
                status: 0,
                ..
            }
        )
    }));
}