table-test 0.2.0

Improve table testing in Rust
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

# Table Test
[![Build Status](https://travis-ci.org/nathanielsimard/table-test.svg?branch=master)](https://travis-ci.org/nathanielsimard/table-test)
[![codecov.io](https://codecov.io/gh/nathanielsimard/table-test/coverage.svg?branch=master)](https://codecov.io/gh/nathanielsimard/table-test)
[![Current Crates.io Version](https://img.shields.io/crates/v/table-test.svg)](https://crates.io/crates/table-test)

This library aims to make table testing reliable in Rust. 
The main problem of table testing with basic Rust is `assert_eq!` calling `panic!`.
It means that when an assertion fails, then the rest of the test function is not executed.
In the case of a table test, it will result with potentially multiple use cases untested, making the output of that test unreliable.

## Usage

Specify this crate as `[dev-dependencies]`.

```toml
[dev-dependencies]
table_test = "0.2.0"
```

```rust
#[cfg(test)] // <-- not needed in integration tests
#[macro_use]
extern crate table_test;
```

The table iterator returns a tuple `(test_case, input, expected)`.
If you have more than one input, just use a tuple of inputs.
The `test_case` allows you to add comments like `given` `when` and `then`, but also `description` and `custom` giving you the freedom to log your tests the best way possible.

## Examples

If we make a simple test for an `add` function that takes two values as input:

```rust
#[test]
fn test_add() {
    let table = vec![
        ((1, 2), 3),
        ((2, 5), 7),
        ((0, 0), 0),
        ((0, 1), 1),
        ((2, 2), 4),
    ];

    for (validator, (input_1, input_2), expected) in table_test!(table) {
        let actual = add(input_1, input_2);

        validator
            .given(&format!("{}, {}", input_1, input_2))
            .when("add")
            .then(&format!("it should be {}", expected))
            .assert_eq(expected, actual);
    }
}
```
If we make a mistake in the implementation of the `add` function and multiplying instead, then the output will look like this:

![multiple inputs](https://github.com/nathanielsimard/table-test/blob/master/examples_outputs/multiple_inputs.png)

As we can see, it would be easier to debug than with a normal `assert_eq!` output.
But the gain is when we work with something more complex.
The example [here](examples/mutable_struct.rs) test the changing name method and the result looks like this:

![mutable struct](https://github.com/nathanielsimard/table-test/blob/master/examples_outputs/mutable_struct.png)

More examples can be found in the examples folder.