just/tests/test.rs

331 lines
8.5 KiB
Rust
Raw Normal View History

2022-12-27 20:16:18 -08:00
use {super::*, pretty_assertions::assert_eq};
macro_rules! test {
{
name: $name:ident,
$(justfile: $justfile:expr,)?
$(args: ($($arg:tt),*),)?
$(env: { $($env_key:literal : $env_value:literal,)* },)?
$(stdin: $stdin:expr,)?
$(stdout: $stdout:expr,)?
2022-05-04 16:18:31 -07:00
$(stdout_regex: $stdout_regex:expr,)?
$(stderr: $stderr:expr,)?
$(stderr_regex: $stderr_regex:expr,)?
$(status: $status:expr,)?
$(shell: $shell:expr,)?
} => {
#[test]
fn $name() {
let test = crate::test::Test::new();
$($(let test = test.arg($arg);)*)?
$($(let test = test.env($env_key, $env_value);)*)?
$(let test = test.justfile($justfile);)?
$(let test = test.shell($shell);)?
$(let test = test.status($status);)?
$(let test = test.stderr($stderr);)?
$(let test = test.stderr_regex($stderr_regex);)?
$(let test = test.stdin($stdin);)?
$(let test = test.stdout($stdout);)?
2022-05-04 16:18:31 -07:00
$(let test = test.stdout_regex($stdout_regex);)?
test.run();
}
}
}
pub(crate) struct Output {
2024-01-11 19:22:27 -08:00
pub(crate) pid: u32,
pub(crate) stdout: String,
pub(crate) tempdir: TempDir,
}
2023-10-27 13:07:46 -07:00
#[must_use]
pub(crate) struct Test {
pub(crate) args: Vec<String>,
pub(crate) current_dir: PathBuf,
pub(crate) env: BTreeMap<String, String>,
pub(crate) justfile: Option<String>,
pub(crate) shell: bool,
pub(crate) status: i32,
pub(crate) stderr: String,
pub(crate) stderr_regex: Option<Regex>,
pub(crate) stdin: String,
pub(crate) stdout: String,
2022-05-04 16:18:31 -07:00
pub(crate) stdout_regex: Option<Regex>,
pub(crate) tempdir: TempDir,
2023-01-12 19:25:28 -08:00
pub(crate) test_round_trip: bool,
pub(crate) unindent_stdout: bool,
}
impl Test {
pub(crate) fn new() -> Self {
Self::with_tempdir(tempdir())
}
pub(crate) fn with_tempdir(tempdir: TempDir) -> Self {
Self {
args: Vec::new(),
current_dir: PathBuf::new(),
env: BTreeMap::new(),
justfile: Some(String::new()),
shell: true,
status: EXIT_SUCCESS,
stderr: String::new(),
stderr_regex: None,
stdin: String::new(),
stdout: String::new(),
2022-05-04 16:18:31 -07:00
stdout_regex: None,
tempdir,
2023-01-12 19:25:28 -08:00
test_round_trip: true,
unindent_stdout: true,
}
}
pub(crate) fn arg(mut self, val: &str) -> Self {
self.args.push(val.to_owned());
self
}
2023-01-03 22:31:56 -08:00
pub(crate) fn args<'a>(mut self, args: impl AsRef<[&'a str]>) -> Self {
for arg in args.as_ref() {
self = self.arg(arg);
}
self
}
pub(crate) fn create_dir(self, path: impl AsRef<Path>) -> Self {
fs::create_dir_all(self.tempdir.path().join(path.as_ref())).unwrap();
self
}
pub(crate) fn current_dir(mut self, path: impl AsRef<Path>) -> Self {
path.as_ref().clone_into(&mut self.current_dir);
self
}
pub(crate) fn env(mut self, key: &str, val: &str) -> Self {
self.env.insert(key.to_string(), val.to_string());
self
}
pub(crate) fn justfile(mut self, justfile: impl Into<String>) -> Self {
self.justfile = Some(justfile.into());
self
}
pub(crate) fn justfile_path(&self) -> PathBuf {
self.tempdir.path().join("justfile")
}
#[cfg(unix)]
#[track_caller]
pub(crate) fn symlink(self, original: &str, link: &str) -> Self {
std::os::unix::fs::symlink(
self.tempdir.path().join(original),
self.tempdir.path().join(link),
)
.unwrap();
self
}
pub(crate) fn no_justfile(mut self) -> Self {
self.justfile = None;
self
}
pub(crate) fn shell(mut self, shell: bool) -> Self {
self.shell = shell;
self
}
pub(crate) fn status(mut self, exit_status: i32) -> Self {
self.status = exit_status;
self
}
pub(crate) fn stderr(mut self, stderr: impl Into<String>) -> Self {
self.stderr = stderr.into();
self
}
pub(crate) fn stderr_regex(mut self, stderr_regex: impl AsRef<str>) -> Self {
self.stderr_regex = Some(Regex::new(&format!("^(?s){}$", stderr_regex.as_ref())).unwrap());
self
}
pub(crate) fn stdin(mut self, stdin: impl Into<String>) -> Self {
self.stdin = stdin.into();
self
}
pub(crate) fn stdout(mut self, stdout: impl Into<String>) -> Self {
self.stdout = stdout.into();
self
}
2022-05-04 16:18:31 -07:00
pub(crate) fn stdout_regex(mut self, stdout_regex: impl AsRef<str>) -> Self {
2023-01-12 19:25:28 -08:00
self.stdout_regex = Some(Regex::new(&format!("^{}$", stdout_regex.as_ref())).unwrap());
self
}
2024-07-14 14:22:03 -07:00
#[allow(unused)]
2023-01-12 19:25:28 -08:00
pub(crate) fn test_round_trip(mut self, test_round_trip: bool) -> Self {
self.test_round_trip = test_round_trip;
2022-05-04 16:18:31 -07:00
self
}
pub(crate) fn tree(self, mut tree: Tree) -> Self {
tree.map(|_name, content| unindent(content));
2022-01-30 12:16:10 -08:00
tree.instantiate(self.tempdir.path()).unwrap();
self
}
pub(crate) fn unindent_stdout(mut self, unindent_stdout: bool) -> Self {
self.unindent_stdout = unindent_stdout;
self
}
2023-01-03 22:31:56 -08:00
pub(crate) fn write(self, path: impl AsRef<Path>, content: impl AsRef<[u8]>) -> Self {
let path = self.tempdir.path().join(path);
2023-06-12 09:53:55 -07:00
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, content).unwrap();
2023-01-03 22:31:56 -08:00
self
}
}
impl Test {
2024-05-14 20:29:40 -07:00
#[track_caller]
pub(crate) fn run(self) -> Output {
if let Some(justfile) = &self.justfile {
let justfile = unindent(justfile);
fs::write(self.justfile_path(), justfile).unwrap();
}
let stdout = if self.unindent_stdout {
unindent(&self.stdout)
} else {
2024-05-18 22:41:38 -07:00
self.stdout.clone()
};
let stderr = unindent(&self.stderr);
2022-12-15 16:53:21 -08:00
let mut command = Command::new(executable_path("just"));
if self.shell {
2022-11-22 16:36:23 -08:00
command.args(["--shell", "bash"]);
}
let mut child = command
2024-05-18 22:41:38 -07:00
.args(&self.args)
.envs(&self.env)
2024-05-18 22:41:38 -07:00
.current_dir(self.tempdir.path().join(&self.current_dir))
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("just invocation failed");
2024-01-11 19:22:27 -08:00
let pid = child.id();
{
let mut stdin_handle = child.stdin.take().expect("failed to unwrap stdin handle");
stdin_handle
.write_all(self.stdin.as_bytes())
.expect("failed to write stdin to just process");
}
let output = child
.wait_with_output()
.expect("failed to wait for just process");
fn compare<T: PartialEq + Debug>(name: &str, have: T, want: T) -> bool {
let equal = have == want;
if !equal {
2023-06-12 09:53:55 -07:00
eprintln!("Bad {name}: {}", Comparison::new(&have, &want));
}
equal
}
2022-05-04 16:18:31 -07:00
let output_stdout = str::from_utf8(&output.stdout).unwrap();
let output_stderr = str::from_utf8(&output.stderr).unwrap();
2022-05-04 16:18:31 -07:00
if let Some(ref stdout_regex) = self.stdout_regex {
if !stdout_regex.is_match(output_stdout) {
panic!("Stdout regex mismatch:\n{output_stdout:?}\n!~=\n/{stdout_regex:?}/");
2022-05-04 16:18:31 -07:00
}
}
if let Some(ref stderr_regex) = self.stderr_regex {
if !stderr_regex.is_match(output_stderr) {
panic!("Stderr regex mismatch:\n{output_stderr:?}\n!~=\n/{stderr_regex:?}/");
}
}
if !compare("status", output.status.code(), Some(self.status))
2022-05-04 16:18:31 -07:00
| (self.stdout_regex.is_none() && !compare("stdout", output_stdout, &stdout))
| (self.stderr_regex.is_none() && !compare("stderr", output_stderr, &stderr))
{
panic!("Output mismatch.");
}
2023-01-12 19:25:28 -08:00
if self.test_round_trip && self.status == EXIT_SUCCESS {
2024-05-18 22:41:38 -07:00
self.round_trip();
}
Output {
2024-01-11 19:22:27 -08:00
pid,
stdout: output_stdout.into(),
2024-01-11 19:22:27 -08:00
tempdir: self.tempdir,
}
}
2024-05-18 22:41:38 -07:00
fn round_trip(&self) {
println!("Reparsing...");
2024-05-18 22:41:38 -07:00
let output = Command::new(executable_path("just"))
.current_dir(self.tempdir.path())
.arg("--dump")
.envs(&self.env)
.output()
.expect("just invocation failed");
2024-05-18 22:41:38 -07:00
if !output.status.success() {
panic!("dump failed: {} {:?}", output.status, output);
}
2024-05-18 22:41:38 -07:00
let dumped = String::from_utf8(output.stdout).unwrap();
2024-05-18 22:41:38 -07:00
let reparsed_path = self.tempdir.path().join("reparsed.just");
2024-05-18 22:41:38 -07:00
fs::write(&reparsed_path, &dumped).unwrap();
2024-05-18 22:41:38 -07:00
let output = Command::new(executable_path("just"))
.current_dir(self.tempdir.path())
.arg("--justfile")
.arg(&reparsed_path)
.arg("--dump")
.envs(&self.env)
.output()
.expect("just invocation failed");
2024-05-18 22:41:38 -07:00
if !output.status.success() {
panic!("reparse failed: {}", output.status);
}
2024-05-18 22:41:38 -07:00
let reparsed = String::from_utf8(output.stdout).unwrap();
2024-05-18 22:41:38 -07:00
assert_eq!(reparsed, dumped, "reparse mismatch");
}
}
2024-05-18 16:12:11 -07:00
pub fn assert_eval_eq(expression: &str, result: &str) {
Test::new()
.justfile(format!("x := {expression}"))
.args(["--evaluate", "x"])
.stdout(result)
.unindent_stdout(false)
.run();
}