riot-api 0.1.2

A rust crate to interact with Riot Games Developer 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
163

use std::collections::HashMap;
use crate::models::{
    RiotApiClient, ApiResult,
    routing::RegionRouting,
    tournament::{
        TournamentCodeParamsV5,
        TournamentCodeV5Dto,
        LobbyEventV5DtoWrapper,
        ProviderRegistrationParamsV5,
        TournamentRegistrationParamsV5,
    }
};

impl RiotApiClient {
    pub async fn stub_codes(
        &self,
        region_routing: Option<RegionRouting>,
        tournament_id: i64,
        count: Option<usize>,
        params: TournamentCodeParamsV5,
    ) -> ApiResult<Vec<String>> {
        let routing = region_routing.unwrap_or(self.configuration.default_region);

        let mut options = HashMap::new();

        options.insert("tournamentId".to_string(), tournament_id.to_string());
        if let Some(count) = count {
            options.insert("count".to_string(), count.to_string());
        }

        self.make_request(
            "/lol/tournament-stub/v5/codes".to_string(),
            routing,
            reqwest::Method::POST,
            HashMap::new(),
            options,
            Some(params),
        ).await
    }

    pub async fn stub_codes_by_tournament_code(
        &self,
        region_routing: Option<RegionRouting>,
        tournament_code: String,
    ) -> ApiResult<TournamentCodeV5Dto> {
        let routing = region_routing.unwrap_or(self.configuration.default_region);

        self.make_request(
            format!("/lol/tournament-stub/v5/codes/{tournament_code}"),
            routing,
            reqwest::Method::GET,
            HashMap::new(),
            HashMap::new(),
            None::<()>,
        ).await
    }

    pub async fn stub_get_lobby_events(
        &self,
        region_routing: Option<RegionRouting>,
        tournament_code: String,
    ) -> ApiResult<LobbyEventV5DtoWrapper> {
        let routing = region_routing.unwrap_or(self.configuration.default_region);

        self.make_request(
            format!("/lol/tournament-stub/v5/lobby-events/by-code/{tournament_code}"),
            routing,
            reqwest::Method::GET,
            HashMap::new(),
            HashMap::new(),
            None::<()>,
        ).await
    }

    pub async fn stub_register_provider(
        &self,
        region_routing: Option<RegionRouting>,
        registration_params: ProviderRegistrationParamsV5,
    ) -> ApiResult<usize> {
        let routing = region_routing.unwrap_or(self.configuration.default_region);

        self.make_request(
            "/lol/tournament-stub/v5/providers".to_string(),
            routing,
            reqwest::Method::POST,
            HashMap::new(),
            HashMap::new(),
            Some(registration_params),
        ).await
    }

    pub async fn stub_register_tournament(
        &self,
        region_routing: Option<RegionRouting>,
        registration_params: TournamentRegistrationParamsV5,
    ) -> ApiResult<usize> {
        let routing = region_routing.unwrap_or(self.configuration.default_region);

        self.make_request(
            "/lol/tournament-stub/v5/tournaments".to_string(),
            routing,
            reqwest::Method::POST,
            HashMap::new(),
            HashMap::new(),
            Some(registration_params),
        ).await
    }
}

#[cfg(test)]
mod tests {

    #[tokio::test]
    async fn test_create_codes() {
        let (client, test_vars) = crate::tests::setup();

        let codes = client.stub_codes(
            None, test_vars.test_tournament_id.into(), Some(5), test_vars.test_tournament_code_params
        ).await.unwrap();

       assert_eq!(codes.len(), 5);
    }

    #[tokio::test]
    async fn test_get_tournament_code() {
        let (client, test_vars) = crate::tests::setup();

        let details = client.stub_codes_by_tournament_code(None, test_vars.test_tournament_code).await.unwrap();

        assert_eq!(details.id, 0);
        assert_eq!(details.provider_id, test_vars.test_tournament_provider_id);
        assert_eq!(details.tournament_id, test_vars.test_tournament_id);
        assert_eq!(details.lobby_name, test_vars.test_tournament_lobby);
    }

    #[tokio::test]
    async fn test_get_lobby_events() {
        let (client, test_vars) = crate::tests::setup();

        let events = client.stub_get_lobby_events(None, test_vars.test_tournament_code).await.unwrap();
        let test_event = events.event_list.first().unwrap();

        assert_eq!(test_event.event_type, "PracticeGameCreatedEvent".to_string());
    }

    #[tokio::test]
    async fn test_create_provider() {
        let (client, test_vars) = crate::tests::setup();

        let provider = client.stub_register_provider(None, test_vars.test_tournament_provider_params).await.unwrap();

        assert_eq!(provider, test_vars.test_tournament_provider_id as usize);
    }

    #[tokio::test]
    async fn test_register_tournament() {
        let (client, test_vars) = crate::tests::setup();

        let tournament = client.stub_register_tournament(None, test_vars.test_tournament_registration_params).await.unwrap();

        assert_eq!(tournament, test_vars.test_tournament_id as usize);
    }
}