Fluid

Summary

fluid is an human readable test library.

The current goals of this crate are:

• Easily readable tests: they should be read like english sentences.
• Nice and understandable error messages.
• Provide the most possible useful assertions for common cases: numbers, Iterators, Options, Results, etc.

How to use it

Add the crate in your Cargo.toml:

# Do not use in crate build, only in test
[dev-dependencies]
fluid = "0.1"

Reference the crate in your main file:

#[macro_use] extern crate fluid;

Import the crate content in scope of your tests file:

use fluid::*;

Examples

Simple equality

theory!(1 + 1).should().be_equal_to(2);

Negation

theory!(1 + 1).should().not().be_equal_to(10);

Explanation

theory!(1 + 1).should().be_equal_to(2)
    .because("this is basic arithmetic");

Nice error message

let my_result: Result<i32, ()> = Err(()); //Oops
theory!(my_result).should().not().be_an_error()
    .and_should().contain(42)
    .because("I must have the answer");

Displays:

The test failed at src/tests.rs:76:
    'my_result' should not have been an error
    But it is: 'Err(())'

    'my_result' should have contain '42'
    But it does not.
This test should have pass because I must have the answer

Floats precision

theory!(1.).should().be_equal_to(1.01).with_precision(0.1);

Result::Err

let parse_error = match "?".parse::<i32>() {
    Ok(_) => unimplemented!(),
    Err(e) => e,
};
let result = "two".parse::<i32>();
theory!(result).should().be_an_error()
    .and_should().be_this_error(parse_error);

Iterators

fn error(e: bool) -> Result<i32, i32> {
    match e {
        true => Result::Err(0),
        false => Result::Ok(0),
    }
}

theory!(error(false)).should().contain(0);
theory!(error(true)).should().not().contain(0);
theory!(&[1, 2, 3]).should().not().contain(&0);