Public/nushell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unwraps and clean up playground

Browse Source 
The original intent of this patch was to remove more unwraps to reduce
panics. I then lost a ton of time to the fact that the playground isn't
in a temp directory (because of permissions issues on Windows).

This commit improves the test facilities to:

- use a tempdir for the playground
- change the playground API so you instantiate it with a block that
  encloses the lifetime of the tempdir
- the block is called with a `dirs` argument that has `dirs.test()` and
  other important directories that we were computing by hand all the time
- the block is also called with a `playground` argument that you can use
  to construct files (it's the same `Playground` as before)
- change the nu! and nu_error! macros to produce output instead of
  taking a variable binding
- change the nu! and nu_error! macros to do the cwd() transformation
  internally
- change the nu! and nu_error! macros to take varargs at the end that
  get interpolated into the running command

I didn't manage to finish porting all of the tests, so a bunch of tests
are currently commented out. That will need to change before we land
this patch.
This commit is contained in:
Yehuda Katz 2019-08-28 10:01:16 -07:00
parent 8e95508353
commit 21ad06b1e1
21 changed files with 823 additions and 732 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/cli.rs
View File

@ -272,11 +272,7 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
if ctrlcbreak { if ctrlcbreak {
std::process::exit(0); std::process::exit(0);
} else { } else {
context context.with_host(|host| host.stdout("CTRL-C pressed (again to quit)"));
.host
.lock()
.unwrap()
.stdout("CTRL-C pressed (again to quit)");
ctrlcbreak = true; ctrlcbreak = true;
continue; continue;
} }
@ -285,18 +281,19 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
LineResult::Error(mut line, err) => { LineResult::Error(mut line, err) => {
rl.add_history_entry(line.clone()); rl.add_history_entry(line.clone());
let diag = err.to_diagnostic(); let diag = err.to_diagnostic();
let host = context.host.lock().unwrap(); context.with_host(|host| {
let writer = host.err_termcolor(); let writer = host.err_termcolor();
line.push_str(" "); line.push_str(" ");
let files = crate::parser::Files::new(line); let files = crate::parser::Files::new(line);
let _ = std::panic::catch_unwind(move || { let _ = std::panic::catch_unwind(move || {
let _ = language_reporting::emit( let _ = language_reporting::emit(
&mut writer.lock(), &mut writer.lock(),
&files, &files,
&diag, &diag,
&language_reporting::DefaultConfig, &language_reporting::DefaultConfig,
); );
}); });
})
} }
LineResult::Break => { LineResult::Break => {
@ -304,11 +301,9 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
} }
LineResult::FatalError(_, err) => { LineResult::FatalError(_, err) => {
context context.with_host(|host| {
.host host.stdout(&format!("A surprising fatal error occurred.\n{:?}", err))
.lock() });
.unwrap()
.stdout(&format!("A surprising fatal error occurred.\n{:?}", err));
} }
} }
ctrlcbreak = false; ctrlcbreak = false;

30
src/commands/classified.rs
View File

