brawl-rs 0.1.0

A Rust wrapper for the Brawl Stars 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

#[cfg(test)]
mod tests {
    use brawl_rs::prelude::*;
    use std::env::var;

    const TEST_PLAYER_TAG: &str = "20YY0G9L0";
    const TEST_CLUB_TAG: &str = "82Y2QCCCQ";

    #[tokio::test]
    #[cfg(feature = "player")]
    async fn test_player() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());
        let player = Player::get(&client, TEST_PLAYER_TAG).await;

        assert!(player.is_ok());

        let player = player.unwrap();

        assert_eq!(player.tag, format!("#{TEST_PLAYER_TAG}"));
        assert_eq!(player.name, "k1llm3sixy");

        assert!(player.trophies > 0);
        assert!(player.highest_trophies >= player.trophies);
        assert!(!player.brawlers.is_empty());
    }

    #[tokio::test]
    #[cfg(feature = "club")]
    async fn test_club() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());
        let club = Club::get(&client, TEST_CLUB_TAG).await;

        assert!(club.is_ok());

        let club = club.unwrap();

        assert_eq!(club.tag, format!("#{TEST_CLUB_TAG}"));
        assert!(!club.name.is_empty());
        assert!(!club.kind.is_empty());
        assert!(club.trophies > 0);
        assert!(club.badge_id > 0);
        assert!(!club.members.is_empty());
    }

    #[tokio::test]
    #[cfg(feature = "battle_log")]
    async fn test_battle_log() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());
        let battle_log = BattleLog::get(&client, TEST_PLAYER_TAG).await;

        assert!(battle_log.is_ok());

        let battle_log = battle_log.unwrap();

        if !battle_log.items.is_empty() {
            for battle in &battle_log.items {
                assert!(battle.battle_time <= chrono::Utc::now());
                assert_ne!(battle.event.mode_id, 0);
                assert!(!battle.battle.mode.is_empty());
                assert!(!battle.battle.kind.is_empty());
            }
        }
    }

    #[tokio::test]
    #[cfg(feature = "brawlers")]
    async fn test_brawlers() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());
        let brawlers = Brawlers::get(&client).await;

        assert!(brawlers.is_ok());

        let brawlers = brawlers.unwrap();

        assert!(!brawlers.items.is_empty());

        for brawler in &brawlers.items {
            assert!(brawler.id > 0);
            assert!(!brawler.name.is_empty());
        }
    }

    #[tokio::test]
    #[cfg(feature = "events")]
    async fn test_events() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());

        // Test GameModes
        let game_modes = GameModes::get(&client).await;
        assert!(game_modes.is_ok());
        let game_modes = game_modes.unwrap();
        assert!(!game_modes.items.is_empty());

        // Test Rotation
        let rotation = Rotation::get(&client).await;
        assert!(rotation.is_ok());
        let rotation = rotation.unwrap();
        assert!(!rotation.is_empty());
        for rot in &rotation {
            assert!(rot.start_time < rot.end_time);
            assert!(!rot.event.mode.is_empty());
            assert!(!rot.event.map.is_empty());
        }
    }

    #[tokio::test]
    #[cfg(feature = "rankings")]
    async fn test_rankings() {
        let client = BrawlClient::new(var("BRAWL_TOKEN").unwrap());

        // Test club rankings
        let club_rankings = RankingsClub::get(&client, "global").await;
        assert!(club_rankings.is_ok());
        let club_rankings = club_rankings.unwrap();
        assert!(!club_rankings.items.is_empty());
        for club in &club_rankings.items {
            assert!(!club.tag.is_empty());
            assert!(!club.name.is_empty());
            assert!(club.trophies > 0);
            assert!(club.rank > 0);
            assert!(club.badge_id > 0);
            assert!(club.member_count > 0);
        }

        // Test player rankings
        let player_rankings = RankingsPlayer::get(&client, "global").await;
        assert!(player_rankings.is_ok());
        let player_rankings = player_rankings.unwrap();
        assert!(!player_rankings.items.is_empty());
        for player in &player_rankings.items {
            assert!(!player.tag.is_empty());
            assert!(!player.name.is_empty());
            assert!(player.trophies > 0);
            assert!(player.rank > 0);
            assert!(!player.name_color.is_empty());
        }
    }
}