lemma-engine 0.8.10

A language that means business.
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
146
147
148
149
150
151
152
153
154

use lemma::parsing::ast::DateTimeValue;
use lemma::Engine;
use std::collections::HashMap;

#[test]
fn test_equal_operator_numbers() {
    let mut engine = Engine::new();
    engine
        .load(
            r#"
spec test_equal_numbers

fact a: 42
fact b: 42
fact c: 100

rule equal_true: a is b
rule equal_false: a is c
"#,
            lemma::SourceType::Labeled("test.lemma"),
        )
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run("test_equal_numbers", Some(&now), HashMap::new(), false)
        .unwrap();

    let equal_true = response.results.get("equal_true").unwrap();
    assert_eq!(equal_true.result.value().unwrap().to_string(), "true");

    let equal_false = response.results.get("equal_false").unwrap();
    assert_eq!(equal_false.result.value().unwrap().to_string(), "false");
}

#[test]
fn test_equal_operator_text() {
    let mut engine = Engine::new();
    engine
        .load(
            r#"
spec test_equal_text

fact greeting: "hello"
fact other: "world"

rule same_greeting: greeting is "hello"
rule different_greeting: greeting is other
"#,
            lemma::SourceType::Labeled("test.lemma"),
        )
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run("test_equal_text", Some(&now), HashMap::new(), false)
        .unwrap();

    let same = response.results.get("same_greeting").unwrap();
    assert_eq!(same.result.value().unwrap().to_string(), "true");

    let different = response.results.get("different_greeting").unwrap();
    assert_eq!(different.result.value().unwrap().to_string(), "false");
}

#[test]
fn test_equal_operator_money() {
    let mut engine = Engine::new();
    engine
        .load(
            r#"
spec test_equal_money

fact price_a: 100
fact price_b: 100
fact price_c: 50

rule same_price: price_a is price_b
rule different_price: price_a is price_c
"#,
            lemma::SourceType::Labeled("test.lemma"),
        )
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run("test_equal_money", Some(&now), HashMap::new(), false)
        .unwrap();

    let same = response.results.get("same_price").unwrap();
    assert_eq!(same.result.value().unwrap().to_string(), "true");

    let different = response.results.get("different_price").unwrap();
    assert_eq!(different.result.value().unwrap().to_string(), "false");
}

#[test]
fn test_equal_operator_booleans() {
    let mut engine = Engine::new();
    engine
        .load(
            r#"
spec test_equal_booleans

fact flag_a: true
fact flag_b: true
fact flag_c: false

rule both_true: flag_a is flag_b
rule mixed: flag_a is flag_c
"#,
            lemma::SourceType::Labeled("test.lemma"),
        )
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run("test_equal_booleans", Some(&now), HashMap::new(), false)
        .unwrap();

    let both_true = response.results.get("both_true").unwrap();
    assert_eq!(both_true.result.value().unwrap().to_string(), "true");

    let mixed = response.results.get("mixed").unwrap();
    assert_eq!(mixed.result.value().unwrap().to_string(), "false");
}

#[test]
fn test_equal_operator_in_conditions() {
    let mut engine = Engine::new();
    engine
        .load(
            r#"
spec test_equal_conditions

fact status: "active"
fact count: 10

rule message: "inactive"
  unless status is "active" then "active"
  unless count is 10 then "count is 10"
"#,
            lemma::SourceType::Labeled("test.lemma"),
        )
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run("test_equal_conditions", Some(&now), HashMap::new(), false)
        .unwrap();

    let message = response.results.get("message").unwrap();
    assert_eq!(message.result.value().unwrap().to_string(), "count is 10");
}