lemma-engine 0.9.9

A pure, declarative language for business rules.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Rule-embed evaluation schedule: deps evaluate in plan order; tip-only
//! missing_data matches full-run missing_data for gated dependencies.

use lemma::{DateTimeValue, Engine, SourceType};
use rust_decimal::Decimal;
use std::collections::HashMap;
use std::str::FromStr;

#[test]
fn unless_gated_dep_flag_false_empty_missing_data() {
    let mut engine = Engine::new();
    engine
        .load([(
            SourceType::Volatile,
            r#"
spec gated
data amount: number
data flag: boolean
rule dep: amount * 2
rule total: 0
  unless flag then dep
"#
            .to_string(),
        )])
        .expect("load");
    let now = DateTimeValue::now();
    let mut data = HashMap::new();
    data.insert("flag".to_string(), "false".to_string());
    let response = engine
        .run(
            None,
            "gated",
            Some(&now),
            data,
            Some(&["total".to_string()]),
            false,
        )
        .expect("run");
    let total = response.results.get("total").expect("total");
    assert!(!total.vetoed);
    assert!(
        total.missing_data().is_empty(),
        "flag=false must not surface amount: {:?}",
        total.missing_data()
    );
    let number = Decimal::from_str(
        total
            .value
            .as_ref()
            .expect("value")
            .number
            .as_ref()
            .expect("number"),
    )
    .expect("decimal");
    assert_eq!(number, Decimal::ZERO);
}

#[test]
fn unless_gated_dep_flag_true_lists_amount() {
    let mut engine = Engine::new();
    engine
        .load([(
            SourceType::Volatile,
            r#"
spec gated
data amount: number
data flag: boolean
rule dep: amount * 2
rule total: 0
  unless flag then dep
"#
            .to_string(),
        )])
        .expect("load");
    let now = DateTimeValue::now();
    let mut data = HashMap::new();
    data.insert("flag".to_string(), "true".to_string());
    let response = engine
        .run(
            None,
            "gated",
            Some(&now),
            data,
            Some(&["total".to_string()]),
            false,
        )
        .expect("run");
    let total = response.results.get("total").expect("total");
    assert!(total.vetoed);
    assert!(
        total.awaits_missing_data(),
        "flag=true unbound amount must await: {:?}",
        total.veto_reason
    );
    assert_eq!(
        total.missing_data(),
        &["amount".to_string()][..],
        "live dep arm must list amount: {:?}",
        total.missing_data()
    );
}

#[test]
fn cross_spec_tip_only_run() {
    let mut engine = Engine::new();
    engine
        .load([(
            SourceType::Volatile,
            r#"
spec a
rule x: 7

spec b
uses a: a
rule y: a.x + 1
"#
            .to_string(),
        )])
        .expect("load");
    let now = DateTimeValue::now();
    let response = engine
        .run(
            None,
            "b",
            Some(&now),
            HashMap::new(),
            Some(&["y".to_string()]),
            false,
        )
        .expect("run");
    assert_eq!(response.results.len(), 1);
    let y = response.results.get("y").expect("y");
    assert!(!y.vetoed);
    let number = Decimal::from_str(
        y.value
            .as_ref()
            .expect("value")
            .number
            .as_ref()
            .expect("number"),
    )
    .expect("decimal");
    assert_eq!(number, Decimal::from(8));
}