contrafact 0.2.0-rc.1

A trait for highly composable constraints ("facts") which can be used both to verify data and to generate arbitrary data within those constraints
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use arbitrary::*;
use contrafact::{facts::*, utils::random_generator, *};

#[derive(Arbitrary, Debug, Clone, PartialEq, Eq, std::hash::Hash)]
enum Color {
    Cyan,
    Magenta,
    Yellow,
    Black,
}

#[derive(Arbitrary, Debug, PartialEq, Clone)]
struct Link {
    prev: u32,
    author: String,
}

#[derive(Arbitrary, Debug, PartialEq, Clone)]
struct Wrapper {
    color: Color,
    link: Link,
}

/// Fact: all Links in a chain are by the same `author`, and any chain link has
/// consecutive `prev` values starting with 0.
fn chain_fact<'a>(author: String) -> impl Fact<'a, Link> {
    facts![
        lens1("Link::author", |o: &mut Link| &mut o.author, eq(author),),
        lens1(
            "Link::prev",
            |o: &mut Link| &mut o.prev,
            consecutive_int("increasing prev", 0),
        ),
    ]
}

/// Fact: the Links within each wrapper form a valid chain, and the color
/// of the wrapper is in the given set.
fn wrapper_fact<'a>(author: String, valid_colors: &'a [Color]) -> impl Fact<'a, Wrapper> {
    facts![
        lens1(
            "Wrapper::color",
            |o: &mut Wrapper| &mut o.color,
            in_slice("valid color", valid_colors),
        ),
        lens1(
            "Wrapper::link",
            |o: &mut Wrapper| &mut o.link,
            chain_fact(author),
        ),
    ]
}

#[test]
fn test_link() {
    observability::test_run().ok();
    let mut g = random_generator();

    const NUM: u32 = 10;
    let author = "alice".to_string();
    let fact = move || vec_of_length(NUM as usize, chain_fact(author.clone()));

    let chain = fact().build(&mut g);
    dbg!(&chain);
    fact().check(&chain).unwrap();

    assert!(chain.iter().all(|c| c.author == "alice"));
    assert_eq!(chain.iter().last().unwrap().prev, NUM - 1);
}

#[test]
fn test_wrapper() {
    observability::test_run().ok();
    let mut g = random_generator();

    const NUM: u32 = 10;
    let author = "alice".to_string();
    let fact = move || {
        vec_of_length(
            NUM as usize,
            wrapper_fact(author.clone(), &[Color::Cyan, Color::Magenta]),
        )
    };

    let chain = fact().build(&mut g);
    dbg!(&chain);
    fact().check(&chain).unwrap();

    assert!(chain.iter().all(|c| c.link.author == "alice"));
    assert!(chain.iter().all(|c| c.color != Color::Black));
    assert_eq!(chain.iter().last().unwrap().link.prev, NUM - 1);

    // there is a high probability that this will be true
    assert!(chain.iter().any(|c| c.color == Color::Magenta));
}