nushell/crates/nu-command/tests/commands/use_.rs

use nu_test_support::fs::AbsolutePath;
use nu_test_support::fs::Stub::{FileWithContent, FileWithContentToBeTrimmed};
use nu_test_support::nu;
use nu_test_support::pipeline;
use nu_test_support::playground::Playground;

#[test]
fn use_module_file_within_block() {
    Playground::setup("use_test_1", |dirs, nu| {
        let file = AbsolutePath::new(dirs.test().join("spam.nu"));

        nu.with_files(vec![FileWithContent(
            &file.to_string(),
            r#"
                export def foo [] {
                    echo "hello world"
                }
            "#,
        )]);

        let actual = nu!(
            cwd: dirs.test(), pipeline(
                r#"
                    def bar [] {
                        use spam.nu foo;
                        foo
                    };
                    bar
                "#
            )
        );

        assert_eq!(actual.out, "hello world");
    })
}

#[test]
fn use_keeps_doc_comments() {
    Playground::setup("use_doc_comments", |dirs, nu| {
        let file = AbsolutePath::new(dirs.test().join("spam.nu"));

        nu.with_files(vec![FileWithContent(
            &file.to_string(),
            r#"
                # this is my foo command
                export def foo [
                    x:string # this is an x parameter
                ] {
                    echo "hello world"
                }
            "#,
        )]);

        let actual = nu!(
            cwd: dirs.test(), pipeline(
                r#"
                    use spam.nu foo;
                    help foo
                "#
            )
        );

        assert!(actual.out.contains("this is my foo command"));
        assert!(actual.out.contains("this is an x parameter"));
    })
}

#[test]
fn use_eval_export_env() {
    Playground::setup("use_eval_export_env", |dirs, sandbox| {
        sandbox.with_files(vec![FileWithContentToBeTrimmed(
            "spam.nu",
            r#"
                export-env { $env.FOO = 'foo' }
            "#,
        )]);

        let inp = &[r#"use spam.nu"#, r#"$env.FOO"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));

        assert_eq!(actual.out, "foo");
    })
}

#[test]
fn use_eval_export_env_hide() {
    Playground::setup("use_eval_export_env", |dirs, sandbox| {
        sandbox.with_files(vec![FileWithContentToBeTrimmed(
            "spam.nu",
            r#"
                export-env { hide-env FOO }
            "#,
        )]);

        let inp = &[r#"$env.FOO = 'foo'"#, r#"use spam.nu"#, r#"$env.FOO"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));

        assert!(actual.err.contains("not_found"));
    })
}

#[test]
fn use_do_cd() {
    Playground::setup("use_do_cd", |dirs, sandbox| {
        sandbox
            .mkdir("test1/test2")
            .with_files(vec![FileWithContentToBeTrimmed(
                "test1/test2/spam.nu",
                r#"
                    export-env { cd test1/test2 }
                "#,
            )]);

        let inp = &[r#"use test1/test2/spam.nu"#, r#"$env.PWD | path basename"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));

        assert_eq!(actual.out, "test2");
    })
}

#[test]
fn use_do_cd_file_relative() {
    Playground::setup("use_do_cd_file_relative", |dirs, sandbox| {
        sandbox
            .mkdir("test1/test2")
            .with_files(vec![FileWithContentToBeTrimmed(
                "test1/test2/spam.nu",
                r#"
                    export-env { cd ($env.FILE_PWD | path join '..') }
                "#,
            )]);

        let inp = &[r#"use test1/test2/spam.nu"#, r#"$env.PWD | path basename"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));

        assert_eq!(actual.out, "test1");
    })
}

#[test]
fn use_dont_cd_overlay() {
    Playground::setup("use_dont_cd_overlay", |dirs, sandbox| {
        sandbox
            .mkdir("test1/test2")
            .with_files(vec![FileWithContentToBeTrimmed(
                "test1/test2/spam.nu",
                r#"
                    export-env {
                        overlay new spam
                        cd test1/test2
                        overlay hide spam
                    }
                "#,
            )]);

        let inp = &[r#"use test1/test2/spam.nu"#, r#"$env.PWD | path basename"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));

        assert_eq!(actual.out, "use_dont_cd_overlay");
    })
}

#[test]
fn use_export_env_combined() {
    Playground::setup("use_is_scoped", |dirs, sandbox| {
        sandbox.with_files(vec![FileWithContentToBeTrimmed(
            "spam.nu",
            r#"
                def foo [] { 'foo' }
                alias bar = foo
                export-env { $env.FOO = (bar) }
            "#,
        )]);

        let inp = &[r#"use spam.nu"#, r#"$env.FOO"#];

        let actual = nu!(cwd: dirs.test(), pipeline(&inp.join("; ")));
        assert_eq!(actual.out, "foo");
    })
}

#[test]
fn use_module_creates_accurate_did_you_mean_1() {
    let actual = nu!(
    cwd: ".", pipeline(
        r#"
            module spam { export def foo [] { "foo" } }; use spam; foo
        "#
        )
    );
    assert!(actual.err.contains(
        "command 'foo' was not found but it was imported from module 'spam'; try using `spam foo`"
    ));
}

#[test]
fn use_module_creates_accurate_did_you_mean_2() {
    let actual = nu!(
    cwd: ".", pipeline(
        r#"
            module spam { export def foo [] { "foo" } }; foo
        "#
        )
    );
    assert!(actual.err.contains(
        "command 'foo' was not found but it exists in module 'spam'; try importing it with `use`"
    ));
}

#[test]
fn use_main_1() {
    let inp = &[
        r#"module spam { export def main [] { "spam" } }"#,
        r#"use spam"#,
        r#"spam"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert_eq!(actual.out, "spam");
}

#[test]
fn use_main_2() {
    let inp = &[
        r#"module spam { export def main [] { "spam" } }"#,
        r#"use spam main"#,
        r#"spam"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert_eq!(actual.out, "spam");
}

#[test]
fn use_main_3() {
    let inp = &[
        r#"module spam { export def main [] { "spam" } }"#,
        r#"use spam [ main ]"#,
        r#"spam"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert_eq!(actual.out, "spam");
}

#[test]
fn use_main_4() {
    let inp = &[
        r#"module spam { export def main [] { "spam" } }"#,
        r#"use spam *"#,
        r#"spam"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert_eq!(actual.out, "spam");
}

#[test]
fn use_main_def_env() {
    let inp = &[
        r#"module spam { export def-env main [] { $env.SPAM = "spam" } }"#,
        r#"use spam"#,
        r#"spam"#,
        r#"$env.SPAM"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert_eq!(actual.out, "spam");
}

#[test]
fn use_main_def_known_external() {
    // note: requires installed cargo
    let inp = &[
        r#"module cargo { export extern main [] }"#,
        r#"use cargo"#,
        r#"cargo --version"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert!(actual.out.contains("cargo"));
}

#[test]
fn use_main_not_exported() {
    let inp = &[
        r#"module spam { def main [] { "spam" } }"#,
        r#"use spam"#,
        r#"spam"#,
    ];

    let actual = nu!(cwd: ".", pipeline(&inp.join("; ")));

    assert!(actual.err.contains("external_command"));
}