Improve testing for Rust orders module (#2578)

Author: dakshbtc

crates/model/src/orders/any.rs

@@ -281,3 +281,269 @@ impl PartialEq for StopOrderAny {
         }
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////////////
+#[cfg(test)]
+mod tests {
+    use rust_decimal::Decimal;
+
+    use super::*;
+    use crate::{
+        enums::{OrderType, TrailingOffsetType},
+        events::{OrderEventAny, OrderUpdated, order::initialized::OrderInitializedBuilder},
+        identifiers::{ClientOrderId, InstrumentId, StrategyId},
+        orders::builder::OrderTestBuilder,
+        types::{Price, Quantity},
+    };
+
+    #[test]
+    fn test_order_any_equality() {
+        // Create two orders with different types but same client_order_id
+        let client_order_id = ClientOrderId::from("ORDER-001");
+
+        let market_order = OrderTestBuilder::new(OrderType::Market)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .client_order_id(client_order_id.clone())
+            .build();
+
+        let limit_order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .client_order_id(client_order_id)
+            .build();
+
+        // They should be equal because they have the same client_order_id
+        assert_eq!(market_order, limit_order);
+    }
+
+    #[test]
+    fn test_order_any_conversion_from_events() {
+        // Create an OrderInitialized event
+        let init_event = OrderInitializedBuilder::default()
+            .order_type(OrderType::Market)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .build()
+            .unwrap();
+
+        // Create a vector of events
+        let events = vec![OrderEventAny::Initialized(init_event.clone())];
+
+        // Create OrderAny from events
+        let order = OrderAny::from_events(events).unwrap();
+
+        // Verify the order was created properly
+        assert_eq!(order.order_type(), OrderType::Market);
+        assert_eq!(order.instrument_id(), init_event.instrument_id);
+        assert_eq!(order.quantity(), init_event.quantity);
+    }
+
+    #[test]
+    fn test_order_any_from_events_empty_error() {
+        let events: Vec<OrderEventAny> = vec![];
+        let result = OrderAny::from_events(events);
+
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "No order events provided to create OrderAny"
+        );
+    }
+
+    #[test]
+    fn test_order_any_from_events_wrong_first_event() {
+        // Create an event that is not OrderInitialized
+        let client_order_id = ClientOrderId::from("ORDER-001");
+        let strategy_id = StrategyId::from("STRATEGY-001");
+
+        let update_event = OrderUpdated {
+            client_order_id,
+            strategy_id,
+            quantity: Quantity::from(20),
+            ..Default::default()
+        };
+
+        // Create a vector with a non-initialization event first
+        let events = vec![OrderEventAny::Updated(update_event)];
+
+        // Attempt to create order should fail
+        let result = OrderAny::from_events(events);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "First event must be `OrderInitialized`"
+        );
+    }
+
+    #[test]
+    fn test_passive_order_any_conversion() {
+        // Create a limit order
+        let limit_order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to PassiveOrderAny and back
+        let passive_order: PassiveOrderAny = limit_order.clone().into();
+        let order_any: OrderAny = passive_order.into();
+
+        // Verify it maintained its properties
+        assert_eq!(order_any.order_type(), OrderType::Limit);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+    }
+
+    #[test]
+    fn test_stop_order_any_conversion() {
+        // Create a stop market order
+        let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .trigger_price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to StopOrderAny and back
+        let stop_order_any: StopOrderAny = stop_order.into();
+        let order_any: OrderAny = stop_order_any.into();
+
+        // Verify it maintained its properties
+        assert_eq!(order_any.order_type(), OrderType::StopMarket);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
+    }
+
+    #[test]
+    fn test_limit_order_any_conversion() {
+        // Create a limit order
+        let limit_order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to LimitOrderAny and back
+        let limit_order_any: LimitOrderAny = limit_order.into();
+        let order_any: OrderAny = limit_order_any.into();
+
+        // Verify it maintained its properties
+        assert_eq!(order_any.order_type(), OrderType::Limit);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+    }
+
+    #[test]
+    fn test_limit_order_any_limit_price() {
+        // Create a limit order
+        let limit_order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to LimitOrderAny
+        let limit_order_any: LimitOrderAny = limit_order.into();
+
+        // Check limit price accessor
+        let limit_px = limit_order_any.limit_px();
+        assert_eq!(limit_px, Price::new(100.0, 2));
+    }
+
+    #[test]
+    fn test_stop_order_any_stop_price() {
+        // Create a stop market order
+        let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .trigger_price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to StopOrderAny
+        let stop_order_any: StopOrderAny = stop_order.into();
+
+        // Check stop price accessor
+        let stop_px = stop_order_any.stop_px();
+        assert_eq!(stop_px, Price::new(100.0, 2));
+    }
+
+    #[test]
+    fn test_trailing_stop_market_order_conversion() {
+        // Create a trailing stop market order
+        let trailing_stop_order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .trigger_price(Price::new(100.0, 2))
+            .trailing_offset(Decimal::new(5, 1)) // 0.5
+            .trailing_offset_type(TrailingOffsetType::NoTrailingOffset)
+            .build();
+
+        // Convert to StopOrderAny
+        let stop_order_any: StopOrderAny = trailing_stop_order.clone().into();
+
+        // And back to OrderAny
+        let order_any: OrderAny = stop_order_any.into();
+
+        // Verify properties are preserved
+        assert_eq!(order_any.order_type(), OrderType::TrailingStopMarket);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
+        assert_eq!(order_any.trailing_offset(), Some(Decimal::new(5, 1)));
+        assert_eq!(
+            order_any.trailing_offset_type(),
+            Some(TrailingOffsetType::NoTrailingOffset)
+        );
+    }
+
+    #[test]
+    fn test_trailing_stop_limit_order_conversion() {
+        // Create a trailing stop limit order
+        let trailing_stop_limit = OrderTestBuilder::new(OrderType::TrailingStopLimit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(99.0, 2))
+            .trigger_price(Price::new(100.0, 2))
+            .limit_offset(Decimal::new(10, 1)) // 1.0
+            .trailing_offset(Decimal::new(5, 1)) // 0.5
+            .trailing_offset_type(TrailingOffsetType::NoTrailingOffset)
+            .build();
+
+        // Convert to LimitOrderAny
+        let limit_order_any: LimitOrderAny = trailing_stop_limit.clone().into();
+
+        // Check limit price
+        assert_eq!(limit_order_any.limit_px(), Price::new(99.0, 2));
+
+        // Convert back to OrderAny
+        let order_any: OrderAny = limit_order_any.into();
+
+        // Verify properties are preserved
+        assert_eq!(order_any.order_type(), OrderType::TrailingStopLimit);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+        assert_eq!(order_any.price(), Some(Price::new(99.0, 2)));
+        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
+        assert_eq!(order_any.trailing_offset(), Some(Decimal::new(5, 1)));
+    }
+
+    #[test]
+    fn test_passive_order_any_to_any() {
+        // Create a limit order
+        let limit_order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .build();
+
+        // Convert to PassiveOrderAny
+        let passive_order: PassiveOrderAny = limit_order.into();
+
+        // Use to_any method
+        let order_any = passive_order.to_any();
+
+        // Verify it maintained its properties
+        assert_eq!(order_any.order_type(), OrderType::Limit);
+        assert_eq!(order_any.quantity(), Quantity::from(10));
+        assert_eq!(order_any.price(), Some(Price::new(100.0, 2)));
+    }
+}

