coder 0.3.5

Asynchronous, pure Rust bindings to the Coder On-Prem 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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

imports!();

new_builder!(
    /// /api/orgs/:id
    Org,
    /// /api/orgs
    Orgs,
    /// /api/orgs/:id/members/:id
    Member,
    /// /api/orgs/:id/members
    Members,
    /// /api/orgs/namespaces
    OrgNamespaces
);

exec!(
    Org -> crate::models::Organization,
    Orgs -> Vec<crate::models::Organization>,

    Member -> crate::models::OrgMember,
    Members -> Vec<crate::models::OrgMember>,

    OrgNamespaces -> Vec<String>,
);

from!(
    @Orgs
        -> Org,
        -> OrgNamespaces,
    @Org
        -> Members,
    @Members
        -> Member,
);

impl_client!(
    /// Begins an organization query.
    -> orgs ["orgs"] -> Orgs,
);

impl_builder!(
    @Orgs
        /// Queries an organization by its id.
        => get [] -> Org = id,
        /// Queries the available namespaces for organizations.
        -> namespaces ["namespaces"] -> OrgNamespaces,
    @Org
        /// Queries all members in an organization.
        -> members ["members"] -> Members,
    @Members
        /// Queries a specific member in an organization by their user id.
        => get [] -> Member = user_id,
);

#[cfg(test)]
mod test {
    use crate::client::test::{client, ids::*};
    use crate::client::Executor;

    #[tokio::test]
    async fn test_orgs() {
        let c = client();

        let res = c
            .orgs()
            .execute()
            .await
            .expect("send request")
            .response
            .expect("api error returned");

        // we should have at least one
        assert_ne!(res.len(), 0);

        // they should all have non-empty ids
        let ok = res.iter().fold(false, |ok, org| ok || org.id != "");
        assert_eq!(ok, true);
    }

    #[tokio::test]
    async fn test_org() {
        let c = client();

        let res = c
            .orgs()
            .get(ORG_ID)
            .execute()
            .await
            .expect("send request")
            .response
            .expect("api error returned");

        // just make sure the id is correct
        assert_eq!(res.id, ORG_ID);
    }

    #[tokio::test]
    async fn test_org_namespaces() {
        let c = client();

        let res = c
            .orgs()
            .namespaces()
            .execute()
            .await
            .expect("send request")
            .response
            .expect("api error returned");

        // we should get at least 1
        assert_ne!(res.len(), 0);

        // they should all be a non-empty string
        let ok = res.iter().fold(false, |ok, n| ok || n != "");
        assert_eq!(ok, true);
    }

    mod members {
        use super::*;

        #[tokio::test]
        async fn test_org_members() {
            let c = client();

            let res = c
                .orgs()
                .get(ORG_ID)
                .members()
                .execute()
                .await
                .expect("send request")
                .response
                .expect("api error returned");

            // we should get at least 1
            assert_ne!(res.len(), 0);

            // they should all have non-empty ids
            let ok = res.iter().fold(false, |ok, mem| ok || mem.user.id != "");
            assert_eq!(ok, true);
        }

        #[tokio::test]
        async fn test_org_member() {
            let c = client();

            let res = c
                .orgs()
                .get(ORG_ID)
                .members()
                .get(MEMBER_ID)
                .execute()
                .await
                .expect("send request")
                .response
                .expect("api error returned");

            // id should be a non-empty string
            assert_ne!(res.user.id, "");
        }
    }
}