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

Migrate nu-test-support part 1

Browse Source
This commit is contained in:
Ian Manske 2024-07-08 20:12:38 -07:00
parent 0178295363
commit 3c1cb715db
13 changed files with 96 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/nu-cli/tests/completions/mod.rs
View File

@ -721,7 +721,7 @@ fn file_completion_quoted() {
"`te#st.txt`".to_string(),
"`te'st.txt`".to_string(),
"`te(st).txt`".to_string(),
format!("`{}`", folder("test dir".into())),
format!("`{}`", folder("test dir")),
];
match_suggestions(expected_paths, suggestions);

20
crates/nu-cli/tests/completions/support/completions_helpers.rs
View File

@ -1,5 +1,6 @@
use nu_engine::eval_block;
use nu_parser::parse;
use nu_path::{AbsolutePathBuf, PathBuf};
use nu_protocol::{
debugger::WithoutDebug,
engine::{EngineState, Stack, StateWorkingSet},
@ -7,14 +8,14 @@ use nu_protocol::{
};
use nu_test_support::fs;
use reedline::Suggestion;
use std::path::{PathBuf, MAIN_SEPARATOR};
use std::path::MAIN_SEPARATOR;
fn create_default_context() -> EngineState {
nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
}
// creates a new engine with the current path into the completions fixtures folder
pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
pub fn new_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
// Target folder inside assets
let dir = fs::fixtures().join("completions");
let dir_str = dir
@ -69,7 +70,7 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
}
// creates a new engine with the current path into the completions fixtures folder
pub fn new_dotnu_engine() -> (PathBuf, String, EngineState, Stack) {
pub fn new_dotnu_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
// Target folder inside assets
let dir = fs::fixtures().join("dotnu_completions");
let dir_str = dir
@ -114,7 +115,7 @@ pub fn new_dotnu_engine() -> (PathBuf, String, EngineState, Stack) {
(dir, dir_str, engine_state, stack)
}
pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
pub fn new_quote_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
// Target folder inside assets
let dir = fs::fixtures().join("quoted_completions");
let dir_str = dir
@ -149,7 +150,7 @@ pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
(dir, dir_str, engine_state, stack)
}
pub fn new_partial_engine() -> (PathBuf, String, EngineState, Stack) {
pub fn new_partial_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
// Target folder inside assets
let dir = fs::fixtures().join("partial_completions");
let dir_str = dir
@ -205,16 +206,15 @@ pub fn match_suggestions(expected: Vec<String>, suggestions: Vec<Suggestion>) {
}
// append the separator to the converted path
pub fn folder(path: PathBuf) -> String {
pub fn folder(path: impl Into<PathBuf>) -> String {
let mut converted_path = file(path);
converted_path.push(MAIN_SEPARATOR);
converted_path
}
// convert a given path to string
pub fn file(path: PathBuf) -> String {
path.into_os_string().into_string().unwrap_or_default()
pub fn file(path: impl Into<PathBuf>) -> String {
path.into().into_os_string().into_string().unwrap()
}
// merge_input executes the given input into the engine
@ -223,7 +223,7 @@ pub fn merge_input(
input: &[u8],
engine_state: &mut EngineState,
stack: &mut Stack,
dir: PathBuf,
dir: AbsolutePathBuf,
) -> Result<(), ShellError> {
let (block, delta) = {
let mut working_set = StateWorkingSet::new(engine_state);

2
crates/nu-command/src/system/run_external.rs
View File

@ -606,7 +606,7 @@ mod test {
Playground::setup("test_expand_glob", |dirs, play| {
play.with_files(&[Stub::EmptyFile("a.txt"), Stub::EmptyFile("b.txt")]);
let cwd = dirs.test();
let cwd = dirs.test().as_std_path();
let actual = expand_glob("*.txt", cwd, Span::unknown(), &Signals::empty()).unwrap();
let expected = &["a.txt", "b.txt"];

2
crates/nu-command/tests/commands/database/into_sqlite.rs
View File

@ -465,7 +465,7 @@ fn make_sqlite_db(dirs: &Dirs, nu_table: &str) -> PathBuf {
);
assert!(nucmd.status.success());
testdb_path
testdb_path.into()
}
fn insert_test_rows(dirs: &Dirs, nu_table: &str, sql_query: Option<&str>, expected: Vec<TestRow>) {

2
crates/nu-command/tests/commands/rm.rs
View File

@ -437,7 +437,7 @@ fn rm_prints_filenames_on_error() {
.collect();
sandbox.with_files(&with_files);
let test_dir = dirs.test();
let test_dir = dirs.test().as_std_path();
set_dir_read_only(test_dir, true);
let _cleanup = Cleanup {

10
crates/nu-command/tests/commands/source_env.rs
View File

@ -1,4 +1,3 @@
use nu_test_support::fs::AbsolutePath;
use nu_test_support::fs::Stub::{FileWithContent, FileWithContentToBeTrimmed};
use nu_test_support::nu;
use nu_test_support::pipeline;
@ -8,17 +7,18 @@ use nu_test_support::playground::Playground;
#[test]
fn sources_also_files_under_custom_lib_dirs_path() {
Playground::setup("source_test_1", |dirs, nu| {
let file = AbsolutePath::new(dirs.test().join("config.toml"));
let library_path = AbsolutePath::new(dirs.test().join("lib"));
let file = dirs.test().join("config.toml");
let library_path = dirs.test().join("lib");
nu.with_config(&file);
nu.with_files(&[FileWithContent(
"config.toml",
&format!(
r#"
lib_dirs = ["{library_path}"]
lib_dirs = ["{}"]
skip_welcome_message = true
"#
"#,
library_path.as_os_str().to_str().unwrap(),
),
)]);

8
crates/nu-command/tests/commands/ucp.rs
View File

@ -1,6 +1,6 @@
use nu_test_support::fs::file_contents;
use nu_test_support::fs::{
files_exist_at, AbsoluteFile,
files_exist_at,
Stub::{EmptyFile, FileWithContent, FileWithPermission},
};
use nu_test_support::nu;
@ -55,7 +55,7 @@ fn copies_the_file_inside_directory_if_path_to_copy_is_directory() {
fn copies_the_file_inside_directory_if_path_to_copy_is_directory_impl(progress: bool) {
Playground::setup("ucp_test_2", |dirs, _| {
let expected_file = AbsoluteFile::new(dirs.test().join("sample.ini"));
let expected_file = dirs.test().join("sample.ini");
let progress_flag = if progress { "-p" } else { "" };
// Get the hash of the file content to check integrity after copy.
@ -64,13 +64,13 @@ fn copies_the_file_inside_directory_if_path_to_copy_is_directory_impl(progress:
cwd: dirs.formats(),
"cp {} ../formats/sample.ini {}",
progress_flag,
expected_file.dir()
expected_file.parent().unwrap().as_os_str().to_str().unwrap(),
);
assert!(dirs.test().join("sample.ini").exists());
// Check the integrity of the file.
let after_cp_hash = get_file_hash(expected_file);
let after_cp_hash = get_file_hash(expected_file.display());
assert_eq!(first_hash, after_cp_hash);
})
}

9
crates/nu-command/tests/commands/use_.rs
View File

@ -1,4 +1,3 @@
use nu_test_support::fs::AbsolutePath;
use nu_test_support::fs::Stub::{FileWithContent, FileWithContentToBeTrimmed};
use nu_test_support::nu;
use nu_test_support::pipeline;
@ -7,10 +6,10 @@ 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"));
let file = dirs.test().join("spam.nu");
nu.with_files(&[FileWithContent(
&file.to_string(),
file.as_os_str().to_str().unwrap(),
r#"
export def foo [] {
echo "hello world"
@ -37,10 +36,10 @@ fn use_module_file_within_block() {
#[test]
fn use_keeps_doc_comments() {
Playground::setup("use_doc_comments", |dirs, nu| {
let file = AbsolutePath::new(dirs.test().join("spam.nu"));
let file = dirs.test().join("spam.nu");
nu.with_files(&[FileWithContent(
&file.to_string(),
file.as_os_str().to_str().unwrap(),
r#"
# this is my foo command
export def foo [

161
crates/nu-test-support/src/fs.rs
View File

@ -1,138 +1,7 @@
use std::fmt::Display;
use nu_path::AbsolutePathBuf;
use std::io::Read;
use std::ops::Div;
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(if let Some(parent) = self.inner.parent() {
parent
} else {
unreachable!("Internal error: could not get parent in dir")
})
}
}
impl From<AbsoluteFile> for PathBuf {
fn from(file: AbsoluteFile) -> Self {
file.inner
}
}
pub struct AbsolutePath {
pub inner: PathBuf,
}
impl AbsolutePath {
pub fn new(path: impl AsRef<Path>) -> AbsolutePath {
let path = path.as_ref();
if path.is_absolute() {
AbsolutePath {
inner: path.to_path_buf(),
}
} else {
panic!("AbsolutePath::new must take an absolute path")
}
}
}
impl Div<&str> for &AbsolutePath {
type Output = AbsolutePath;
fn div(self, rhs: &str) -> Self::Output {
let parts = rhs.split('/');
let mut result = self.inner.clone();
for part in parts {
result = result.join(part);
}
AbsolutePath::new(result)
}
}
impl AsRef<Path> for AbsolutePath {
fn as_ref(&self) -> &Path {
self.inner.as_path()
}
}
pub struct RelativePath {
inner: PathBuf,
}
impl RelativePath {
pub fn new(path: impl Into<PathBuf>) -> RelativePath {
let path = path.into();
if path.is_relative() {
RelativePath { inner: path }
} else {
panic!("RelativePath::new must take a relative path")
}
}
}
impl<T: AsRef<str>> Div<T> for &RelativePath {
type Output = RelativePath;
fn div(self, rhs: T) -> Self::Output {
let parts = rhs.as_ref().split('/');
let mut result = self.inner.clone();
for part in parts {
result = result.join(part);
}
RelativePath::new(result)
}
}
impl Display for AbsoluteFile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.inner.display())
}
}
impl Display for AbsolutePath {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.inner.display())
}
}
impl Display for RelativePath {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.inner.display())
}
}
pub enum Stub<'a> {
FileWithContent(&'a str, &'a str),
FileWithContentToBeTrimmed(&'a str, &'a str),
@ -204,7 +73,7 @@ pub fn delete_directory_at(full_path: &str) {
pub fn executable_path() -> PathBuf {
let mut path = binaries();
path.push("nu");
path
path.into()
}
pub fn installed_nu_path() -> PathBuf {
@ -212,11 +81,12 @@ pub fn installed_nu_path() -> PathBuf {
which::which_in("nu", path, ".").unwrap_or_else(|_| executable_path())
}
pub fn root() -> PathBuf {
pub fn root() -> AbsolutePathBuf {
let manifest_dir = if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
PathBuf::from(manifest_dir)
AbsolutePathBuf::try_from(manifest_dir).expect("CARGO_MANIFEST_DIR is not an absolute path")
} else {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
AbsolutePathBuf::try_from(env!("CARGO_MANIFEST_DIR"))
.expect("CARGO_MANIFEST_DIR is not an absolute path")
};
let test_path = manifest_dir.join("Cargo.lock");
@ -228,11 +98,11 @@ pub fn root() -> PathBuf {
.expect("Couldn't find the debug binaries directory")
.parent()
.expect("Couldn't find the debug binaries directory")
.to_path_buf()
.into()
}
}
pub fn binaries() -> PathBuf {
pub fn binaries() -> AbsolutePathBuf {
let build_target = std::env::var("CARGO_BUILD_TARGET").unwrap_or_default();
let profile = if let Ok(env_profile) = std::env::var("NUSHELL_CARGO_PROFILE") {
@ -244,26 +114,27 @@ pub fn binaries() -> PathBuf {
};
std::env::var("CARGO_TARGET_DIR")
.map(PathBuf::from)
.unwrap_or_else(|_| root().join("target"))
.ok()
.and_then(|p| AbsolutePathBuf::try_from(p).ok())
.unwrap_or_else(|| root().join("target"))
.join(build_target)
.join(profile)
}
pub fn fixtures() -> PathBuf {
pub fn fixtures() -> AbsolutePathBuf {
root().join("tests").join("fixtures")
}
pub fn assets() -> PathBuf {
root().join("tests/assets")
pub fn assets() -> AbsolutePathBuf {
root().join("tests").join("assets")
}
pub fn in_directory(str: impl AsRef<Path>) -> String {
let path = str.as_ref();
let path = if path.is_relative() {
root().join(path)
root().join(path).into_any()
} else {
path.to_path_buf()
path.into()
};
path.display().to_string()

114
crates/nu-test-support/src/playground/play.rs
View File

@ -1,7 +1,7 @@
use super::Director;
use crate::fs;
use crate::fs::Stub;
use crate::fs::{self, Stub};
use nu_glob::glob;
use nu_path::{AbsolutePath, AbsolutePathBuf};
use std::path::{Path, PathBuf};
use std::str;
use tempfile::{tempdir, TempDir};
@ -22,46 +22,46 @@ impl EnvironmentVariable {
}
pub struct Playground<'a> {
root: TempDir,
_root: TempDir,
tests: String,
cwd: PathBuf,
cwd: AbsolutePathBuf,
config: Option<PathBuf>,
environment_vars: Vec<EnvironmentVariable>,
dirs: &'a Dirs,
}
#[derive(Default, Clone)]
#[derive(Clone)]
pub struct Dirs {
pub root: PathBuf,
pub test: PathBuf,
pub fixtures: PathBuf,
pub root: AbsolutePathBuf,
pub test: AbsolutePathBuf,
pub fixtures: AbsolutePathBuf,
}
impl Dirs {
pub fn formats(&self) -> PathBuf {
pub fn formats(&self) -> AbsolutePathBuf {
self.fixtures.join("formats")
}
pub fn root(&self) -> &Path {
self.root.as_path()
pub fn root(&self) -> &AbsolutePath {
&self.root
}
pub fn test(&self) -> &Path {
self.test.as_path()
pub fn test(&self) -> &AbsolutePath {
&self.test
}
}
impl<'a> Playground<'a> {
pub fn root(&self) -> &Path {
self.root.path()
pub fn root(&self) -> &AbsolutePath {
&self.dirs.root
}
pub fn cwd(&self) -> &Path {
pub fn cwd(&self) -> &AbsolutePath {
&self.cwd
}
pub fn back_to_playground(&mut self) -> &mut Self {
self.cwd = PathBuf::from(self.root()).join(self.tests.clone());
self.cwd = self.root().join(&self.tests);
self
}
@ -70,62 +70,40 @@ impl<'a> Playground<'a> {
}
pub fn setup(topic: &str, block: impl FnOnce(Dirs, &mut Playground)) {
let root = tempdir().expect("Couldn't create a tempdir");
let nuplay_dir = root.path().join(topic);
let temp = tempdir().expect("Could not create a tempdir");
if PathBuf::from(&nuplay_dir).exists() {
std::fs::remove_dir_all(PathBuf::from(&nuplay_dir)).expect("can not remove directory");
let root = AbsolutePathBuf::try_from(temp.path())
.expect("Tempdir is not an absolute path")
.canonicalize()
.expect("Could not canonicalize tempdir");
let test = root.join(topic);
if test.exists() {
std::fs::remove_dir_all(&test).expect("Could not remove directory");
}
std::fs::create_dir(&test).expect("Could not create directory");
let test = test
.canonicalize()
.expect("Could not canonicalize test path");
std::fs::create_dir(PathBuf::from(&nuplay_dir)).expect("can not create directory");
let fixtures = fs::fixtures();
let cwd = std::env::current_dir().expect("Could not get current working directory.");
let fixtures = nu_path::canonicalize_with(fixtures.clone(), cwd).unwrap_or_else(|e| {
panic!(
"Couldn't canonicalize fixtures path {}: {:?}",
fixtures.display(),
e
)
});
let mut playground = Playground {
root,
tests: topic.to_string(),
cwd: nuplay_dir,
config: None,
environment_vars: Vec::default(),
dirs: &Dirs::default(),
};
let playground_root = playground.root.path();
let cwd = std::env::current_dir().expect("Could not get current working directory.");
let test =
nu_path::canonicalize_with(playground_root.join(topic), cwd).unwrap_or_else(|e| {
panic!(
"Couldn't canonicalize test path {}: {:?}",
playground_root.join(topic).display(),
e
)
});
let cwd = std::env::current_dir().expect("Could not get current working directory.");
let root = nu_path::canonicalize_with(playground_root, cwd).unwrap_or_else(|e| {
panic!(
"Couldn't canonicalize tests root path {}: {:?}",
playground_root.display(),
e
)
});
let fixtures = fs::fixtures()
.canonicalize()
.expect("Could not canonicalize fixtures path");
let dirs = Dirs {
root,
test,
fixtures,
root: root.into(),
test: test.as_path().into(),
fixtures: fixtures.into(),
};
playground.dirs = &dirs;
let mut playground = Playground {
_root: temp,
tests: topic.to_string(),
cwd: test.into(),
config: None,
environment_vars: Vec::default(),
dirs: &dirs,
};
block(dirs.clone(), &mut playground);
}
@ -173,8 +151,8 @@ impl<'a> Playground<'a> {
#[cfg(not(target_arch = "wasm32"))]
pub fn symlink(&mut self, from: impl AsRef<Path>, to: impl AsRef<Path>) -> &mut Self {
let from = self.cwd.join(from);
let to = self.cwd.join(to);
let from = self.cwd.join(from.as_ref());
let to = self.cwd.join(to.as_ref());
let create_symlink = {
#[cfg(unix)]

11
crates/nu-test-support/src/playground/tests.rs
View File

@ -1,11 +1,4 @@
use crate::playground::Playground;
use std::path::{Path, PathBuf};
fn path(p: &Path) -> PathBuf {
let cwd = std::env::current_dir().expect("Could not get current working directory.");
nu_path::canonicalize_with(p, cwd)
.unwrap_or_else(|e| panic!("Couldn't canonicalize path {}: {:?}", p.display(), e))
}
#[test]
fn current_working_directory_in_sandbox_directory_created() {
@ -13,7 +6,7 @@ fn current_working_directory_in_sandbox_directory_created() {
let original_cwd = dirs.test();
nu.within("some_directory_within");
assert_eq!(path(nu.cwd()), original_cwd.join("some_directory_within"));
assert_eq!(nu.cwd(), original_cwd.join("some_directory_within"));
})
}
@ -25,6 +18,6 @@ fn current_working_directory_back_to_root_from_anywhere() {
nu.within("some_directory_within");
nu.back_to_playground();
assert_eq!(path(nu.cwd()), *original_cwd);
assert_eq!(nu.cwd(), original_cwd);
})
}

2
tests/plugins/nu_plugin_nu_example.rs
View File

@ -4,7 +4,7 @@ use assert_cmd::Command;
fn call() {
// Add the `nu` binaries to the path env
let path_env = std::env::join_paths(
std::iter::once(nu_test_support::fs::binaries()).chain(
std::iter::once(nu_test_support::fs::binaries().into()).chain(
std::env::var_os(nu_test_support::NATIVE_PATH_ENV_VAR)
.as_deref()
.map(std::env::split_paths)

8
tests/plugins/registry_file.rs
View File

@ -162,7 +162,7 @@ fn plugin_rm_then_restart_nu() {
contents.upsert_plugin(PluginRegistryItem {
name: "foo".into(),
// this doesn't exist, but it should be ok
filename: dirs.test().join("nu_plugin_foo"),
filename: dirs.test().join("nu_plugin_foo").into(),
shell: None,
data: valid_plugin_item_data(),
});
@ -238,7 +238,7 @@ fn plugin_rm_from_custom_path() {
contents.upsert_plugin(PluginRegistryItem {
name: "foo".into(),
// this doesn't exist, but it should be ok
filename: dirs.test().join("nu_plugin_foo"),
filename: dirs.test().join("nu_plugin_foo").into(),
shell: None,
data: valid_plugin_item_data(),
});
@ -286,7 +286,7 @@ fn plugin_rm_using_filename() {
contents.upsert_plugin(PluginRegistryItem {
name: "foo".into(),
// this doesn't exist, but it should be ok
filename: dirs.test().join("nu_plugin_foo"),
filename: dirs.test().join("nu_plugin_foo").into(),
shell: None,
data: valid_plugin_item_data(),
});
@ -344,7 +344,7 @@ fn warning_on_invalid_plugin_item() {
contents.upsert_plugin(PluginRegistryItem {
name: "badtest".into(),
// this doesn't exist, but it should be ok
filename: dirs.test().join("nu_plugin_badtest"),
filename: dirs.test().join("nu_plugin_badtest").into(),
shell: None,
data: PluginRegistryItemData::Invalid,
});