test-better 0.1.0

Result-returning tests with `?`: composable matchers, rich failure output, no `.unwrap()`.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

//! Acceptance tests for the runtime-free `eventually_blocking` polling helper,
//! exercised through the `test-better` facade.
//!
//! The async `eventually` is covered by the per-runtime crates under
//! `tests/timeout-*`, where a real runtime drives its inter-probe sleep.
//! `eventually_blocking` needs no runtime, so it is tested here as an ordinary
//! `#[test]`.

use std::cell::Cell;
use std::time::{Duration, Instant};

use test_better::prelude::*;

#[test]
fn eventually_blocking_returns_the_moment_the_probe_passes() -> TestResult {
    let polls = Cell::new(0u32);
    eventually_blocking(Duration::from_secs(5), || {
        polls.set(polls.get() + 1);
        polls.get() >= 4
    })?;
    // A generous 5s budget, but the probe passes on its fourth call, so polling
    // stops there rather than running to the deadline.
    expect!(polls.get()).to(eq(4u32))?;
    Ok(())
}

#[test]
fn eventually_blocking_failure_names_the_elapsed_time_and_probe_count() -> TestResult {
    let polls = Cell::new(0u32);
    let started = Instant::now();
    let error = eventually_blocking(Duration::from_millis(50), || {
        polls.set(polls.get() + 1);
        false
    })
    .expect_err("a probe that never passes must time out");
    // It did not give up early: the whole budget was spent.
    expect!(started.elapsed() >= Duration::from_millis(50)).to(is_true())?;
    let rendered = error.to_string();
    // The failure reports both how long it waited and how many times it probed.
    expect!(rendered.contains("was not met within")).to(is_true())?;
    expect!(rendered.contains(&format!("{} probe", polls.get()))).to(is_true())?;
    Ok(())
}