64 lines
2.2 KiB
Rust
64 lines
2.2 KiB
Rust
//! Shared helpers for the CLI integration tests.
|
|
//!
|
|
//! Each test copies a fixture tree into a fresh tempdir, runs the real
|
|
//! binary with `--root <tmp>` and asserts on exit codes, stdout/stderr and
|
|
//! the resulting files on disk.
|
|
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use assert_cmd::Command;
|
|
use assert_cmd::assert::Assert;
|
|
use tempfile::TempDir;
|
|
|
|
/// Recursively copy `tests/<language>/<name>` into a tempdir and return it.
|
|
///
|
|
/// An empty `.git` marker is created in the copy: the `ignore` crate only
|
|
/// applies `.gitignore` rules inside a git repository by default, and the
|
|
/// typescript `normal` fixture relies on its `node_modules/` rule being
|
|
/// effective.
|
|
pub fn copy_fixture(language: &str, name: &str) -> TempDir {
|
|
let tmp = TempDir::new().expect("tempdir");
|
|
copy_dir(&fixture_dir(language, name), tmp.path());
|
|
fs::create_dir(tmp.path().join(".git")).expect("git marker");
|
|
tmp
|
|
}
|
|
|
|
/// Source path of a fixture tree inside the repository.
|
|
pub fn fixture_dir(language: &str, name: &str) -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("tests")
|
|
.join(language)
|
|
.join(name)
|
|
}
|
|
|
|
/// Recursive file/dir copy; plain `std::fs` only, no symlinks in fixtures.
|
|
fn copy_dir(from: &Path, to: &Path) {
|
|
fs::create_dir_all(to).expect("create dir");
|
|
for entry in fs::read_dir(from).expect("read dir") {
|
|
let entry = entry.expect("entry");
|
|
let target = to.join(entry.file_name());
|
|
if entry.file_type().expect("file type").is_dir() {
|
|
copy_dir(&entry.path(), &target);
|
|
} else {
|
|
fs::copy(entry.path(), target).expect("copy file");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Run `jmove --root <dir> <args…>` and return an assertable outcome.
|
|
pub fn jmove(root: &TempDir, args: &[&str]) -> Assert {
|
|
let mut cmd = Command::cargo_bin("jmove").expect("jmove binary");
|
|
cmd.arg("--root").arg(root.path()).args(args);
|
|
cmd.assert()
|
|
}
|
|
|
|
/// Read `path` as a string, panicking with the path on failure.
|
|
pub fn read(path: &Path) -> String {
|
|
fs::read_to_string(path).unwrap_or_else(|err| panic!("read {}: {err}", path.display()))
|
|
}
|
|
|
|
/// Build a path inside the tempdir root from a `/`-separated relative path.
|
|
pub fn in_root(root: &Path, rel: &str) -> PathBuf {
|
|
root.join(rel)
|
|
}
|