diff --git a/src/logger.rs b/src/logger.rs index d33bc91..dfa9759 100644 --- a/src/logger.rs +++ b/src/logger.rs @@ -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>>); + + impl Write for Captured { + fn write(&mut self, buf: &[u8]) -> io::Result { + 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" + ); + } +} diff --git a/tests/ai_test_error_paths.rs b/tests/ai_test_error_paths.rs new file mode 100644 index 0000000..1b3ddd6 --- /dev/null +++ b/tests/ai_test_error_paths.rs @@ -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(()) +}