fast_vk 0.3.1

Low-level VK API library designed for millions requests
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

mod build_error;
pub use build_error::BuildError;

use super::Instance;

use std::time::Duration;

pub struct InstanceBuilder {
    pub token: Option<String>,
    pub client: reqwest::Client,
    pub api_url: String,
    pub api_version: String,
    pub time_between_requests: std::time::Duration,
}

impl InstanceBuilder {
    pub fn new() -> InstanceBuilder {
        InstanceBuilder::default()
    }

    pub fn token<T>(mut self, token: T) -> InstanceBuilder
    where 
        T: ToString
    {
        self.token = Some(token.to_string());
        self
    }

    pub fn api_url<T>(mut self, api_url: T) -> InstanceBuilder
    where 
        T: ToString
    {
        self.api_url = api_url.to_string();
        self
    }

    pub fn api_version<T>(mut self, api_version: T ) -> InstanceBuilder
    where 
        T: ToString
    {
        self.api_version = api_version.to_string();
        self
    }

    pub fn time_between_requests(mut self, time_between_requests: std::time::Duration) -> InstanceBuilder {
        self.time_between_requests = time_between_requests;
        self
    }

    pub fn build(self) -> Result<Instance, BuildError> {
        let token = match self.token {
            Some(token) => token,
            None => return Err(BuildError::MissingParameter(String::from("token"))),
        };

        Ok(Instance {
            token,
            client: self.client,
            api_url: self.api_url,
            api_version: self.api_version,
            time_between_requests: self.time_between_requests,
        })
    }
}

impl Default for InstanceBuilder {
    fn default() -> Self {
        InstanceBuilder {
            token: None,
            client: reqwest::Client::new(),
            api_url: String::from("https://api.vk.com/"),
            api_version: String::from("5.103"),
            time_between_requests: Duration::from_millis(334),
        }
    }
}

#[cfg(test)]
mod tests {
    use reqwest::Client;

    use super::*;

    #[test]
    fn missing_token() {
        let instance = InstanceBuilder::new().build();

        assert_eq!(
            instance.err(),
            Some(BuildError::MissingParameter(String::from("token")))
        );
    }

    #[test]
    fn custom_api_url() {
        let instance = InstanceBuilder::new()
            .api_url("https://example.com/")
            .token(String::from("token"))
            .build()
            .unwrap();

        assert_eq!(
            instance,
            Instance {
                token: String::from("token"),
                client: Client::new(),
                api_url: String::from("https://example.com/"),
                api_version: String::from("5.103"),
                time_between_requests: Duration::from_millis(334)
            }
        );
    }

    #[test]
    fn custom_all() {
        let instance = InstanceBuilder::new()
            .api_url("https://api.vk.ru/")
            .api_version("5.143")
            .token(String::from("123456789"))
            .time_between_requests(Duration::from_millis(500))
            .build()
            .unwrap();

        assert_eq!(
            instance,
            Instance {
                token: String::from("123456789"),
                client: Client::new(),
                api_url: String::from("https://api.vk.ru/"),
                api_version: String::from("5.143"),
                time_between_requests: Duration::from_millis(500)
            }
        );
    }
}