zlink-macros 0.4.2

Macros providing the high-level zlink API
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Error;

#[tokio::test]
async fn generic_test() {
    use serde_json::json;
    use zlink::{Connection, proxy, test_utils::mock_socket::MockSocket};

    #[derive(Debug, Serialize, Deserialize)]
    struct ProcessReply<'a> {
        #[serde(borrow)]
        result: &'a str,
    }

    #[proxy("org.example.Generic")]
    trait GenericProxy {
        async fn process<T: Serialize + std::fmt::Debug>(
            &mut self,
            data: T,
        ) -> zlink::Result<Result<ProcessReply<'_>, Error>>;
        async fn process2<U: Serialize + std::fmt::Debug>(
            &mut self,
            data: U,
        ) -> zlink::Result<Result<ProcessReply<'_>, Error>>;
    }

    // Test process with String type parameter
    let responses = json!({"parameters": {"result": "success"}}).to_string();
    let socket = MockSocket::with_responses(&[&responses]);
    let mut conn = Connection::new(socket);

    let result = conn
        .process("test data".to_string())
        .await
        .unwrap()
        .unwrap();
    assert_eq!(result.result, "success");

    // Test process2 with i32 type parameter
    let responses = json!({"parameters": {"result": "process2 result"}}).to_string();
    let socket = MockSocket::with_responses(&[&responses]);
    let mut conn = Connection::new(socket);

    let result = conn.process2(123).await.unwrap().unwrap();
    assert_eq!(result.result, "process2 result");
}

#[tokio::test]
async fn where_clause_test() {
    use serde_json::json;
    use zlink::{Connection, proxy, test_utils::mock_socket::MockSocket};

    #[derive(Debug, Serialize, Deserialize)]
    struct GetReply<'a> {
        #[serde(borrow)]
        value: &'a str,
    }

    #[proxy("org.example.WhereClause")]
    trait WhereProxy {
        async fn get<T>(&mut self, value: T) -> zlink::Result<Result<GetReply<'_>, Error>>
        where
            T: Serialize + std::fmt::Debug;
        async fn get2<U>(&mut self, value: U) -> zlink::Result<Result<GetReply<'_>, Error>>
        where
            U: Serialize + std::fmt::Debug;
    }

    // Test get with i32 type parameter
    let responses = json!({"parameters": {"value": "42"}}).to_string();
    let socket = MockSocket::with_responses(&[&responses]);
    let mut conn = Connection::new(socket);

    let result = conn.get(42).await.unwrap().unwrap();
    assert_eq!(result.value, "42");

    // Test get2 with bool type parameter
    let responses = json!({"parameters": {"value": "true"}}).to_string();
    let socket = MockSocket::with_responses(&[&responses]);
    let mut conn = Connection::new(socket);

    let result = conn.get2(true).await.unwrap().unwrap();
    assert_eq!(result.value, "true");
}