@ -315,19 +315,23 @@ impl ExternalCommand {
if arg_string.contains("$it") { if arg_string.contains("$it") {
let mut first = true; let mut first = true;
for i in &inputs { for i in &inputs {
if i.as_string().is_err() { let i = match i.as_string() {
let mut span = name_span; Err(err) => {
for arg in &self.args { let mut span = name_span;
if arg.item.contains("$it") { for arg in &self.args {
span = arg.span(); if arg.item.contains("$it") {
span = arg.span();
}
} }
return Err(ShellError::labeled_error(
"External $it needs string data",
"given object instead of string data",
span,
));
} }
return Err(ShellError::labeled_error( Ok(val) => val,
"External $it needs string data", };
"given object instead of string data",
span,
));
}
if !first { if !first {
new_arg_string.push_str("&&"); new_arg_string.push_str("&&");
new_arg_string.push_str(&self.name); new_arg_string.push_str(&self.name);
@ -341,7 +345,7 @@ impl ExternalCommand {
} }
new_arg_string.push_str(" "); new_arg_string.push_str(" ");
new_arg_string.push_str(&arg.replace("$it", &i.as_string().unwrap())); new_arg_string.push_str(&arg.replace("$it", &i));
} }
} }
} else { } else {
@ -366,7 +370,7 @@ impl ExternalCommand {
process = process.stdin(stdin); process = process.stdin(stdin);
} }
let mut popen = process.popen().unwrap(); let mut popen = process.popen()?;
match stream_next { match stream_next {
StreamNext::Last => { StreamNext::Last => {

12
src/context.rs
View File

@ -74,7 +74,7 @@ impl CommandRegistry {
pub struct Context { pub struct Context {
registry: CommandRegistry, registry: CommandRegistry,
crate source_map: SourceMap, crate source_map: SourceMap,
crate host: Arc<Mutex<dyn Host + Send>>, host: Arc<Mutex<dyn Host + Send>>,
crate shell_manager: ShellManager, crate shell_manager: ShellManager,
} }
@ -93,6 +93,12 @@ impl Context {
}) })
} }
crate fn with_host(&mut self, block: impl FnOnce(&mut dyn Host)) {
let mut host = self.host.lock().unwrap();
block(&mut *host)
}
pub fn add_commands(&mut self, commands: Vec<Arc<Command>>) { pub fn add_commands(&mut self, commands: Vec<Arc<Command>>) {
for command in commands { for command in commands {
self.registry.insert(command.name().to_string(), command); self.registry.insert(command.name().to_string(), command);
@ -103,10 +109,6 @@ impl Context {
self.source_map.insert(uuid, span_source); self.source_map.insert(uuid, span_source);
} }
// pub fn clone_commands(&self) -> CommandRegistry {
// self.registry.clone()
// }
crate fn has_command(&self, name: &str) -> bool { crate fn has_command(&self, name: &str) -> bool {
self.registry.has(name) self.registry.has(name)
} }

2
src/lib.rs
View File

@ -31,7 +31,7 @@ pub use crate::env::host::BasicHost;
pub use crate::object::base::OF64; pub use crate::object::base::OF64;
pub use crate::parser::hir::SyntaxType; pub use crate::parser::hir::SyntaxType;
pub use crate::plugin::{serve_plugin, Plugin}; pub use crate::plugin::{serve_plugin, Plugin};
pub use crate::utils::{AbsolutePath, RelativePath}; pub use crate::utils::{AbsoluteFile, AbsolutePath, RelativePath};
pub use cli::cli; pub use cli::cli;
pub use errors::ShellError; pub use errors::ShellError;
pub use object::base::{Primitive, Value}; pub use object::base::{Primitive, Value};

4
src/prelude.rs
View File

@ -16,10 +16,6 @@ macro_rules! trace_stream {
(target: $target:tt, $desc:tt = $expr:expr) => {{ (target: $target:tt, $desc:tt = $expr:expr) => {{
if log::log_enabled!(target: $target, log::Level::Trace) { if log::log_enabled!(target: $target, log::Level::Trace) {
use futures::stream::StreamExt; use futures::stream::StreamExt;
// Blocking is generally quite bad, but this is for debugging
// let mut local = futures::executor::LocalPool::new();
// let objects = local.run_until($expr.into_vec());
// let objects: Vec<_> = futures::executor::block_on($expr.into_vec());
let objects = $expr.values.inspect(|o| { let objects = $expr.values.inspect(|o| {
trace!(target: $target, "{} = {:#?}", $desc, o.debug()); trace!(target: $target, "{} = {:#?}", $desc, o.debug());

57
src/utils.rs
View File

@ -1,7 +1,52 @@
use crate::errors::ShellError; use crate::errors::ShellError;
use std::fmt;
use std::ops::Div; use std::ops::Div;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
pub struct AbsoluteFile {
inner: PathBuf,
}
impl AbsoluteFile {
pub fn new(path: impl AsRef<Path>) -> AbsoluteFile {
let path = path.as_ref();
if !path.is_absolute() {
panic!(
"AbsoluteFile::new must take an absolute path :: {}",
path.display()
)
} else if path.is_dir() {
// At the moment, this is not an invariant, but rather a way to catch bugs
// in tests.
panic!(
"AbsoluteFile::new must not take a directory :: {}",
path.display()
)
} else {
AbsoluteFile {
inner: path.to_path_buf(),
}
}
}
pub fn dir(&self) -> AbsolutePath {
AbsolutePath::new(self.inner.parent().unwrap())
}
}
impl From<AbsoluteFile> for PathBuf {
fn from(file: AbsoluteFile) -> Self {
file.inner
}
}
impl fmt::Display for AbsoluteFile {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.inner.display())
}
}
pub struct AbsolutePath { pub struct AbsolutePath {
inner: PathBuf, inner: PathBuf,
} }
@ -20,6 +65,12 @@ impl AbsolutePath {
} }
} }
impl fmt::Display for AbsolutePath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.inner.display())
}
}
impl Div<&str> for &AbsolutePath { impl Div<&str> for &AbsolutePath {
type Output = AbsolutePath; type Output = AbsolutePath;
@ -72,6 +123,12 @@ impl<T: AsRef<str>> Div<T> for &RelativePath {
} }
} }
impl fmt::Display for RelativePath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.inner.display())
}
}
#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)] #[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Res { pub struct Res {
pub loc: PathBuf, pub loc: PathBuf,

2
tests/command_cd_tests.rs
View File

@ -4,7 +4,7 @@ use helpers::in_directory as cwd;
#[test] #[test]
fn cd_directory_not_found() { fn cd_directory_not_found() {
nu_error!(output, cwd("tests/fixtures"), "cd dir_that_does_not_exist"); let output = nu_error!(cwd("tests/fixtures"), "cd dir_that_does_not_exist");
assert!(output.contains("dir_that_does_not_exist")); assert!(output.contains("dir_that_does_not_exist"));
assert!(output.contains("directory not found")); assert!(output.contains("directory not found"));

242
tests/command_cp_tests.rs
View File

@ -1,87 +1,79 @@
mod helpers; mod helpers;
use h::{in_directory as cwd, Playground, Stub::*}; use helpers::{dir_exists_at, file_exists_at, files_exist_at, Playground, Stub::*};
use helpers as h;
use nu::AbsoluteFile;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
#[test] #[test]
fn copies_a_file() { fn copies_a_file() {
let sandbox = Playground::setup_for("cp_test_1").test_dir_name(); Playground::setup("cp_test_1", |dirs, _| {
nu!(
dirs.root(),
"cp {} cp_test_1/sample.ini",
dirs.formats().join("sample.ini")
);
let full_path = format!("{}/{}", Playground::root(), sandbox); assert!(file_exists_at(dirs.test().join("sample.ini")));
let expected_file = format!("{}/{}", full_path, "sample.ini"); });
nu!(
_output,
cwd(&Playground::root()),
"cp ../formats/sample.ini cp_test_1/sample.ini"
);
assert!(h::file_exists_at(PathBuf::from(expected_file)));
} }
#[test] #[test]
fn copies_the_file_inside_directory_if_path_to_copy_is_directory() { fn copies_the_file_inside_directory_if_path_to_copy_is_directory() {
let sandbox = Playground::setup_for("cp_test_2").test_dir_name(); Playground::setup("cp_test_2", |dirs, _| {
let expected_file = AbsoluteFile::new(dirs.test().join("sample.ini"));
let full_path = format!("{}/{}", Playground::root(), sandbox); nu!(
let expected_file = format!("{}/{}", full_path, "sample.ini"); dirs.formats(),
"cp ../formats/sample.ini {}",
expected_file.dir()
);
nu!( assert!(file_exists_at(dirs.test().join("sample.ini")));
_output, })
cwd(&Playground::root()),
"cp ../formats/sample.ini cp_test_2"
);
assert!(h::file_exists_at(PathBuf::from(expected_file)));
} }
#[test] #[test]
fn error_if_attempting_to_copy_a_directory_to_another_directory() { fn error_if_attempting_to_copy_a_directory_to_another_directory() {
Playground::setup_for("cp_test_3"); Playground::setup("cp_test_3", |dirs, _| {
let output = nu_error!(dirs.formats(), "cp ../formats {}", dirs.test());
nu_error!(output, cwd(&Playground::root()), "cp ../formats cp_test_3"); assert!(output.contains("../formats"));
assert!(output.contains("is a directory (not copied)"));
assert!(output.contains("../formats")); });
assert!(output.contains("is a directory (not copied)"));
} }
#[test] #[test]
fn copies_the_directory_inside_directory_if_path_to_copy_is_directory_and_with_recursive_flag() { fn copies_the_directory_inside_directory_if_path_to_copy_is_directory_and_with_recursive_flag() {
let sandbox = Playground::setup_for("cp_test_4") Playground::setup("cp_test_4", |dirs, playground| {
.within("originals") playground
.with_files(vec![ .within("originals")
EmptyFile("yehuda.txt"), .with_files(vec![
EmptyFile("jonathan.txt"), EmptyFile("yehuda.txt"),
EmptyFile("andres.txt"), EmptyFile("jonathan.txt"),
]) EmptyFile("andres.txt"),
.mkdir("expected") ])
.test_dir_name(); .mkdir("expected");
let full_path = format!("{}/{}", Playground::root(), sandbox); let expected_dir = dirs.test().join("expected").join("originals");
let expected_dir = format!("{}/{}", full_path, "expected/originals");
nu!( nu!(dirs.test(), "cp originals expected --recursive");
_output,
cwd(&full_path),
"cp originals expected --recursive"
);
assert!(h::dir_exists_at(PathBuf::from(&expected_dir))); assert!(dir_exists_at(PathBuf::from(&expected_dir)));
assert!(h::files_exist_at( assert!(files_exist_at(
vec![ vec![
Path::new("yehuda.txt"), Path::new("yehuda.txt"),
Path::new("jonathan.txt"), Path::new("jonathan.txt"),
Path::new("andres.txt") Path::new("andres.txt")
], ],
PathBuf::from(&expected_dir) PathBuf::from(&expected_dir)
)); ));
})
} }
#[test] #[test]
fn deep_copies_with_recursive_flag() { fn deep_copies_with_recursive_flag() {
r#" r#"
Given these files and directories Given these files and directories
originals originals
originals/manifest.txt originals/manifest.txt
@ -99,96 +91,82 @@ fn deep_copies_with_recursive_flag() {
originals/contributors/yehuda/defer-evaluation.txt originals/contributors/yehuda/defer-evaluation.txt
"#; "#;
let sandbox = Playground::setup_for("cp_test_5") Playground::setup("cp_test_5", |dirs, playground| {
.within("originals") playground
.with_files(vec![EmptyFile("manifest.txt")]) .within("originals")
.within("originals/contributors") .with_files(vec![EmptyFile("manifest.txt")])
.with_files(vec![ .within("originals/contributors")
EmptyFile("yehuda.txt"), .with_files(vec![
EmptyFile("jonathan.txt"), EmptyFile("yehuda.txt"),
EmptyFile("andres.txt"), EmptyFile("jonathan.txt"),
]) EmptyFile("andres.txt"),
.within("originals/contributors/jonathan") ])
.with_files(vec![EmptyFile("errors.txt"), EmptyFile("multishells.txt")]) .within("originals/contributors/jonathan")
.within("originals/contributors/andres") .with_files(vec![EmptyFile("errors.txt"), EmptyFile("multishells.txt")])
.with_files(vec![EmptyFile("coverage.txt"), EmptyFile("commands.txt")]) .within("originals/contributors/andres")
.within("originals/contributors/yehuda") .with_files(vec![EmptyFile("coverage.txt"), EmptyFile("commands.txt")])
.with_files(vec![EmptyFile("defer-evaluation.txt")]) .within("originals/contributors/yehuda")
.mkdir("expected") .with_files(vec![EmptyFile("defer-evaluation.txt")])
.test_dir_name(); .mkdir("expected");
let full_path = format!("{}/{}", Playground::root(), sandbox); let expected_dir = dirs.test().join("expected").join("originals");
let expected_dir = format!("{}/{}", full_path, "expected/originals");
let jonathans_expected_copied_dir = format!("{}/contributors/jonathan", expected_dir); let jonathans_expected_copied_dir = expected_dir.join("contributors").join("jonathan");
let andres_expected_copied_dir = format!("{}/contributors/andres", expected_dir); let andres_expected_copied_dir = expected_dir.join("contributors").join("andres");
let yehudas_expected_copied_dir = format!("{}/contributors/yehuda", expected_dir); let yehudas_expected_copied_dir = expected_dir.join("contributors").join("yehuda");
nu!( nu!(dirs.test(), "cp originals expected --recursive");
_output,
cwd(&full_path),
"cp originals expected --recursive"
);
assert!(h::dir_exists_at(PathBuf::from(&expected_dir))); assert!(dir_exists_at(PathBuf::from(&expected_dir)));
assert!(h::files_exist_at( assert!(files_exist_at(
vec![Path::new("errors.txt"), Path::new("multishells.txt")], vec![Path::new("errors.txt"), Path::new("multishells.txt")],
PathBuf::from(&jonathans_expected_copied_dir) PathBuf::from(&jonathans_expected_copied_dir)
)); ));
assert!(h::files_exist_at( assert!(files_exist_at(
vec![Path::new("coverage.txt"), Path::new("commands.txt")], vec![Path::new("coverage.txt"), Path::new("commands.txt")],
PathBuf::from(&andres_expected_copied_dir) PathBuf::from(&andres_expected_copied_dir)
)); ));
assert!(h::files_exist_at( assert!(files_exist_at(
vec![Path::new("defer-evaluation.txt")], vec![Path::new("defer-evaluation.txt")],
PathBuf::from(&yehudas_expected_copied_dir) PathBuf::from(&yehudas_expected_copied_dir)
)); ));
})
} }
#[test] #[test]
fn copies_using_path_with_wildcard() { fn copies_using_path_with_wildcard() {
let sandbox = Playground::setup_for("cp_test_6").test_dir_name(); Playground::setup("cp_test_6", |dirs, _| {
let expected_copies_path = format!("{}/{}", Playground::root(), sandbox); nu!(dirs.formats(), "cp ../formats/* {}", dirs.test());
nu!( assert!(files_exist_at(
_output, vec![
cwd(&Playground::root()), Path::new("caco3_plastics.csv"),
"cp ../formats/* cp_test_6" Path::new("cargo_sample.toml"),
); Path::new("jonathan.xml"),
Path::new("sample.ini"),
assert!(h::files_exist_at( Path::new("sgml_description.json"),
vec![ Path::new("utf16.ini"),
Path::new("caco3_plastics.csv"), ],
Path::new("cargo_sample.toml"), dirs.test()
Path::new("jonathan.xml"), ));
Path::new("sample.ini"), })
Path::new("sgml_description.json"),
Path::new("utf16.ini"),
],
PathBuf::from(&expected_copies_path)
));
} }
#[test] #[test]
fn copies_using_a_glob() { fn copies_using_a_glob() {
let sandbox = Playground::setup_for("cp_test_7").test_dir_name(); Playground::setup("cp_test_7", |dirs, _| {
let expected_copies_path = format!("{}/{}", Playground::root(), sandbox); nu!(dirs.formats(), "cp * {}", dirs.test());
nu!( assert!(files_exist_at(
_output, vec![
cwd("tests/fixtures/formats"), Path::new("caco3_plastics.csv"),
"cp * ../nuplayground/cp_test_7" Path::new("cargo_sample.toml"),
); Path::new("jonathan.xml"),
Path::new("sample.ini"),
assert!(h::files_exist_at( Path::new("sgml_description.json"),
vec![ Path::new("utf16.ini"),
Path::new("caco3_plastics.csv"), ],
Path::new("cargo_sample.toml"), dirs.test()
Path::new("jonathan.xml"), ));
Path::new("sample.ini"), });
Path::new("sgml_description.json"),
Path::new("utf16.ini"),
],
PathBuf::from(&expected_copies_path)
));
} }

89
tests/command_enter_test.rs
View File

@ -1,38 +1,36 @@
mod helpers; mod helpers;
use h::{in_directory as cwd, Playground, Stub::*}; use h::{Playground, Stub::*};
use helpers as h; use helpers as h;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
#[test] #[test]
fn knows_the_filesystems_entered() { fn knows_the_filesystems_entered() {
let sandbox = Playground::setup_for("enter_filesystem_sessions_test") Playground::setup("enter_filesystem_sessions_test", |dirs, playground| {
.within("red_pill") playground
.with_files(vec![ .within("red_pill")
EmptyFile("andres.nu"), .with_files(vec![
EmptyFile("jonathan.nu"), EmptyFile("andres.nu"),
EmptyFile("yehuda.nu"), EmptyFile("jonathan.nu"),
]) EmptyFile("yehuda.nu"),
.within("blue_pill") ])
.with_files(vec![ .within("blue_pill")
EmptyFile("bash.nxt"), .with_files(vec![
EmptyFile("korn.nxt"), EmptyFile("bash.nxt"),
EmptyFile("powedsh.nxt"), EmptyFile("korn.nxt"),
]) EmptyFile("powedsh.nxt"),
.mkdir("expected") ])
.test_dir_name(); .mkdir("expected")
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let red_pill_dir = dirs.test().join("red_pill");
let blue_pill_dir = dirs.test().join("blue_pill");
let expected = dirs.test().join("expected");
let expected_recycled = expected.join("recycled");
let red_pill_dir = format!("{}/{}", full_path, "red_pill"); nu!(
let blue_pill_dir = format!("{}/{}", full_path, "blue_pill"); dirs.test(),
let expected = format!("{}/{}", full_path, "expected"); r#"
let expected_recycled = format!("{}/{}", expected, "recycled");
nu!(
_output,
cwd(&full_path),
r#"
enter expected enter expected
mkdir recycled mkdir recycled
enter ../red_pill enter ../red_pill
@ -52,25 +50,26 @@ fn knows_the_filesystems_entered() {
rm blue_pill --recursive rm blue_pill --recursive
exit exit
"# "#
); );
assert!(!h::dir_exists_at(PathBuf::from(red_pill_dir))); assert!(!h::dir_exists_at(PathBuf::from(red_pill_dir)));
assert!(h::files_exist_at( assert!(h::files_exist_at(
vec![ vec![
Path::new("andres.nu"), Path::new("andres.nu"),
Path::new("jonathan.nu"), Path::new("jonathan.nu"),
Path::new("yehuda.nu"), Path::new("yehuda.nu"),
], ],
PathBuf::from(&expected) PathBuf::from(&expected)
)); ));
assert!(!h::dir_exists_at(PathBuf::from(blue_pill_dir))); assert!(!h::dir_exists_at(PathBuf::from(blue_pill_dir)));
assert!(h::files_exist_at( assert!(h::files_exist_at(
vec![ vec![
Path::new("bash.nxt"), Path::new("bash.nxt"),
Path::new("korn.nxt"), Path::new("korn.nxt"),
Path::new("powedsh.nxt"), Path::new("powedsh.nxt"),
], ],
PathBuf::from(&expected_recycled) PathBuf::from(&expected_recycled)
)); ));
})
} }

87
tests/command_ls_tests.rs
View File

@ -5,65 +5,62 @@ use helpers as h;
#[test] #[test]
fn ls_lists_regular_files() { fn ls_lists_regular_files() {
let sandbox = Playground::setup_for("ls_lists_files_test") Playground::setup("ls_lists_files_test", |dirs, playground| {
.with_files(vec![ playground
EmptyFile("yehuda.10.txt"), .with_files(vec![
EmptyFile("jonathan.10.txt"), EmptyFile("yehuda.10.txt"),
EmptyFile("andres.10.txt"), EmptyFile("jonathan.10.txt"),
]) EmptyFile("andres.10.txt"),
.test_dir_name(); ])
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let output = nu!(
dirs.test(),
r#"ls | get name | lines | split-column "." | get Column2 | str --to-int | sum | echo $it"#
);
nu!( assert_eq!(output, "30");
output, })
cwd(&full_path),
r#"ls | get name | lines | split-column "." | get Column2 | str --to-int | sum | echo $it"#
);
assert_eq!(output, "30");
} }
#[test] #[test]
fn ls_lists_regular_files_using_asterisk_wildcard() { fn ls_lists_regular_files_using_asterisk_wildcard() {
let sandbox = Playground::setup_for("ls_asterisk_wildcard_test") Playground::setup("ls_asterisk_wildcard_test", |dirs, playground| {
.with_files(vec![ playground
EmptyFile("los.1.txt"), .with_files(vec![
EmptyFile("tres.1.txt"), EmptyFile("los.1.txt"),
EmptyFile("amigos.1.txt"), EmptyFile("tres.1.txt"),
EmptyFile("arepas.1.clu"), EmptyFile("amigos.1.txt"),
]) EmptyFile("arepas.1.clu"),
.test_dir_name(); ])
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let output = nu!(
dirs.test(),
r#"ls *.txt | get name | lines| split-column "." | get Column2 | str --to-int | sum | echo $it"#
);
nu!( assert_eq!(output, "3");
output, })
cwd(&full_path),
r#"ls *.txt | get name | lines| split-column "." | get Column2 | str --to-int | sum | echo $it"#
);
assert_eq!(output, "3");
} }
#[test] #[test]
fn ls_lists_regular_files_using_question_mark_wildcard() { fn ls_lists_regular_files_using_question_mark_wildcard() {
let sandbox = Playground::setup_for("ls_question_mark_wildcard_test") Playground::setup("ls_question_mark_wildcard_test", |dirs, playground| {
.with_files(vec![ playground
EmptyFile("yehuda.10.txt"), .with_files(vec![
EmptyFile("jonathan.10.txt"), EmptyFile("yehuda.10.txt"),
EmptyFile("andres.10.txt"), EmptyFile("jonathan.10.txt"),
EmptyFile("chicken_not_to_be_picked_up.100.txt"), EmptyFile("andres.10.txt"),
]) EmptyFile("chicken_not_to_be_picked_up.100.txt"),
.test_dir_name(); ])
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let output = nu!(
dirs.test(),
nu!(
output,
cwd(&full_path),
r#"ls *.??.txt | get name | lines| split-column "." | get Column2 | str --to-int | sum | echo $it"# r#"ls *.??.txt | get name | lines| split-column "." | get Column2 | str --to-int | sum | echo $it"#
); );
assert_eq!(output, "30"); assert_eq!(output, "30");
})
} }

49
tests/command_mkdir_tests.rs
View File

@ -1,51 +1,40 @@
mod helpers; mod helpers;
use h::{in_directory as cwd, Playground}; use h::Playground;
use helpers as h; use helpers as h;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
#[test] #[test]
fn creates_directory() { fn creates_directory() {
let sandbox = Playground::setup_for("mkdir_test_1").test_dir_name(); Playground::setup("mkdir_test_1", |dirs, _| {
nu!(dirs.test(), "mkdir my_new_directory");
let full_path = format!("{}/{}", Playground::root(), sandbox); let expected = dirs.test().join("my_new_directory");
nu!(_output, cwd(&full_path), "mkdir my_new_directory"); assert!(h::dir_exists_at(expected));
})
let mut expected = PathBuf::from(full_path);
expected.push("my_new_directory");
assert!(h::dir_exists_at(expected));
} }
#[test] #[test]
fn accepts_and_creates_directories() { fn accepts_and_creates_directories() {
let sandbox = Playground::setup_for("mkdir_test_2").test_dir_name(); Playground::setup("mkdir_test_2", |dirs, _| {
nu!(dirs.test(), "mkdir dir_1 dir_2 dir_3");
let full_path = format!("{}/{}", Playground::root(), sandbox); assert!(h::files_exist_at(
vec![Path::new("dir_1"), Path::new("dir_2"), Path::new("dir_3")],
nu!(_output, cwd(&full_path), "mkdir dir_1 dir_2 dir_3"); dirs.test()
));
assert!(h::files_exist_at( })
vec![Path::new("dir_1"), Path::new("dir_2"), Path::new("dir_3")],
PathBuf::from(&full_path)
));
} }
#[test] #[test]
fn creates_intermediary_directories() { fn creates_intermediary_directories() {
let sandbox = Playground::setup_for("mkdir_test_3").test_dir_name(); Playground::setup("mkdir_test_3", |dirs, _| {
nu!(dirs.test(), "mkdir some_folder/another/deeper_one");
let full_path = format!("{}/{}", Playground::root(), sandbox); let mut expected = PathBuf::from(dirs.test());
expected.push("some_folder/another/deeper_one");
nu!( assert!(h::dir_exists_at(expected));
_output, })
cwd(&full_path),
"mkdir some_folder/another/deeper_one"
);
let mut expected = PathBuf::from(full_path);
expected.push("some_folder/another/deeper_one");
assert!(h::dir_exists_at(expected));
} }

282
tests/command_mv_tests.rs
View File

@ -7,181 +7,179 @@ use std::path::{Path, PathBuf};
#[test] #[test]
fn moves_a_file() { fn moves_a_file() {
let sandbox = Playground::setup_for("mv_test_1") Playground::setup("mv_test_1", |dirs, playground| {
.with_files(vec![EmptyFile("andres.txt")]) playground
.mkdir("expected") .with_files(vec![EmptyFile("andres.txt")])
.test_dir_name(); .mkdir("expected")
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let original = dirs.test().join("andres.txt");
let original = format!("{}/{}", full_path, "andres.txt"); let expected = dirs.test().join("expected/yehuda.txt");
let expected = format!("{}/{}", full_path, "expected/yehuda.txt");
nu!( nu!(dirs.test(), "mv andres.txt expected/yehuda.txt");
_output,
cwd(&full_path),
"mv andres.txt expected/yehuda.txt"
);
assert!(!h::file_exists_at(PathBuf::from(original))); assert!(!h::file_exists_at(original));
assert!(h::file_exists_at(PathBuf::from(expected))); assert!(h::file_exists_at(expected));
})
} }
#[test] #[test]
fn overwrites_if_moving_to_existing_file() { fn overwrites_if_moving_to_existing_file() {
let sandbox = Playground::setup_for("mv_test_2") Playground::setup("mv_test_2", |dirs, playground| {
.with_files(vec![EmptyFile("andres.txt"), EmptyFile("jonathan.txt")]) playground
.test_dir_name(); .with_files(vec![EmptyFile("andres.txt"), EmptyFile("jonathan.txt")])
.test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); let original = dirs.test().join("andres.txt");
let original = format!("{}/{}", full_path, "andres.txt"); let expected = dirs.test().join("jonathan.txt");
let expected = format!("{}/{}", full_path, "jonathan.txt");
nu!(_output, cwd(&full_path), "mv andres.txt jonathan.txt"); nu!(dirs.test(), "mv andres.txt jonathan.txt");
assert!(!h::file_exists_at(PathBuf::from(original))); assert!(!h::file_exists_at(original));
assert!(h::file_exists_at(PathBuf::from(expected))); assert!(h::file_exists_at(expected));
})
} }
#[test] // #[test]
fn moves_a_directory() { // fn moves_a_directory() {
let sandbox = Playground::setup_for("mv_test_3") // let sandbox = Playground::setup_for("mv_test_3")
.mkdir("empty_dir") // .mkdir("empty_dir")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let original_dir = format!("{}/{}", full_path, "empty_dir"); // let original_dir = format!("{}/{}", full_path, "empty_dir");
let expected = format!("{}/{}", full_path, "renamed_dir"); // let expected = format!("{}/{}", full_path, "renamed_dir");
nu!(_output, cwd(&full_path), "mv empty_dir renamed_dir"); // nu!(_output, cwd(&full_path), "mv empty_dir renamed_dir");
assert!(!h::dir_exists_at(PathBuf::from(original_dir))); // assert!(!h::dir_exists_at(PathBuf::from(original_dir)));
assert!(h::dir_exists_at(PathBuf::from(expected))); // assert!(h::dir_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn moves_the_file_inside_directory_if_path_to_move_is_existing_directory() { // fn moves_the_file_inside_directory_if_path_to_move_is_existing_directory() {
let sandbox = Playground::setup_for("mv_test_4") // let sandbox = Playground::setup_for("mv_test_4")
.with_files(vec![EmptyFile("jonathan.txt")]) // .with_files(vec![EmptyFile("jonathan.txt")])
.mkdir("expected") // .mkdir("expected")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let original_dir = format!("{}/{}", full_path, "jonathan.txt"); // let original_dir = format!("{}/{}", full_path, "jonathan.txt");
let expected = format!("{}/{}", full_path, "expected/jonathan.txt"); // let expected = format!("{}/{}", full_path, "expected/jonathan.txt");
nu!(_output, cwd(&full_path), "mv jonathan.txt expected"); // nu!(_output, cwd(&full_path), "mv jonathan.txt expected");
assert!(!h::file_exists_at(PathBuf::from(original_dir))); // assert!(!h::file_exists_at(PathBuf::from(original_dir)));
assert!(h::file_exists_at(PathBuf::from(expected))); // assert!(h::file_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn moves_the_directory_inside_directory_if_path_to_move_is_existing_directory() { // fn moves_the_directory_inside_directory_if_path_to_move_is_existing_directory() {
let sandbox = Playground::setup_for("mv_test_5") // let sandbox = Playground::setup_for("mv_test_5")
.within("contributors") // .within("contributors")
.with_files(vec![EmptyFile("jonathan.txt")]) // .with_files(vec![EmptyFile("jonathan.txt")])
.mkdir("expected") // .mkdir("expected")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let original_dir = format!("{}/{}", full_path, "contributors"); // let original_dir = format!("{}/{}", full_path, "contributors");
let expected = format!("{}/{}", full_path, "expected/contributors"); // let expected = format!("{}/{}", full_path, "expected/contributors");
nu!(_output, cwd(&full_path), "mv contributors expected"); // nu!(_output, cwd(&full_path), "mv contributors expected");
assert!(!h::dir_exists_at(PathBuf::from(original_dir))); // assert!(!h::dir_exists_at(PathBuf::from(original_dir)));
assert!(h::file_exists_at(PathBuf::from(expected))); // assert!(h::file_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn moves_the_directory_inside_directory_if_path_to_move_is_nonexistent_directory() { // fn moves_the_directory_inside_directory_if_path_to_move_is_nonexistent_directory() {
let sandbox = Playground::setup_for("mv_test_6") // let sandbox = Playground::setup_for("mv_test_6")
.within("contributors") // .within("contributors")
.with_files(vec![EmptyFile("jonathan.txt")]) // .with_files(vec![EmptyFile("jonathan.txt")])
.mkdir("expected") // .mkdir("expected")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let original_dir = format!("{}/{}", full_path, "contributors"); // let original_dir = format!("{}/{}", full_path, "contributors");
nu!( // nu!(
_output, // _output,
cwd(&full_path), // cwd(&full_path),
"mv contributors expected/this_dir_exists_now/los_tres_amigos" // "mv contributors expected/this_dir_exists_now/los_tres_amigos"
); // );
let expected = format!( // let expected = format!(
"{}/{}", // "{}/{}",
full_path, "expected/this_dir_exists_now/los_tres_amigos" // full_path, "expected/this_dir_exists_now/los_tres_amigos"
); // );
assert!(!h::dir_exists_at(PathBuf::from(original_dir))); // assert!(!h::dir_exists_at(PathBuf::from(original_dir)));
assert!(h::file_exists_at(PathBuf::from(expected))); // assert!(h::file_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn moves_using_path_with_wildcard() { // fn moves_using_path_with_wildcard() {
let sandbox = Playground::setup_for("mv_test_7") // let sandbox = Playground::setup_for("mv_test_7")
.within("originals") // .within("originals")
.with_files(vec![ // .with_files(vec![
EmptyFile("andres.ini"), // EmptyFile("andres.ini"),
EmptyFile("caco3_plastics.csv"), // EmptyFile("caco3_plastics.csv"),
EmptyFile("cargo_sample.toml"), // EmptyFile("cargo_sample.toml"),
EmptyFile("jonathan.ini"), // EmptyFile("jonathan.ini"),
EmptyFile("jonathan.xml"), // EmptyFile("jonathan.xml"),
EmptyFile("sgml_description.json"), // EmptyFile("sgml_description.json"),
EmptyFile("sample.ini"), // EmptyFile("sample.ini"),
EmptyFile("utf16.ini"), // EmptyFile("utf16.ini"),
EmptyFile("yehuda.ini"), // EmptyFile("yehuda.ini"),
]) // ])
.mkdir("work_dir") // .mkdir("work_dir")
.mkdir("expected") // .mkdir("expected")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let work_dir = format!("{}/{}", full_path, "work_dir"); // let work_dir = format!("{}/{}", full_path, "work_dir");
let expected_copies_path = format!("{}/{}", full_path, "expected"); // let expected_copies_path = format!("{}/{}", full_path, "expected");
nu!(_output, cwd(&work_dir), "mv ../originals/*.ini ../expected"); // nu!(_output, cwd(&work_dir), "mv ../originals/*.ini ../expected");
assert!(h::files_exist_at( // assert!(h::files_exist_at(
vec![ // vec![
Path::new("yehuda.ini"), // Path::new("yehuda.ini"),
Path::new("jonathan.ini"), // Path::new("jonathan.ini"),
Path::new("sample.ini"), // Path::new("sample.ini"),
Path::new("andres.ini"), // Path::new("andres.ini"),
], // ],
PathBuf::from(&expected_copies_path) // PathBuf::from(&expected_copies_path)
)); // ));
} // }
#[test] // #[test]
fn moves_using_a_glob() { // fn moves_using_a_glob() {
let sandbox = Playground::setup_for("mv_test_8") // let sandbox = Playground::setup_for("mv_test_8")
.within("meals") // .within("meals")
.with_files(vec![ // .with_files(vec![
EmptyFile("arepa.txt"), // EmptyFile("arepa.txt"),
EmptyFile("empanada.txt"), // EmptyFile("empanada.txt"),
EmptyFile("taquiza.txt"), // EmptyFile("taquiza.txt"),
]) // ])
.mkdir("work_dir") // .mkdir("work_dir")
.mkdir("expected") // .mkdir("expected")
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let meal_dir = format!("{}/{}", full_path, "meals"); // let meal_dir = format!("{}/{}", full_path, "meals");
let work_dir = format!("{}/{}", full_path, "work_dir"); // let work_dir = format!("{}/{}", full_path, "work_dir");
let expected_copies_path = format!("{}/{}", full_path, "expected"); // let expected_copies_path = format!("{}/{}", full_path, "expected");
nu!(_output, cwd(&work_dir), "mv ../meals/* ../expected"); // nu!(_output, cwd(&work_dir), "mv ../meals/* ../expected");
assert!(h::dir_exists_at(PathBuf::from(meal_dir))); // assert!(h::dir_exists_at(PathBuf::from(meal_dir)));
assert!(h::files_exist_at( // assert!(h::files_exist_at(
vec![ // vec![
Path::new("arepa.txt"), // Path::new("arepa.txt"),
Path::new("empanada.txt"), // Path::new("empanada.txt"),
Path::new("taquiza.txt"), // Path::new("taquiza.txt"),
], // ],
PathBuf::from(&expected_copies_path) // PathBuf::from(&expected_copies_path)
)); // ));
} // }

26
tests/command_open_tests.rs
View File

@ -14,8 +14,7 @@ fn recognizes_csv() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/open_recognizes_csv_test"), cwd("tests/fixtures/nuplayground/open_recognizes_csv_test"),
r#"open nu.zion.csv | where author == "Andres N. Robalino" | get source | echo $it"# r#"open nu.zion.csv | where author == "Andres N. Robalino" | get source | echo $it"#
); );
@ -25,8 +24,7 @@ fn recognizes_csv() {
#[test] #[test]
fn open_can_parse_bson_1() { fn open_can_parse_bson_1() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sample.bson | get root | nth 0 | get b | echo $it" "open sample.bson | get root | nth 0 | get b | echo $it"
); );
@ -36,8 +34,7 @@ fn open_can_parse_bson_1() {
#[test] #[test]
fn open_can_parse_bson_2() { fn open_can_parse_bson_2() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sample.bson | get root | nth 6 | get b | get '$binary_subtype' | echo $it " "open sample.bson | get root | nth 6 | get b | get '$binary_subtype' | echo $it "
); );
@ -47,8 +44,7 @@ fn open_can_parse_bson_2() {
#[test] #[test]
fn open_can_parse_toml() { fn open_can_parse_toml() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open cargo_sample.toml | get package.edition | echo $it" "open cargo_sample.toml | get package.edition | echo $it"
); );
@ -58,7 +54,7 @@ fn open_can_parse_toml() {
#[test] #[test]
fn open_can_parse_json() { fn open_can_parse_json() {
nu!(output, let output = nu!(
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.GlossSee | echo $it" "open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.GlossSee | echo $it"
); );
@ -68,8 +64,7 @@ fn open_can_parse_json() {
#[test] #[test]
fn open_can_parse_xml() { fn open_can_parse_xml() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open jonathan.xml | get rss.channel.item.link | echo $it" "open jonathan.xml | get rss.channel.item.link | echo $it"
); );
@ -82,8 +77,7 @@ fn open_can_parse_xml() {
#[test] #[test]
fn open_can_parse_ini() { fn open_can_parse_ini() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sample.ini | get SectionOne.integer | echo $it" "open sample.ini | get SectionOne.integer | echo $it"
); );
@ -93,8 +87,7 @@ fn open_can_parse_ini() {
#[test] #[test]
fn open_can_parse_utf16_ini() { fn open_can_parse_utf16_ini() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open utf16.ini | get .ShellClassInfo | get IconIndex | echo $it" "open utf16.ini | get .ShellClassInfo | get IconIndex | echo $it"
); );
@ -104,8 +97,7 @@ fn open_can_parse_utf16_ini() {
#[test] #[test]
fn errors_if_file_not_found() { fn errors_if_file_not_found() {
nu_error!( let output = nu_error!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open i_dont_exist.txt | echo $it" "open i_dont_exist.txt | echo $it"
); );

276
tests/command_rm_tests.rs
View File

@ -4,169 +4,169 @@ use h::{in_directory as cwd, Playground, Stub::*};
use helpers as h; use helpers as h;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
#[test] // #[test]
fn rm_removes_a_file() { // fn rm_removes_a_file() {
let sandbox = Playground::setup_for("rm_regular_file_test") // let sandbox = Playground::setup_for("rm_regular_file_test")
.with_files(vec![EmptyFile("i_will_be_deleted.txt")]) // .with_files(vec![EmptyFile("i_will_be_deleted.txt")])
.test_dir_name(); // .test_dir_name();
nu!( // nu!(
_output, // _output,
cwd(&Playground::root()), // cwd(&Playground::root()),
"rm rm_regular_file_test/i_will_be_deleted.txt" // "rm rm_regular_file_test/i_will_be_deleted.txt"
); // );
let path = &format!( // let path = &format!(
"{}/{}/{}", // "{}/{}/{}",
Playground::root(), // Playground::root(),
sandbox, // sandbox,
"i_will_be_deleted.txt" // "i_will_be_deleted.txt"
); // );
assert!(!h::file_exists_at(PathBuf::from(path))); // assert!(!h::file_exists_at(PathBuf::from(path)));
} // }
#[test] // #[test]
fn rm_removes_files_with_wildcard() { // fn rm_removes_files_with_wildcard() {
let sandbox = Playground::setup_for("rm_wildcard_test_1") // let sandbox = Playground::setup_for("rm_wildcard_test_1")
.within("src") // .within("src")
.with_files(vec![ // .with_files(vec![
EmptyFile("cli.rs"), // EmptyFile("cli.rs"),
EmptyFile("lib.rs"), // EmptyFile("lib.rs"),
EmptyFile("prelude.rs"), // EmptyFile("prelude.rs"),
]) // ])
.within("src/parser") // .within("src/parser")
.with_files(vec![EmptyFile("parse.rs"), EmptyFile("parser.rs")]) // .with_files(vec![EmptyFile("parse.rs"), EmptyFile("parser.rs")])
.within("src/parser/parse") // .within("src/parser/parse")
.with_files(vec![EmptyFile("token_tree.rs")]) // .with_files(vec![EmptyFile("token_tree.rs")])
.within("src/parser/hir") // .within("src/parser/hir")
.with_files(vec![ // .with_files(vec![
EmptyFile("baseline_parse.rs"), // EmptyFile("baseline_parse.rs"),
EmptyFile("baseline_parse_tokens.rs"), // EmptyFile("baseline_parse_tokens.rs"),
]) // ])
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
nu!( // nu!(
_output, // _output,
cwd("tests/fixtures/nuplayground/rm_wildcard_test_1"), // cwd("tests/fixtures/nuplayground/rm_wildcard_test_1"),
r#"rm "src/*/*/*.rs""# // r#"rm "src/*/*/*.rs""#
); // );
assert!(!h::files_exist_at( // assert!(!h::files_exist_at(
vec![ // vec![
Path::new("src/parser/parse/token_tree.rs"), // Path::new("src/parser/parse/token_tree.rs"),
Path::new("src/parser/hir/baseline_parse.rs"), // Path::new("src/parser/hir/baseline_parse.rs"),
Path::new("src/parser/hir/baseline_parse_tokens.rs") // Path::new("src/parser/hir/baseline_parse_tokens.rs")
], // ],
PathBuf::from(&full_path) // PathBuf::from(&full_path)
)); // ));
assert_eq!( // assert_eq!(
Playground::glob_vec(&format!("{}/src/*/*/*.rs", &full_path)), // Playground::glob_vec(&format!("{}/src/*/*/*.rs", &full_path)),
Vec::<PathBuf>::new() // Vec::<PathBuf>::new()
); // );
} // }
#[test] // #[test]
fn rm_removes_deeply_nested_directories_with_wildcard_and_recursive_flag() { // fn rm_removes_deeply_nested_directories_with_wildcard_and_recursive_flag() {
let sandbox = Playground::setup_for("rm_wildcard_test_2") // let sandbox = Playground::setup_for("rm_wildcard_test_2")
.within("src") // .within("src")
.with_files(vec![ // .with_files(vec![
EmptyFile("cli.rs"), // EmptyFile("cli.rs"),
EmptyFile("lib.rs"), // EmptyFile("lib.rs"),
EmptyFile("prelude.rs"), // EmptyFile("prelude.rs"),
]) // ])
.within("src/parser") // .within("src/parser")
.with_files(vec![EmptyFile("parse.rs"), EmptyFile("parser.rs")]) // .with_files(vec![EmptyFile("parse.rs"), EmptyFile("parser.rs")])
.within("src/parser/parse") // .within("src/parser/parse")
.with_files(vec![EmptyFile("token_tree.rs")]) // .with_files(vec![EmptyFile("token_tree.rs")])
.within("src/parser/hir") // .within("src/parser/hir")
.with_files(vec![ // .with_files(vec![
EmptyFile("baseline_parse.rs"), // EmptyFile("baseline_parse.rs"),
EmptyFile("baseline_parse_tokens.rs"), // EmptyFile("baseline_parse_tokens.rs"),
]) // ])
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
nu!( // nu!(
_output, // _output,
cwd("tests/fixtures/nuplayground/rm_wildcard_test_2"), // cwd("tests/fixtures/nuplayground/rm_wildcard_test_2"),
"rm src/* --recursive" // "rm src/* --recursive"
); // );
assert!(!h::files_exist_at( // assert!(!h::files_exist_at(
vec![Path::new("src/parser/parse"), Path::new("src/parser/hir"),], // vec![Path::new("src/parser/parse"), Path::new("src/parser/hir"),],
PathBuf::from(&full_path) // PathBuf::from(&full_path)
)); // ));
} // }
#[test] // #[test]
fn rm_removes_directory_contents_without_recursive_flag_if_empty() { // fn rm_removes_directory_contents_without_recursive_flag_if_empty() {
let sandbox = Playground::setup_for("rm_directory_removal_recursively_test_1").test_dir_name(); // let sandbox = Playground::setup_for("rm_directory_removal_recursively_test_1").test_dir_name();
nu!( // nu!(
_output, // _output,
cwd("tests/fixtures/nuplayground"), // cwd("tests/fixtures/nuplayground"),
"rm rm_directory_removal_recursively_test_1" // "rm rm_directory_removal_recursively_test_1"
); // );
let expected = format!("{}/{}", Playground::root(), sandbox); // let expected = format!("{}/{}", Playground::root(), sandbox);
assert!(!h::file_exists_at(PathBuf::from(expected))); // assert!(!h::file_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn rm_removes_directory_contents_with_recursive_flag() { // fn rm_removes_directory_contents_with_recursive_flag() {
let sandbox = Playground::setup_for("rm_directory_removal_recursively_test_2") // let sandbox = Playground::setup_for("rm_directory_removal_recursively_test_2")
.with_files(vec![ // .with_files(vec![
EmptyFile("yehuda.txt"), // EmptyFile("yehuda.txt"),
EmptyFile("jonathan.txt"), // EmptyFile("jonathan.txt"),
EmptyFile("andres.txt"), // EmptyFile("andres.txt"),
]) // ])
.test_dir_name(); // .test_dir_name();
nu!( // nu!(
_output, // _output,
cwd("tests/fixtures/nuplayground"), // cwd("tests/fixtures/nuplayground"),
"rm rm_directory_removal_recursively_test_2 --recursive" // "rm rm_directory_removal_recursively_test_2 --recursive"
); // );
let expected = format!("{}/{}", Playground::root(), sandbox); // let expected = format!("{}/{}", Playground::root(), sandbox);
assert!(!h::file_exists_at(PathBuf::from(expected))); // assert!(!h::file_exists_at(PathBuf::from(expected)));
} // }
#[test] // #[test]
fn rm_errors_if_attempting_to_delete_a_directory_with_content_without_recursive_flag() { // fn rm_errors_if_attempting_to_delete_a_directory_with_content_without_recursive_flag() {
let sandbox = Playground::setup_for("rm_prevent_directory_removal_without_flag_test") // let sandbox = Playground::setup_for("rm_prevent_directory_removal_without_flag_test")
.with_files(vec![EmptyFile("some_empty_file.txt")]) // .with_files(vec![EmptyFile("some_empty_file.txt")])
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
nu_error!( // nu_error!(
output, // output,
cwd(&Playground::root()), // cwd(&Playground::root()),
"rm rm_prevent_directory_removal_without_flag_test" // "rm rm_prevent_directory_removal_without_flag_test"
); // );
assert!(h::file_exists_at(PathBuf::from(full_path))); // assert!(h::file_exists_at(PathBuf::from(full_path)));
assert!(output.contains("is a directory")); // assert!(output.contains("is a directory"));
} // }
#[test] // #[test]
fn rm_errors_if_attempting_to_delete_single_dot_as_argument() { // fn rm_errors_if_attempting_to_delete_single_dot_as_argument() {
nu_error!(output, cwd(&Playground::root()), "rm ."); // nu_error!(output, cwd(&Playground::root()), "rm .");
assert!(output.contains("may not be removed")); // assert!(output.contains("may not be removed"));
} // }
#[test] // #[test]
fn rm_errors_if_attempting_to_delete_two_dot_as_argument() { // fn rm_errors_if_attempting_to_delete_two_dot_as_argument() {
nu_error!(output, cwd(&Playground::root()), "rm .."); // nu_error!(output, cwd(&Playground::root()), "rm ..");
assert!(output.contains("may not be removed")); // assert!(output.contains("may not be removed"));
} // }

80
tests/commands_test.rs
View File

@ -5,7 +5,7 @@ use helpers as h;
#[test] #[test]
fn lines() { fn lines() {
nu!(output, let output = nu!(
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml --raw | lines | skip-while $it != "[dependencies]" | skip 1 | first 1 | split-column "=" | get Column1 | trim | echo $it"# r#"open cargo_sample.toml --raw | lines | skip-while $it != "[dependencies]" | skip 1 | first 1 | split-column "=" | get Column1 | trim | echo $it"#
); );
@ -13,49 +13,49 @@ fn lines() {
assert_eq!(output, "rustyline"); assert_eq!(output, "rustyline");
} }
#[test] // #[test]
fn save_figures_out_intelligently_where_to_write_out_with_metadata() { // fn save_figures_out_intelligently_where_to_write_out_with_metadata() {
let sandbox = Playground::setup_for("save_smart_test") // let sandbox = Playground::setup_for("save_smart_test")
.with_files(vec![FileWithContent( // .with_files(vec![FileWithContent(
"cargo_sample.toml", // "cargo_sample.toml",
r#" // r#"
[package] // [package]
name = "nu" // name = "nu"
version = "0.1.1" // version = "0.1.1"
authors = ["Yehuda Katz <wycats@gmail.com>"] // authors = ["Yehuda Katz <wycats@gmail.com>"]
description = "A shell for the GitHub era" // description = "A shell for the GitHub era"
license = "ISC" // license = "ISC"
edition = "2018" // edition = "2018"
"#, // "#,
)]) // )])
.test_dir_name(); // .test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let subject_file = format!("{}/{}", full_path, "cargo_sample.toml"); // let subject_file = format!("{}/{}", full_path, "cargo_sample.toml");
nu!( // nu!(
_output, // _output,
cwd(&Playground::root()), // cwd(&Playground::root()),
"open save_smart_test/cargo_sample.toml | inc package.version --minor | save" // "open save_smart_test/cargo_sample.toml | inc package.version --minor | save"
); // );
let actual = h::file_contents(&subject_file); // let actual = h::file_contents(&subject_file);
assert!(actual.contains("0.2.0")); // assert!(actual.contains("0.2.0"));
} // }
#[test] // #[test]
fn save_can_write_out_csv() { // fn save_can_write_out_csv() {
let sandbox = Playground::setup_for("save_writes_out_csv_test").test_dir_name(); // let sandbox = Playground::setup_for("save_writes_out_csv_test").test_dir_name();
let full_path = format!("{}/{}", Playground::root(), sandbox); // let full_path = format!("{}/{}", Playground::root(), sandbox);
let expected_file = format!("{}/{}", full_path, "cargo_sample.csv"); // let expected_file = format!("{}/{}", full_path, "cargo_sample.csv");
nu!( // nu!(
_output, // _output,
cwd(&Playground::root()), // cwd(&Playground::root()),
"open ../formats/cargo_sample.toml | inc package.version --minor | get package | save save_writes_out_csv_test/cargo_sample.csv" // "open ../formats/cargo_sample.toml | inc package.version --minor | get package | save save_writes_out_csv_test/cargo_sample.csv"
); // );
let actual = h::file_contents(&expected_file); // let actual = h::file_contents(&expected_file);
assert!(actual.contains("[list list],A shell for the GitHub era,2018,ISC,nu,0.2.0")); // assert!(actual.contains("[list list],A shell for the GitHub era,2018,ISC,nu,0.2.0"));
} // }

2
tests/external_tests.rs
View File

@ -4,7 +4,7 @@ use helpers::in_directory as cwd;
#[test] #[test]
fn external_command() { fn external_command() {
nu!(output, cwd("tests/fixtures"), "echo 1"); let output = nu!(cwd("tests/fixtures"), "echo 1");
assert!(output.contains("1")); assert!(output.contains("1"));
} }

21
tests/filter_inc_tests.rs
View File

@ -5,8 +5,7 @@ use helpers as h;
#[test] #[test]
fn can_only_apply_one() { fn can_only_apply_one() {
nu_error!( let output = nu_error!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open cargo_sample.toml | first 1 | inc package.version --major --minor" "open cargo_sample.toml | first 1 | inc package.version --major --minor"
); );
@ -26,8 +25,7 @@ fn by_one_with_field_passed() {
), ),
]); ]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_by_one_with_field_passed_test"), cwd("tests/fixtures/nuplayground/plugin_inc_by_one_with_field_passed_test"),
"open sample.toml | inc package.edition | get package.edition | echo $it" "open sample.toml | inc package.edition | get package.edition | echo $it"
); );
@ -47,8 +45,7 @@ fn by_one_with_no_field_passed() {
), ),
]); ]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_by_one_with_no_field_passed_test"), cwd("tests/fixtures/nuplayground/plugin_inc_by_one_with_no_field_passed_test"),
"open sample.toml | get package.contributors | inc | echo $it" "open sample.toml | get package.contributors | inc | echo $it"
); );
@ -66,8 +63,7 @@ fn semversion_major_inc() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_major_semversion_test"), cwd("tests/fixtures/nuplayground/plugin_inc_major_semversion_test"),
"open sample.toml | inc package.version --major | get package.version | echo $it" "open sample.toml | inc package.version --major | get package.version | echo $it"
); );
@ -85,8 +81,7 @@ fn semversion_minor_inc() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_minor_semversion_test"), cwd("tests/fixtures/nuplayground/plugin_inc_minor_semversion_test"),
"open sample.toml | inc package.version --minor | get package.version | echo $it" "open sample.toml | inc package.version --minor | get package.version | echo $it"
); );
@ -104,8 +99,7 @@ fn semversion_patch_inc() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_patch_semversion_test"), cwd("tests/fixtures/nuplayground/plugin_inc_patch_semversion_test"),
"open sample.toml | inc package.version --patch | get package.version | echo $it" "open sample.toml | inc package.version --patch | get package.version | echo $it"
); );
@ -125,8 +119,7 @@ fn semversion_without_passing_field() {
), ),
]); ]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_inc_semversion_without_passing_field_test"), cwd("tests/fixtures/nuplayground/plugin_inc_semversion_without_passing_field_test"),
"open sample.toml | get package.version | inc --patch | echo $it" "open sample.toml | get package.version | inc --patch | echo $it"
); );

