sfox 0.1.4

Unofficial HTTP and Websocket Client for the SFox 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

use futures_util::Future;
use serde::Deserialize;

use super::super::{Client, HttpError, HttpVerb};

#[derive(Clone, Debug, Deserialize)]
pub struct AccountBalance {
    pub currency: String,
    pub balance: f64,
    pub available: f64,
    pub held: f64,
    pub borrow_wallet: f64,
    pub collateral_wallet: f64,
    pub lending_wallet: f64,
    pub trading_wallet: f64,
}

static RESOURCE: &str = "user/balance";

impl Client {
    pub fn account_balance(self) -> impl Future<Output = Result<Vec<AccountBalance>, HttpError>> {
        let url = self.url_for_v1_resource(RESOURCE);
        self.request::<Vec<AccountBalance>>(HttpVerb::Get, &url, None)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::util::server::{new_test_server_and_client, ApiMock};

    const RESPONSE_BODY: &str = r#"
               [
                 {
                   "currency": "USD",
                   "balance": 140.55,
                   "available": 130.55,
                   "held": 10.0,
                   "borrow_wallet": 20.0,
                   "collateral_wallet": 30.0,
                   "lending_wallet": 40.0,
                   "trading_wallet": 50.0
                 },
                 {
                   "currency": "USD",
                   "balance": 0,
                   "available": 0,
                   "held": 0,
                   "borrow_wallet": 0,
                   "collateral_wallet": 0,
                   "lending_wallet": 0,
                   "trading_wallet": 0
                 }
               ]
           "#;

    #[tokio::test]
    async fn test_account_balance() {
        let mock = ApiMock {
            action: HttpVerb::Get,
            body: RESPONSE_BODY.into(),
            path: format!("/v1/{}", RESOURCE),
            response_code: 200,
        };

        let (client, _server, mock_results) = new_test_server_and_client(vec![mock]).await;
        let result = client.account_balance().await;

        assert!(result.is_ok());

        for mock in mock_results {
            mock.assert_async().await;
        }
    }
}