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:

```toml

Do not use in crate build, only in test

[dev-dependencies] fluid = "0.1" ```

Reference the crate in your main file:

```rust

[macro_use] extern crate fluid;

```

Import the crate content in scope of your tests file:

rust use fluid::*;

Examples

Simple equality

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

Negation

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

Explanation

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

Nice error message

rust 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:

```none 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

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

Result::Err

rust 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

```rust fn error(e: bool) -> Result { 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); ```