camel-dsl 0.7.6

DSL support for rust-camel (YAML, etc)
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

use camel_core::route::BuilderStep;
use camel_dsl::compile::compile_declarative_step;
use camel_dsl::{DeclarativeRoute, DeclarativeStep, yaml::parse_yaml_to_declarative};

fn parse_routes(yaml: &str) -> Vec<DeclarativeRoute> {
    parse_yaml_to_declarative(yaml).expect("YAML should parse")
}

#[test]
fn stream_cache_step_compiles_to_pipeline() {
    let yaml = r#"
routes:
  - id: "sc-basic"
    from: "direct:start"
    steps:
      - stream_cache: true
      - to: "log:out"
"#;
    let routes = parse_routes(yaml);
    assert_eq!(routes.len(), 1);
    assert!(matches!(
        &routes[0].steps[0],
        DeclarativeStep::StreamCache(_)
    ));
}

#[test]
fn convert_body_to_after_stream_source() {
    let yaml = r#"
routes:
  - id: "sc-convert"
    from: "direct:start"
    steps:
      - stream_cache: true
      - convert_body_to: "text"
      - to: "log:out"
"#;
    let routes = parse_routes(yaml);
    assert_eq!(routes.len(), 1);
    assert_eq!(routes[0].steps.len(), 3);
}

#[test]
fn stream_cache_with_custom_threshold() {
    let yaml = r#"
routes:
  - id: "sc-threshold"
    from: "direct:start"
    steps:
      - stream_cache: { threshold: 65536 }
      - to: "log:out"
"#;
    let routes = parse_routes(yaml);
    assert_eq!(routes.len(), 1);
    match &routes[0].steps[0] {
        DeclarativeStep::StreamCache(def) => assert_eq!(def.threshold, Some(65536)),
        other => panic!("expected StreamCache, got {:?}", other),
    }
}

#[test]
fn stream_cache_with_unmarshal() {
    let yaml = r#"
routes:
  - id: "sc-unmarshal"
    from: "direct:start"
    steps:
      - stream_cache: true
      - unmarshal: "json"
      - to: "log:out"
"#;
    let routes = parse_routes(yaml);
    assert_eq!(routes.len(), 1);
    assert_eq!(routes[0].steps.len(), 3);
}

#[test]
fn stream_cache_false_rejected() {
    let yaml = r#"
routes:
  - id: "sc-false"
    from: "direct:start"
    steps:
      - stream_cache: false
"#;
    let result = parse_yaml_to_declarative(yaml);
    let err = result.expect_err("stream_cache: false should be rejected");
    let msg = err.to_string();
    assert!(
        msg.contains("stream_cache: false"),
        "error should mention stream_cache: false, got: {msg}"
    );
}

#[test]
fn stream_cache_compiles_to_processor() {
    use camel_dsl::model::StreamCacheStepDef;
    let step = DeclarativeStep::StreamCache(StreamCacheStepDef { threshold: None });
    let result = compile_declarative_step(step);
    assert!(result.is_ok());
    assert!(matches!(result.unwrap(), BuilderStep::Processor(_)));
}

#[test]
fn stream_cache_full_pipeline() {
    let yaml = r#"
routes:
  - id: "sc-full"
    from: "direct:start"
    steps:
      - stream_cache: true
      - convert_body_to: "text"
      - set_header:
          key: "processed"
          value: "true"
      - to: "log:out"
"#;
    let routes = parse_routes(yaml);
    assert_eq!(routes.len(), 1);
    assert_eq!(routes[0].steps.len(), 4);
}