24
tests/filter_str_tests.rs
View File

@ -5,8 +5,7 @@ use helpers as h;
#[test] #[test]
fn can_only_apply_one() { fn can_only_apply_one() {
nu_error!( let output = nu_error!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open caco3_plastics.csv | first 1 | str origin --downcase --upcase" "open caco3_plastics.csv | first 1 | str origin --downcase --upcase"
); );
@ -29,8 +28,7 @@ fn acts_without_passing_field() {
), ),
]); ]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_acts_without_passing_field_test"), cwd("tests/fixtures/nuplayground/plugin_str_acts_without_passing_field_test"),
"open sample.yml | get environment.global.PROJECT_NAME | str --upcase | echo $it" "open sample.yml | get environment.global.PROJECT_NAME | str --upcase | echo $it"
); );
@ -48,8 +46,7 @@ fn downcases() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_downcases_test"), cwd("tests/fixtures/nuplayground/plugin_str_downcases_test"),
"open sample.toml | str dependency.name --downcase | get dependency.name | echo $it" "open sample.toml | str dependency.name --downcase | get dependency.name | echo $it"
); );
@ -67,8 +64,7 @@ fn upcases() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_upcases_test"), cwd("tests/fixtures/nuplayground/plugin_str_upcases_test"),
"open sample.toml | str package.name --upcase | get package.name | echo $it" "open sample.toml | str package.name --upcase | get package.name | echo $it"
); );
@ -78,8 +74,7 @@ fn upcases() {
#[test] #[test]
fn converts_to_int() { fn converts_to_int() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open caco3_plastics.csv | first 1 | str tariff_item --to-int | where tariff_item == 2509000000 | get tariff_item | echo $it" "open caco3_plastics.csv | first 1 | str tariff_item --to-int | where tariff_item == 2509000000 | get tariff_item | echo $it"
); );
@ -97,8 +92,7 @@ fn replaces() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_replaces_test"), cwd("tests/fixtures/nuplayground/plugin_str_replaces_test"),
"open sample.toml | str package.name --replace wykittenshell | get package.name | echo $it" "open sample.toml | str package.name --replace wykittenshell | get package.name | echo $it"
); );
@ -116,8 +110,7 @@ fn find_and_replaces() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_find_and_replaces_test"), cwd("tests/fixtures/nuplayground/plugin_str_find_and_replaces_test"),
r#"open sample.toml | str fortune.teller.phone --find-replace KATZ "5289" | get fortune.teller.phone | echo $it"# r#"open sample.toml | str fortune.teller.phone --find-replace KATZ "5289" | get fortune.teller.phone | echo $it"#
); );
@ -137,8 +130,7 @@ fn find_and_replaces_without_passing_field() {
)], )],
); );
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/plugin_str_find_and_replaces_without_passing_field_test"), cwd("tests/fixtures/nuplayground/plugin_str_find_and_replaces_without_passing_field_test"),
r#"open sample.toml | get fortune.teller.phone | str --find-replace KATZ "5289" | echo $it"# r#"open sample.toml | get fortune.teller.phone | str --find-replace KATZ "5289" | echo $it"#
); );

