ibapi 4.0.1

A Rust implementation of the Interactive Brokers TWS API, providing a reliable and user friendly interface for TWS and IB Gateway. Designed with a focus on simplicity and performance.
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

//! Unit tests for `ClientBuilder` — exercise the validation paths without a
//! gateway. Live-handshake assertions live in `integration/{sync,async}/tests/connection.rs`.

use crate::errors::Error;
use crate::transport::common::MAX_RECONNECT_ATTEMPTS;

use super::BuilderState;

fn assert_invalid_argument(err: Option<Error>, expected_substr: &str) {
    let err = err.expect("expected failure");
    assert!(
        matches!(&err, Error::InvalidArgument(m) if m.contains(expected_substr)),
        "expected InvalidArgument containing {expected_substr:?}, got {err:?}"
    );
}

#[test]
fn validate_passes_reconnect_limit_through() {
    let base = || BuilderState {
        address: Some("127.0.0.1:4002".into()),
        client_id: Some(100),
        ..Default::default()
    };

    let pieces = base().validate().expect("validate");
    assert_eq!(pieces.max_reconnect_attempts, Some(MAX_RECONNECT_ATTEMPTS));

    let mut limited = base();
    limited.max_reconnect_attempts = Some(50);
    assert_eq!(limited.validate().expect("validate").max_reconnect_attempts, Some(50));

    let mut unlimited = base();
    unlimited.max_reconnect_attempts = None;
    assert_eq!(unlimited.validate().expect("validate").max_reconnect_attempts, None);
}

#[cfg(feature = "sync")]
mod sync_tests {
    use super::super::sync_impl::ClientBuilder;
    use super::assert_invalid_argument;

    #[test]
    fn connect_without_address_returns_invalid_argument() {
        let result = ClientBuilder::default().client_id(100).connect();
        assert_invalid_argument(result.err(), "address");
    }

    #[test]
    fn connect_without_client_id_returns_invalid_argument() {
        let result = ClientBuilder::default().address("127.0.0.1:4002").connect();
        assert_invalid_argument(result.err(), "client_id");
    }

    #[test]
    fn reconnect_limit_configurators_set_state() {
        assert_eq!(
            ClientBuilder::default().state.max_reconnect_attempts,
            Some(crate::transport::common::MAX_RECONNECT_ATTEMPTS)
        );
        assert_eq!(ClientBuilder::default().max_reconnect_attempts(50).state.max_reconnect_attempts, Some(50));
        assert_eq!(ClientBuilder::default().reconnect_forever().state.max_reconnect_attempts, None);
    }

    #[test]
    fn tcp_no_delay_defaults_on() {
        assert!(ClientBuilder::default().state.tcp_no_delay);
        assert!(!ClientBuilder::default().tcp_no_delay(false).state.tcp_no_delay);
    }
}

#[cfg(feature = "async")]
mod async_tests {
    use super::super::async_impl::ClientBuilder;
    use super::assert_invalid_argument;

    #[tokio::test]
    async fn connect_without_address_returns_invalid_argument() {
        let result = ClientBuilder::default().client_id(100).connect().await;
        assert_invalid_argument(result.err(), "address");
    }

    #[tokio::test]
    async fn connect_without_client_id_returns_invalid_argument() {
        let result = ClientBuilder::default().address("127.0.0.1:4002").connect().await;
        assert_invalid_argument(result.err(), "client_id");
    }

    #[tokio::test]
    async fn connect_with_zero_channel_capacity_returns_invalid_argument() {
        // tokio's broadcast::channel(0) panics; the builder must reject it
        // at the validation seam instead.
        let result = ClientBuilder::default()
            .address("127.0.0.1:4002")
            .client_id(100)
            .channel_capacity(0)
            .connect()
            .await;
        assert_invalid_argument(result.err(), "channel_capacity");
    }

    #[test]
    fn reconnect_limit_configurators_set_state() {
        assert_eq!(
            ClientBuilder::default().state.max_reconnect_attempts,
            Some(crate::transport::common::MAX_RECONNECT_ATTEMPTS)
        );
        assert_eq!(ClientBuilder::default().max_reconnect_attempts(50).state.max_reconnect_attempts, Some(50));
        assert_eq!(ClientBuilder::default().reconnect_forever().state.max_reconnect_attempts, None);
    }

    #[test]
    fn tcp_no_delay_defaults_on() {
        assert!(ClientBuilder::default().state.tcp_no_delay);
        assert!(!ClientBuilder::default().tcp_no_delay(false).state.tcp_no_delay);
    }
}