nomad_client_rs/api/
variable.rs

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
133
134
135
use reqwest::Method;

use crate::api::path_combine;
use crate::api::variable::models::{
    VariableCreateRequest, VariableDeleteParams, VariableGetParams, VariableListParams,
};
use crate::models::variable::Variable;
use crate::{ClientError, NomadClient};

impl NomadClient {
    pub async fn variables_list(
        &self,
        params: &VariableListParams,
    ) -> Result<Vec<Variable>, ClientError> {
        let req = self.request(Method::GET, "/vars").query(&params);

        self.send::<Vec<Variable>>(req).await
    }

    pub async fn variable_get(
        &self,
        var_path: &str,
        params: &VariableGetParams,
    ) -> Result<Variable, ClientError> {
        let req = self
            .request(Method::GET, &path_combine("/var", var_path))
            .query(&params);

        self.send::<Variable>(req).await
    }

    pub async fn variable_create(
        &self,
        var_path: &str,
        req: &VariableCreateRequest,
    ) -> Result<Variable, ClientError> {
        let req = self
            .request(Method::PUT, &path_combine("/var", var_path))
            .json(&req);

        self.send::<Variable>(req).await
    }

    pub async fn variable_delete(
        &self,
        var_path: &str,
        params: &VariableDeleteParams,
    ) -> Result<(), ClientError> {
        let req = self
            .request(Method::DELETE, &path_combine("/var", var_path))
            .query(&params);

        self.send_plain(req).await.map(|_| ())
    }
}

pub mod models {
    use std::collections::HashMap;

    use serde::Serialize;

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "camelCase")]
    pub struct VariableListParams {
        pub prefix: Option<String>,
        #[serde(rename = "next_token")]
        pub next_token: Option<String>,
        #[serde(rename = "per_page")]
        pub per_page: Option<u64>,
        pub filter: Option<String>,
        pub namespace: Option<String>,
    }

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "camelCase")]
    pub struct VariableGetParams {
        pub namespace: Option<String>,
    }

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "PascalCase")]
    pub struct VariableCreateRequest {
        pub namespace: String,
        pub path: String,
        pub items: HashMap<String, String>,
    }

    #[derive(Debug, Default, Serialize)]
    #[serde(rename_all = "camelCase")]
    pub struct VariableDeleteParams {
        pub namespace: Option<String>,
    }
}

#[cfg(test)]
mod tests {
    use crate::api::namespace::models::{NamespaceListParams, NamespaceRequest};
    use crate::api::variable::models::{VariableCreateRequest, VariableDeleteParams};
    use crate::models::variable::Variable;
    use crate::{ClientError, NomadClient};

    #[tokio::test]
    async fn variable_create() {
        let client = NomadClient::default();

        let mut request = VariableCreateRequest::default();
        request.items.insert("key".to_string(), "value".to_string());

        match client.variable_create("testVariable", &request).await {
            Ok(_) => assert!(true),
            Err(err) => panic!("{err}"),
        }
    }

    #[tokio::test]
    async fn variable_delete_should_return_void() {
        let client = NomadClient::default();

        match client
            .variable_delete("thisDoesNotExist", &VariableDeleteParams::default())
            .await
        {
            Ok(v) => assert!(true),
            Err(e) => panic!("{:#?}", e),
        }

        match client
            .variable_delete("testVariable", &VariableDeleteParams::default())
            .await
        {
            Ok(_) => assert!(true),
            Err(err) => panic!("{err}"),
        }
    }
}