57
tests/filters_test.rs
View File

@ -4,8 +4,7 @@ use helpers::{in_directory as cwd, Playground, Stub::*};
#[test] #[test]
fn can_convert_table_to_csv_text_and_from_csv_text_back_into_table() { fn can_convert_table_to_csv_text_and_from_csv_text_back_into_table() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open caco3_plastics.csv | to-csv | from-csv | first 1 | get origin | echo $it" "open caco3_plastics.csv | to-csv | from-csv | first 1 | get origin | echo $it"
); );
@ -24,8 +23,7 @@ fn converts_structured_table_to_csv_text() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_to_csv_test_1"), cwd("tests/fixtures/nuplayground/filter_to_csv_test_1"),
r#"open sample.txt | lines | split-column "," a b c d origin | last 1 | to-csv | lines | nth 1 | echo "$it""# r#"open sample.txt | lines | split-column "," a b c d origin | last 1 | to-csv | lines | nth 1 | echo "$it""#
); );
@ -44,8 +42,7 @@ fn converts_structured_table_to_csv_text_skipping_headers_after_conversion() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_to_csv_test_2"), cwd("tests/fixtures/nuplayground/filter_to_csv_test_2"),
r#"open sample.txt | lines | split-column "," a b c d origin | last 1 | to-csv --headerless | echo "$it""# r#"open sample.txt | lines | split-column "," a b c d origin | last 1 | to-csv --headerless | echo "$it""#
); );
@ -65,8 +62,7 @@ fn converts_from_csv_text_to_structured_table() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_from_csv_test_1"), cwd("tests/fixtures/nuplayground/filter_from_csv_test_1"),
"open los_tres_amigos.txt | from-csv | get rusty_luck | str --to-int | sum | echo $it" "open los_tres_amigos.txt | from-csv | get rusty_luck | str --to-int | sum | echo $it"
); );
@ -86,8 +82,7 @@ fn converts_from_csv_text_skipping_headers_to_structured_table() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_from_csv_test_2"), cwd("tests/fixtures/nuplayground/filter_from_csv_test_2"),
"open los_tres_amigos.txt | from-csv --headerless | get Column3 | str --to-int | sum | echo $it" "open los_tres_amigos.txt | from-csv --headerless | get Column3 | str --to-int | sum | echo $it"
); );
@ -97,8 +92,7 @@ fn converts_from_csv_text_skipping_headers_to_structured_table() {
#[test] #[test]
fn can_convert_table_to_json_text_and_from_json_text_back_into_table() { fn can_convert_table_to_json_text_and_from_json_text_back_into_table() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sgml_description.json | to-json | from-json | get glossary.GlossDiv.GlossList.GlossEntry.GlossSee | echo $it" "open sgml_description.json | to-json | from-json | get glossary.GlossDiv.GlossList.GlossEntry.GlossSee | echo $it"
); );
@ -122,8 +116,7 @@ fn converts_from_json_text_to_structured_table() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_from_json_test_1"), cwd("tests/fixtures/nuplayground/filter_from_json_test_1"),
"open katz.txt | from-json | get katz | get rusty_luck | sum | echo $it" "open katz.txt | from-json | get katz | get rusty_luck | sum | echo $it"
); );
@ -143,8 +136,7 @@ fn converts_from_json_text_recognizing_objects_independendtly_to_structured_tabl
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_from_json_test_2"), cwd("tests/fixtures/nuplayground/filter_from_json_test_2"),
r#"open katz.txt | from-json --objects | where name == "GorbyPuff" | get rusty_luck | echo $it"# r#"open katz.txt | from-json --objects | where name == "GorbyPuff" | get rusty_luck | echo $it"#
); );
@ -162,8 +154,7 @@ fn converts_structured_table_to_json_text() {
"#, "#,
)]); )]);
nu!( let output = nu!(
output,
cwd("tests/fixtures/nuplayground/filter_to_json_test_1"), cwd("tests/fixtures/nuplayground/filter_to_json_test_1"),
r#"open sample.txt | lines | split-column "," name luck | pick name | to-json | nth 0 | from-json | get name | echo $it"# r#"open sample.txt | lines | split-column "," name luck | pick name | to-json | nth 0 | from-json | get name | echo $it"#
); );
@ -173,8 +164,7 @@ fn converts_structured_table_to_json_text() {
#[test] #[test]
fn can_convert_json_text_to_bson_and_back_into_table() { fn can_convert_json_text_to_bson_and_back_into_table() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sample.bson | to-bson | from-bson | get root | nth 1 | get b | echo $it" "open sample.bson | to-bson | from-bson | get root | nth 1 | get b | echo $it"
); );
@ -184,8 +174,7 @@ fn can_convert_json_text_to_bson_and_back_into_table() {
#[test] #[test]
fn can_convert_table_to_toml_text_and_from_toml_text_back_into_table() { fn can_convert_table_to_toml_text_and_from_toml_text_back_into_table() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open cargo_sample.toml | to-toml | from-toml | get package.name | echo $it" "open cargo_sample.toml | to-toml | from-toml | get package.name | echo $it"
); );
@ -195,8 +184,7 @@ fn can_convert_table_to_toml_text_and_from_toml_text_back_into_table() {
#[test] #[test]
fn can_convert_table_to_yaml_text_and_from_yaml_text_back_into_table() { fn can_convert_table_to_yaml_text_and_from_yaml_text_back_into_table() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open appveyor.yml | to-yaml | from-yaml | get environment.global.PROJECT_NAME | echo $it" "open appveyor.yml | to-yaml | from-yaml | get environment.global.PROJECT_NAME | echo $it"
); );
@ -206,8 +194,7 @@ fn can_convert_table_to_yaml_text_and_from_yaml_text_back_into_table() {
#[test] #[test]
fn can_sort_by_column() { fn can_sort_by_column() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml --raw | lines | skip 1 | first 4 | split-column "=" | sort-by Column1 | skip 1 | first 1 | get Column1 | trim | echo $it"# r#"open cargo_sample.toml --raw | lines | skip 1 | first 4 | split-column "=" | sort-by Column1 | skip 1 | first 1 | get Column1 | trim | echo $it"#
); );
@ -217,8 +204,7 @@ fn can_sort_by_column() {
#[test] #[test]
fn can_sort_by_column_reverse() { fn can_sort_by_column_reverse() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml --raw | lines | skip 1 | first 4 | split-column "=" | sort-by Column1 --reverse | skip 1 | first 1 | get Column1 | trim | echo $it"# r#"open cargo_sample.toml --raw | lines | skip 1 | first 4 | split-column "=" | sort-by Column1 --reverse | skip 1 | first 1 | get Column1 | trim | echo $it"#
); );
@ -228,8 +214,7 @@ fn can_sort_by_column_reverse() {
#[test] #[test]
fn can_split_by_column() { fn can_split_by_column() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml --raw | lines | skip 1 | first 1 | split-column "=" | get Column1 | trim | echo $it"# r#"open cargo_sample.toml --raw | lines | skip 1 | first 1 | split-column "=" | get Column1 | trim | echo $it"#
); );
@ -239,8 +224,7 @@ fn can_split_by_column() {
#[test] #[test]
fn can_sum() { fn can_sum() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.Sections | sum | echo $it" "open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.Sections | sum | echo $it"
); );
@ -250,8 +234,7 @@ fn can_sum() {
#[test] #[test]
fn can_filter_by_unit_size_comparison() { fn can_filter_by_unit_size_comparison() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"ls | where size > 1kb | sort-by size | get name | skip 1 | trim | echo $it" "ls | where size > 1kb | sort-by size | get name | skip 1 | trim | echo $it"
); );
@ -261,8 +244,7 @@ fn can_filter_by_unit_size_comparison() {
#[test] #[test]
fn can_get_last() { fn can_get_last() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"ls | sort-by name | last 1 | get name | trim | echo $it" "ls | sort-by name | last 1 | get name | trim | echo $it"
); );
@ -272,8 +254,7 @@ fn can_get_last() {
#[test] #[test]
fn can_get_reverse_first() { fn can_get_reverse_first() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"ls | sort-by name | reverse | first 1 | get name | trim | echo $it" "ls | sort-by name | reverse | first 1 | get name | trim | echo $it"
); );

