lemma-engine 0.9.0

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

use std::collections::HashMap;

use lemma::DateTimeValue;
use lemma::{Engine, ValueKind};

#[test]
fn test_duration_conversion_properties() {
    let mut engine = Engine::new();
    let code = r#"
spec test
uses lemma units
data duration: 60 minute
rule to_hours: duration as hour
"#;
    engine
        .load([(
            lemma::SourceType::Path(std::sync::Arc::new(std::path::PathBuf::from("test"))),
            code.to_string(),
        )])
        .unwrap();

    let now = DateTimeValue::now();
    let response = engine
        .run(None, "test", Some(&now), HashMap::new(), None, true)
        .unwrap();
    let rule_result = response
        .results
        .values()
        .find(|r| r.rule.name == "to_hours")
        .unwrap();
    let val = rule_result
        .explanation
        .as_ref()
        .expect("explanation")
        .result
        .value()
        .expect("value")
        .clone();

    if let ValueKind::Measure(_, _) = &val.value {
        assert_eq!(
            rule_result
                .measure
                .as_ref()
                .and_then(|m| m.get("hour"))
                .map(String::as_str),
            Some("1"),
            "60 minute as hour"
        );
    } else {
        panic!(
            "to_hours should be a Measure after conversion, got {:?}",
            val
        );
    }
}