Struct TestHarness 

pub struct TestHarness {
    pub config: HarnessConfig,
    pub logger: TestLogger,
    /* private fields */
}

E2E Test Harness for managing test execution

Fields

config: HarnessConfig

logger: TestLogger

Implementations

impl TestHarness

pub fn new(test_name: &str, config: HarnessConfig) -> HarnessResult<Self>

Create a new test harness with the given configuration

pub fn default_for_test(test_name: &str) -> HarnessResult<Self>

Create a harness with default configuration

pub fn test_dir(&self) -> &Path

Get the test directory path

pub fn run_reliability_scenario( &self, scenario: &ReliabilityScenarioSpec, ) -> HarnessResult<ReliabilityScenarioReport>

Run a reliability scenario with deterministic setup/execute/verify/cleanup phases.

This is the shared foundation consumed by scenario-specific suites (path dependencies, repo convergence, disk pressure, and process triage) so they can reuse one orchestration engine instead of bespoke scaffolding.

pub fn create_dir(&self, name: &str) -> HarnessResult<PathBuf>

Create a subdirectory in the test directory

pub fn create_file(&self, name: &str, content: &str) -> HarnessResult<PathBuf>

Create a file in the test directory

pub fn create_daemon_config( &self, config_content: &str, ) -> HarnessResult<PathBuf>

Create a config file for the daemon

pub fn create_workers_config( &self, config_content: &str, ) -> HarnessResult<PathBuf>

Create a workers config file

pub fn spawn_process<I, S>( &self, name: &str, program: &Path, args: I, env: Option<&HashMap<String, String>>, ) -> HarnessResult<u32>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Spawn a managed process

pub fn start_daemon(&self, extra_args: &[&str]) -> HarnessResult<u32>

Start the daemon process

pub fn stop_process(&self, name: &str) -> HarnessResult<()>

Stop a managed process by name

pub fn wait_for_process_exit( &self, name: &str, timeout: Duration, ) -> HarnessResult<ExitStatus>

Wait for a managed process to exit without killing it.

pub fn stop_all_processes(&self)

Stop all managed processes

pub fn exec<I, S>(&self, program: &str, args: I) -> HarnessResult<CommandResult>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Execute a command and capture output

pub fn exec_with_timeout<I, S>( &self, program: &str, args: I, timeout: Duration, ) -> HarnessResult<CommandResult>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Execute a command with a specific timeout

Terminates the process if it exceeds the provided timeout.

pub fn exec_rch<I, S>(&self, args: I) -> HarnessResult<CommandResult>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Execute the rch binary

pub fn exec_rchd<I, S>(&self, args: I) -> HarnessResult<CommandResult>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Execute the rchd binary

pub fn exec_rch_wkr<I, S>(&self, args: I) -> HarnessResult<CommandResult>

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Execute the rch-wkr binary

pub fn wait_for<F>( &self, description: &str, timeout: Duration, interval: Duration, condition: F, ) -> HarnessResult<()>

where F: Fn() -> bool,

Wait for a condition to become true

pub fn wait_for_file(&self, path: &Path, timeout: Duration) -> HarnessResult<()>

Wait for a file to exist

pub fn wait_for_socket( &self, socket_path: &Path, timeout: Duration, ) -> HarnessResult<()>

Wait for a socket to be available

pub fn wait_for_socket_with_backoff( &self, socket_path: &Path, max_wait: Duration, ) -> HarnessResult<()>

Wait for a socket using exponential backoff for more reliable detection.

Starts with a 10ms delay and doubles up to a maximum of 500ms per iteration. This reduces CPU usage while maintaining responsiveness for fast-starting daemons.

pub fn mark_passed(&self)

Mark the test as passed

pub fn mark_failed(&self, reason: &str)

Mark the test as failed with a reason

pub fn passed(&self) -> bool

Check if the test passed

pub fn assert(&self, condition: bool, message: &str) -> HarnessResult<()>

Assert that a condition is true

pub fn assert_eq<T: PartialEq + Debug>( &self, actual: T, expected: T, message: &str, ) -> HarnessResult<()>

Assert that two values are equal

pub fn assert_success( &self, result: &CommandResult, context: &str, ) -> HarnessResult<()>

Assert that a command result succeeded

pub fn assert_stdout_contains( &self, result: &CommandResult, pattern: &str, context: &str, ) -> HarnessResult<()>

Assert that a command result contains expected output

pub fn cleanup(&self)

Perform cleanup

Trait Implementations

impl Drop for TestHarness

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.