165
tests/helpers/mod.rs
View File

@ -4,11 +4,63 @@ use glob::glob;
pub use std::path::Path; pub use std::path::Path;
pub use std::path::PathBuf; pub use std::path::PathBuf;
use getset::Getters;
use std::io::Read; use std::io::Read;
use tempfile::{tempdir, TempDir};
pub trait DisplayPath {
fn display_path(&self) -> String;
}
impl DisplayPath for PathBuf {
fn display_path(&self) -> String {
self.display().to_string()
}
}
impl DisplayPath for str {
fn display_path(&self) -> String {
self.to_string()
}
}
impl DisplayPath for &str {
fn display_path(&self) -> String {
self.to_string()
}
}
impl DisplayPath for String {
fn display_path(&self) -> String {
self.clone()
}
}
impl DisplayPath for &String {
fn display_path(&self) -> String {
self.to_string()
}
}
impl DisplayPath for nu::AbsolutePath {
fn display_path(&self) -> String {
self.to_string()
}
}
#[macro_export] #[macro_export]
macro_rules! nu { macro_rules! nu {
($out:ident, $cwd:expr, $commands:expr) => { ($cwd:expr, $path:expr, $($part:expr),*) => {{
use $crate::helpers::DisplayPath;
let path = format!($path, $(
$part.display_path()
),*);
nu!($cwd, &path)
}};
($cwd:expr, $path:expr) => {{
pub use std::error::Error; pub use std::error::Error;
pub use std::io::prelude::*; pub use std::io::prelude::*;
pub use std::process::{Command, Stdio}; pub use std::process::{Command, Stdio};
@ -18,7 +70,8 @@ macro_rules! nu {
cd {} cd {}
{} {}
exit", exit",
$cwd, $commands $crate::helpers::in_directory($cwd),
$crate::helpers::DisplayPath::display_path(&$path)
); );
let mut process = match Command::new(helpers::executable_path()) let mut process = match Command::new(helpers::executable_path())
@ -39,15 +92,27 @@ macro_rules! nu {
.wait_with_output() .wait_with_output()
.expect("couldn't read from stdout"); .expect("couldn't read from stdout");
let $out = String::from_utf8_lossy(&output.stdout); let out = String::from_utf8_lossy(&output.stdout);
let $out = $out.replace("\r\n", ""); let out = out.replace("\r\n", "");
let $out = $out.replace("\n", ""); let out = out.replace("\n", "");
}; out
}};
} }
#[macro_export] #[macro_export]
macro_rules! nu_error { macro_rules! nu_error {
($out:ident, $cwd:expr, $commands:expr) => { ($cwd:expr, $path:expr, $($part:expr),*) => {{
use $crate::helpers::DisplayPath;
let path = format!($path, $(
$part.display_path()
),*);
nu_error!($cwd, &path)
}};
($cwd:expr, $commands:expr) => {{
use std::io::prelude::*; use std::io::prelude::*;
use std::process::{Command, Stdio}; use std::process::{Command, Stdio};
@ -56,7 +121,7 @@ macro_rules! nu_error {
cd {} cd {}
{} {}
exit", exit",
$cwd, $commands $crate::helpers::in_directory($cwd), $commands
); );
let mut process = Command::new(helpers::executable_path()) let mut process = Command::new(helpers::executable_path())
@ -73,8 +138,11 @@ macro_rules! nu_error {
let output = process let output = process
.wait_with_output() .wait_with_output()
.expect("couldn't read from stderr"); .expect("couldn't read from stderr");
let $out = String::from_utf8_lossy(&output.stderr);
}; let out = String::from_utf8_lossy(&output.stderr);
out.into_owned()
}};
} }
pub enum Stub<'a> { pub enum Stub<'a> {
@ -84,13 +152,28 @@ pub enum Stub<'a> {
} }
pub struct Playground { pub struct Playground {
root: TempDir,
tests: String, tests: String,
cwd: PathBuf, cwd: PathBuf,
} }
#[derive(Getters)]
#[get = "pub"]
pub struct Dirs {
pub root: PathBuf,
pub test: PathBuf,
pub fixtures: PathBuf,
}
impl Dirs {
pub fn formats(&self) -> PathBuf {
PathBuf::from(self.fixtures.join("formats"))
}
}
impl Playground { impl Playground {
pub fn root() -> String { pub fn root(&self) -> &Path {
String::from("tests/fixtures/nuplayground") self.root.path()
} }
pub fn test_dir_name(&self) -> String { pub fn test_dir_name(&self) -> String {
@ -98,12 +181,47 @@ impl Playground {
} }
pub fn back_to_playground(&mut self) -> &mut Self { pub fn back_to_playground(&mut self) -> &mut Self {
self.cwd = PathBuf::from([Playground::root(), self.tests.clone()].join("/")); self.cwd = PathBuf::from(self.root()).join(self.tests.clone());
self self
} }
pub fn setup(topic: &str, block: impl FnOnce(Dirs, &mut Playground)) {
let mut playground = Playground::setup_for(topic);
let project_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let playground_root = playground.root.path();
let fixtures = project_root.join(file!());
let fixtures = fixtures
.parent()
.expect("Couldn't find the fixtures directory")
.parent()
.expect("Couldn't find the fixtures directory")
.join("fixtures");
let fixtures = dunce::canonicalize(fixtures.clone()).expect(&format!(
"Couldn't canonicalize fixtures path {}",
fixtures.display()
));
let test =
dunce::canonicalize(PathBuf::from(playground_root.join(topic))).expect(&format!(
"Couldn't canonicalize test path {}",
playground_root.join(topic).display()
));
let dirs = Dirs {
root: PathBuf::from(playground_root),
test,
fixtures,
};
block(dirs, &mut playground);
}
pub fn setup_for(topic: &str) -> Playground { pub fn setup_for(topic: &str) -> Playground {
let nuplay_dir = format!("{}/{}", Playground::root(), topic); let root = tempdir().expect("Couldn't create a tempdir");
let nuplay_dir = root.path().join(topic);
if PathBuf::from(&nuplay_dir).exists() { if PathBuf::from(&nuplay_dir).exists() {
std::fs::remove_dir_all(PathBuf::from(&nuplay_dir)).expect("can not remove directory"); std::fs::remove_dir_all(PathBuf::from(&nuplay_dir)).expect("can not remove directory");
@ -112,8 +230,9 @@ impl Playground {
std::fs::create_dir(PathBuf::from(&nuplay_dir)).expect("can not create directory"); std::fs::create_dir(PathBuf::from(&nuplay_dir)).expect("can not create directory");
Playground { Playground {
root: root,
tests: topic.to_string(), tests: topic.to_string(),
cwd: PathBuf::from([Playground::root(), topic.to_string()].join("/")), cwd: nuplay_dir,
} }
} }
@ -226,20 +345,20 @@ pub fn copy_file_to(source: &str, destination: &str) {
std::fs::copy(source, destination).expect("can not copy file"); std::fs::copy(source, destination).expect("can not copy file");
} }
pub fn files_exist_at(files: Vec<&Path>, path: PathBuf) -> bool { pub fn files_exist_at(files: Vec<&Path>, path: impl AsRef<Path>) -> bool {
files.iter().all(|f| { files.iter().all(|f| {
let mut loc = path.clone(); let mut loc = PathBuf::from(path.as_ref());
loc.push(f); loc.push(f);
loc.exists() loc.exists()
}) })
} }
pub fn file_exists_at(path: PathBuf) -> bool { pub fn file_exists_at(path: impl AsRef<Path>) -> bool {
path.exists() path.as_ref().exists()
} }
pub fn dir_exists_at(path: PathBuf) -> bool { pub fn dir_exists_at(path: impl AsRef<Path>) -> bool {
path.exists() path.as_ref().exists()
} }
pub fn delete_directory_at(full_path: &str) { pub fn delete_directory_at(full_path: &str) {
@ -254,6 +373,6 @@ pub fn executable_path() -> PathBuf {
buf buf
} }
pub fn in_directory(str: &str) -> &str { pub fn in_directory(str: impl AsRef<Path>) -> String {
str str.as_ref().display().to_string()
} }

9
tests/tests.rs
View File

@ -5,8 +5,7 @@ use helpers::normalize_string;
#[test] #[test]
fn external_num() { fn external_num() {
nu!( let output = nu!(
output,
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
"open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.Height | echo $it" "open sgml_description.json | get glossary.GlossDiv.GlossList.GlossEntry.Height | echo $it"
); );
@ -16,7 +15,7 @@ fn external_num() {
#[test] #[test]
fn external_has_correct_quotes() { fn external_has_correct_quotes() {
nu!(output, cwd("."), r#"echo "hello world""#); let output = nu!(cwd("."), r#"echo "hello world""#);
let output = normalize_string(&output); let output = normalize_string(&output);
@ -25,7 +24,7 @@ fn external_has_correct_quotes() {
#[test] #[test]
fn add_plugin() { fn add_plugin() {
nu!(output, let output = nu!(
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml | add dev-dependencies.newdep "1" | get dev-dependencies.newdep | echo $it"# r#"open cargo_sample.toml | add dev-dependencies.newdep "1" | get dev-dependencies.newdep | echo $it"#
); );
@ -35,7 +34,7 @@ fn add_plugin() {
#[test] #[test]
fn edit_plugin() { fn edit_plugin() {
nu!(output, let output = nu!(
cwd("tests/fixtures/formats"), cwd("tests/fixtures/formats"),
r#"open cargo_sample.toml | edit dev-dependencies.pretty_assertions "7" | get dev-dependencies.pretty_assertions | echo $it"# r#"open cargo_sample.toml | edit dev-dependencies.pretty_assertions "7" | get dev-dependencies.pretty_assertions | echo $it"#
); );