fyers 0.2.1

Idiomatic async Rust client for the Fyers trading 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

mod common;
use fyers::FyersError;
use httpmock::prelude::*;

const RANDOM_ERROR: &str = include_str!("fixtures/error/random_error.json");
const INVALID_JSON: &str = include_str!("fixtures/error/invalid.json");
const MISSING_FIELD: &str = include_str!("fixtures/error/missing_field.json");
const INVALID_TOKEN: &str = include_str!("fixtures/error/invalid_token.json");

#[tokio::test]
async fn http_status_error() {
    let ctx = common::setup().await;

    let mock = ctx
        .server
        .mock_async(|when, then| {
            when.method(GET).path("/profile");

            then.status(403).body("Forbidden");
        })
        .await;

    let result = ctx.fyers.profile().await;

    match result {
        Err(FyersError::HttpStatus { status, body }) => {
            assert_eq!(status.as_u16(), 403);
            assert_eq!(body, "Forbidden")
        }
        other => panic!("Expected HttpStatus error, got {other:?}"),
    }

    mock.assert();
}

#[tokio::test]
async fn api_envelope_error() {
    let ctx = common::setup().await;

    let mock = ctx
        .server
        .mock_async(|when, then| {
            when.method(GET).path("/profile");

            then.status(200)
                .header("content-type", "application/json")
                .body(RANDOM_ERROR);
        })
        .await;

    let result = ctx.fyers.profile().await;

    match result {
        Err(FyersError::Api { code, message }) => {
            assert_eq!(code, 9999);
            assert_eq!(message, "This is a random error".to_string());
        }
        other => panic!("Expected Api error, got {other:?}"),
    }

    mock.assert();
}

#[tokio::test]
async fn json_parse_error() {
    let ctx = common::setup().await;

    let mock = ctx
        .server
        .mock_async(|when, then| {
            when.method(GET).path("/profile");

            then.status(200)
                .header("content-type", "application/json")
                .body(INVALID_JSON);
        })
        .await;

    let result = ctx.fyers.profile().await;

    match result {
        Err(FyersError::Json(_)) => {}
        other => panic!("Expected Json error, got {other:?}"),
    }

    mock.assert();
}

#[tokio::test]
async fn missing_field_on_success_error() {
    let ctx = common::setup().await;

    let mock = ctx
        .server
        .mock_async(|when, then| {
            when.method(GET).path("/profile");

            then.status(200)
                .header("content-type", "application/json")
                .body(MISSING_FIELD);
        })
        .await;

    let result = ctx.fyers.profile().await;

    match result {
        Err(FyersError::MissingField(_)) => {}
        other => panic!("Expected MissingField error, got {other:?}"),
    }

    mock.assert();
}

// Test one of the error variants to make sure our mapping
// function works as intended
#[tokio::test]
async fn variant_error() {
    let ctx = common::setup().await;

    let mock = ctx
        .server
        .mock_async(|when, then| {
            when.method(GET).path("/profile");

            then.status(200)
                .header("content-type", "application/json")
                .body(INVALID_TOKEN);
        })
        .await;

    let result = ctx.fyers.profile().await;

    match result {
        Err(FyersError::InvalidToken) => {}
        other => panic!("Expected InvalidToken error, got {other:?}"),
    }

    mock.assert();
}