camel-component-grpc 0.11.1

gRPC component for rust-camel (dynamic producer and consumer)
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

use prost_reflect::MethodDescriptor;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GrpcMode {
    Unary,
    ServerStreaming,
    ClientStreaming,
    Bidi,
}

impl GrpcMode {
    pub fn from_method(method: &MethodDescriptor) -> Self {
        match (method.is_server_streaming(), method.is_client_streaming()) {
            (false, false) => GrpcMode::Unary,
            (true, false) => GrpcMode::ServerStreaming,
            (false, true) => GrpcMode::ClientStreaming,
            (true, true) => GrpcMode::Bidi,
        }
    }
}

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

    #[test]
    fn test_grpc_mode_variants_exist() {
        let _ = GrpcMode::Unary;
        let _ = GrpcMode::ServerStreaming;
        let _ = GrpcMode::ClientStreaming;
        let _ = GrpcMode::Bidi;
    }

    #[test]
    fn test_grpc_mode_equality() {
        assert_eq!(GrpcMode::Unary, GrpcMode::Unary);
        assert_ne!(GrpcMode::Unary, GrpcMode::Bidi);
        assert_eq!(GrpcMode::ServerStreaming, GrpcMode::ServerStreaming);
        assert_ne!(GrpcMode::ClientStreaming, GrpcMode::ServerStreaming);
    }

    #[test]
    fn test_grpc_mode_copy_and_clone() {
        let mode = GrpcMode::Unary;
        let copied = mode;
        #[allow(clippy::clone_on_copy)]
        let cloned = mode.clone();
        assert_eq!(mode, copied);
        assert_eq!(mode, cloned);
    }

    #[test]
    fn test_grpc_mode_debug() {
        let debug_unary = format!("{:?}", GrpcMode::Unary);
        assert!(debug_unary.contains("Unary"));

        let debug_bidi = format!("{:?}", GrpcMode::Bidi);
        assert!(debug_bidi.contains("Bidi"));
    }

    #[test]
    fn test_grpc_mode_all_variants_distinct() {
        let modes = [
            GrpcMode::Unary,
            GrpcMode::ServerStreaming,
            GrpcMode::ClientStreaming,
            GrpcMode::Bidi,
        ];
        for (i, a) in modes.iter().enumerate() {
            for (j, b) in modes.iter().enumerate() {
                if i == j {
                    assert_eq!(a, b);
                } else {
                    assert_ne!(a, b);
                }
            }
        }
    }
}