Command tests (#922)

* WIP command tests

* Finish marking todo tests

* update

* update

* Windows cd test ignoring

crates/nu-command/tests/commands/math/avg.rs

@@ -0,0 +1,27 @@
+use nu_test_support::{nu, pipeline};
+
+#[test]
+fn can_average_numbers() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+             open sgml_description.json
+             | get glossary.GlossDiv.GlossList.GlossEntry.Sections
+             | math avg
+         "#
+    ));
+
+    assert_eq!(actual.out, "101.5")
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn can_average_bytes() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats",
+        "ls | sort-by name | skip 1 | first 2 | get size | math avg | format \"{$it}\" "
+    );
+
+    assert_eq!(actual.out, "1.6 KB");
+}

crates/nu-command/tests/commands/math/eval.rs

@@ -0,0 +1,93 @@
+use nu_test_support::{nu, pipeline};
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn evaluates_two_plus_two() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        math eval "2 + 2"
+        "#
+    ));
+
+    assert!(actual.out.contains("4.0"));
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn evaluates_two_to_the_power_four() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        echo "2 ^ 4" | math eval
+        "#
+    ));
+
+    assert!(actual.out.contains("16.0"));
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn evaluates_three_multiplied_by_five() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        echo "3 * 5" | math eval
+        "#
+    ));
+
+    assert!(actual.out.contains("15.0"));
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn evaluates_twenty_four_divided_by_two() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        echo "24 / 2" | math eval
+        "#
+    ));
+
+    assert!(actual.out.contains("12.0"));
+}
+
+#[test]
+fn evaluates_twenty_eight_minus_seven() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        echo "28 - 7" | math eval
+        "#
+    ));
+
+    assert!(actual.out.contains("21"));
+}
+
+#[test]
+fn evaluates_pi() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        math eval pi
+        "#
+    ));
+
+    assert!(actual.out.contains("3.14"));
+}
+
+#[test]
+fn evaluates_tau() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        math eval tau
+        "#
+    ));
+
+    assert!(actual.out.contains("6.28"));
+}

crates/nu-command/tests/commands/math/median.rs

@@ -0,0 +1,40 @@
+use nu_test_support::{nu, pipeline};
+
+#[test]
+fn median_numbers_with_even_rows() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+             echo [10 6 19 21 4]
+             | math median
+         "#
+    ));
+
+    assert_eq!(actual.out, "10")
+}
+
+#[test]
+fn median_numbers_with_odd_rows() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+             echo [3 8 9 12 12 15]
+             | math median
+         "#
+    ));
+
+    assert_eq!(actual.out, "10.5")
+}
+
+#[test]
+fn median_mixed_numbers() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+             echo [-11.5 -13.5 10]
+             | math median
+         "#
+    ));
+
+    assert_eq!(actual.out, "-11.5")
+}

crates/nu-command/tests/commands/math/mod.rs

@@ -0,0 +1,288 @@
+mod avg;
+mod eval;
+mod median;
+mod round;
+mod sqrt;
+mod sum;
+
+use nu_test_support::{nu, pipeline};
+
+#[test]
+fn one_arg() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1
+        "#
+    ));
+
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn add() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 + 1
+        "#
+    ));
+
+    assert_eq!(actual.out, "2");
+}
+
+#[test]
+fn add_compound() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 + 2 + 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "5");
+}
+
+#[test]
+fn precedence_of_operators() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 + 2 * 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "5");
+}
+
+#[test]
+fn precedence_of_operators2() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 + 2 * 2 + 1
+        "#
+    ));
+
+    assert_eq!(actual.out, "6");
+}
+
+#[test]
+fn division_of_ints() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            4 / 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "2");
+}
+
+#[test]
+fn division_of_ints2() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 / 4
+        "#
+    ));
+
+    assert_eq!(actual.out, "0.25");
+}
+
+#[test]
+fn error_zero_division_int_int() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 / 0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_division_decimal_int() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1.0 / 0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_division_int_decimal() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1 / 0.0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn error_zero_division_decimal_decimal() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1.0 / 0.0
+        "#
+    ));
+
+    assert!(actual.err.contains("division by zero"));
+}
+
+#[test]
+fn proper_precedence_history() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            2 / 2 / 2 + 1
+        "#
+    ));
+
+    assert_eq!(actual.out, "1.5");
+}
+
+#[test]
+fn parens_precedence() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            4 * (6 - 3)
+        "#
+    ));
+
+    assert_eq!(actual.out, "12");
+}
+
+#[test]
+fn modulo() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            9 mod 2
+        "#
+    ));
+
+    assert_eq!(actual.out, "1");
+}
+
+#[test]
+fn duration_math() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1wk + 1day
+        "#
+    ));
+
+    assert_eq!(actual.out, "8day");
+}
+
+#[test]
+fn duration_decimal_math() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            5.5day + 0.5day
+        "#
+    ));
+
+    assert_eq!(actual.out, "6day");
+}
+
+#[test]
+fn duration_math_with_nanoseconds() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1wk + 10ns
+        "#
+    ));
+
+    assert_eq!(actual.out, "7day 10ns");
+}
+
+#[test]
+fn duration_decimal_math_with_nanoseconds() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1.5wk + 10ns
+        "#
+    ));
+
+    assert_eq!(actual.out, "10day 10ns");
+}
+
+#[test]
+fn duration_math_with_negative() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            1day - 1wk
+        "#
+    ));
+
+    assert_eq!(actual.out, "-6day");
+}
+
+#[test]
+fn compound_comparison() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            4 > 3 && 2 > 1
+        "#
+    ));
+
+    assert_eq!(actual.out, "true");
+}
+
+#[test]
+fn compound_comparison2() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            4 < 3 || 2 > 1
+        "#
+    ));
+
+    assert_eq!(actual.out, "true");
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn compound_where() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            echo '[{"a": 1, "b": 1}, {"a": 2, "b": 1}, {"a": 2, "b": 2}]' | from json | where a == 2 && b == 1 | to json
+        "#
+    ));
+
+    assert_eq!(actual.out, r#"{"a":2,"b":1}"#);
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn compound_where_paren() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            echo '[{"a": 1, "b": 1}, {"a": 2, "b": 1}, {"a": 2, "b": 2}]' | from json | where ($it.a == 2 && $it.b == 1) || $it.b == 2 | to json
+        "#
+    ));
+
+    assert_eq!(actual.out, r#"[{"a":2,"b":1},{"a":2,"b":2}]"#);
+}

