mirror of
https://github.com/nushell/nushell
synced 2025-01-14 06:04:09 +00:00
4af24363c2
# Description For years, Nushell has used `let-env` to set a single environment variable. As our work on scoping continued, we refined what it meant for a variable to be in scope using `let` but never updated how `let-env` would work. Instead, `let-env` confusingly created mutations to the command's copy of `$env`. So, to help fix the mental model and point people to the right way of thinking about what changing the environment means, this PR removes `let-env` to encourage people to think of it as updating the command's environment variable via mutation. Before: ``` let-env FOO = "BAR" ``` Now: ``` $env.FOO = "BAR" ``` It's also a good reminder that the environment owned by the command is in the `$env` variable rather than global like it is in other shells. # User-Facing Changes BREAKING CHANGE BREAKING CHANGE This completely removes `let-env FOO = "BAR"` so that we can focus on `$env.FOO = "BAR"`. # Tests + Formatting <!-- Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect -A clippy::result_large_err` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass - `cargo run -- crates/nu-std/tests/run.nu` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` --> # After / Before Submitting integration scripts to update: - ✔️ [starship](https://github.com/starship/starship/blob/master/src/init/starship.nu) - ✔️ [virtualenv](https://github.com/pypa/virtualenv/blob/main/src/virtualenv/activation/nushell/activate.nu) - ✔️ [atuin](https://github.com/ellie/atuin/blob/main/atuin/src/shell/atuin.nu) (PR: https://github.com/ellie/atuin/pull/1080) - ❌ [zoxide](https://github.com/ajeetdsouza/zoxide/blob/main/templates/nushell.txt) (PR: https://github.com/ajeetdsouza/zoxide/pull/587) - ✔️ [oh-my-posh](https://github.com/JanDeDobbeleer/oh-my-posh/blob/main/src/shell/scripts/omp.nu) (pr: https://github.com/JanDeDobbeleer/oh-my-posh/pull/4011)
752 lines
21 KiB
Rust
752 lines
21 KiB
Rust
use nu_test_support::fs::Stub::FileWithContentToBeTrimmed;
|
|
use nu_test_support::playground::Playground;
|
|
use nu_test_support::{nu, nu_repl_code, pipeline};
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[test]
|
|
fn module_private_import_decl() {
|
|
Playground::setup("module_private_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
use spam.nu foo-helper
|
|
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def get-foo [] { "foo" }
|
|
export def foo-helper [] { get-foo }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_private_import_alias() {
|
|
Playground::setup("module_private_import_alias", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
use spam.nu foo-helper
|
|
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export alias foo-helper = echo "foo"
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_private_import_decl_not_public() {
|
|
Playground::setup("module_private_import_decl_not_public", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
use spam.nu foo-helper
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def get-foo [] { "foo" }
|
|
export def foo-helper [] { get-foo }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu foo"#, r#"foo-helper"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert!(!actual.err.is_empty());
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_decl() {
|
|
Playground::setup("module_public_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam.nu foo
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def foo-helper [] { "foo" }
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_alias() {
|
|
Playground::setup("module_public_import_alias", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam.nu foo
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export alias foo = echo "foo"
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports() {
|
|
Playground::setup("module_nested_imports", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export use spam2.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam2.nu",
|
|
r#"
|
|
export use spam3.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &[r#"use main.nu foo"#, r#"foo"#];
|
|
let inp2 = &[r#"use main.nu bar"#, r#"bar"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp1.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp2.join("; ")));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports_in_dirs() {
|
|
Playground::setup("module_nested_imports_in_dirs", |dirs, sandbox| {
|
|
sandbox
|
|
.mkdir("spam")
|
|
.mkdir("spam/spam2")
|
|
.mkdir("spam/spam3")
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam/spam.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam.nu",
|
|
r#"
|
|
export use spam2/spam2.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam2/spam2.nu",
|
|
r#"
|
|
export use ../spam3/spam3.nu [ foo bar ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam3/spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &[r#"use main.nu foo"#, r#"foo"#];
|
|
let inp2 = &[r#"use main.nu bar"#, r#"bar"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp1.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp2.join("; ")));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_decl_prefixed() {
|
|
Playground::setup("module_public_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam.nu
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def foo-helper [] { "foo" }
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use main.nu"#, r#"main spam foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports_in_dirs_prefixed() {
|
|
Playground::setup("module_nested_imports_in_dirs", |dirs, sandbox| {
|
|
sandbox
|
|
.mkdir("spam")
|
|
.mkdir("spam/spam2")
|
|
.mkdir("spam/spam3")
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam/spam.nu [ "spam2 foo" "spam2 spam3 bar" ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam.nu",
|
|
r#"
|
|
export use spam2/spam2.nu
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam2/spam2.nu",
|
|
r#"
|
|
export use ../spam3/spam3.nu
|
|
export use ../spam3/spam3.nu foo
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam3/spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &[r#"use main.nu"#, r#"main spam2 foo"#];
|
|
let inp2 = &[r#"use main.nu "spam2 spam3 bar""#, r#"spam2 spam3 bar"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp1.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp2.join("; ")));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_env_1() {
|
|
Playground::setup("module_import_env_1", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export-env { source-env spam.nu }
|
|
|
|
export def foo [] { $env.FOO_HELPER }
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export-env { $env.FOO_HELPER = "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"source-env main.nu"#, r#"use main.nu foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_env_2() {
|
|
Playground::setup("module_import_env_2", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export-env { source-env spam.nu }
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export-env { $env.FOO = "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"source-env main.nu"#, r#"$env.FOO"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_0() {
|
|
Playground::setup("module_cyclical_imports_0", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
use eggs.nu
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"module eggs { use spam.nu }"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("module not found"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_1() {
|
|
Playground::setup("module_cyclical_imports_1", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
use spam.nu
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use spam.nu"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_2() {
|
|
Playground::setup("module_cyclical_imports_2", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
use eggs.nu
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"eggs.nu",
|
|
r#"
|
|
use spam.nu
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use spam.nu"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_3() {
|
|
Playground::setup("module_cyclical_imports_3", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
use eggs.nu
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"eggs.nu",
|
|
r#"
|
|
use bacon.nu
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"bacon.nu",
|
|
r#"
|
|
use spam.nu
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"use spam.nu"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_const_file() {
|
|
Playground::setup("module_import_const_file", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[r#"const file = 'spam.nu'"#, r#"use $file foo"#, r#"foo"#];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_const_module_name() {
|
|
Playground::setup("module_import_const_file", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[
|
|
r#"module spam { export def foo [] { "foo" } }"#,
|
|
r#"const mod = 'spam'"#,
|
|
r#"use $mod foo"#,
|
|
r#"foo"#,
|
|
];
|
|
|
|
let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_def_name() {
|
|
let inp = &[r#"module spam { def spam [] { "spam" } }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_def_name() {
|
|
let inp = &[r#"module spam { export def spam [] { "spam" } }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_alias_name_1() {
|
|
let inp = &[r#"module spam { alias spam = echo "spam" }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_alias_name_2() {
|
|
let inp = &[r#"module spam { alias main = echo "spam" }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_alias_name() {
|
|
let inp = &[r#"module spam { export alias spam = echo "spam" }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_main_alias_not_allowed() {
|
|
let inp = &[r#"module spam { export alias main = echo 'spam' }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("export_main_alias_not_allowed"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_known_external_name() {
|
|
let inp = &[r#"module spam { extern spam [] }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_known_external_name() {
|
|
let inp = &[r#"module spam { export extern spam [] }"#];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn main_inside_module_is_main() {
|
|
let inp = &[
|
|
r#"module spam {
|
|
export def main [] { 'foo' };
|
|
export def foo [] { main }
|
|
}"#,
|
|
"use spam foo",
|
|
"foo",
|
|
];
|
|
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_as_file() {
|
|
let inp = &[r#"module samples/spam.nu"#, "use spam foo", "foo"];
|
|
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn export_module_as_file() {
|
|
let inp = &[r#"export module samples/spam.nu"#, "use spam foo", "foo"];
|
|
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn deep_import_patterns() {
|
|
let module_decl = r#"
|
|
module spam {
|
|
export module eggs {
|
|
export module beans {
|
|
export def foo [] { 'foo' };
|
|
export def bar [] { 'bar' }
|
|
};
|
|
};
|
|
}
|
|
"#;
|
|
|
|
let inp = &[module_decl, "use spam", "spam eggs beans foo"];
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs", "eggs beans foo"];
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs beans", "beans foo"];
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs beans foo", "foo"];
|
|
let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir() {
|
|
let import = "use samples/spam";
|
|
|
|
let inp = &[import, "spam"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "spam");
|
|
|
|
let inp = &[import, "spam foo"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[import, "spam bar"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "bar");
|
|
|
|
let inp = &[import, "spam foo baz"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "foobaz");
|
|
|
|
let inp = &[import, "spam bar baz"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "barbaz");
|
|
|
|
let inp = &[import, "spam baz"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "spambaz");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_deep() {
|
|
let import = "use samples/spam";
|
|
|
|
let inp = &[import, "spam bacon"];
|
|
let actual_repl = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual_repl.out, "bacon");
|
|
|
|
let inp = &[import, "spam bacon foo"];
|
|
let actual_repl = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual_repl.out, "bacon foo");
|
|
|
|
let inp = &[import, "spam bacon beans"];
|
|
let actual_repl = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual_repl.out, "beans");
|
|
|
|
let inp = &[import, "spam bacon beans foo"];
|
|
let actual_repl = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual_repl.out, "beans foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_import_twice_no_panic() {
|
|
let import = "use samples/spam";
|
|
let inp = &[import, import, "spam"];
|
|
let actual_repl = nu!(cwd: "tests/modules", nu_repl_code(inp));
|
|
assert_eq!(actual_repl.out, "spam");
|
|
}
|
|
|
|
#[test]
|
|
fn not_allowed_submodule_file() {
|
|
let inp = &["use samples/not_allowed"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("invalid_module_file_name"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_missing_mod_nu() {
|
|
let inp = &["use samples/missing_mod_nu"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("module_missing_mod_nu_file"));
|
|
}
|
|
|
|
#[test]
|
|
fn allowed_local_module() {
|
|
let inp = &["module spam { module spam {} }"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn not_allowed_submodule() {
|
|
let inp = &["module spam { export module spam {} }"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_self_name() {
|
|
let inp = &[
|
|
"module spam { export module mod { export def main [] { 'spam' } } }",
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert_eq!(actual.out, "spam");
|
|
}
|
|
|
|
#[test]
|
|
fn module_self_name_main_not_allowed() {
|
|
let inp = &[
|
|
r#"module spam {
|
|
export def main [] { 'main spam' };
|
|
|
|
export module mod {
|
|
export def main [] { 'mod spam' }
|
|
}
|
|
}"#,
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("module_double_main"));
|
|
|
|
let inp = &[
|
|
r#"module spam {
|
|
export module mod {
|
|
export def main [] { 'mod spam' }
|
|
};
|
|
|
|
export def main [] { 'main spam' }
|
|
}"#,
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("module_double_main"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_main_not_found() {
|
|
let inp = &["module spam {}", "use spam main"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("export_not_found"));
|
|
|
|
let inp = &["module spam {}", "use spam [ main ]"];
|
|
let actual = nu!(cwd: "tests/modules", pipeline(&inp.join("; ")));
|
|
assert!(actual.err.contains("export_not_found"));
|
|
}
|