bpxe 0.2.1

Business Process eXecution Engine
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

use bpxe;
use bpxe::bpmn::schema::*;
use bpxe_internal_macros as bpxe_im;

#[cfg(all(test, target_arch = "wasm32", target_os = "unknown"))]
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);

#[bpxe_im::test]
fn parse_sample() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(sample).unwrap();
    assert!(definitions.root_elements.len() > 0);
}

#[bpxe_im::test]
fn parse_formal_expr() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(sample).unwrap();
    let flow = definitions
        .find_by_id("x2")
        .unwrap()
        .downcast_ref::<SequenceFlow>()
        .unwrap();
    assert!(matches!(&flow.condition_expression,
            Some(SequenceFlowConditionExpression(Expr::FormalExpression(FormalExpression{ content: Some(content), .. })))
            if content == "a"));
}

#[bpxe_im::test]
fn parse_expr() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(sample).unwrap();
    let flow = definitions
        .find_by_id("x3")
        .unwrap()
        .downcast_ref::<SequenceFlow>()
        .unwrap();
    assert!(matches!(
        &flow.condition_expression,
        Some(SequenceFlowConditionExpression(Expr::Expression(_)))
    ));
}

#[bpxe_im::test]
fn normalization() {
    let sample = include_str!("fixtures/sample_ns.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    assert!(definitions.root_elements.len() > 0);
}

#[bpxe_im::test]
fn serialize_deserialize_serde_yaml() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    let yaml = serde_yaml::to_string(&definitions).unwrap();
    let definitions_1: Definitions = serde_yaml::from_str(&yaml).unwrap();
    assert_eq!(definitions_1, definitions);
}

#[bpxe_im::test]
fn serialize_deserialize_serde_json() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    let json = serde_json::to_string(&definitions).unwrap();
    let definitions_1: Definitions = serde_json::from_str(&json).unwrap();
    assert_eq!(definitions_1, definitions);
}

#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] // ignore on wasm32-unknown for now
#[bpxe_im::test]
#[ignore] // FIXME: https://github.com/bpxe/bpxe.rs/issues/3
fn serialize_deserialize_serde_toml() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    let toml = toml::to_string(&definitions).unwrap();
    let definitions_1: Definitions = toml::from_str(&toml).unwrap();
    assert_eq!(definitions_1, definitions);
}

#[bpxe_im::test]
fn serialize_deserialize_serde_ron() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    let ron = ron::to_string(&definitions).unwrap();
    let definitions_1: Definitions = ron::from_str(&ron).unwrap();
    assert_eq!(definitions_1, definitions);
}

#[bpxe_im::test]
fn serialize_deserialize_serde_message_pack() {
    let sample = include_str!("fixtures/sample.bpmn");
    let definitions = bpxe::bpmn::parse(&sample).unwrap();
    let msgpack = rmp_serde::to_vec(&definitions).unwrap();
    let definitions_1: Definitions = rmp_serde::from_read(std::io::Cursor::new(msgpack)).unwrap();
    assert_eq!(definitions_1, definitions);
}