rusty_oms/

order_manager.rs

//! Order management module for handling order lifecycle
//!
//! This module provides the main interface for submitting orders,
//! managing their lifecycle, and processing execution events.

use crate::execution_engine::{Exchange, ExecutionEngine, ExecutionEvent};
use crate::risk_manager::RiskManager;
use rust_decimal::Decimal;
use rusty_model::trading_order::Order;
// use smartstring::alias::String; // Using std::string::String instead
use tokio::sync::mpsc;

/// High-level order manager that coordinates between risk management and execution
pub struct OrderManager<T: Exchange> {
    /// Execution engine for processing orders
    execution_engine: ExecutionEngine<T>,
    /// Channel receiver for execution events
    event_receiver: mpsc::Receiver<ExecutionEvent>,
}

impl<T: Exchange> OrderManager<T> {
    /// Create a new order manager with risk limits
    #[must_use]
    pub fn new(
        max_order_quantity: Decimal,
        min_price: Decimal,
        max_price: Decimal,
        exchange: T,
    ) -> Self {
        let (event_sender, event_receiver) = mpsc::channel(100);
        let risk_manager = RiskManager::new(max_order_quantity, min_price, max_price);

        Self {
            execution_engine: ExecutionEngine::<T>::new(risk_manager, event_sender, exchange),
            event_receiver,
        }
    }

    /// Submit an order for processing
    ///
    /// The order will be validated by the risk manager before being sent to the exchange.
    pub async fn submit_order(&mut self, order: Order) -> crate::Result<()> {
        self.execution_engine
            .process_order(order)
            .await
            .map_err(std::convert::Into::into)
    }

    /// Start processing execution events
    ///
    /// This method runs a loop that processes execution events from the exchange.
    /// It should be run in a separate task.
    pub async fn start_event_processing(&mut self) {
        while let Some(event) = self.event_receiver.recv().await {
            match event {
                ExecutionEvent::OrderAccepted(order) => {
                    log::info!("Order accepted: {order:?}");
                }
                ExecutionEvent::OrderRejected(order, reason) => {
                    log::error!("Order rejected: {order:?}, Reason: {reason}");
                }
                ExecutionEvent::OrderFilled(order) => {
                    log::info!("Order fully filled: {order:?}");
                }
                ExecutionEvent::PartialFill(order, filled_quantity) => {
                    log::info!("Order partially filled: {order:?}, Filled: {filled_quantity}");
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rust_decimal_macros::dec;
    use rusty_model::{
        enums::{OrderSide, OrderType},
        venues::Venue,
    };
    use std::sync::Arc;
    use tokio::sync::Mutex;

    // Mock Exchange implementation for testing
    struct MockExchange {
        // Track calls to send_order
        send_order_calls: Arc<Mutex<Vec<Order>>>,
        // Control whether send_order succeeds or fails
        should_fail: bool,
        // Error message to return when should_fail is true
        error_message: std::string::String,
    }

    impl MockExchange {
        fn new(should_fail: bool, error_message: std::string::String) -> Self {
            Self {
                send_order_calls: Arc::new(Mutex::new(Vec::new())),
                should_fail,
                error_message,
            }
        }

        #[allow(dead_code)]
        async fn get_send_order_calls(&self) -> Vec<Order> {
            let calls = self.send_order_calls.lock().await;
            calls.clone()
        }
    }

    #[async_trait::async_trait]
    impl Exchange for MockExchange {
        async fn send_order(&self, order: Order) -> crate::Result<()> {
            // Record the call
            let mut calls = self.send_order_calls.lock().await;
            calls.push(order);

            if self.should_fail {
                Err(crate::OmsError::Exchange(self.error_message.clone().into()))
            } else {
                Ok(())
            }
        }

        async fn cancel_order(&self, _order_id: std::string::String) -> crate::Result<()> {
            // Not used in these tests
            Ok(())
        }

        async fn get_order_status(
            &self,
            _order_id: std::string::String,
        ) -> crate::Result<std::string::String> {
            // Not used in these tests
            Ok("FILLED".into())
        }
    }

    fn create_test_order() -> Order {
        Order::new(
            Venue::Test,
            "BTCUSDT",
            OrderSide::Buy,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(50000.0)),
            rusty_model::types::ClientId::new("test_client"),
        )
    }

    #[tokio::test]
    async fn test_order_manager_new() {
        let max_quantity = dec!(10.0);
        let min_price = dec!(1000.0);
        let max_price = dec!(100000.0);
        let exchange = MockExchange::new(false, std::string::String::new());

        let _order_manager = OrderManager::new(max_quantity, min_price, max_price, exchange);
        // Just testing that it can be created without panicking
    }

    #[tokio::test]
    async fn test_submit_order_success() {
        // Create a mock exchange that succeeds
        let mock_exchange = MockExchange::new(false, std::string::String::new());
        let send_order_calls = mock_exchange.send_order_calls.clone();

        // Create an order manager with generous risk limits
        let mut order_manager =
            OrderManager::new(dec!(100.0), dec!(1.0), dec!(1000000.0), mock_exchange);

        // Submit an order
        let order = create_test_order();
        let result = order_manager.submit_order(order.clone()).await;

        // Verify the result
        assert!(result.is_ok());

        // Verify the order was sent to the exchange
        let calls = send_order_calls.lock().await;
        assert_eq!(calls.len(), 1);
        assert_eq!(calls[0].id, order.id);
    }

    #[tokio::test]
    async fn test_submit_order_exchange_failure() {
        // Create a mock exchange that fails
        let error_message = "Exchange error".to_string();
        let mock_exchange = MockExchange::new(true, error_message.clone());
        let send_order_calls = mock_exchange.send_order_calls.clone();

        // Create an order manager with generous risk limits
        let mut order_manager =
            OrderManager::new(dec!(100.0), dec!(1.0), dec!(1000000.0), mock_exchange);

        // Submit an order
        let order = create_test_order();
        let result = order_manager.submit_order(order.clone()).await;

        // Verify the result - should still be Ok since we handle exchange errors in the execution engine
        assert!(result.is_ok());

        // Verify the order was sent to the exchange
        let calls = send_order_calls.lock().await;
        assert_eq!(calls.len(), 1);
        assert_eq!(calls[0].id, order.id);
    }

    #[tokio::test]
    async fn test_submit_order_risk_failure() {
        // Create a mock exchange
        let mock_exchange = MockExchange::new(false, std::string::String::new());

        // Create an order manager with strict risk limits that will reject the order
        let mut order_manager = OrderManager::new(
            dec!(0.5), // Max quantity is 0.5
            dec!(1.0),
            dec!(1000000.0),
            mock_exchange,
        );

        // Submit an order with quantity that exceeds the risk limit
        let order = create_test_order(); // Quantity is 1.0, which exceeds the limit of 0.5
        let result = order_manager.submit_order(order).await;

        // Verify the result - should be an error
        assert!(result.is_err());
        assert!(
            matches!(result.unwrap_err(), crate::OmsError::RiskViolation(msg) if msg.contains("QuantityTooLarge"))
        );
    }
}