Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
96 changes: 96 additions & 0 deletions src/logger.rs
Original file line number Diff line number Diff line change
Expand Up @@ -100,3 +100,99 @@ impl Log for SandboxLogger {
let _ = self.output.lock().expect("Failed to lock output").flush();
}
}

#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;

/// A writer that keeps everything written to it so tests can inspect it
#[derive(Clone, Default)]
struct Captured(Arc<Mutex<Vec<u8>>>);

impl Write for Captured {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.lock().unwrap().extend_from_slice(buf);
Ok(buf.len())
}

fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}

impl Captured {
fn text(&self) -> String {
String::from_utf8(self.0.lock().unwrap().clone()).unwrap()
}
}

fn logger(level: LevelFilter, captured: &Captured) -> SandboxLogger {
SandboxLogger {
level: Mutex::new(level),
output: Mutex::new(Box::new(captured.clone())),
deferred: Mutex::new(Vec::new()),
defer_output: Mutex::new(true),
}
}

fn log(logger: &SandboxLogger, level: Level, message: &str) {
logger.log(
&Record::builder()
.level(level)
.target("test")
.args(format_args!("{}", message))
.build(),
);
}

#[test]
fn test_log_levels() {
colored::control::set_override(false);
let captured = Captured::default();
let logger = logger(LevelFilter::Trace, &captured);
logger.print_deferred();

log(&logger, Level::Error, "an error");
log(&logger, Level::Warn, "a warning");
log(&logger, Level::Info, "some info");
log(&logger, Level::Debug, "debugging");
log(&logger, Level::Trace, "tracing");

// Warn and info are padded so every level lines up
assert_eq!(
captured.text(),
"[ERROR] test: an error\n\
[WARN ] test: a warning\n\
[INFO ] test: some info\n\
[DEBUG] test: debugging\n\
[TRACE] test: tracing\n"
);
}

#[test]
fn test_deferred_output_is_filtered_by_level() {
colored::control::set_override(false);
let captured = Captured::default();
let logger = logger(LevelFilter::Trace, &captured);

// Messages logged before the level is known are held back...
log(&logger, Level::Warn, "kept");
log(&logger, Level::Debug, "dropped");
assert_eq!(captured.text(), "");

// ...and only the ones that pass the final level are printed
logger.set_level(LevelFilter::Warn);
logger.print_deferred();
assert_eq!(captured.text(), "[WARN ] test: kept\n");

// After that, messages are filtered as they're logged
log(&logger, Level::Debug, "dropped");
log(&logger, Level::Error, "printed");
logger.flush();
assert_eq!(
captured.text(),
"[WARN ] test: kept\n[ERROR] test: printed\n"
);
}
}
83 changes: 83 additions & 0 deletions tests/ai_test_error_paths.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,83 @@
// Tests for error and recovery paths that ordinary usage doesn't reach

mod fixtures;

use anyhow::Result;
use fixtures::*;
use rstest::*;
use std::fs;
use std::path::PathBuf;

#[rstest]
fn ai_test_bind_source_missing(mut sandbox: SandboxManager) -> Result<()> {
let missing = format!("/does-not-exist-{}", rid());
let bind = format!("--bind={}", missing);
assert!(sandbox.xfail(&[&bind, "config", "bind"]));
assert!(
sandbox.last_stderr.contains(&format!(
"Failed to canonicalize source path: {}",
missing
)),
"{}",
sandbox.last_stderr
);
Ok(())
}

#[rstest]
fn ai_test_config_file_unreadable(mut sandbox: SandboxManager) -> Result<()> {
// The path exists, but it's a directory so it can't be read
let dir = sandbox.test_filename("config-dir");
fs::create_dir_all(&dir)?;
assert!(sandbox.xfail(&["--config", &dir, "config"]));
assert!(
sandbox
.last_stderr
.contains(&format!("Failed to read config file {}", dir)),
"{}",
sandbox.last_stderr
);
Ok(())
}

#[rstest]
fn ai_test_new_with_unusable_storage_dir(
mut sandbox: SandboxManager,
) -> Result<()> {
// --new looks for an unused name in the storage directory, which fails
// when the storage directory can't be used. --new conflicts with the
// --name the fixture normally adds.
sandbox.no_default_options = true;
let storage_dir = format!("--storage-dir=/proc/sandbox-coverage-{}", rid());
assert!(sandbox.xfail(&["--new", &storage_dir, "config", "name"]));
assert!(
sandbox
.last_stderr
.contains("Failed to find a suitable storage directory"),
"{}",
sandbox.last_stderr
);
Ok(())
}

#[rstest]
fn ai_test_running_sandbox_without_settings(
mut sandbox: SandboxManager,
) -> Result<()> {
sandbox.run(&["true"])?;

// Sandboxes started before settings were recorded don't have a
// settings file, so there is nothing to validate the config against
sandbox.run(&["config", "sandbox_dir"])?;
let settings =
PathBuf::from(sandbox.last_stdout.trim()).join("data/settings.json");
assert!(settings.exists());
let removed = std::process::Command::new("sudo")
.args(["rm", &settings.to_string_lossy()])
.status()?;
assert!(removed.success());

sandbox.run(&["echo", "still running"])?;
assert_eq!(sandbox.last_stdout.trim(), "still running");
Ok(())
}
Loading