orderbook-rs 0.8.0

A high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for multiple order types and concurrent access patterns.
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

//! Tests for OrderBook serialization functionality

#[cfg(test)]
mod tests {
    use crate::orderbook::OrderBook;
    use pricelevel::{Id, Side, TimeInForce};
    use serde_json;

    #[test]
    fn test_orderbook_serialize_empty() {
        let orderbook: OrderBook<String> = OrderBook::new("BTCUSD");

        // Test that empty orderbook can be serialized
        let json_result = serde_json::to_string(&orderbook);
        assert!(json_result.is_ok(), "Failed to serialize empty orderbook");

        let json = json_result.unwrap();
        assert!(
            json.contains("BTCUSD"),
            "Serialized JSON should contain symbol"
        );
        assert!(
            json.contains("bids"),
            "Serialized JSON should contain bids field"
        );
        assert!(
            json.contains("asks"),
            "Serialized JSON should contain asks field"
        );
    }

    #[test]
    fn test_orderbook_serialize_with_orders() {
        let orderbook: OrderBook<String> = OrderBook::new("ETHUSD");

        // Add some orders using the add_limit_order method
        let buy_order_id = Id::new_uuid();
        let sell_order_id = Id::new_uuid();

        let _ = orderbook.add_limit_order(
            buy_order_id,
            50000,
            100,
            Side::Buy,
            TimeInForce::Gtc,
            Some("buy_order_1".to_string()),
        );

        let _ = orderbook.add_limit_order(
            sell_order_id,
            51000,
            200,
            Side::Sell,
            TimeInForce::Gtc,
            Some("sell_order_1".to_string()),
        );

        // Test serialization
        let json_result = serde_json::to_string_pretty(&orderbook);

        assert!(
            json_result.is_ok(),
            "Failed to serialize orderbook with orders"
        );

        let json = json_result.unwrap();
        assert!(
            json.contains("ETHUSD"),
            "Serialized JSON should contain symbol"
        );
        assert!(
            json.contains("bids"),
            "Serialized JSON should contain bids field"
        );
        assert!(
            json.contains("asks"),
            "Serialized JSON should contain asks field"
        );
        assert!(
            json.contains("order_locations"),
            "Serialized JSON should contain order_locations field"
        );
        assert!(
            json.contains("cache"),
            "Serialized JSON should contain cache field"
        );

        // Verify the JSON is valid by parsing it back
        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed["symbol"], "ETHUSD");
    }

    #[test]
    fn test_orderbook_serialize_pretty() {
        let orderbook: OrderBook<()> = OrderBook::new("ADAUSD");

        // Test pretty printing
        let json_result = serde_json::to_string_pretty(&orderbook);
        assert!(json_result.is_ok(), "Failed to pretty serialize orderbook");

        let json = json_result.unwrap();
        assert!(
            json.contains("ADAUSD"),
            "Pretty serialized JSON should contain symbol"
        );
        // Pretty JSON should have newlines
        assert!(json.contains('\n'), "Pretty JSON should contain newlines");
    }

    #[test]
    fn test_orderbook_serialize_with_market_close() {
        let orderbook: OrderBook<i32> = OrderBook::new("DOGUSD");

        // Set market close timestamp
        orderbook.set_market_close_timestamp(9999999999);

        let json_result = serde_json::to_string(&orderbook);
        assert!(
            json_result.is_ok(),
            "Failed to serialize orderbook with market close"
        );

        let json = json_result.unwrap();
        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();

        assert_eq!(parsed["symbol"], "DOGUSD");
        assert_eq!(parsed["market_close_timestamp"], 9999999999u64);
        assert_eq!(parsed["has_market_close"], true);
    }
}