conch-runtime 0.1.2

A library for evaluating/executing programs written in the shell programming language.
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

#![cfg(feature = "conch-parser")]

extern crate conch_runtime;

use conch_runtime::env::VarEnv;
use conch_runtime::eval::{error, Fields, TildeExpansion, WordEvalConfig};

#[macro_use]
mod support;
pub use self::support::*;

const CFG: TildeExpansion = TildeExpansion::All;
const DEFAULT_MSG: &str = "parameter null or not set";

fn eval<W: Into<Option<MockWord>>>(strict: bool, param: &MockParam, word: W)
    -> Result<Fields<String>, MockErr>
{
    let env = VarEnv::<String, String>::new();
    error(strict, param, word.into(), &env, CFG)
        .pin_env(env)
        .wait()
}

#[test]
fn should_evaluate_appropriately() {
    let must_not_run = mock_word_panic("should not run");
    let msg = "err msg".to_owned();
    let mock_word = mock_word_fields(Fields::Split(vec!(
        "err".to_owned(),
        "msg".to_owned(),
    )));

    // Param not present
    let param = MockParam::Fields(None);
    let err = ExpansionError::EmptyParameter(param.to_string(), msg.clone());
    assert_eq!(eval(false, &param, mock_word.clone()), Err(err.clone().into()));
    assert_eq!(eval(true, &param, mock_word.clone()), Err(err.clone().into()));
    let err = ExpansionError::EmptyParameter(param.to_string(), DEFAULT_MSG.to_owned());
    assert_eq!(eval(false, &param, None), Err(err.clone().into()));
    assert_eq!(eval(true, &param, None), Err(err.clone().into()));

    // Present and non-empty
    let param_fields = Fields::Single("foo".to_owned());
    let param = MockParam::Split(false, param_fields.clone());
    assert_eq!(eval(false, &param, must_not_run.clone()), Ok(param_fields.clone()));
    assert_eq!(eval(true, &param, must_not_run.clone()), Ok(param_fields.clone()));
    assert_eq!(eval(false, &param, None), Ok(param_fields.clone()));
    assert_eq!(eval(true, &param, None), Ok(param_fields.clone()));

    // Present but empty
    let param = MockParam::Fields(Some(Fields::Single("".to_owned())));
    let err = ExpansionError::EmptyParameter(param.to_string(), msg.clone());
    assert_eq!(eval(false, &param, must_not_run.clone()), Ok(Fields::Zero));
    assert_eq!(eval(true, &param, mock_word.clone()), Err(err.into()));
    let err = ExpansionError::EmptyParameter(param.to_string(), DEFAULT_MSG.to_owned());
    assert_eq!(eval(false, &param, None), Ok(Fields::Zero));
    assert_eq!(eval(true, &param, None), Err(err.clone().into()));

    // Assert eval configs
    let param = MockParam::Fields(None);
    let mock_word = mock_word_assert_cfg(WordEvalConfig {
        split_fields_further: false,
        tilde_expansion: CFG,
    });
    eval(false, &param, mock_word.clone()).unwrap_err();
    eval(true, &param, mock_word.clone()).unwrap_err();

    // Assert param configs
    let param = MockParam::Split(false, Fields::Single("foo".to_owned()));
    eval(false, &param, None).unwrap();
    eval(true, &param, None).unwrap();
}

#[test]
fn should_propagate_errors_from_word_if_applicable() {
    let must_not_run = mock_word_panic("should not run");

    // Param not present
    let param = MockParam::Fields(None);
    let err = MockErr::Fatal(false);
    assert_eq!(eval(false, &param, mock_word_error(false)), Err(err.clone()));
    assert_eq!(eval(true, &param, mock_word_error(false)), Err(err.clone()));
    let err = ExpansionError::EmptyParameter(param.to_string(), DEFAULT_MSG.to_owned());
    assert_eq!(eval(false, &param, None), Err(err.clone().into()));
    assert_eq!(eval(true, &param, None), Err(err.clone().into()));

    // Present and non-empty
    let param = MockParam::Fields(Some(Fields::Single("foo".to_owned())));
    eval(false, &param, must_not_run.clone()).unwrap();
    eval(true, &param, must_not_run.clone()).unwrap();
    eval(false, &param, None).unwrap();
    eval(true, &param, None).unwrap();

    // Present but empty
    let param = MockParam::Fields(Some(Fields::Single("".to_owned())));
    let err = MockErr::Fatal(true);
    eval(false, &param, must_not_run.clone()).unwrap();
    assert_eq!(eval(true, &param, mock_word_error(true)), Err(err));
    let err = ExpansionError::EmptyParameter(param.to_string(), DEFAULT_MSG.to_owned());
    eval(false, &param, None).unwrap();
    assert_eq!(eval(true, &param, None), Err(err.into()));
}

#[test]
fn should_propagate_cancel_if_required() {
    let mut env = VarEnv::<String, String>::new();
    let must_not_run = Some(mock_word_panic("should not run"));
    let must_cancel = Some(mock_word_must_cancel());

    // Param not present
    let param = MockParam::Fields(None);
    test_cancel!(error(false, &param, must_cancel.clone(), &env, CFG), env);
    test_cancel!(error(true, &param, must_cancel.clone(), &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(false, &param, None, &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(true, &param, None, &env, CFG), env);

    // Present and non-empty
    let param = MockParam::Fields(Some(Fields::Single("foo".to_owned())));
    test_cancel!(error(false, &param, must_not_run.clone(), &env, CFG), env);
    test_cancel!(error(true, &param, must_not_run.clone(), &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(false, &param, None, &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(true, &param, None, &env, CFG), env);

    // Present but empty
    let param = MockParam::Fields(Some(Fields::Single("".to_owned())));
    test_cancel!(error(false, &param, must_not_run.clone(), &env, CFG), env);
    test_cancel!(error(true, &param, must_cancel.clone(), &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(false, &param, None, &env, CFG), env);
    test_cancel!(error::<_, MockWord, _>(true, &param, None, &env, CFG), env);
}