camel-component-jms 0.28.0

JMS component for rust-camel via Java bridge
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

use camel_component_api::UriConfig;

#[allow(dead_code)]
#[derive(UriConfig)]
#[uri_scheme = "jms"]
#[uri_config(
    skip_impl,
    descriptor,
    metadata(
        scheme = "jms",
        description = "JMS / ActiveMQ / Artemis messaging",
        producer,
        consumer
    ),
    crate = "camel_component_api"
)]
pub(super) struct JmsMetadataDescriptor {
    #[uri_param(name = "broker")]
    pub _broker: Option<String>,

    #[uri_param(name = "acknowledgementMode", default = "Auto")]
    pub _acknowledgement_mode: String,

    #[uri_param(name = "messageSelector")]
    pub _message_selector: Option<String>,

    #[uri_param(name = "concurrentConsumers", default = "1")]
    pub _concurrent_consumers: u32,

    #[uri_param(name = "transactionMode", default = "None")]
    pub _transaction_mode: String,

    #[uri_param(name = "timeToLive")]
    pub _time_to_live: Option<u64>,

    #[uri_param(name = "priority")]
    pub _priority: Option<u8>,

    #[uri_param(name = "persistentDelivery", default = "true")]
    pub _persistent_delivery: bool,

    #[uri_param(name = "mapJmsHeaders", default = "true")]
    pub _map_jms_headers: bool,

    #[uri_param(name = "exchangePattern", default = "InOnly")]
    pub _exchange_pattern: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    use camel_component_api::ComponentMetadata;

    fn find<'a>(
        meta: &'a [camel_component_api::UriOption],
        name: &str,
    ) -> &'a camel_component_api::UriOption {
        meta.iter()
            .find(|o| o.name == name)
            .unwrap_or_else(|| panic!("uri_option '{}' not found", name))
    }

    #[test]
    fn jms_metadata_uri_options_parity() {
        let meta: ComponentMetadata = JmsMetadataDescriptor::metadata();
        let mut names: Vec<&str> = meta.uri_options.iter().map(|o| o.name.as_str()).collect();
        names.sort();

        let mut expected = vec![
            "acknowledgementMode",
            "broker",
            "concurrentConsumers",
            "exchangePattern",
            "mapJmsHeaders",
            "messageSelector",
            "persistentDelivery",
            "priority",
            "timeToLive",
            "transactionMode",
        ];
        expected.sort();

        assert_eq!(
            names, expected,
            "metadata uri_options names must match parser keys"
        );

        // ── required + default_value assertions ──────────────────────────────

        // Option<String> fields — never required
        assert!(!find(&meta.uri_options, "broker").required);
        assert!(!find(&meta.uri_options, "messageSelector").required);
        assert!(!find(&meta.uri_options, "timeToLive").required);
        assert!(!find(&meta.uri_options, "priority").required);

        // descriptor-defaulted fields — not required, carry runtime default
        let ack = find(&meta.uri_options, "acknowledgementMode");
        assert_eq!(ack.default_value.as_deref(), Some("Auto"));
        assert!(!ack.required);

        let tx = find(&meta.uri_options, "transactionMode");
        assert_eq!(tx.default_value.as_deref(), Some("None"));
        assert!(!tx.required);

        let ep = find(&meta.uri_options, "exchangePattern");
        assert_eq!(ep.default_value.as_deref(), Some("InOnly"));
        assert!(!ep.required);

        // Existing defaults — keep
        assert_eq!(
            find(&meta.uri_options, "concurrentConsumers")
                .default_value
                .as_deref(),
            Some("1")
        );
        assert!(!find(&meta.uri_options, "concurrentConsumers").required);
        assert_eq!(
            find(&meta.uri_options, "persistentDelivery")
                .default_value
                .as_deref(),
            Some("true")
        );
        assert!(!find(&meta.uri_options, "persistentDelivery").required);
        assert_eq!(
            find(&meta.uri_options, "mapJmsHeaders")
                .default_value
                .as_deref(),
            Some("true")
        );
        assert!(!find(&meta.uri_options, "mapJmsHeaders").required);
    }
}