orderbook-rs 0.7.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

#[cfg(test)]
mod tests {
    use crate::OrderBookError;
    use pricelevel::{PriceLevelError, Side};

    #[test]
    fn test_display_price_level_error() {
        let err = OrderBookError::PriceLevelError(PriceLevelError::InvalidFormat);
        assert_eq!(format!("{err}"), "Price level error: Invalid format");
    }

    #[test]
    fn test_display_order_not_found() {
        let order_id = "e4968197-6137-47a4-ba79-690d8c552248";
        let err = OrderBookError::OrderNotFound(order_id.to_string());
        assert_eq!(format!("{err}"), format!("Order not found: {}", order_id));
    }

    #[test]
    fn test_display_invalid_price_level() {
        let price = 1000;
        let err = OrderBookError::InvalidPriceLevel(price);
        assert_eq!(format!("{err}"), format!("Invalid price level: {}", price));
    }

    #[test]
    fn test_display_price_crossing() {
        let err = OrderBookError::PriceCrossing {
            price: 1000,
            side: Side::Buy,
            opposite_price: 999,
        };
        assert_eq!(
            format!("{err}"),
            "Price crossing: BUY 1000 would cross opposite at 999"
        );
    }

    #[test]
    fn test_display_insufficient_liquidity() {
        let err = OrderBookError::InsufficientLiquidity {
            side: Side::Sell,
            requested: 100,
            available: 50,
        };
        assert_eq!(
            format!("{err}"),
            "Insufficient liquidity for SELL order: requested 100, available 50"
        );
    }

    #[test]
    fn test_display_invalid_operation() {
        let message = "Cannot update price to the same value";
        let err = OrderBookError::InvalidOperation {
            message: message.to_string(),
        };
        assert_eq!(format!("{err}"), format!("Invalid operation: {}", message));
    }

    #[test]
    fn test_from_price_level_error() {
        let price_level_error = PriceLevelError::InvalidFormat;
        let order_book_error: OrderBookError = price_level_error.into();

        match order_book_error {
            OrderBookError::PriceLevelError(err) => match err {
                PriceLevelError::InvalidFormat => (),
                _ => panic!("Expected PriceLevelError::InvalidFormat"),
            },
            _ => panic!("Expected OrderBookError::PriceLevelError"),
        }
    }

    #[test]
    fn test_error_trait_implementation() {
        let err = OrderBookError::InvalidPriceLevel(1000);
        let _: &dyn std::error::Error = &err; // This will compile only if OrderBookError implements std::error::Error
    }

    #[test]
    fn test_missing_field_conversion() {
        let field_name = "price";
        let price_level_error = PriceLevelError::MissingField(field_name.to_string());
        let order_book_error: OrderBookError = price_level_error.into();

        match order_book_error {
            OrderBookError::PriceLevelError(PriceLevelError::MissingField(field)) => {
                assert_eq!(field, field_name);
            }
            _ => panic!("Expected OrderBookError::PriceLevelError(PriceLevelError::MissingField)"),
        }
    }

    #[test]
    fn test_invalid_field_value_conversion() {
        let price_level_error = PriceLevelError::InvalidFieldValue {
            field: "price".to_string(),
            value: "invalid".to_string(),
        };
        let order_book_error: OrderBookError = price_level_error.into();

        match order_book_error {
            OrderBookError::PriceLevelError(PriceLevelError::InvalidFieldValue {
                field,
                value,
            }) => {
                assert_eq!(field, "price");
                assert_eq!(value, "invalid");
            }
            _ => panic!(
                "Expected OrderBookError::PriceLevelError(PriceLevelError::InvalidFieldValue)"
            ),
        }
    }
}