gotify 0.4.0

Idiomatic client for the Gotify 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
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

use reqwest::Method;

use crate::{models::Client, utils::request_builder, ClientClient, Result};

/// List, create, update or delete clients.
impl ClientClient {
    /// Return all clients.
    pub async fn get_clients(&self) -> Result<Vec<Client>> {
        self.request(Method::GET, ["client"])
            .send_and_read_json()
            .await
    }
    /// Create a client.
    pub fn create_client(&self, name: impl Into<String>) -> ClientBuilder {
        ClientBuilder::new(self, name)
    }
    /// Update a client.
    pub fn update_client(&self, id: i64, name: impl Into<String>) -> ClientUpdateBuilder {
        ClientUpdateBuilder::new(self, id, name)
    }
    /// Delete a client.
    pub async fn delete_client(&self, id: i64) -> Result<()> {
        self.request(Method::DELETE, ["client".into(), id.to_string()])
            .send()
            .await
    }
}

request_builder! {
    name = ClientBuilder,
    client_type = ClientClient,
    method = Method::POST,
    uri = ["client"],
    return_type = Client,
    required_fields = {
        name: impl Into<String> => .into() => String,
    },
    optional_fields = {}
}
request_builder! {
    name = ClientUpdateBuilder,
    client_type = ClientClient,
    method = Method::PUT,
    uri_with = |builder: &Self| ["client".into(), builder.id.to_string()],
    return_type = Client,
    required_fields = {
        #[serde(skip)]
        id: i64 => i64,
        name: impl Into<String> => .into() => String,
    },
    optional_fields = {}
}

#[cfg(test)]
pub(crate) mod tests {
    use crate::testsuite::*;

    #[apply(run_test_server!)]
    #[test]
    async fn get_clients() -> eyre::Result<()> {
        let clients = client_client().get_clients().await?;

        assert_eq!(
            clients.into_iter().map(|a| a.name).collect::<Vec<_>>(),
            vec!["gotify-rs"]
        );

        Ok(())
    }

    #[apply(run_test_server!)]
    #[test]
    async fn create_client() -> eyre::Result<()> {
        let client = client_client().create_application("new-client").await?;
        assert_eq!(client.name, "new-client");
        assert_eq!(client.description, "");

        Ok(())
    }

    #[apply(run_test_server!)]
    #[test]
    async fn update_client() -> eyre::Result<()> {
        let client = client_client();

        assert!(!client
            .get_clients()
            .await?
            .iter()
            .any(|a| a.name == "new-client-name"));

        let client = client.update_client(1, "new-client-name").await?;

        assert_eq!(client.name, "new-client-name");

        Ok(())
    }

    #[apply(run_test_server!)]
    #[test]
    async fn delete_client() -> eyre::Result<()> {
        let client = client_client();

        let new_client = client.create_client("new-client").await?;

        assert!(client
            .get_clients()
            .await?
            .iter()
            .any(|a| a.id == new_client.id));

        client.delete_client(new_client.id).await?;

        assert!(!client
            .get_clients()
            .await?
            .iter()
            .any(|a| a.id == new_client.id));

        Ok(())
    }
}