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.2" ```

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 the_answer: Result = Err("Oops, error!");

theory!(theanswer).should().not().beanerror() .andshould().contain(42) .because("we need the answer"); ```

Displays:

```none The test failed at src/tests/message.rs:16: the_answer should not have been an error but it is: Err("Oops, error!").

the_answer does not contain 42: Err("Oops, error!")
but it should.

This test should pass because we need 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(_) => unreachable!(), 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); ```