fugle 0.3.8

A Simple, Lightweight, Fast and Safe Fugle 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
126
127
128
129
130
131
132
133
134
135
136
137
138

use fugle::{
    errors::FugleError,
    http::{marketdata::CandleField, marketdata::CandlesRequest, RestfulBuilder},
};
mod util;

#[test]
fn test_marketdata_candles_pass() {
    let client = RestfulBuilder::default()
        .read_timeout_sec(3)
        .build()
        .unwrap();
    let candles = client
        .call(
            CandlesRequest::new()
                .from("2022-08-01")
                .to("2022-08-08")
                .unset_field(CandleField::Open)
                .unset_field(CandleField::High)
                .unset_field(CandleField::Low)
                .unset_field(CandleField::Close)
                .unset_field(CandleField::Volume)
                .unset_field(CandleField::Turnover)
                .unset_field(CandleField::Change)
                .set_field(CandleField::Open)
                .set_field(CandleField::High)
                .set_field(CandleField::Low)
                .set_field(CandleField::Close)
                .set_field(CandleField::Volume)
                .set_field(CandleField::Turnover)
                .set_field(CandleField::Change),
        )
        .unwrap();
    assert_eq!(candles.symbol_id, "2884");
    assert_eq!(candles.typ, "EQUITY");
    assert_ne!(candles.candles[0].turnover, 0);
    assert_ne!(candles.candles[0].volume, 0);
}

#[tokio::test]
async fn test_marketdata_async_candles_pass() {
    let client = RestfulBuilder::default()
        .read_timeout_sec(3)
        .build_async()
        .unwrap();
    let candles = client
        .call(
            CandlesRequest::new()
                .from("2022-08-01")
                .to("2022-08-08")
                .unset_field(CandleField::Open)
                .unset_field(CandleField::High)
                .unset_field(CandleField::Low)
                .unset_field(CandleField::Close)
                .unset_field(CandleField::Volume)
                .unset_field(CandleField::Turnover)
                .unset_field(CandleField::Change)
                .set_field(CandleField::Open)
                .set_field(CandleField::High)
                .set_field(CandleField::Low)
                .set_field(CandleField::Close)
                .set_field(CandleField::Volume)
                .set_field(CandleField::Turnover)
                .set_field(CandleField::Change),
        )
        .await
        .unwrap();
    assert_eq!(candles.symbol_id, "2884");
    assert_eq!(candles.typ, "EQUITY");
    assert_ne!(candles.candles[0].turnover, 0);
    assert_ne!(candles.candles[0].volume, 0);
}

// fugle marketdata candles endpoint will goes into 401 if
// 1. token or
// 2. symbol_id
// not provided, not like intraday endpoints have more richable error status
#[test]
fn test_marketdata_candles_401_failed() {
    let client = RestfulBuilder::new().token("").build().unwrap();
    assert_err!(
        client.call(CandlesRequest::default()),
        Err(FugleError::Unauthorized)
    );

    let client = RestfulBuilder::new().build().unwrap();
    assert_err!(
        client.call(CandlesRequest::default().symbol_id("")),
        Err(FugleError::Unauthorized)
    );
}

#[tokio::test]
async fn test_marketdata_async_candles_401_failed() {
    let client = RestfulBuilder::new().token("").build_async().unwrap();
    assert_err!(
        client.call(CandlesRequest::default()).await,
        Err(FugleError::Unauthorized)
    );

    let client = RestfulBuilder::new().build_async().unwrap();
    assert_err!(
        client.call(CandlesRequest::default().symbol_id("")).await,
        Err(FugleError::Unauthorized)
    );
}

#[test]
fn test_error_rate_limit_exceeded() {
    let client = RestfulBuilder::default().build().unwrap();
    for _ in 0..9 {
        let res = client.call(CandlesRequest::new().from("2022-08-01").to("2022-08-08"));
        match res {
            Ok(_) => continue,
            Err(e) => match e {
                FugleError::RateLimitExceeded => break,
                _ => panic!("error: {}", e),
            },
        }
    }
}

#[tokio::test]
async fn test_error_async_rate_limit_exceeded() {
    let client = RestfulBuilder::default().build_async().unwrap();
    for _ in 0..9 {
        let res = client
            .call(CandlesRequest::new().from("2022-08-01").to("2022-08-08"))
            .await;
        match res {
            Ok(_) => continue,
            Err(e) => match e {
                FugleError::RateLimitExceeded => break,
                _ => panic!("error: {}", e),
            },
        }
    }
}