dco3 0.20.1

Async API wrapper for DRACOON in Rust.
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
163

#[cfg(test)]
mod tests {
    use dco3_crypto::{DracoonCrypto, DracoonRSACrypto, UserKeyPairContainer};

    use crate::{
        tests::dracoon::{assert_user_account, get_connected_client},
        user::UpdateUserAccountRequest,
        User, UserAccountKeyPairs,
    };

    #[tokio::test]
    async fn test_get_keypair() {
        let (client, mock_server) = get_connected_client().await;
        let mut mock_server = mock_server;

        let keypair_res = include_str!("../tests/responses/keypair_ok.json");

        let kp_from_json = serde_json::from_str::<UserKeyPairContainer>(keypair_res).unwrap();
        let plain_kp_compare =
            DracoonCrypto::decrypt_keypair("TopSecret1234!", kp_from_json).unwrap();

        let keypair_mock = mock_server
            .mock("GET", "/api/v4/user/account/keypair")
            .with_status(200)
            .with_body(keypair_res)
            .with_header("content-type", "application/json")
            .create();

        let keypair = client
            .user()
            .get_user_keypair("TopSecret1234!")
            .await
            .unwrap();

        keypair_mock.assert();

        assert_eq!(
            keypair.private_key_container.private_key,
            plain_kp_compare.private_key_container.private_key
        );
        assert_eq!(
            keypair.public_key_container.public_key,
            plain_kp_compare.public_key_container.public_key
        );
        assert_eq!(
            keypair.private_key_container.version,
            plain_kp_compare.private_key_container.version
        );
        assert_eq!(
            keypair.public_key_container.version,
            plain_kp_compare.public_key_container.version
        );
    }

    #[tokio::test]
    async fn test_set_keypair() {
        let (client, mock_server) = get_connected_client().await;
        let mut mock_server = mock_server;

        let keypair_mock = mock_server
            .mock("POST", "/api/v4/user/account/keypair")
            .with_status(204)
            .create();

        let res = client.user().set_user_keypair("TopSecret1234!").await;

        keypair_mock.assert();

        assert!(res.is_ok());
    }

    #[tokio::test]
    async fn test_delete_keypair() {
        let (client, mock_server) = get_connected_client().await;
        let mut mock_server = mock_server;

        let keypair_mock = mock_server
            .mock("DELETE", "/api/v4/user/account/keypair")
            .with_status(204)
            .create();

        let res = client.user().delete_user_keypair().await;

        keypair_mock.assert();

        assert!(res.is_ok());
    }

    #[tokio::test]
    async fn test_get_user_account() {
        let (client, mut mock_server) = get_connected_client().await;

        let account_res = include_str!("../tests/responses/user_info_ok.json");
        let user_account_mock = mock_server
            .mock("GET", "/api/v4/user/account")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(account_res)
            .create();

        let user_account = client.user().get_user_account().await.unwrap();

        user_account_mock.assert();

        assert_user_account(&user_account);
    }

    #[tokio::test]
    async fn test_update_user_account() {
        let (client, mut mock_server) = get_connected_client().await;

        let account_res = include_str!("../tests/responses/user_info_ok.json");

        let user_account_mock = mock_server
            .mock("PUT", "/api/v4/user/account")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(account_res)
            .create();

        let update = UpdateUserAccountRequest::builder()
            .with_first_name("test")
            .with_last_name("test")
            .with_phone("test")
            .with_email("test@localhost")
            .build();

        let user_account = client.user().update_user_account(update).await.unwrap();

        user_account_mock.assert();

        assert_user_account(&user_account);
    }

    #[tokio::test]
    async fn test_get_customer_info() {
        let (client, mut mock_server) = get_connected_client().await;

        let customer_res = include_str!("../tests/responses/customer_info_ok.json");

        let customer_mock = mock_server
            .mock("GET", "/api/v4/user/account/customer")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(customer_res)
            .create();

        let customer = client.user().get_customer_info().await.unwrap();

        customer_mock.assert();

        assert_eq!(customer.name, "string");
        assert_eq!(customer.id, 1);
        assert!(customer.is_provider_customer);
        assert_eq!(customer.accounts_limit, 100);
        assert_eq!(customer.space_limit, 100);
        assert_eq!(customer.space_used, 10);
        assert_eq!(customer.accounts_used, 10);
        assert_eq!(customer.cnt_guest_user.unwrap(), 1);
        assert_eq!(customer.cnt_internal_user.unwrap(), 9);
        assert!(customer.customer_encryption_enabled);
    }
}