trellis-testing 0.1.1

Companion testing support for Trellis graph invariants.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use trellis_core::{Graph, TransactionPhase};
use trellis_testing::{
    ConformanceCheckResult, ConformanceLevel, ConformanceSuite, Scenario, conformance,
};

fn deterministic_graph_dump() -> String {
    let mut graph = Graph::<(), usize>::new_with_output_type();
    let mut tx = graph.begin_transaction().unwrap();
    let scope = tx.create_scope("screen").unwrap();
    let input = tx.input::<usize>("count").unwrap();
    tx.set_input(input, 1).unwrap();
    tx.attach_node_to_scope(input, scope).unwrap();
    tx.commit().unwrap();
    drop(tx);
    graph.debug_dump()
}

#[test]
fn executable_conformance_runs_app_owned_checks() {
    let report = conformance()
        .check(
            ConformanceLevel::DeterministicTrace,
            "debug dump is deterministic",
            || {
                if deterministic_graph_dump() == deterministic_graph_dump() {
                    ConformanceCheckResult::passed()
                } else {
                    ConformanceCheckResult::failed("debug dump differed between fresh graphs")
                }
            },
        )
        .unsupported(
            ConformanceLevel::GeneratedModelSequences,
            "app has not opted into generated sequence hooks",
        )
        .run()
        .unwrap();

    assert!(report.supports(ConformanceLevel::DeterministicTrace));
    assert!(
        report
            .unsupported_levels()
            .contains(&ConformanceLevel::GeneratedModelSequences)
    );
    assert_eq!(report.check_results().len(), 1);
}

#[test]
fn required_levels_without_hooks_are_reported_unsupported() {
    let report = ConformanceSuite::all()
        .runner()
        .check(
            ConformanceLevel::DeterministicTrace,
            "phase order is stable",
            || {
                let mut graph = Graph::<(), ()>::new();
                let mut tx = graph.begin_transaction().unwrap();
                let result = tx.commit().unwrap();
                drop(tx);
                if result
                    .phase_trace
                    .contains(&TransactionPhase::ReturnTransactionResult)
                {
                    ConformanceCheckResult::passed()
                } else {
                    ConformanceCheckResult::failed("missing return phase")
                }
            },
        )
        .run()
        .unwrap();

    assert!(report.supports(ConformanceLevel::DeterministicTrace));
    assert!(
        report
            .unsupported_levels()
            .contains(&ConformanceLevel::MaterializedOutput)
    );
    assert!(
        report
            .unsupported_reasons()
            .get(&ConformanceLevel::MaterializedOutput)
            .unwrap()
            .iter()
            .any(|reason| reason.contains("no conformance check registered"))
    );
}

#[test]
fn failures_include_invariant_and_trace_context() {
    let mut scenario = Scenario::new();
    let mut graph = Graph::<(), ()>::new();
    let mut tx = graph.begin_transaction().unwrap();
    let result = tx.commit().unwrap();
    drop(tx);
    scenario.record("empty", &result);

    let failure = conformance()
        .check(
            ConformanceLevel::DeterministicTrace,
            "same input sequence produces same trace",
            move || {
                ConformanceCheckResult::failed(format!(
                    "scenario empty trace: {:#?}",
                    scenario.step("empty").unwrap().trace
                ))
            },
        )
        .run()
        .unwrap_err();

    assert_eq!(
        failure.invariant,
        "same input sequence produces same trace".to_owned()
    );
    assert!(failure.detail.contains("scenario empty trace"));
}