crates/nu-command/tests/commands/math/round.rs

@@ -0,0 +1,21 @@
+use nu_test_support::nu;
+
+#[test]
+fn can_round_very_large_numbers() {
+    let actual = nu!(
+        cwd: ".",
+        "echo 18.1372544780074142289927665486772012345 | math round"
+    );
+
+    assert_eq!(actual.out, "18")
+}
+
+#[test]
+fn can_round_very_large_numbers_with_precision() {
+    let actual = nu!(
+        cwd: ".",
+        "echo 18.13725447800741422899276654867720121457878988 | math round -p 10"
+    );
+
+    assert_eq!(actual.out, "18.137254478")
+}

crates/nu-command/tests/commands/math/sqrt.rs

@@ -0,0 +1,35 @@
+use nu_test_support::nu;
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn can_sqrt_numbers() {
+    let actual = nu!(
+        cwd: ".",
+        "echo [0.25 2 4] | math sqrt | math sum"
+    );
+
+    assert_eq!(actual.out, "3.914213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573");
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn can_sqrt_irrational() {
+    let actual = nu!(
+        cwd: ".",
+        "echo 2 | math sqrt"
+    );
+
+    assert_eq!(actual.out, "1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573");
+}
+
+#[test]
+fn can_sqrt_perfect_square() {
+    let actual = nu!(
+        cwd: ".",
+        "echo 4 | math sqrt"
+    );
+
+    assert_eq!(actual.out, "2");
+}

crates/nu-command/tests/commands/math/sum.rs

@@ -0,0 +1,89 @@
+use nu_test_support::fs::Stub::FileWithContentToBeTrimmed;
+use nu_test_support::playground::Playground;
+use nu_test_support::{nu, pipeline};
+use std::str::FromStr;
+
+#[test]
+fn all() {
+    Playground::setup("sum_test_1", |dirs, sandbox| {
+        sandbox.with_files(vec![FileWithContentToBeTrimmed(
+            "meals.json",
+            r#"
+                {
+                    meals: [
+                        {description: "1 large egg", calories: 90},
+                        {description: "1 cup white rice", calories: 250},
+                        {description: "1 tablespoon fish oil", calories: 108}
+                    ]
+                }
+            "#,
+        )]);
+
+        let actual = nu!(
+            cwd: dirs.test(), pipeline(
+            r#"
+                open meals.json
+                | get meals
+                | get calories
+                | math sum
+            "#
+        ));
+
+        assert_eq!(actual.out, "448");
+    })
+}
+
+#[test]
+#[allow(clippy::unreadable_literal)]
+#[allow(clippy::float_cmp)]
+fn compute_sum_of_individual_row() -> Result<(), String> {
+    let answers_for_columns = [
+        ("cpu", 88.257434),
+        ("mem", 3032375296.),
+        ("virtual", 102579965952.),
+    ];
+    for (column_name, expected_value) in answers_for_columns {
+        let actual = nu!(
+            cwd: "tests/fixtures/formats/",
+            format!("open sample-ps-output.json | select {} | math sum | get {}", column_name, column_name)
+        );
+        let result =
+            f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;
+        assert_eq!(result, expected_value);
+    }
+    Ok(())
+}
+
+#[test]
+#[allow(clippy::unreadable_literal)]
+#[allow(clippy::float_cmp)]
+fn compute_sum_of_table() -> Result<(), String> {
+    let answers_for_columns = [
+        ("cpu", 88.257434),
+        ("mem", 3032375296.),
+        ("virtual", 102579965952.),
+    ];
+    for (column_name, expected_value) in answers_for_columns {
+        let actual = nu!(
+            cwd: "tests/fixtures/formats/",
+            format!("open sample-ps-output.json | select cpu mem virtual | math sum | get {}", column_name)
+        );
+        let result =
+            f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;
+        assert_eq!(result, expected_value);
+    }
+    Ok(())
+}
+
+// FIXME: jt: needs more work
+#[ignore]
+#[test]
+fn sum_of_a_row_containing_a_table_is_an_error() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats/",
+        "open sample-sys-output.json | math sum"
+    );
+    assert!(actual
+        .err
+        .contains("Attempted to compute values that can't be operated on"));
+}