598 lines
20 KiB
Rust
598 lines
20 KiB
Rust
use std::{process::Command, time::Duration};
|
|
|
|
use color_eyre::eyre::{eyre, Result};
|
|
use regex::RegexSet;
|
|
use tempfile::tempdir;
|
|
|
|
use zebra_test::{
|
|
args,
|
|
command::{TestDirExt, NO_MATCHES_REGEX_ITER},
|
|
prelude::Stdio,
|
|
};
|
|
|
|
/// Returns true if `cmd` with `args` runs successfully.
|
|
///
|
|
/// On failure, prints an error message to stderr.
|
|
/// (This message is captured by the test runner, use `cargo test -- --nocapture` to see it.)
|
|
///
|
|
/// The command's stdout and stderr are ignored.
|
|
#[allow(clippy::print_stderr)]
|
|
fn is_command_available(cmd: &str, args: &[&str]) -> bool {
|
|
let status = Command::new(cmd)
|
|
.args(args)
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::null())
|
|
.status();
|
|
|
|
match status {
|
|
Err(e) => {
|
|
eprintln!(
|
|
"Skipping test because '{} {:?}' returned error {:?}",
|
|
cmd, args, e
|
|
);
|
|
false
|
|
}
|
|
Ok(status) if !status.success() => {
|
|
eprintln!(
|
|
"Skipping test because '{} {:?}' returned status {:?}",
|
|
cmd, args, status
|
|
);
|
|
false
|
|
}
|
|
_ => true,
|
|
}
|
|
}
|
|
|
|
/// Test if a process that keeps on producing lines of output is killed after the timeout.
|
|
#[test]
|
|
fn kill_on_timeout_output_continuous_lines() -> Result<()> {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
// Ideally, we'd want to use the 'yes' command here, but BSD yes treats
|
|
// every string as an argument to repeat - so we can't test if it is
|
|
// present on the system.
|
|
const TEST_CMD: &str = "hexdump";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &["/dev/null"]) {
|
|
return Ok(());
|
|
}
|
|
|
|
// Without '-v', hexdump hides duplicate lines. But we want duplicate lines
|
|
// in this test.
|
|
let mut child = tempdir()?
|
|
.spawn_child_with_command(TEST_CMD, args!["-v", "-n", "1024", "/dev/zero"])?
|
|
.with_timeout(Duration::from_secs(2));
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout.
|
|
assert!(child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.is_err());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test if the tests pass for a process that produces a single line of output,
|
|
/// then exits before the timeout.
|
|
//
|
|
// TODO: create a similar test that pauses after output (#1140)
|
|
#[test]
|
|
fn finish_before_timeout_output_single_line() -> Result<()> {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return Ok(());
|
|
}
|
|
|
|
let mut child = tempdir()?
|
|
.spawn_child_with_command(TEST_CMD, args!["zebra_test_output"])?
|
|
.with_timeout(Duration::from_secs(2));
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout.
|
|
assert!(child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.is_err());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test if a process that keeps on producing output, but doesn't produce any newlines,
|
|
/// is killed after the timeout.
|
|
///
|
|
/// This test fails due to bugs in TestDirExt, see #1140 for details.
|
|
//#[test]
|
|
//#[ignore]
|
|
#[allow(dead_code)]
|
|
fn kill_on_timeout_continuous_output_no_newlines() -> Result<()> {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "head";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &["/dev/null"]) {
|
|
return Ok(());
|
|
}
|
|
|
|
let mut child = tempdir()?
|
|
.spawn_child_with_command(TEST_CMD, args!["-c", "1024", "/dev/zero"])?
|
|
.with_timeout(Duration::from_secs(2));
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout.
|
|
assert!(child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.is_err());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test if tests pass for a process that produces a small amount of output,
|
|
/// with no newlines, then exits before the timeout.
|
|
//
|
|
// TODO: create a similar test that pauses after output (#1140)
|
|
#[test]
|
|
fn finish_before_timeout_short_output_no_newlines() -> Result<()> {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "printf";
|
|
// Skip the test if the test system does not have the command
|
|
// The empty argument is required, because printf expects at least one argument.
|
|
if !is_command_available(TEST_CMD, &[""]) {
|
|
return Ok(());
|
|
}
|
|
|
|
let mut child = tempdir()?
|
|
.spawn_child_with_command(TEST_CMD, args!["zebra_test_output"])?
|
|
.with_timeout(Duration::from_secs(2));
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout.
|
|
assert!(child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.is_err());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test if the timeout works for a process that produces no output.
|
|
///
|
|
/// This test fails due to bugs in TestDirExt, see #1140 for details.
|
|
// #[test]
|
|
// #[ignore]
|
|
#[allow(dead_code)]
|
|
fn kill_on_timeout_no_output() -> Result<()> {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "sleep";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &["0"]) {
|
|
return Ok(());
|
|
}
|
|
|
|
let mut child = tempdir()?
|
|
.spawn_child_with_command(TEST_CMD, args!["120"])?
|
|
.with_timeout(Duration::from_secs(2));
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout.
|
|
assert!(child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.is_err());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// and fail with a test failure message.
|
|
#[test]
|
|
fn failure_regex_matches_stdout_failure_message() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(2))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Any method that reads output should work here.
|
|
// We use a non-matching regex, to trigger the failure panic.
|
|
let expected_error = child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.unwrap_err();
|
|
|
|
let expected_error = format!("{:?}", expected_error);
|
|
assert!(
|
|
expected_error.contains("Logged a failure message"),
|
|
"error did not contain expected failure message: {}",
|
|
expected_error,
|
|
);
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stderr,
|
|
/// and panic with a test failure message.
|
|
#[test]
|
|
fn failure_regex_matches_stderr_failure_message() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
// The read command prints its prompt to stderr.
|
|
//
|
|
// This is tricky to get right, because:
|
|
// - some read command versions only accept integer timeouts
|
|
// - some installs only have read as a shell builtin
|
|
// - some `sh` shells don't allow the `-t` option for read
|
|
const TEST_CMD: &str = "bash";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &["-c", "read -t 1 -p failure_message"]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args![ "-c": "read -t 1 -p failure_message" ])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Any method that reads output should work here.
|
|
// We use a non-matching regex, to trigger the failure panic.
|
|
let expected_error = child
|
|
.expect_stderr_line_matches("this regex should not match")
|
|
.unwrap_err();
|
|
|
|
let expected_error = format!("{:?}", expected_error);
|
|
assert!(
|
|
expected_error.contains("Logged a failure message"),
|
|
"error did not contain expected failure message: {}",
|
|
expected_error,
|
|
);
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// then the child process is dropped without being killed.
|
|
#[test]
|
|
#[should_panic(expected = "Logged a failure message")]
|
|
fn failure_regex_matches_stdout_failure_message_drop() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let _child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Drop should read all unread output.
|
|
}
|
|
|
|
/// When checking output, make sure failure regexes detect when a child process
|
|
/// prints a failure message to stdout, then they fail the test,
|
|
/// and read any extra multi-line output from the child process.
|
|
#[test]
|
|
fn failure_regex_reads_multi_line_output_on_expect_line() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(
|
|
TEST_CMD,
|
|
args![
|
|
"failure_message\n\
|
|
multi-line failure message"
|
|
],
|
|
)
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("failure_message", RegexSet::empty());
|
|
|
|
// Any method that reads output should work here.
|
|
// We use a non-matching regex, to trigger the failure panic.
|
|
let expected_error = child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.unwrap_err();
|
|
|
|
let expected_error = format!("{:?}", expected_error);
|
|
assert!(
|
|
expected_error.contains(
|
|
"\
|
|
Unread Stdout:
|
|
multi-line failure message\
|
|
"
|
|
),
|
|
"error did not contain expected failure message: {}",
|
|
expected_error,
|
|
);
|
|
}
|
|
|
|
/// On drop, make sure failure regexes detect when a child process prints a failure message.
|
|
/// then they fail the test, and read any extra multi-line output from the child process.
|
|
#[test]
|
|
#[should_panic(expected = "Unread Stdout:
|
|
multi-line failure message")]
|
|
fn failure_regex_reads_multi_line_output_on_drop() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let _child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(
|
|
TEST_CMD,
|
|
args![
|
|
"failure_message\n\
|
|
multi-line failure message"
|
|
],
|
|
)
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("failure_message", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Drop should read all unread output.
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// then the child process is killed.
|
|
#[test]
|
|
#[should_panic(expected = "Logged a failure message")]
|
|
fn failure_regex_matches_stdout_failure_message_kill() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Kill should read all unread output to generate the error context,
|
|
// or the output should be read on drop.
|
|
child.kill(true).unwrap();
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// then the child process is killed on error.
|
|
#[test]
|
|
#[should_panic(expected = "Logged a failure message")]
|
|
fn failure_regex_matches_stdout_failure_message_kill_on_error() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Kill on error should read all unread output to generate the error context,
|
|
// or the output should be read on drop.
|
|
let test_error: Result<()> = Err(eyre!("test error"));
|
|
child.kill_on_error(test_error).unwrap();
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// then the child process is not killed because there is no error.
|
|
#[test]
|
|
#[should_panic(expected = "Logged a failure message")]
|
|
fn failure_regex_matches_stdout_failure_message_no_kill_on_error() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Kill on error should read all unread output to generate the error context,
|
|
// or the output should be read on drop.
|
|
let test_ok: Result<()> = Ok(());
|
|
child.kill_on_error(test_ok).unwrap();
|
|
}
|
|
|
|
/// Make sure failure regexes detect when a child process prints a failure message to stdout,
|
|
/// then times out waiting for a specific output line.
|
|
///
|
|
/// TODO: test the failure regex on timeouts with no output (#1140)
|
|
#[test]
|
|
fn failure_regex_timeout_continuous_output() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
// Ideally, we'd want to use the 'yes' command here, but BSD yes treats
|
|
// every string as an argument to repeat - so we can't test if it is
|
|
// present on the system.
|
|
const TEST_CMD: &str = "hexdump";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &["/dev/null"]) {
|
|
return;
|
|
}
|
|
|
|
// Without '-v', hexdump hides duplicate lines. But we want duplicate lines
|
|
// in this test.
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["-v", "/dev/zero"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(2))
|
|
.with_failure_regex_set("0", RegexSet::empty());
|
|
|
|
// We need to use expect_stdout_line_matches, because wait_with_output ignores timeouts.
|
|
// We use a non-matching regex, to trigger the timeout and the failure panic.
|
|
let expected_error = child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.unwrap_err();
|
|
|
|
let expected_error = format!("{:?}", expected_error);
|
|
assert!(
|
|
expected_error.contains("Logged a failure message"),
|
|
"error did not contain expected failure message: {}",
|
|
expected_error,
|
|
);
|
|
}
|
|
|
|
/// Make sure failure regexes are checked when a child process prints a failure message to stdout,
|
|
/// then the child process' output is waited for.
|
|
///
|
|
/// This is an error, but we still want to check failure logs.
|
|
#[test]
|
|
#[should_panic(expected = "Logged a failure message")]
|
|
fn failure_regex_matches_stdout_failure_message_wait_for_output() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(5))
|
|
.with_failure_regex_set("fail", RegexSet::empty());
|
|
|
|
// Give the child process enough time to print its output.
|
|
std::thread::sleep(Duration::from_secs(1));
|
|
|
|
// Wait with output should read all unread output to generate the error context,
|
|
// or the output should be read on drop.
|
|
child.wait_with_output().unwrap_err();
|
|
}
|
|
|
|
/// Make sure failure regex iters detect when a child process prints a failure message to stdout,
|
|
/// and panic with a test failure message.
|
|
#[test]
|
|
fn failure_regex_iter_matches_stdout_failure_message() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(2))
|
|
.with_failure_regex_iter(
|
|
["fail"].iter().cloned(),
|
|
NO_MATCHES_REGEX_ITER.iter().cloned(),
|
|
);
|
|
|
|
// Any method that reads output should work here.
|
|
// We use a non-matching regex, to trigger the failure panic.
|
|
let expected_error = child
|
|
.expect_stdout_line_matches("this regex should not match")
|
|
.unwrap_err();
|
|
|
|
let expected_error = format!("{:?}", expected_error);
|
|
assert!(
|
|
expected_error.contains("Logged a failure message"),
|
|
"error did not contain expected failure message: {}",
|
|
expected_error,
|
|
);
|
|
}
|
|
|
|
/// Make sure ignore regexes override failure regexes.
|
|
#[test]
|
|
fn ignore_regex_ignores_stdout_failure_message() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message ignore_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(2))
|
|
.with_failure_regex_set("fail", "ignore");
|
|
|
|
// Any method that reads output should work here.
|
|
child.expect_stdout_line_matches("ignore_message").unwrap();
|
|
}
|
|
|
|
/// Make sure ignore regex iters override failure regex iters.
|
|
#[test]
|
|
fn ignore_regex_iter_ignores_stdout_failure_message() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
const TEST_CMD: &str = "echo";
|
|
// Skip the test if the test system does not have the command
|
|
if !is_command_available(TEST_CMD, &[]) {
|
|
return;
|
|
}
|
|
|
|
let mut child = tempdir()
|
|
.unwrap()
|
|
.spawn_child_with_command(TEST_CMD, args!["failure_message ignore_message"])
|
|
.unwrap()
|
|
.with_timeout(Duration::from_secs(2))
|
|
.with_failure_regex_iter(["fail"].iter().cloned(), ["ignore"].iter().cloned());
|
|
|
|
// Any method that reads output should work here.
|
|
child.expect_stdout_line_matches("ignore_message").unwrap();
|
|
}
|