gw2lib 3.0.2

A simple to use Gw2 API wrapper library
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

#![cfg(feature = "blocking")]
#![allow(dead_code)]

use std::sync::Arc;

use gw2lib::{
    model::misc::{build::Build, colors::ColorId},
    Requester,
};

pub mod setup;

#[test]
fn get() {
    let client = setup::setup();
    let _: Build = client.get().unwrap();
}

//#[test]
fn inflight() {
    let client = Arc::new(setup::setup());
    let tclient = client.clone();
    let join = std::thread::spawn(move || {
        let _: Build = tclient.get().unwrap();
        chrono::Utc::now()
    });
    let _: Build = client.get().unwrap();
    let main = chrono::Utc::now();
    let join = join.join().unwrap();
    let diff = (main - join).num_nanoseconds().unwrap().abs();
    assert!(dbg!(diff) < 100_000);
}

mod cache {
    use std::time::Duration;

    use gw2lib::model::misc::colors::Color;

    use super::*;
    //#[test]
    fn hit() {
        let client = setup::setup();
        let _: Build = client.get().unwrap();

        let start = chrono::Utc::now();
        let _: Build = client.get().unwrap();
        let end = chrono::Utc::now();
        let cached = (end - start).num_nanoseconds().unwrap();
        assert!(dbg!(cached) < 100_000);
    }

    //#[test]
    fn miss() {
        let client = setup::setup();
        let _: Build = client.get().unwrap();

        let start = chrono::Utc::now();
        let _: Vec<ColorId> = client.ids::<Color, ColorId>().unwrap();
        let end = chrono::Utc::now();
        let cached = dbg!(end - start).num_nanoseconds().unwrap();
        assert!(dbg!(cached) > 100_000);
    }

    //#[test]
    fn forced() {
        let client = setup::setup();
        let _: Build = client.get().unwrap();

        let start = chrono::Utc::now();
        let _: Build = client.forced().get().unwrap();
        let end = chrono::Utc::now();
        let cached = (end - start).num_nanoseconds().unwrap();
        assert!(dbg!(cached) > 100_000);
    }

    //#[test]
    fn duration() {
        let client = setup::setup();
        let duration = Duration::from_secs(2);
        let chrono_duration = chrono::Duration::from_std(duration).unwrap();

        let _: Build = client.cached(chrono_duration).get().unwrap();

        // cache hit
        let start = chrono::Utc::now();
        let _: Build = client.get().unwrap();
        let end = chrono::Utc::now();
        let cached = (end - start).num_nanoseconds().unwrap();
        assert!(dbg!(cached) < 100_000);

        std::thread::sleep(duration);

        // cache miss
        let start = chrono::Utc::now();
        let _: Build = client.get().unwrap();
        let end = chrono::Utc::now();
        let cached = (end - start).num_nanoseconds().unwrap();
        assert!(dbg!(cached) > 100_000);
    }
}

mod rate_limit {
    use gw2lib::{rate_limit::BucketRateLimiter, Requester};

    use super::*;

    #[test]
    fn hit() {
        // 1 request every 3 seconds
        let rate_limiter = BucketRateLimiter::new(1, 20);
        let client = setup::setup().rate_limiter(rate_limiter);
        let client = client.forced();

        let start = chrono::Utc::now();

        // first request
        let _: Build = client.get().unwrap();
        // rate limited request
        let _: Build = client.get().unwrap();

        let end = chrono::Utc::now();
        let limit = (end - start).num_milliseconds();
        assert!(dbg!(limit) > 3_000);
    }
}