ibapi 5.4.0

An unofficial Rust client for the Interactive Brokers TWS API: market data, orders, and account data, with async (Tokio) and blocking clients for TWS and IB Gateway.
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

use super::*;

#[test]
fn require_some_value() {
    let result = require(Some(42), "Value required");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

#[test]
fn require_none_value() {
    let result: Result<i32, Error> = require(None, "Value required");
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Value required"));
}

#[test]
fn require_with_some_value() {
    let result = require_with(Some("hello"), || "Value is missing".to_string());
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "hello");
}

#[test]
fn require_with_none_value() {
    let result: Result<&str, Error> = require_with(None, || "Custom error message".to_string());
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Custom error message"));
}

#[test]
fn require_request_id_some() {
    let result = require_request_id(Some(123));
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 123);
}

#[test]
fn require_request_id_none() {
    let result = require_request_id(None);
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Request ID required"));
}

#[test]
fn require_request_id_for_some() {
    let result = require_request_id_for(Some(456), "process order");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 456);
}

#[test]
fn require_request_id_for_none() {
    let result = require_request_id_for(None, "cancel subscription");
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Request ID required to cancel subscription"));
}

#[test]
fn require_not_empty_valid() {
    let result = require_not_empty("hello", "name");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "hello");
}

#[test]
fn require_not_empty_invalid() {
    let result = require_not_empty("", "name");
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "name cannot be empty"));
}

#[test]
fn require_not_empty_vec_valid() {
    let vec = vec![1, 2, 3];
    let result = require_not_empty_vec(&vec, "numbers");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), &vec[..]);
}

#[test]
fn require_not_empty_vec_invalid() {
    let vec: Vec<i32> = vec![];
    let result = require_not_empty_vec(&vec, "numbers");
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "numbers must contain at least one element"));
}

#[test]
fn map_error_ok() {
    let ok_result: Result<i32, &str> = Ok(42);
    let result = map_error(ok_result, "Failed to process");
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

#[test]
fn map_error_err() {
    let err_result: Result<i32, &str> = Err("internal error");
    let result = map_error(err_result, "Failed to process");
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Failed to process: internal error"));
}

#[test]
fn map_error_with_ok() {
    let ok_result: Result<&str, &str> = Ok("success");
    let result = map_error_with(ok_result, |e| format!("Custom error: {}", e));
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "success");
}

#[test]
fn map_error_with_err() {
    let err_result: Result<&str, &str> = Err("not found");
    let result = map_error_with(err_result, |e| format!("Could not find resource: {}", e));
    assert!(result.is_err());
    assert!(matches!(result.unwrap_err(), Error::InvalidArgument(msg) if msg == "Could not find resource: not found"));
}