commit 89cf19042172c9c8475c6334079edeb01d329238
parent eeefb789d1597e532c7b5bafad6ede78ac5859ef
Author: Asher Morgan <59518073+ashermorgan@users.noreply.github.com>
Date: Sun, 30 Jun 2024 19:49:29 -0700
Reorganize test temporary directories
Diffstat:
11 files changed, 641 insertions(+), 244 deletions(-)
diff --git a/.gitignore b/.gitignore
@@ -1 +1,7 @@
/target
+
+# Temporary directories used for testing
+/tests/.temp/home/*
+/tests/.temp/local/*
+/tests/.temp/ssh/*
+!/tests/.temp/ssh/.gitkeep
diff --git a/src/core.rs b/src/core.rs
@@ -3,7 +3,7 @@ use std::path::Path;
use super::manifest::{CopyLinkOptions, RunOptions, Manifest, parse_manifest_file
};
use super::tags::tags_match;
-use super::utils::{copy_file, link_file, run_script};
+use super::local::{copy_file, link_file, run_script};
/// Execute the steps in a coliru manifest file according to a set of tag rules
pub fn execute_manifest_file(path: &Path, tag_rules: Vec<String>, host: &str,
diff --git a/src/local.rs b/src/local.rs
@@ -0,0 +1,363 @@
+use shellexpand::tilde;
+use std::io;
+use std::fs;
+#[cfg(target_family = "unix")]
+use std::os::unix::fs::symlink;
+use std::path::{PathBuf, absolute};
+use std::process::Command;
+
+/// Copies the contents of a local file to another local file.
+///
+/// Tildes are expanded if present and the destination file is overwritten if
+/// necessary.
+pub fn copy_file(src: &str, dst: &str) -> io::Result<()> {
+ if absolute(src)? == absolute(dst)? { return Ok(()); }
+ let _dst = prepare_path(dst)?;
+ fs::copy(src, _dst)?;
+ Ok(())
+}
+
+/// Creates a symbolic link to a local file.
+///
+/// Tildes are expanded if present and the destination file is overwritten if
+/// necessary. On non-Unix platforms, a hard link will be created instead.
+#[cfg(target_family = "unix")]
+pub fn link_file(src: &str, dst: &str) -> io::Result<()> {
+ if absolute(src)? == absolute(dst)? { return Ok(()); }
+ let _dst = prepare_path(dst)?;
+ symlink(fs::canonicalize(src)?, _dst)?;
+ Ok(())
+}
+#[cfg(not(target_family = "unix"))]
+pub fn link_file(src: &str, dst: &str) -> io::Result<()> {
+ if absolute(src)? == absolute(dst)? { return Ok(()); }
+ let _dst = prepare_path(dst)?;
+ fs::hard_link(src, _dst)?;
+ Ok(())
+}
+
+/// Creates the parent directories of a path and return the path with tildes
+/// expanded.
+fn prepare_path(path: &str) -> io::Result<PathBuf> {
+ let _dst: PathBuf = (&tilde(path).to_mut()).into();
+ if let Some(_path) = _dst.parent() {
+ fs::create_dir_all(_path)?;
+ }
+ if fs::symlink_metadata(&_dst).is_ok() {
+ // Check for existing files, including broken symlinks
+ fs::remove_file(&_dst)?;
+ }
+ Ok(_dst)
+}
+
+/// Executes a local shell script, optionally with a command prefix or postfix.
+///
+/// Uses sh on Unix and PowerShell on Windows.
+pub fn run_script(path: &str, prefix: &str, postfix: &str) -> Result<(), String>
+{
+ // Use absolute() to avoid incompatible "UNC" paths on Windows:
+ // https://github.com/rust-lang/rust/issues/42869
+ let _path = absolute(path).map_err(|why| why.to_string())?;
+ let status;
+ if cfg!(target_family = "unix") {
+ status = Command::new("sh")
+ .arg("-c")
+ .arg(format!("{} {} {}", prefix, _path.display(), postfix))
+ .status()
+ .map_err(|why| why.to_string())?;
+ } else {
+ status = Command::new("powershell")
+ .args(["-ExecutionPolicy", "Bypass", "-Command"])
+ .arg(format!("{} {} {}", prefix, _path.display(), postfix))
+ .status()
+ .map_err(|why| why.to_string())?;
+ }
+ if status.success() {
+ Ok(())
+ } else {
+ Err(format!("Process exited with {status}"))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::common::{setup_integration, write_file};
+
+ #[test]
+ fn test_copy_file_create_dirs() {
+ let tmp = setup_integration("test_copy_file_create_dirs");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("dir1").join("dir2").join("bar");
+ write_file(src, "old contents of foo");
+
+ let result = copy_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "old contents of foo");
+ }
+
+ #[test]
+ fn test_copy_file_same_file() {
+ let tmp = setup_integration("test_copy_file_same_file");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("foo");
+ write_file(src, "contents of foo");
+
+ let result = copy_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "contents of foo");
+ }
+
+ #[test]
+ fn test_copy_file_existing_file() {
+ let tmp = setup_integration("test_copy_file_existing_file");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("bar");
+ write_file(src, "old contents of foo");
+ write_file(dst, "old contents of bar");
+
+ let result = copy_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "old contents of foo");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_copy_file_existing_broken_symlink() {
+ let tmp = setup_integration("test_copy_file_existing_broken_symlink");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("bar");
+ write_file(src, "old contents of foo");
+ symlink("missing", dst).unwrap();
+
+ let result = copy_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "old contents of foo");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_copy_file_tilde_expansion() {
+ let tmp = setup_integration("test_copy_file_tilde_expansion");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.home.join("dir").join("bar");
+ let dst_tilde = "~/test_copy_file_tilde_expansion/dir/bar";
+ write_file(src, "old contents of foo");
+
+ let result = copy_file(src.to_str().unwrap(), dst_tilde);
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "old contents of foo");
+ }
+
+ #[test]
+ fn test_link_file_create_dirs() {
+ let tmp = setup_integration("test_link_file_create_dirs");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("dir1").join("dir2").join("bar");
+ write_file(src, "old contents of foo");
+
+ let result = link_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "new contents of foo");
+ }
+
+ #[test]
+ fn test_link_file_same_file() {
+ let tmp = setup_integration("test_link_file_same_file");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("foo");
+ write_file(src, "contents of foo");
+
+ let result = link_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "contents of foo");
+ }
+
+ #[test]
+ fn test_link_file_existing_file() {
+ let tmp = setup_integration("test_link_file_existing_file");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("bar");
+ write_file(src, "old contents of foo");
+ write_file(dst, "old contents of bar");
+
+ let result = link_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "new contents of foo");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_link_file_existing_broken_symlink() {
+ let tmp = setup_integration("test_link_file_existing_broken_symlink");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("bar");
+ write_file(src, "old contents of foo");
+ symlink("missing", dst).unwrap();
+
+ let result = link_file(src.to_str().unwrap(), dst.to_str().unwrap());
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "new contents of foo");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_link_file_tilde_expansion() {
+ let tmp = setup_integration("test_link_file_tilde_expansion");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.home.join("dir").join("bar");
+ let dst_tilde = "~/test_link_file_tilde_expansion/dir/bar";
+ write_file(src, "old contents of foo");
+
+ let result = link_file(src.to_str().unwrap(), dst_tilde);
+
+ write_file(src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "new contents of foo");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_link_file_relative_source() {
+ let dir = PathBuf::from("tests/.temp/ssh/test_link_file_relative_source");
+ fs::create_dir_all(&dir).unwrap();
+
+ let src = absolute(&dir.join("foo")).unwrap();
+ let src_rel = "tests/.temp/ssh/test_link_file_relative_source/foo";
+ let dst = &dir.join("dir1").join("dir2").join("bar");
+ write_file(&src, "old contents of foo");
+
+ let result = link_file(src_rel, dst.to_str().unwrap());
+
+ write_file(&src, "new contents of foo");
+ let contents = fs::read_to_string(dst).unwrap();
+ let link = fs::read_link(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "new contents of foo");
+ assert_eq!(link, src); // src changed to absolute path
+
+ fs::remove_dir_all(&dir).unwrap();
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_run_script_successful() {
+ let tmp = setup_integration("test_run_script_successful");
+
+ let src = &tmp.local.join("foo");
+ write_file(src, "exit 0");
+
+ let result = run_script(src.to_str().unwrap(), "sh", "");
+
+ assert_eq!(result.is_ok(), true);
+ }
+
+ #[test]
+ #[cfg(target_family = "windows")]
+ fn test_run_script_successful() {
+ let tmp = setup_integration("test_run_script_successful");
+
+ let src = &tmp.local.join("foo.bat");
+ write_file(src, "exit 0");
+
+ let result = run_script(src.to_str().unwrap(), "", "");
+
+ assert_eq!(result.is_ok(), true);
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_run_script_failure() {
+ let tmp = setup_integration("test_run_script_failure");
+
+ let src = &tmp.local.join("foo");
+ write_file(src, "exit 2");
+
+ let result = run_script(src.to_str().unwrap(), "sh", "");
+
+ assert_eq!(result.is_ok(), false);
+ assert_eq!(result.unwrap_err(), "Process exited with exit status: 2");
+ }
+
+ #[test]
+ #[cfg(target_family = "windows")]
+ fn test_run_script_failure() {
+ let tmp = setup_integration("test_run_script_failure");
+
+ let src = &tmp.local.join("foo.bat");
+ write_file(src, "exit 1");
+
+ let result = run_script(src.to_str().unwrap(), "", "");
+
+ assert_eq!(result.is_ok(), false);
+ assert_eq!(result.unwrap_err(), "Process exited with exit code: 1");
+ }
+
+ #[test]
+ #[cfg(target_family = "unix")]
+ fn test_run_script_postfix() {
+ let tmp = setup_integration("test_run_script_postfix");
+
+ let src = &tmp.local.join("foo");
+ let dst = &tmp.local.join("bar");
+ write_file(src, &format!("echo $@ > {}", dst.to_str().unwrap()));
+
+ let result = run_script(src.to_str().unwrap(), "sh", "arg1 arg2");
+
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "arg1 arg2\n");
+ }
+
+ #[test]
+ #[cfg(target_family = "windows")]
+ fn test_run_script_postfix() {
+ let tmp = setup_integration("test_run_script_postfix");
+
+ let src = &tmp.local.join("foo.bat");
+ let dst = &tmp.local.join("bar");
+ write_file(src, &format!("echo %* > {}", dst.to_str().unwrap()));
+
+ let result = run_script(src.to_str().unwrap(), "", "arg1 arg2");
+
+ let contents = fs::read_to_string(dst).unwrap();
+ assert_eq!(result.is_ok(), true);
+ assert_eq!(contents, "arg1 arg2 \r\n");
+ }
+}
diff --git a/src/main.rs b/src/main.rs
@@ -1,9 +1,13 @@
mod cli;
mod core;
+mod local;
mod manifest;
mod ssh;
mod tags;
-mod utils;
+
+#[cfg(test)]
+#[path = "../tests/common/mod.rs"]
+mod common; // Re-use e2e test utils for integration tests
fn main() {
cli::run();
diff --git a/src/ssh.rs b/src/ssh.rs
@@ -19,62 +19,43 @@ fn send_dir(src: &str, dst: &str, host: &str) -> Result<(), String> {
}
#[cfg(test)]
-#[path = "../tests/common/mod.rs"]
-mod common;
-
-#[cfg(test)]
#[cfg(target_family = "unix")]
mod tests {
use super::*;
- use common::{SSH_HOST, read_file, setup_integration, write_file};
+ use crate::common::{SSH_HOST, read_file, setup_integration, write_file};
use std::fs;
- use std::path::PathBuf;
#[test]
fn test_send_dir_basic() {
let tmp = setup_integration("test_send_dir_basic");
- write_file(&tmp.dir.join("foo"), "contents of foo");
- write_file(&tmp.dir.join("bar"), "contents of bar");
- let dst = "~/test_send_dir_basic";
- let dst_real = PathBuf::from("tests/.temp/ssh/test_send_dir_basic");
- if dst_real.exists() {
- fs::remove_dir_all(&dst_real).unwrap();
- }
+ write_file(&tmp.local.join("foo"), "contents of foo");
+ write_file(&tmp.local.join("bar"), "contents of bar");
- let result = send_dir(tmp.dir.to_str().unwrap(), dst, SSH_HOST);
+ let result = send_dir(&tmp.local.to_str().unwrap(), "~/", SSH_HOST);
assert_eq!(result.is_ok(), true);
- let contents1 = read_file(&dst_real.join("foo"));
+ let contents1 = read_file(&tmp.ssh.join("foo"));
assert_eq!(contents1, "contents of foo");
- let contents2 = read_file(&dst_real.join("bar"));
+ let contents2 = read_file(&tmp.ssh.join("bar"));
assert_eq!(contents2, "contents of bar");
-
- fs::remove_dir_all(&dst_real).unwrap();
}
#[test]
fn test_send_dir_nested() {
let tmp = setup_integration("test_send_dir_nested");
- write_file(&tmp.dir.join("foo"), "contents of foo");
- fs::create_dir_all(&tmp.dir.join("dir")).unwrap();
- write_file(&tmp.dir.join("dir").join("bar"), "contents of bar");
- let dst = "~/test_send_dir_nested";
- let dst_real = PathBuf::from("tests/.temp/ssh/test_send_dir_nested");
- if dst_real.exists() {
- fs::remove_dir_all(&dst_real).unwrap();
- }
+ write_file(&tmp.local.join("foo"), "contents of foo");
+ fs::create_dir_all(&tmp.local.join("dir")).unwrap();
+ write_file(&tmp.local.join("dir").join("bar"), "contents of bar");
- let result = send_dir(tmp.dir.to_str().unwrap(), dst, SSH_HOST);
+ let result = send_dir(tmp.local.to_str().unwrap(), "~/", SSH_HOST);
assert_eq!(result.is_ok(), true);
- let contents1 = read_file(&dst_real.join("foo"));
+ let contents1 = read_file(&tmp.ssh.join("foo"));
assert_eq!(contents1, "contents of foo");
- let contents2 = read_file(&dst_real.join("dir").join("bar"));
+ let contents2 = read_file(&tmp.ssh.join("dir").join("bar"));
assert_eq!(contents2, "contents of bar");
-
- fs::remove_dir_all(&dst_real).unwrap();
}
}
diff --git a/tests/.temp/ssh/.gitignore b/tests/.temp/ssh/.gitignore
@@ -1,6 +0,0 @@
-# This directory is mounted to the SSH docker container used for E2E tests. All
-# children are ignored, but the .gitignore file guarantees that the directory
-# will exist.
-
-./*
-!.gitignore
diff --git a/tests/.temp/ssh/.gitkeep b/tests/.temp/ssh/.gitkeep
@@ -0,0 +1,3 @@
+# This directory is mounted to the SSH docker container used for E2E tests. All
+# children are ignored, but this file guarantees that the directory will exist
+# on a fresh clone.
diff --git a/tests/basic.rs b/tests/basic.rs
@@ -8,7 +8,7 @@ use std::env::consts::EXE_SUFFIX;
#[test]
fn test_basic_help() {
- let (_dir, mut cmd) = setup_e2e("test_basic_help");
+ let (_dirs, mut cmd) = setup_e2e("test_basic_help");
cmd.arg("--help");
let expected = format!("\
A minimal, flexible, dotfile installer
@@ -32,9 +32,9 @@ Options:
#[test]
fn test_basic_empty_manifest() {
- let (dir, mut cmd) = setup_e2e("test_basic_empty_manifest");
+ let (dirs, mut cmd) = setup_e2e("test_basic_empty_manifest");
cmd.args(["manifest.yml"]);
- write_file(&dir.dir.join("manifest.yml"), "");
+ write_file(&dirs.local.join("manifest.yml"), "");
let expected = "Error: missing field `steps`\n";
assert_eq!(&stdout_to_string(&mut cmd), "");
@@ -44,7 +44,7 @@ fn test_basic_empty_manifest() {
#[test]
#[cfg(target_family = "unix")]
fn test_basic_missing_manifest() {
- let (_dir, mut cmd) = setup_e2e("test_basic_missing_manifest");
+ let (_dirs, mut cmd) = setup_e2e("test_basic_missing_manifest");
cmd.args(["missing.yml"]);
let expected = "Error: No such file or directory (os error 2)\n";
@@ -55,7 +55,7 @@ fn test_basic_missing_manifest() {
#[test]
#[cfg(target_family = "windows")]
fn test_basic_missing_manifest() {
- let (_dir, mut cmd) = setup_e2e("test_basic_missing_manifest");
+ let (_dirs, mut cmd) = setup_e2e("test_basic_missing_manifest");
cmd.args(["missing.yml"]);
let expected = "Error: The system cannot find the file specified. \
@@ -66,10 +66,10 @@ fn test_basic_missing_manifest() {
#[test]
fn test_basic_absolute_manifest() {
- let (dir, mut cmd) = setup_e2e("test_basic_absolute_manifest");
- let manifest_path = dir.dir.join("manifest.yml");
+ let (dirs, mut cmd) = setup_e2e("test_basic_absolute_manifest");
+ let manifest_path = dirs.local.join("manifest.yml");
cmd.args([&manifest_path.to_str().unwrap(), "--dry-run", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru (DRY RUN)
@@ -81,11 +81,11 @@ fn test_basic_absolute_manifest() {
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_exists = dir.dir.join(".gitconfig.coliru").exists();
- let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_exists = dir.dir.join("log.txt").exists();
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_exists = dirs.local.join(".gitconfig.coliru").exists();
+ let vim1_exists = dirs.local.join(".vimrc.coliru").exists();
+ let vim2_exists = dirs.local.join("_vimrc.coliru").exists();
+ let log_exists = dirs.local.join("log.txt").exists();
assert_eq!(bash_exists, false);
assert_eq!(git_exists, false);
assert_eq!(vim1_exists, false);
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
@@ -9,66 +9,83 @@ use std::process::Command;
/// The SSH test server
pub const SSH_HOST: &str = "test@localhost"; // TODO: add explicit port
-/// Stores the path to a temporary directory that is automatically deleted
-/// when the value is dropped.
-///
-/// Adapted from ripgrep's tests (crates/ignore/src/lib.rs)
+/// A set of temporary directories that are automatically deleted when the value
+/// is dropped
pub struct TempDir {
- pub dir: PathBuf
+ /// A temporary directory that is located at or in $HOME on Unix
+ pub home: PathBuf,
+
+ /// A temporary directory that is located at or under the CWD
+ pub local: PathBuf,
+
+ /// A temporary directory that is mounted to the SSH server under $HOME
+ pub ssh: PathBuf,
}
impl Drop for TempDir {
fn drop(&mut self) {
- fs::remove_dir_all(&self.dir).unwrap();
+ fs::remove_dir_all(&self.ssh).unwrap();
+ fs::remove_dir_all(&self.local).unwrap();
+ fs::remove_dir_all(&self.home).unwrap();
}
}
impl TempDir {
fn new(name: &str) -> TempDir {
- let dir = env::temp_dir().join("coliru-tests").join(name);
- assert_eq!(dir.exists(), false);
- fs::create_dir_all(&dir).unwrap();
- TempDir { dir }
+ // The CWD of the current process is always the repository root
+ let dir = env::current_dir().unwrap().join("tests").join(".temp");
+
+ let home = dir.join("home").join(name);
+ let local = dir.join("local").join(name);
+ let ssh = dir.join("ssh").join(name);
+
+ assert_eq!(home.exists(), false);
+ assert_eq!(local.exists(), false);
+ assert_eq!(ssh.exists(), false);
+
+ fs::create_dir_all(&home).unwrap();
+ fs::create_dir_all(&local).unwrap();
+ fs::create_dir_all(&ssh).unwrap();
+
+ TempDir { home, local, ssh }
}
}
-/// Creates a temporary directory with a certain name and sets $HOME to the
-/// parent directory.
+/// Initializes temporary directories for integration tests
///
-/// All tests in this module use the same values for $HOME, which prevents
-/// issues when tests are run in multiple threads.
+/// On Unix, $HOME is set to the parent directory of the home temporary
+/// directory, which is the same for all integration tests. This prevents issues
+/// when tests are run in multiple threads.
pub fn setup_integration(name: &str) -> TempDir {
- let dir = TempDir::new(name);
- let root = dir.dir.parent().unwrap();
+ let dirs = TempDir::new(name);
if cfg!(target_family = "unix") {
- env::set_var("HOME", root);
+ env::set_var("HOME", dirs.home.parent().unwrap());
}
- dir
+ dirs
}
-/// Creates a temporary directory with a certain name and create a new coliru
-/// Command with $HOME and the CWD set the the temporary directory.
+/// Initializes temporary directories and a coliru Command for e2e tests
///
-/// Adapted from ripgrep's tests (tests/utils.rs)
+/// The Command's CWD is set to the local temporary directory, and on Unix, the
+/// Command's $HOME variable is set to the home temporary directory.
pub fn setup_e2e(name: &str) -> (TempDir, Command) {
- let dir = TempDir::new(name);
+ let dirs = TempDir::new(name);
let exe = env::current_exe().unwrap().parent().unwrap().to_path_buf()
.join(format!("../coliru{}", env::consts::EXE_SUFFIX));
let mut cmd = Command::new(exe);
- cmd.current_dir(&dir.dir);
-
+ cmd.current_dir(&dirs.local);
if cfg!(target_family = "unix") {
- cmd.env("HOME", &dir.dir);
+ cmd.env("HOME", &dirs.home);
}
- (dir, cmd)
+ (dirs, cmd)
}
-/// Prepares a temporary directory and a new Command for an e2e test, with the
-/// --host argument already provided
+/// Initializes temporary directories and a coliru Command with the --host
+/// argument set for e2e tests
pub fn setup_e2e_ssh(name: &str) -> (TempDir, Command) {
- let (dir, mut cmd) = setup_e2e(name);
+ let (dirs, mut cmd) = setup_e2e(name);
cmd.args(["--host", SSH_HOST]);
- (dir, cmd)
+ (dirs, cmd)
}
/// Create a basic manifest file and its associated dotfiles in a directory
diff --git a/tests/local.rs b/tests/local.rs
@@ -9,9 +9,9 @@ use std::fs::remove_file;
#[test]
#[cfg(target_family = "unix")]
fn test_local_standard() {
- let (dir, mut cmd) = setup_e2e("test_local_standard");
+ let (dirs, mut cmd) = setup_e2e("test_local_standard");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru
@@ -24,14 +24,14 @@ script.sh called with arg1 linux
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_contents = read_file(&dirs.home.join(".gitconfig.coliru"));
+ let vim1_contents = read_file(&dirs.home.join(".vimrc.coliru"));
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_contents, "bash #2");
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_contents, "vim #2");
@@ -42,9 +42,9 @@ script.sh called with arg1 linux
#[test]
#[cfg(target_family = "windows")]
fn test_local_standard() {
- let (dir, mut cmd) = setup_e2e("test_local_standard");
+ let (dirs, mut cmd) = setup_e2e("test_local_standard");
cmd.args(["manifest-windows-test.yml", "-t", "windows"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to .gitconfig.coliru
@@ -56,13 +56,13 @@ script.bat called with arg1 windows\r
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- let vim2_contents = read_file(&dir.dir.join("_vimrc.coliru"));
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_contents = read_file(&dirs.local.join(".gitconfig.coliru"));
+ let vim1_exists = dirs.local.join(".vimrc.coliru").exists();
+ let vim2_contents = read_file(&dirs.local.join("_vimrc.coliru"));
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_exists, false);
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_exists, false);
@@ -73,9 +73,9 @@ script.bat called with arg1 windows\r
#[test]
#[cfg(target_family = "unix")]
fn test_local_run_alternate_tag_rules_1() {
- let (dir, mut cmd) = setup_e2e("test_local_run_alternate_tag_rules_1");
+ let (dirs, mut cmd) = setup_e2e("test_local_run_alternate_tag_rules_1");
cmd.args(["manifest.yml", "-t", "linux", "^windows"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[2/3] Link bashrc to ~/.bashrc.coliru
@@ -87,13 +87,13 @@ script.sh called with arg1 linux ^windows
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_exists = dir.dir.join(".gitconfig.coliru").exists();
- let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_exists = dirs.home.join(".gitconfig.coliru").exists();
+ let vim1_contents = read_file(&dirs.home.join(".vimrc.coliru"));
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_contents, "bash #2");
assert_eq!(git_exists, false);
assert_eq!(vim1_contents, "vim #2");
@@ -104,9 +104,9 @@ script.sh called with arg1 linux ^windows
#[test]
#[cfg(target_family = "unix")]
fn test_local_run_alternate_tag_rules_2() {
- let (dir, mut cmd) = setup_e2e("test_local_run_alternate_tag_rules_2");
+ let (dirs, mut cmd) = setup_e2e("test_local_run_alternate_tag_rules_2");
cmd.args(["manifest.yml", "-t", "macos"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru
@@ -119,14 +119,14 @@ script.sh called with arg1 macos
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_contents = read_file(&dirs.home.join(".gitconfig.coliru"));
+ let vim1_contents = read_file(&dirs.home.join(".vimrc.coliru"));
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_contents, "bash #2");
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_contents, "vim #2");
@@ -135,10 +135,11 @@ script.sh called with arg1 macos
}
#[test]
+#[cfg(target_family = "unix")]
fn test_local_dry_run() {
- let (dir, mut cmd) = setup_e2e("test_local_dry_run");
+ let (dirs, mut cmd) = setup_e2e("test_local_dry_run");
cmd.args(["manifest.yml", "--dry-run", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru (DRY RUN)
@@ -150,11 +151,39 @@ fn test_local_dry_run() {
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_exists = dir.dir.join(".gitconfig.coliru").exists();
- let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_exists = dir.dir.join("log.txt").exists();
+ let bash_exists = dirs.home.join(".bashrc.coliru").exists();
+ let git_exists = dirs.home.join(".gitconfig.coliru").exists();
+ let vim1_exists = dirs.home.join(".vimrc.coliru").exists();
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
+ let log_exists = dirs.local.join("log.txt").exists();
+ assert_eq!(bash_exists, false);
+ assert_eq!(git_exists, false);
+ assert_eq!(vim1_exists, false);
+ assert_eq!(vim2_exists, false);
+ assert_eq!(log_exists, false);
+}
+
+#[test]
+#[cfg(target_family = "windows")]
+fn test_local_dry_run() {
+ let (dirs, mut cmd) = setup_e2e("test_local_dry_run");
+ cmd.args(["manifest-windows-test.yml", "--dry-run", "-t", "windows"]);
+ copy_manifest(&dirs.local);
+
+ let expected = "\
+[1/3] Copy gitconfig to .gitconfig.coliru (DRY RUN)
+[3/3] Link vimrc to _vimrc.coliru (DRY RUN)
+[3/3] Run script.bat arg1 windows (DRY RUN)
+";
+ assert_eq!(&stdout_to_string(&mut cmd), expected);
+ assert_eq!(&stderr_to_string(&mut cmd), "");
+
+ // Assert files are correctly copied/linked/run
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_exists = dirs.local.join(".gitconfig.coliru").exists();
+ let vim1_exists = dirs.local.join(".vimrc.coliru").exists();
+ let vim2_exists = dirs.local.join("_vimrc.coliru").exists();
+ let log_exists = dirs.local.join("log.txt").exists();
assert_eq!(bash_exists, false);
assert_eq!(git_exists, false);
assert_eq!(vim1_exists, false);
@@ -165,9 +194,9 @@ fn test_local_dry_run() {
#[test]
#[cfg(target_family = "unix")]
fn test_local_copy() {
- let (dir, mut cmd) = setup_e2e("test_local_copy");
+ let (dirs, mut cmd) = setup_e2e("test_local_copy");
cmd.args(["manifest.yml", "--copy", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru
@@ -180,14 +209,14 @@ script.sh called with arg1 linux
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_contents = read_file(&dirs.home.join(".gitconfig.coliru"));
+ let vim1_contents = read_file(&dirs.home.join(".vimrc.coliru"));
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_contents, "bash #1");
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_contents, "vim #1");
@@ -198,9 +227,9 @@ script.sh called with arg1 linux
#[test]
#[cfg(target_family = "windows")]
fn test_local_copy() {
- let (dir, mut cmd) = setup_e2e("test_local_copy");
+ let (dirs, mut cmd) = setup_e2e("test_local_copy");
cmd.args(["manifest-windows-test.yml", "--copy", "-t", "windows"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = "\
[1/3] Copy gitconfig to .gitconfig.coliru
@@ -212,13 +241,13 @@ script.bat called with arg1 windows\r
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- let vim2_contents = read_file(&dir.dir.join("_vimrc.coliru"));
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_contents = read_file(&dirs.local.join(".gitconfig.coliru"));
+ let vim1_exists = dirs.local.join(".vimrc.coliru").exists();
+ let vim2_contents = read_file(&dirs.local.join("_vimrc.coliru"));
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_exists, false);
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_exists, false);
@@ -229,10 +258,10 @@ script.bat called with arg1 windows\r
#[test]
#[cfg(target_family = "unix")]
fn test_local_run_failure() {
- let (dir, mut cmd) = setup_e2e("test_local_run_failure");
+ let (dirs, mut cmd) = setup_e2e("test_local_run_failure");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
- write_file(&dir.dir.join("script.sh"), "exit 1");
+ copy_manifest(&dirs.local);
+ write_file(&dirs.local.join("script.sh"), "exit 1");
let expected_stdout = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru
@@ -245,13 +274,13 @@ fn test_local_run_failure() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_contents = read_file(&dirs.home.join(".gitconfig.coliru"));
+ let vim1_contents = read_file(&dirs.home.join(".vimrc.coliru"));
+ let vim2_exists = dirs.home.join("_vimrc.coliru").exists();
assert_eq!(bash_contents, "bash #2");
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_contents, "vim #2");
@@ -261,10 +290,10 @@ fn test_local_run_failure() {
#[test]
#[cfg(target_family = "windows")]
fn test_local_run_failure() {
- let (dir, mut cmd) = setup_e2e("test_local_run_failure");
+ let (dirs, mut cmd) = setup_e2e("test_local_run_failure");
cmd.args(["manifest-windows-test.yml", "-t", "windows"]);
- copy_manifest(&dir.dir);
- write_file(&dir.dir.join("script.bat"), "@echo off\r\nexit 1");
+ copy_manifest(&dirs.local);
+ write_file(&dirs.local.join("script.bat"), "@echo off\r\nexit 1");
let expected_stdout = "\
[1/3] Copy gitconfig to .gitconfig.coliru
@@ -276,12 +305,12 @@ fn test_local_run_failure() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("gitconfig"), "git #2");
- write_file(&dir.dir.join("vimrc"), "vim #2");
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- let vim2_contents = read_file(&dir.dir.join("_vimrc.coliru"));
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ write_file(&dirs.local.join("vimrc"), "vim #2");
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_contents = read_file(&dirs.local.join(".gitconfig.coliru"));
+ let vim1_exists = dirs.local.join(".vimrc.coliru").exists();
+ let vim2_contents = read_file(&dirs.local.join("_vimrc.coliru"));
assert_eq!(bash_exists, false);
assert_eq!(git_contents, "git #1");
assert_eq!(vim1_exists, false);
@@ -291,10 +320,10 @@ fn test_local_run_failure() {
#[test]
#[cfg(target_family = "unix")]
fn test_local_missing_file() {
- let (dir, mut cmd) = setup_e2e("test_local_missing_file");
+ let (dirs, mut cmd) = setup_e2e("test_local_missing_file");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
- remove_file(&dir.dir.join("vimrc")).unwrap();
+ copy_manifest(&dirs.local);
+ remove_file(&dirs.local.join("vimrc")).unwrap();
let expected_stdout = "\
[1/3] Copy gitconfig to ~/.gitconfig.coliru
@@ -309,11 +338,11 @@ script.sh called with arg1 linux
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("bashrc"), "bash #2");
- write_file(&dir.dir.join("gitconfig"), "git #2");
- let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("bashrc"), "bash #2");
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ let bash_contents = read_file(&dirs.home.join(".bashrc.coliru"));
+ let git_contents = read_file(&dirs.home.join(".gitconfig.coliru"));
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_contents, "bash #2");
assert_eq!(git_contents, "git #1");
assert_eq!(log_contents, "script.sh called with arg1 linux\n");
@@ -322,10 +351,10 @@ script.sh called with arg1 linux
#[test]
#[cfg(target_family = "windows")]
fn test_local_missing_file() {
- let (dir, mut cmd) = setup_e2e("test_local_missing_file");
+ let (dirs, mut cmd) = setup_e2e("test_local_missing_file");
cmd.args(["manifest-windows-test.yml", "-t", "windows"]);
- copy_manifest(&dir.dir);
- remove_file(&dir.dir.join("vimrc")).unwrap();
+ copy_manifest(&dirs.local);
+ remove_file(&dirs.local.join("vimrc")).unwrap();
let expected_stdout = "\
[1/3] Copy gitconfig to .gitconfig.coliru
@@ -339,10 +368,10 @@ script.bat called with arg1 windows\r
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- write_file(&dir.dir.join("gitconfig"), "git #2");
- let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- let log_contents = read_file(&dir.dir.join("log.txt"));
+ write_file(&dirs.local.join("gitconfig"), "git #2");
+ let bash_exists = dirs.local.join(".bashrc.coliru").exists();
+ let git_contents = read_file(&dirs.local.join(".gitconfig.coliru"));
+ let log_contents = read_file(&dirs.local.join("log.txt"));
assert_eq!(bash_exists, false);
assert_eq!(git_contents, "git #1");
assert_eq!(log_contents, "script.bat called with arg1 windows \r\n");
diff --git a/tests/ssh.rs b/tests/ssh.rs
@@ -8,9 +8,9 @@ use std::fs::remove_file;
#[test]
fn test_ssh_standard() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_standard");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_standard");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected_stdout = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru
@@ -27,14 +27,14 @@ fn test_ssh_standard() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("gitconfig"), "git #2");
- // write_file(&dir.dir.join("vimrc"), "vim #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- // let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- // let log_contents = read_file(&dir.dir.join("log.txt"));
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("gitconfig"), "git #2");
+ // write_file(&dirs.local.join("vimrc"), "vim #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_contents = read_file(&dirs.ssh.join(".gitconfig.coliru"));
+ // let vim1_contents = read_file(&dirs.ssh.join(".vimrc.coliru"));
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
+ // let log_contents = read_file(&dirs.local.join("log.txt"));
// assert_eq!(bash_contents, "bash #2");
// assert_eq!(git_contents, "git #1");
// assert_eq!(vim1_contents, "vim #2");
@@ -44,9 +44,9 @@ fn test_ssh_standard() {
#[test]
fn test_ssh_run_alternate_tag_rules_1() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_run_alternate_tag_rules_1");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_run_alternate_tag_rules_1");
cmd.args(["manifest.yml", "-t", "linux", "^windows"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected_stdout = format!("\
[2/3] Send bashrc to {SSH_HOST}:~/.bashrc.coliru
@@ -61,13 +61,13 @@ fn test_ssh_run_alternate_tag_rules_1() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("vimrc"), "vim #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_exists = dir.dir.join(".gitconfig.coliru").exists();
- // let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- // let log_contents = read_file(&dir.dir.join("log.txt"));
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("vimrc"), "vim #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_exists = dirs.ssh.join(".gitconfig.coliru").exists();
+ // let vim1_contents = read_file(&dirs.ssh.join(".vimrc.coliru"));
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
+ // let log_contents = read_file(&dirs.local.join("log.txt"));
// assert_eq!(bash_contents, "bash #2");
// assert_eq!(git_exists, false);
// assert_eq!(vim1_contents, "vim #2");
@@ -77,9 +77,9 @@ fn test_ssh_run_alternate_tag_rules_1() {
#[test]
fn test_ssh_run_alternate_tag_rules_2() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_run_alternate_tag_rules_2");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_run_alternate_tag_rules_2");
cmd.args(["manifest.yml", "-t", "macos"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected_stdout = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru
@@ -96,14 +96,14 @@ fn test_ssh_run_alternate_tag_rules_2() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("gitconfig"), "git #2");
- // write_file(&dir.dir.join("vimrc"), "vim #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- // let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- // let log_contents = read_file(&dir.dir.join("log.txt"));
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("gitconfig"), "git #2");
+ // write_file(&dirs.local.join("vimrc"), "vim #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_contents = read_file(&dirs.ssh.join(".gitconfig.coliru"));
+ // let vim1_contents = read_file(&dirs.ssh.join(".vimrc.coliru"));
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
+ // let log_contents = read_file(&dirs.local.join("log.txt"));
// assert_eq!(bash_contents, "bash #2");
// assert_eq!(git_contents, "git #1");
// assert_eq!(vim1_contents, "vim #2");
@@ -113,9 +113,9 @@ fn test_ssh_run_alternate_tag_rules_2() {
#[test]
fn test_ssh_dry_run() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_dry_run");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_dry_run");
cmd.args(["manifest.yml", "--dry-run", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru (DRY RUN)
@@ -127,11 +127,11 @@ fn test_ssh_dry_run() {
assert_eq!(&stderr_to_string(&mut cmd), "");
// Assert files are correctly copied/linked/run
- // let bash_exists = dir.dir.join(".bashrc.coliru").exists();
- // let git_exists = dir.dir.join(".gitconfig.coliru").exists();
- // let vim1_exists = dir.dir.join(".vimrc.coliru").exists();
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- // let log_exists = dir.dir.join("log.txt").exists();
+ // let bash_exists = dirs.ssh.join(".bashrc.coliru").exists();
+ // let git_exists = dirs.ssh.join(".gitconfig.coliru").exists();
+ // let vim1_exists = dirs.ssh.join(".vimrc.coliru").exists();
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
+ // let log_exists = dirs.local.join("log.txt").exists();
// assert_eq!(bash_exists, false);
// assert_eq!(git_exists, false);
// assert_eq!(vim1_exists, false);
@@ -141,9 +141,9 @@ fn test_ssh_dry_run() {
#[test]
fn test_ssh_copy() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_copy");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_copy");
cmd.args(["manifest.yml", "--copy", "-t", "linux"]);
- copy_manifest(&dir.dir);
+ copy_manifest(&dirs.local);
let expected_stdout = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru
@@ -160,14 +160,14 @@ fn test_ssh_copy() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("gitconfig"), "git #2");
- // write_file(&dir.dir.join("vimrc"), "vim #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- // let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
- // let log_contents = read_file(&dir.dir.join("log.txt"));
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("gitconfig"), "git #2");
+ // write_file(&dirs.local.join("vimrc"), "vim #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_contents = read_file(&dirs.ssh.join(".gitconfig.coliru"));
+ // let vim1_contents = read_file(&dirs.ssh.join(".vimrc.coliru"));
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
+ // let log_contents = read_file(&dirs.local.join("log.txt"));
// assert_eq!(bash_contents, "bash #1");
// assert_eq!(git_contents, "git #1");
// assert_eq!(vim1_contents, "vim #1");
@@ -177,10 +177,10 @@ fn test_ssh_copy() {
#[test]
fn test_ssh_run_failure() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_run_failure");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_run_failure");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
- write_file(&dir.dir.join("script.sh"), "exit 1");
+ copy_manifest(&dirs.local);
+ write_file(&dirs.local.join("script.sh"), "exit 1");
let expected_stdout = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru
@@ -197,13 +197,13 @@ fn test_ssh_run_failure() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("gitconfig"), "git #2");
- // write_file(&dir.dir.join("vimrc"), "vim #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- // let vim1_contents = read_file(&dir.dir.join(".vimrc.coliru"));
- // let vim2_exists = dir.dir.join("_vimrc.coliru").exists();
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("gitconfig"), "git #2");
+ // write_file(&dirs.local.join("vimrc"), "vim #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_contents = read_file(&dirs.ssh.join(".gitconfig.coliru"));
+ // let vim1_contents = read_file(&dirs.ssh.join(".vimrc.coliru"));
+ // let vim2_exists = dirs.ssh.join("_vimrc.coliru").exists();
// assert_eq!(bash_contents, "bash #2");
// assert_eq!(git_contents, "git #1");
// assert_eq!(vim1_contents, "vim #2");
@@ -212,10 +212,10 @@ fn test_ssh_run_failure() {
#[test]
fn test_ssh_missing_file() {
- let (dir, mut cmd) = setup_e2e_ssh("test_ssh_missing_file");
+ let (dirs, mut cmd) = setup_e2e_ssh("test_ssh_missing_file");
cmd.args(["manifest.yml", "-t", "linux"]);
- copy_manifest(&dir.dir);
- remove_file(&dir.dir.join("vimrc")).unwrap();
+ copy_manifest(&dirs.local);
+ remove_file(&dirs.local.join("vimrc")).unwrap();
let expected_stdout = format!("\
[1/3] Send gitconfig to {SSH_HOST}:~/.gitconfig.coliru
@@ -232,11 +232,11 @@ fn test_ssh_missing_file() {
assert_eq!(&stderr_to_string(&mut cmd), expected_stderr);
// Assert files are correctly copied/linked/run
- // write_file(&dir.dir.join("bashrc"), "bash #2");
- // write_file(&dir.dir.join("gitconfig"), "git #2");
- // let bash_contents = read_file(&dir.dir.join(".bashrc.coliru"));
- // let git_contents = read_file(&dir.dir.join(".gitconfig.coliru"));
- // let log_contents = read_file(&dir.dir.join("log.txt"));
+ // write_file(&dirs.local.join("bashrc"), "bash #2");
+ // write_file(&dirs.local.join("gitconfig"), "git #2");
+ // let bash_contents = read_file(&dirs.ssh.join(".bashrc.coliru"));
+ // let git_contents = read_file(&dirs.ssh.join(".gitconfig.coliru"));
+ // let log_contents = read_file(&dirs.ssh.join("log.txt"));
// assert_eq!(bash_contents, "bash #2");
// assert_eq!(git_contents, "git #1");
// assert_eq!(log_contents, "script.sh called with arg1 linux\n");