crates/model/src/orders/limit.rs

@@ -582,12 +582,15 @@ impl From<OrderInitialized> for LimitOrder {
 ////////////////////////////////////////////////////////////////////////////////
 #[cfg(test)]
 mod tests {
+    use nautilus_core::UnixNanos;
     use rstest::rstest;
 
     use crate::{
         enums::{OrderSide, OrderType, TimeInForce},
+        events::{OrderEventAny, OrderUpdated},
+        identifiers::InstrumentId,
         instruments::{CurrencyPair, stubs::*},
-        orders::{Order, builder::OrderTestBuilder},
+        orders::{Order, OrderTestBuilder, stubs::TestOrderStubs},
         types::{Price, Quantity},
     };
 
@@ -652,4 +655,112 @@ mod tests {
             .time_in_force(TimeInForce::Gtd)
             .build();
     }
+
+    #[test]
+    fn test_limit_order_creation() {
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .side(OrderSide::Buy)
+            .time_in_force(TimeInForce::Gtc)
+            .build();
+
+        assert_eq!(order.price(), Some(Price::new(100.0, 2)));
+        assert_eq!(order.quantity(), Quantity::from(10));
+        assert_eq!(order.time_in_force(), TimeInForce::Gtc);
+        assert_eq!(order.order_side(), OrderSide::Buy);
+    }
+
+    #[test]
+    fn test_limit_order_with_expire_time() {
+        let expire_time = UnixNanos::from(1_700_000_000_000_000);
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .time_in_force(TimeInForce::Gtd)
+            .expire_time(expire_time)
+            .build();
+
+        assert_eq!(order.expire_time(), Some(expire_time));
+        assert_eq!(order.time_in_force(), TimeInForce::Gtd);
+    }
+
+    #[test]
+    #[should_panic(expected = "Condition failed: `expire_time` is required for `GTD` order")]
+    fn test_limit_order_missing_expire_time() {
+        let _ = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .time_in_force(TimeInForce::Gtd)
+            .build();
+    }
+
+    #[test]
+    fn test_limit_order_post_only() {
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .post_only(true)
+            .build();
+
+        assert!(order.is_post_only());
+    }
+
+    #[test]
+    fn test_limit_order_display_quantity() {
+        let display_qty = Quantity::from(5);
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .display_qty(display_qty)
+            .build();
+
+        assert_eq!(order.display_qty(), Some(display_qty));
+    }
+
+    #[test]
+    fn test_limit_order_update() {
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .build();
+
+        let mut accepted_order = TestOrderStubs::make_accepted_order(&order);
+
+        let updated_price = Price::new(105.0, 2);
+        let updated_quantity = Quantity::from(5);
+
+        let event = OrderUpdated {
+            client_order_id: accepted_order.client_order_id(),
+            strategy_id: accepted_order.strategy_id(),
+            price: Some(updated_price),
+            quantity: updated_quantity,
+            ..Default::default()
+        };
+
+        accepted_order.apply(OrderEventAny::Updated(event)).unwrap();
+
+        assert_eq!(accepted_order.quantity(), updated_quantity);
+        assert_eq!(accepted_order.price(), Some(updated_price));
+    }
+
+    #[test]
+    fn test_limit_order_expire_time() {
+        let expire_time = UnixNanos::from(1_700_000_000_000_000);
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
+            .quantity(Quantity::from(10))
+            .price(Price::new(100.0, 2))
+            .time_in_force(TimeInForce::Gtd)
+            .expire_time(expire_time)
+            .build();
+
+        assert_eq!(order.expire_time(), Some(expire_time));
+    }
 }