Migrate nu-test-support part 2

crates/nu-command/tests/commands/rm.rs

@@ -1,3 +1,4 @@
+use nu_path::AbsolutePath;
 use nu_test_support::fs::{files_exist_at, Stub::EmptyFile};
 use nu_test_support::nu;
 use nu_test_support::playground::Playground;
@@ -405,10 +406,10 @@ fn removes_file_after_cd() {
 }
 
 struct Cleanup<'a> {
-    dir_to_clean: &'a Path,
+    dir_to_clean: &'a AbsolutePath,
 }
 
-fn set_dir_read_only(directory: &Path, read_only: bool) {
+fn set_dir_read_only(directory: &AbsolutePath, read_only: bool) {
     let mut permissions = fs::metadata(directory).unwrap().permissions();
     permissions.set_readonly(read_only);
     fs::set_permissions(directory, permissions).expect("failed to set directory permissions");
@@ -437,7 +438,7 @@ fn rm_prints_filenames_on_error() {
             .collect();
         sandbox.with_files(&with_files);
 
-        let test_dir = dirs.test().as_std_path();
+        let test_dir = dirs.test();
 
         set_dir_read_only(test_dir, true);
         let _cleanup = Cleanup {

crates/nu-command/tests/commands/source_env.rs

@@ -10,7 +10,7 @@ fn sources_also_files_under_custom_lib_dirs_path() {
         let file = dirs.test().join("config.toml");
         let library_path = dirs.test().join("lib");
 
-        nu.with_config(&file);
+        nu.with_config(file);
         nu.with_files(&[FileWithContent(
             "config.toml",
             &format!(

crates/nu-test-support/src/fs.rs

@@ -1,6 +1,5 @@
-use nu_path::AbsolutePathBuf;
+use nu_path::{AbsolutePath, AbsolutePathBuf, Path};
 use std::io::Read;
-use std::path::{Path, PathBuf};
 
 pub enum Stub<'a> {
     FileWithContent(&'a str, &'a str),
@@ -9,7 +8,7 @@ pub enum Stub<'a> {
     FileWithPermission(&'a str, bool),
 }
 
-pub fn file_contents(full_path: impl AsRef<Path>) -> String {
+pub fn file_contents(full_path: impl AsRef<AbsolutePath>) -> String {
     let mut file = std::fs::File::open(full_path.as_ref()).expect("can not open file");
     let mut contents = String::new();
     file.read_to_string(&mut contents)
@@ -17,7 +16,7 @@ pub fn file_contents(full_path: impl AsRef<Path>) -> String {
     contents
 }
 
-pub fn file_contents_binary(full_path: impl AsRef<Path>) -> Vec<u8> {
+pub fn file_contents_binary(full_path: impl AsRef<AbsolutePath>) -> Vec<u8> {
     let mut file = std::fs::File::open(full_path.as_ref()).expect("can not open file");
     let mut contents = Vec::new();
     file.read_to_end(&mut contents).expect("can not read file");
@@ -36,49 +35,24 @@ pub fn line_ending() -> String {
     }
 }
 
-pub fn delete_file_at(full_path: impl AsRef<Path>) {
+pub fn files_exist_at(files: Vec<impl AsRef<Path>>, path: impl AsRef<AbsolutePath>) -> bool {
-    let full_path = full_path.as_ref();
+    let path = path.as_ref();
-
+    files.iter().all(|f| path.join(f.as_ref()).exists())
-    if full_path.exists() {
-        std::fs::remove_file(full_path).expect("can not delete file");
-    }
 }
 
-pub fn create_file_at(full_path: impl AsRef<Path>) -> Result<(), std::io::Error> {
+pub fn executable_path() -> AbsolutePathBuf {
-    let full_path = full_path.as_ref();
-
-    if full_path.parent().is_some() {
-        panic!("path exists");
-    }
-
-    std::fs::write(full_path, b"fake data")
-}
-
-pub fn copy_file_to(source: &str, destination: &str) {
-    std::fs::copy(source, destination).expect("can not copy file");
-}
-
-pub fn files_exist_at(files: Vec<impl AsRef<Path>>, path: impl AsRef<Path>) -> bool {
-    files.iter().all(|f| {
-        let mut loc = PathBuf::from(path.as_ref());
-        loc.push(f);
-        loc.exists()
-    })
-}
-
-pub fn delete_directory_at(full_path: &str) {
-    std::fs::remove_dir_all(PathBuf::from(full_path)).expect("can not remove directory");
-}
-
-pub fn executable_path() -> PathBuf {
     let mut path = binaries();
     path.push("nu");
-    path.into()
+    path
 }
 
-pub fn installed_nu_path() -> PathBuf {
+pub fn installed_nu_path() -> AbsolutePathBuf {
     let path = std::env::var_os(crate::NATIVE_PATH_ENV_VAR);
-    which::which_in("nu", path, ".").unwrap_or_else(|_| executable_path())
+    if let Ok(path) = which::which_in("nu", path, ".") {
+        AbsolutePathBuf::try_from(path).expect("installed nushell path is absolute")
+    } else {
+        executable_path()
+    }
 }
 
 pub fn root() -> AbsolutePathBuf {
@@ -122,20 +96,20 @@ pub fn binaries() -> AbsolutePathBuf {
 }
 
 pub fn fixtures() -> AbsolutePathBuf {
-    root().join("tests").join("fixtures")
+    let mut path = root();
+    path.push("tests");
+    path.push("fixtures");
+    path
 }
 
-pub fn assets() -> AbsolutePathBuf {
+// FIXME: re-enable nu_json tests
-    root().join("tests").join("assets")
+// pub fn assets() -> AbsolutePathBuf {
-}
+//     let mut path = root();
+//     path.push("tests");
+//     path.push("assets");
+//     path
+// }
 
-pub fn in_directory(str: impl AsRef<Path>) -> String {
+pub fn in_directory(path: impl AsRef<nu_path::Path>) -> AbsolutePathBuf {
-    let path = str.as_ref();
+    root().join(path)
-    let path = if path.is_relative() {
-        root().join(path).into_any()
-    } else {
-        path.into()
-    };
-
-    path.display().to_string()
 }

crates/nu-test-support/src/macros.rs

@@ -234,35 +234,28 @@ macro_rules! nu_with_plugins {
 }
 
 use crate::{Outcome, NATIVE_PATH_ENV_VAR};
-use std::ffi::OsStr;
+use nu_path::{AbsolutePath, AbsolutePathBuf, Path};
 use std::{
-    path::Path,
+    ffi::OsStr,
     process::{Command, Stdio},
 };
 use tempfile::tempdir;
 
 #[derive(Default)]
 pub struct NuOpts {
-    pub cwd: Option<String>,
+    pub cwd: Option<AbsolutePathBuf>,
     pub locale: Option<String>,
     pub envs: Option<Vec<(String, String)>>,
     pub collapse_output: Option<bool>,
 }
 
 pub fn nu_run_test(opts: NuOpts, commands: impl AsRef<str>, with_std: bool) -> Outcome {
-    let test_bins = crate::fs::binaries();
+    let test_bins = crate::fs::binaries()
-
+        .canonicalize()
-    let cwd = std::env::current_dir().expect("Could not get current working directory.");
+        .expect("Could not canonicalize dummy binaries path");
-    let test_bins = nu_path::canonicalize_with(&test_bins, cwd).unwrap_or_else(|e| {
-        panic!(
-            "Couldn't canonicalize dummy binaries path {}: {:?}",
-            test_bins.display(),
-            e
-        )
-    });
 
     let mut paths = crate::shell_os_paths();
-    paths.insert(0, test_bins);
+    paths.insert(0, test_bins.into());
 
     let commands = commands.as_ref().lines().collect::<Vec<_>>().join("; ");
 
@@ -271,7 +264,7 @@ pub fn nu_run_test(opts: NuOpts, commands: impl AsRef<str>, with_std: bool) -> O
         Err(_) => panic!("Couldn't join paths for PATH var."),
     };
 
-    let target_cwd = opts.cwd.unwrap_or(".".to_string());
+    let target_cwd = opts.cwd.unwrap_or_else(crate::fs::root);
     let locale = opts.locale.unwrap_or("en_US.UTF-8".to_string());
     let executable_path = crate::fs::executable_path();
 
@@ -439,7 +432,7 @@ fn collapse_output(out: &str) -> String {
     out.replace('\n', "")
 }
 
-fn setup_command(executable_path: &Path, target_cwd: &str) -> Command {
+fn setup_command(executable_path: &AbsolutePath, target_cwd: &AbsolutePath) -> Command {
     let mut command = Command::new(executable_path);
 
     command

crates/nu-test-support/src/playground.rs

@@ -6,5 +6,5 @@ mod play;
 mod tests;
 
 pub use director::Director;
-pub use nu_process::{Executable, NuProcess, NuResult, Outcome};
+pub use nu_process::{Executable, NuProcess, Outcome};
 pub use play::{Dirs, EnvironmentVariable, Playground};

crates/nu-test-support/src/playground/director.rs

@@ -83,7 +83,7 @@ impl Director {
 }
 
 impl Executable for Director {
-    fn execute(&mut self) -> NuResult {
+    fn execute(&mut self) -> Result<Outcome, NuError> {
         use std::process::Stdio;
 
         match self.executable() {

crates/nu-test-support/src/playground/nu_process.rs

@@ -1,12 +1,13 @@
 use super::EnvironmentVariable;
 use crate::fs::{binaries as test_bins_path, executable_path};
-use std::ffi::{OsStr, OsString};
+use std::{
-use std::fmt;
+    ffi::{OsStr, OsString},
-use std::path::Path;
+    fmt,
-use std::process::{Command, ExitStatus};
+    process::{Command, ExitStatus},
+};
 
 pub trait Executable {
-    fn execute(&mut self) -> NuResult;
+    fn execute(&mut self) -> Result<Outcome, NuError>;
 }
 
 #[derive(Clone, Debug)]
@@ -24,8 +25,6 @@ impl Outcome {
     }
 }
 
-pub type NuResult = Result<Outcome, NuError>;
-
 #[derive(Debug)]
 pub struct NuError {
     pub desc: String,
@@ -69,14 +68,10 @@ impl NuProcess {
         self
     }
 
-    pub fn get_cwd(&self) -> Option<&Path> {
-        self.cwd.as_ref().map(Path::new)
-    }
-
     pub fn construct(&self) -> Command {
         let mut command = Command::new(executable_path());
 
-        if let Some(cwd) = self.get_cwd() {
+        if let Some(cwd) = &self.cwd {
             command.current_dir(cwd);
         }
 

crates/nu-test-support/src/playground/play.rs

@@ -1,8 +1,9 @@
 use super::Director;
 use crate::fs::{self, Stub};
 use nu_glob::glob;
+#[cfg(not(target_arch = "wasm32"))]
+use nu_path::Path;
 use nu_path::{AbsolutePath, AbsolutePathBuf};
-use std::path::{Path, PathBuf};
 use std::str;
 use tempfile::{tempdir, TempDir};
 
@@ -25,7 +26,7 @@ pub struct Playground<'a> {
     _root: TempDir,
     tests: String,
     cwd: AbsolutePathBuf,
-    config: Option<PathBuf>,
+    config: Option<AbsolutePathBuf>,
     environment_vars: Vec<EnvironmentVariable>,
     dirs: &'a Dirs,
 }
@@ -108,8 +109,8 @@ impl<'a> Playground<'a> {
         block(dirs.clone(), &mut playground);
     }
 
-    pub fn with_config(&mut self, source_file: impl AsRef<Path>) -> &mut Self {
+    pub fn with_config(&mut self, source_file: AbsolutePathBuf) -> &mut Self {
-        self.config = Some(source_file.as_ref().to_path_buf());
+        self.config = Some(source_file);
         self
     }
 
@@ -151,8 +152,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.as_ref());
+        let from = self.cwd.join(from);
-        let to = self.cwd.join(to.as_ref());
+        let to = self.cwd.join(to);
 
         let create_symlink = {
             #[cfg(unix)]
@@ -183,7 +184,6 @@ impl<'a> Playground<'a> {
         files
             .iter()
             .map(|f| {
-                let mut path = PathBuf::from(&self.cwd);
                 let mut permission_set = false;
                 let mut write_able = true;
                 let (file_name, contents) = match *f {
@@ -205,7 +205,7 @@ impl<'a> Playground<'a> {
                     }
                 };
 
-                path.push(file_name);
+                let path = self.cwd.join(file_name);
 
                 std::fs::write(&path, contents.as_bytes()).expect("can not create file");
                 if permission_set {
@@ -230,7 +230,7 @@ impl<'a> Playground<'a> {
         self
     }
 
-    pub fn glob_vec(pattern: &str) -> Vec<PathBuf> {
+    pub fn glob_vec(pattern: &str) -> Vec<std::path::PathBuf> {
         let glob = glob(pattern);
 
         glob.expect("invalid pattern")