mirror of
https://github.com/nushell/nushell
synced 2024-12-27 05:23:11 +00:00
a59477205d
# Description Fixes a bug with `set_last_error()` introduced by @IanManske not being called during the jump to an error handler in IR eval. Without this, `$env.LAST_EXIT_CODE` wasn't getting set in the `catch` block for an external. # Tests + Formatting Added a `tests/eval` test to cover this in both IR and non-IR eval
479 lines
10 KiB
Rust
479 lines
10 KiB
Rust
use nu_test_support::{nu, playground::Playground};
|
|
use regex::Regex;
|
|
|
|
#[test]
|
|
fn record_with_redefined_key() {
|
|
let actual = nu!("{x: 1, x: 2}");
|
|
|
|
assert!(actual.err.contains("redefined"));
|
|
}
|
|
|
|
#[test]
|
|
fn run_file_parse_error() {
|
|
let actual = nu!(
|
|
cwd: "tests/fixtures/eval",
|
|
"nu script.nu"
|
|
);
|
|
|
|
assert!(actual.err.contains("unknown type"));
|
|
}
|
|
|
|
enum ExpectedOut<'a> {
|
|
/// Equals a string exactly
|
|
Eq(&'a str),
|
|
/// Matches a regex
|
|
Matches(&'a str),
|
|
/// Produces an error (match regex)
|
|
Error(&'a str),
|
|
/// Drops a file that contains these contents
|
|
FileEq(&'a str, &'a str),
|
|
}
|
|
use self::ExpectedOut::*;
|
|
|
|
fn test_eval(source: &str, expected_out: ExpectedOut) {
|
|
Playground::setup("test_eval_ast", |ast_dirs, _playground| {
|
|
Playground::setup("test_eval_ir", |ir_dirs, _playground| {
|
|
let actual_ast = nu!(
|
|
cwd: ast_dirs.test(),
|
|
use_ir: false,
|
|
source,
|
|
);
|
|
let actual_ir = nu!(
|
|
cwd: ir_dirs.test(),
|
|
use_ir: true,
|
|
source,
|
|
);
|
|
|
|
match expected_out {
|
|
Eq(eq) => {
|
|
assert_eq!(actual_ast.out, eq);
|
|
assert_eq!(actual_ir.out, eq);
|
|
assert!(actual_ast.status.success());
|
|
assert!(actual_ir.status.success());
|
|
}
|
|
Matches(regex) => {
|
|
let compiled_regex = Regex::new(regex).expect("regex failed to compile");
|
|
assert!(
|
|
compiled_regex.is_match(&actual_ast.out),
|
|
"AST eval out does not match: {}\n{}",
|
|
regex,
|
|
actual_ast.out
|
|
);
|
|
assert!(
|
|
compiled_regex.is_match(&actual_ir.out),
|
|
"IR eval out does not match: {}\n{}",
|
|
regex,
|
|
actual_ir.out,
|
|
);
|
|
assert!(actual_ast.status.success());
|
|
assert!(actual_ir.status.success());
|
|
}
|
|
Error(regex) => {
|
|
let compiled_regex = Regex::new(regex).expect("regex failed to compile");
|
|
assert!(
|
|
compiled_regex.is_match(&actual_ast.err),
|
|
"AST eval err does not match: {}",
|
|
regex
|
|
);
|
|
assert!(
|
|
compiled_regex.is_match(&actual_ir.err),
|
|
"IR eval err does not match: {}",
|
|
regex
|
|
);
|
|
assert!(!actual_ast.status.success());
|
|
assert!(!actual_ir.status.success());
|
|
}
|
|
FileEq(path, contents) => {
|
|
let ast_contents = std::fs::read_to_string(ast_dirs.test().join(path))
|
|
.expect("failed to read AST file");
|
|
let ir_contents = std::fs::read_to_string(ir_dirs.test().join(path))
|
|
.expect("failed to read IR file");
|
|
assert_eq!(ast_contents.trim(), contents);
|
|
assert_eq!(ir_contents.trim(), contents);
|
|
assert!(actual_ast.status.success());
|
|
assert!(actual_ir.status.success());
|
|
}
|
|
}
|
|
assert_eq!(actual_ast.out, actual_ir.out);
|
|
})
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn literal_bool() {
|
|
test_eval("true", Eq("true"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_int() {
|
|
test_eval("1", Eq("1"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_float() {
|
|
test_eval("1.5", Eq("1.5"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_filesize() {
|
|
test_eval("30MiB", Eq("30.0 MiB"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_duration() {
|
|
test_eval("30ms", Eq("30ms"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_binary() {
|
|
test_eval("0x[1f 2f f0]", Matches("Length.*1f.*2f.*f0"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_closure() {
|
|
test_eval("{||}", Matches("<Closure"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_range() {
|
|
test_eval("0..2..10", Matches("10"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_list() {
|
|
test_eval("[foo bar baz]", Matches("foo.*bar.*baz"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_record() {
|
|
test_eval("{foo: bar, baz: quux}", Matches("foo.*bar.*baz.*quux"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_table() {
|
|
test_eval("[[a b]; [1 2] [3 4]]", Matches("a.*b.*1.*2.*3.*4"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_string() {
|
|
test_eval(r#""foobar""#, Eq("foobar"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_raw_string() {
|
|
test_eval(r#"r#'bazquux'#"#, Eq("bazquux"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_date() {
|
|
test_eval("2020-01-01T00:00:00Z", Matches("2020"))
|
|
}
|
|
|
|
#[test]
|
|
fn literal_nothing() {
|
|
test_eval("null", Eq(""))
|
|
}
|
|
|
|
#[test]
|
|
fn list_spread() {
|
|
test_eval("[foo bar ...[baz quux]] | length", Eq("4"))
|
|
}
|
|
|
|
#[test]
|
|
fn record_spread() {
|
|
test_eval("{foo: bar ...{baz: quux}} | columns | length", Eq("2"))
|
|
}
|
|
|
|
#[test]
|
|
fn binary_op_example() {
|
|
test_eval(
|
|
"(([1 2] ++ [3 4]) == [1 2 3 4]) and (([1 2 3] ++ 4) == ([1] ++ [2 3 4]))",
|
|
Eq("true"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn range_from_expressions() {
|
|
test_eval("(1 + 1)..(2 + 2)", Matches("2.*3.*4"))
|
|
}
|
|
|
|
#[test]
|
|
fn list_from_expressions() {
|
|
test_eval(
|
|
"[('foo' | str upcase) ('BAR' | str downcase)]",
|
|
Matches("FOO.*bar"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn record_from_expressions() {
|
|
test_eval("{('foo' | str upcase): 42}", Matches("FOO.*42"))
|
|
}
|
|
|
|
#[test]
|
|
fn call_spread() {
|
|
test_eval(
|
|
"echo foo bar ...[baz quux nushell]",
|
|
Matches("foo.*bar.*baz.*quux.*nushell"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn call_flag() {
|
|
test_eval("print -e message", Eq("")) // should not be visible on stdout
|
|
}
|
|
|
|
#[test]
|
|
fn call_named() {
|
|
test_eval("10.123 | into string --decimals 1", Eq("10.1"))
|
|
}
|
|
|
|
#[test]
|
|
fn external_call() {
|
|
test_eval("nu --testbin cococo foo=bar baz", Eq("foo=bar baz"))
|
|
}
|
|
|
|
#[test]
|
|
fn external_call_redirect_pipe() {
|
|
test_eval(
|
|
"nu --testbin cococo foo=bar baz | str upcase",
|
|
Eq("FOO=BAR BAZ"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn external_call_redirect_capture() {
|
|
test_eval(
|
|
"echo (nu --testbin cococo foo=bar baz) | str upcase",
|
|
Eq("FOO=BAR BAZ"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn external_call_redirect_file() {
|
|
test_eval(
|
|
"nu --testbin cococo hello out> hello.txt",
|
|
FileEq("hello.txt", "hello"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn let_variable() {
|
|
test_eval("let foo = 'test'; print $foo", Eq("test"))
|
|
}
|
|
|
|
#[test]
|
|
fn let_variable_mutate_error() {
|
|
test_eval(
|
|
"let foo = 'test'; $foo = 'bar'; print $foo",
|
|
Error("immutable"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn constant() {
|
|
test_eval("const foo = 1 + 2; print $foo", Eq("3"))
|
|
}
|
|
|
|
#[test]
|
|
fn constant_assign_error() {
|
|
test_eval(
|
|
"const foo = 1 + 2; $foo = 4; print $foo",
|
|
Error("immutable"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn mut_variable() {
|
|
test_eval("mut foo = 'test'; $foo = 'bar'; print $foo", Eq("bar"))
|
|
}
|
|
|
|
#[test]
|
|
fn mut_variable_append_assign() {
|
|
test_eval(
|
|
"mut foo = 'test'; $foo ++= 'bar'; print $foo",
|
|
Eq("testbar"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn bind_in_variable_to_input() {
|
|
test_eval("3 | (4 + $in)", Eq("7"))
|
|
}
|
|
|
|
#[test]
|
|
fn if_true() {
|
|
test_eval("if true { 'foo' }", Eq("foo"))
|
|
}
|
|
|
|
#[test]
|
|
fn if_false() {
|
|
test_eval("if false { 'foo' } | describe", Eq("nothing"))
|
|
}
|
|
|
|
#[test]
|
|
fn if_else_true() {
|
|
test_eval("if 5 > 3 { 'foo' } else { 'bar' }", Eq("foo"))
|
|
}
|
|
|
|
#[test]
|
|
fn if_else_false() {
|
|
test_eval("if 5 < 3 { 'foo' } else { 'bar' }", Eq("bar"))
|
|
}
|
|
|
|
#[test]
|
|
fn match_empty_fallthrough() {
|
|
test_eval("match 42 { }; 'pass'", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn match_value() {
|
|
test_eval("match 1 { 1 => 'pass', 2 => 'fail' }", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn match_value_default() {
|
|
test_eval(
|
|
"match 3 { 1 => 'fail1', 2 => 'fail2', _ => 'pass' }",
|
|
Eq("pass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn match_value_fallthrough() {
|
|
test_eval("match 3 { 1 => 'fail1', 2 => 'fail2' }", Eq(""))
|
|
}
|
|
|
|
#[test]
|
|
fn match_variable() {
|
|
test_eval(
|
|
"match 'pass' { $s => { print $s }, _ => { print 'fail' } }",
|
|
Eq("pass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn match_variable_in_list() {
|
|
test_eval("match [fail pass] { [$f, $p] => { print $p } }", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn match_passthrough_input() {
|
|
test_eval(
|
|
"'yes' | match [pass fail] { [$p, ..] => (collect { |y| $y ++ $p }) }",
|
|
Eq("yespass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn while_mutate_var() {
|
|
test_eval("mut x = 2; while $x > 0 { print $x; $x -= 1 }", Eq("21"))
|
|
}
|
|
|
|
#[test]
|
|
fn for_list() {
|
|
test_eval("for v in [1 2 3] { print ($v * 2) }", Eq(r"246"))
|
|
}
|
|
|
|
#[test]
|
|
fn for_seq() {
|
|
test_eval("for v in (seq 1 4) { print ($v * 2) }", Eq("2468"))
|
|
}
|
|
|
|
#[test]
|
|
fn early_return() {
|
|
test_eval("do { return 'foo'; 'bar' }", Eq("foo"))
|
|
}
|
|
|
|
#[test]
|
|
fn early_return_from_if() {
|
|
test_eval("do { if true { return 'pass' }; 'fail' }", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn early_return_from_loop() {
|
|
test_eval("do { loop { return 'pass' } }", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn early_return_from_while() {
|
|
test_eval(
|
|
"do { let x = true; while $x { return 'pass' } }",
|
|
Eq("pass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn early_return_from_for() {
|
|
test_eval("do { for x in [pass fail] { return $x } }", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn try_no_catch() {
|
|
test_eval("try { error make { msg: foo } }; 'pass'", Eq("pass"))
|
|
}
|
|
|
|
#[test]
|
|
fn try_catch_no_var() {
|
|
test_eval(
|
|
"try { error make { msg: foo } } catch { 'pass' }",
|
|
Eq("pass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn try_catch_var() {
|
|
test_eval(
|
|
"try { error make { msg: foo } } catch { |err| $err.msg }",
|
|
Eq("foo"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn try_catch_with_non_literal_closure_no_var() {
|
|
test_eval(
|
|
r#"
|
|
let error_handler = { || "pass" }
|
|
try { error make { msg: foobar } } catch $error_handler
|
|
"#,
|
|
Eq("pass"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn try_catch_with_non_literal_closure() {
|
|
test_eval(
|
|
r#"
|
|
let error_handler = { |err| $err.msg }
|
|
try { error make { msg: foobar } } catch $error_handler
|
|
"#,
|
|
Eq("foobar"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn try_catch_external() {
|
|
test_eval(
|
|
r#"try { nu -c 'exit 1' } catch { $env.LAST_EXIT_CODE }"#,
|
|
Eq("1"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn row_condition() {
|
|
test_eval(
|
|
"[[a b]; [1 2] [3 4]] | where a < 3 | to nuon",
|
|
Eq("[[a, b]; [1, 2]]"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn custom_command() {
|
|
test_eval(
|
|
r#"
|
|
def cmd [a: int, b: string = 'fail', ...c: string, --x: int] { $"($a)($b)($c)($x)" }
|
|
cmd 42 pass foo --x 30
|
|
"#,
|
|
Eq("42pass[foo]30"),
|
|
)
|
|
}
|