votesmart 0.2.2

A client wrapper for the Votesmart REST 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

use crate::VotesmartProxy;
use reqwest::{Error, Response};

pub struct Rating<'a>(pub &'a VotesmartProxy);

impl Rating<'_> {
    /// This method dumps categories that contain released ratingss according to state.
    pub async fn get_categories(&self, state_id: Option<&str>) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&stateId={state_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getCategories",
            state_id = state_id.unwrap_or(""),
        );

        self.0.client.get(url).send().await
    }

    /// This method dumps Special Interest Groups according to category and state.
    pub async fn get_sig_list(
        &self,
        category_id: i32,
        state_id: Option<&str>,
    ) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&categoryId={category_id}&stateId={state_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getSigList",
            category_id = category_id,
            state_id = state_id.unwrap_or(""),
        );

        self.0.client.get(url).send().await
    }

    /// This method dumps detailed information an a Special Interest Group.
    pub async fn get_sig(&self, sig_id: i32) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&sigId={sig_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getSig",
            sig_id = sig_id
        );

        self.0.client.get(url).send().await
    }

    /// This method dumps detailed information an a Special Interest Group.
    pub async fn get_sig_ratings(&self, sig_id: i32) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&sigId={sig_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getSigRatings",
            sig_id = sig_id
        );

        self.0.client.get(url).send().await
    }

    /// This method dumps a candidate's rating by a Special Interest Group.
    pub async fn get_candidate_rating(
        &self,
        candidate_id: i32,
        sig_id: Option<&str>,
    ) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&candidateId={candidate_id}&sigId={sig_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getCandidateRating",
            candidate_id = candidate_id,
            sig_id = sig_id.unwrap_or("")
        );

        self.0.client.get(url).send().await
    }

    /// This method dumps all candidate ratings from a scorecard by an Special Interest Group.
    pub async fn get_rating(&self, rating_id: i32) -> Result<Response, Error> {
        let url = format!(
            "{base_url}{operation}?key={key}&ratingId={rating_id}&o=JSON",
            base_url = &self.0.base_url,
            key = &self.0.api_key,
            operation = "Rating.getRating",
            rating_id = rating_id
        );

        self.0.client.get(url).send().await
    }
}

#[cfg(test)]
mod tests {
    use serde_json;

    use crate::VotesmartProxy;

    #[tokio::test]
    async fn test_get_candidate_rating() {
        let proxy = VotesmartProxy::new().unwrap();
        let response = proxy
            .rating()
            .get_candidate_rating(53279, None)
            .await
            .unwrap();

        let status = response.status();
        let json = response.json::<serde_json::Value>().await.unwrap();
        println!("{}", serde_json::to_string_pretty(&json).unwrap());
        assert!(status.is_success());
    }

    #[tokio::test]
    async fn test_get_categories() {
        let proxy = VotesmartProxy::new().unwrap();
        let response = proxy.rating().get_categories(None).await.unwrap();

        let status = response.status();
        let json = response.json::<serde_json::Value>().await.unwrap();
        println!("{}", serde_json::to_string_pretty(&json).unwrap());
        assert!(status.is_success());
    }

    #[tokio::test]
    async fn test_get_sig_list() {
        let proxy = VotesmartProxy::new().unwrap();
        let response = proxy.rating().get_sig_list(1, Some("CO")).await.unwrap();

        let status = response.status();
        let json = response.json::<serde_json::Value>().await.unwrap();
        println!("{}", serde_json::to_string_pretty(&json).unwrap());
        assert!(status.is_success());
    }

    #[tokio::test]
    async fn test_get_sig() {
        let proxy = VotesmartProxy::new().unwrap();
        let response = proxy.rating().get_sig(753).await.unwrap();

        let status = response.status();
        let json = response.json::<serde_json::Value>().await.unwrap();
        println!("{}", serde_json::to_string_pretty(&json).unwrap());
        assert!(status.is_success());
    }
}