opentalk-client-requests-api-v1 0.0.2

Datatypes that describe requests to the endpoints of the OpenTalk v1 API to be used by clients
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

// SPDX-FileCopyrightText: OpenTalk GmbH <mail@opentalk.eu>
//
// SPDX-License-Identifier: EUPL-1.2

use http_request_derive::HttpRequest;
use opentalk_types_api_v1::users::PrivateUserProfile;

/// *GET* request on `/users/me`
#[derive(Clone, Debug, PartialEq, Eq, Hash, HttpRequest)]
#[http_request(
        method = "GET",
        response = PrivateUserProfile,
        path = "/users/me",
)]
pub struct UsersMeGetRequest;

#[cfg(test)]
mod tests {
    use httpmock::MockServer;
    use opentalk_types_api_v1::users::PrivateUserProfile;
    use opentalk_types_common::{
        tariffs::TariffStatus,
        users::{DisplayName, Language, Theme, UserId, UserTitle},
        utils::ExampleData,
    };
    use pretty_assertions::assert_matches;

    use crate::{
        test_client::{TestClient, TestClientError},
        users::users_get_me_request::UsersMeGetRequest,
    };

    #[tokio::test]
    async fn success() {
        let server = MockServer::start();
        let response_body = PrivateUserProfile {
            id: UserId::example_data(),
            email: "mail@example.com".to_string(),
            title: UserTitle::example_data(),
            firstname: "Bob".to_string(),
            lastname: "Müller".to_string(),
            display_name: DisplayName::example_data(),
            avatar_url: "".to_string(),
            dashboard_theme: Some(Theme::example_data()),
            conference_theme: Some(Theme::example_data()),
            tariff_status: TariffStatus::Default,
            language: Language::default(),
            used_storage: 0,
        };

        let mock = server.mock(|when, then| {
            _ = when.method("GET").path("/users/me");
            _ = then.status(200).json_body_obj(&response_body);
        });

        let client = TestClient::new();

        let response = client
            .send_request(&server, UsersMeGetRequest)
            .await
            .expect("valid answer expected");

        mock.assert();

        assert_eq!(response_body.id, response.id);
    }

    #[tokio::test]
    async fn internal_server_error() {
        let server = MockServer::start();

        let mock = server.mock(|when, then| {
            _ = when.method("GET").path("/users/me");
            _ = then.status(500).body("internal server error");
        });

        let client = TestClient::new();

        assert_matches!(
            client.send_request(&server, UsersMeGetRequest).await,
            Err(TestClientError::HttpRequestDerive {
                source: http_request_derive::Error::NonSuccessStatus {
                    status: http::StatusCode::INTERNAL_SERVER_ERROR,
                    body: _,
                },
                message: _,
            })
        );

        mock.assert();
    }

    #[tokio::test]
    async fn unauthorized_error() {
        let server = MockServer::start();

        let response_body = PrivateUserProfile {
            id: UserId::example_data(),
            email: "mail@example.com".to_string(),
            title: UserTitle::example_data(),
            firstname: "Bob".to_string(),
            lastname: "Müller".to_string(),
            display_name: DisplayName::example_data(),
            avatar_url: "".to_string(),
            dashboard_theme: Some(Theme::example_data()),
            conference_theme: Some(Theme::example_data()),
            tariff_status: TariffStatus::Default,
            language: Language::default(),
            used_storage: 0,
        };

        let mock = server.mock(|when, then| {
            _ = when.method("GET").path("/users/me");
            _ = then.status(401).json_body_obj(&response_body);
        });

        let client = TestClient::new();

        assert_matches!(
            client.send_request(&server, UsersMeGetRequest {}).await,
            Err(TestClientError::HttpRequestDerive {
                source,
                message: _,
            }) if source.is_unauthorized()
        );

        mock.assert();
    }
}