rsteam 0.2.1

rsteam is a easy to use async wrapper for the steam web 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

use std::num::NonZeroU32;

use crate::client::SteamClient;
use crate::error::Error;
use crate::utils::{ResponseWrapper, Result, AUTHORITY};
use hyper::body::to_bytes;
use hyper::Uri;
use serde::Deserialize;

const PATH: &str = "/ISteamUserStats/GetNumberOfCurrentPlayers/v1/";

#[derive(Deserialize)]
struct PlayerCount {
    player_count: Option<u32>,
    result: u32,
}

type Response = ResponseWrapper<PlayerCount>;

impl SteamClient {
    /// Returns the player count of the app/game
    ///
    /// Works without an API key.
    pub async fn get_number_of_current_players(&self, game_id: NonZeroU32) -> Result<u32> {
        let query = format!("appid={}", game_id);
        let uri = Uri::builder()
            .scheme("https")
            .authority(AUTHORITY)
            .path_and_query(format!("{}?{}", PATH, query))
            .build()?;

        let raw_response = self.client.get(uri).await?;
        let raw_body = raw_response.into_body();
        let response: Response = serde_json::from_slice(&to_bytes(raw_body).await?)
            .map_err(|_| Error::Client("No game with provided game_id".to_owned()))?;

        let PlayerCount {
            player_count,
            result,
        } = response.response;

        if result == 1 && player_count.is_some() {
            Ok(player_count.unwrap())
        } else {
            Err(Error::Client(
                "request failed  check that game_id is valid".to_owned(),
            ))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tokio_test::{assert_err, block_on};

    #[test]
    fn correct_csgo_achievements() {
        let client = SteamClient::new();
        let game_id = NonZeroU32::new(730).unwrap();
        let player_count = block_on(client.get_number_of_current_players(game_id)).unwrap();

        assert!(player_count > 100000);
    }

    #[test]
    fn unknown_game_id_handeled_correctly() {
        let client = SteamClient::new();
        let game_id = NonZeroU32::new(731).unwrap();
        let result = block_on(client.get_number_of_current_players(game_id));

        assert_err!(result);
    }
}