nautilus_model/events/order/

stubs.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

use std::str::FromStr;

use nautilus_core::UUID4;
use rstest::fixture;
use ustr::Ustr;

use crate::{
    enums::{ContingencyType, OrderType, TriggerType},
    events::{
        OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDenied, OrderEmulated,
        OrderExpired, OrderFilled, OrderInitialized, OrderModifyRejected, OrderPendingCancel,
        OrderPendingUpdate, OrderRejected, OrderReleased, OrderSubmitted, OrderTriggered,
        OrderUpdated,
        order::spec::{
            OrderAcceptedSpec, OrderCancelRejectedSpec, OrderCanceledSpec, OrderDeniedSpec,
            OrderEmulatedSpec, OrderExpiredSpec, OrderFilledSpec, OrderInitializedSpec,
            OrderModifyRejectedSpec, OrderPendingCancelSpec, OrderPendingUpdateSpec,
            OrderRejectedSpec, OrderReleasedSpec, OrderSubmittedSpec, OrderTriggeredSpec,
            OrderUpdatedSpec,
        },
    },
    identifiers::{
        AccountId, ClientOrderId, InstrumentId, OrderListId, StrategyId, TraderId, VenueOrderId,
        stubs as id_stubs,
    },
    stubs::TestDefault,
    types::{Currency, Money, Price, Quantity},
};

// Fixture wrappers for rstest - these are not glob-exported to avoid ambiguity
#[fixture]
pub fn trader_id() -> TraderId {
    id_stubs::trader_id()
}

#[fixture]
pub fn strategy_id_ema_cross() -> StrategyId {
    id_stubs::strategy_id_ema_cross()
}

#[fixture]
pub fn instrument_id_btc_usdt() -> InstrumentId {
    id_stubs::instrument_id_btc_usdt()
}

#[fixture]
pub fn client_order_id() -> ClientOrderId {
    id_stubs::client_order_id()
}

#[fixture]
pub fn venue_order_id() -> VenueOrderId {
    id_stubs::venue_order_id()
}

#[fixture]
pub fn account_id() -> AccountId {
    id_stubs::account_id()
}

#[fixture]
pub fn uuid4() -> UUID4 {
    id_stubs::uuid4()
}

#[fixture]
pub fn order_filled(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderFilled {
    OrderFilledSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .venue_order_id(VenueOrderId::new("123456"))
        .order_type(OrderType::Limit)
        .last_qty(Quantity::from_str("0.561").unwrap())
        .last_px(Price::from_str("22000").unwrap())
        .currency(Currency::from_str("USDT").unwrap())
        .event_id(uuid4)
        .commission(Money::from("12.2 USDT"))
        .build()
}

#[fixture]
pub fn order_denied_max_submitted_rate(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderDenied {
    OrderDeniedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .reason(Ustr::from("RATE_LIMIT_EXCEEDED"))
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_rejected_insufficient_margin(
    trader_id: TraderId,
    account_id: AccountId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderRejected {
    OrderRejectedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .account_id(account_id)
        .reason(Ustr::from("INSUFFICIENT_MARGIN"))
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_initialized_buy_limit(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderInitialized {
    let order_list_id = OrderListId::new("1");
    let linked_order_ids = vec![ClientOrderId::new("O-2020872378424")];
    OrderInitializedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .order_type(OrderType::Limit)
        .quantity(Quantity::from_str("0.561").unwrap())
        .post_only(true)
        .reduce_only(true)
        .event_id(uuid4)
        .price(Price::from_str("22000").unwrap())
        .emulation_trigger(TriggerType::BidAsk)
        .trigger_instrument_id(instrument_id_btc_usdt)
        .contingency_type(ContingencyType::Oto)
        .order_list_id(order_list_id)
        .linked_order_ids(linked_order_ids)
        .build()
}

#[fixture]
pub fn order_submitted(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderSubmitted {
    OrderSubmittedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .account_id(account_id)
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_triggered(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    venue_order_id: VenueOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderTriggered {
    OrderTriggeredSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .build()
}

#[fixture]
pub fn order_emulated(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderEmulated {
    OrderEmulatedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_released(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    uuid4: UUID4,
) -> OrderReleased {
    OrderReleasedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .released_price(Price::from_str("22000").unwrap())
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_updated(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    venue_order_id: VenueOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderUpdated {
    OrderUpdatedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .quantity(Quantity::from(100))
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .price(Price::from("22000"))
        .build()
}

#[fixture]
pub fn order_pending_update(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    account_id: AccountId,
    venue_order_id: VenueOrderId,
    uuid4: UUID4,
) -> OrderPendingUpdate {
    OrderPendingUpdateSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .account_id(account_id)
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .build()
}

#[fixture]
pub fn order_pending_cancel(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    account_id: AccountId,
    venue_order_id: VenueOrderId,
    uuid4: UUID4,
) -> OrderPendingCancel {
    OrderPendingCancelSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .account_id(account_id)
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .build()
}

#[fixture]
pub fn order_modify_rejected(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    venue_order_id: VenueOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderModifyRejected {
    OrderModifyRejectedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .reason(Ustr::from("ORDER_DOES_NOT_EXIST"))
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .build()
}

#[fixture]
pub fn order_accepted(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    account_id: AccountId,
    venue_order_id: VenueOrderId,
    uuid4: UUID4,
) -> OrderAccepted {
    OrderAcceptedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .event_id(uuid4)
        .build()
}

#[fixture]
pub fn order_cancel_rejected(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    venue_order_id: VenueOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderCancelRejected {
    OrderCancelRejectedSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .reason(Ustr::from("ORDER_DOES_NOT_EXIST"))
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .build()
}

#[fixture]
pub fn order_expired(
    trader_id: TraderId,
    strategy_id_ema_cross: StrategyId,
    instrument_id_btc_usdt: InstrumentId,
    client_order_id: ClientOrderId,
    venue_order_id: VenueOrderId,
    account_id: AccountId,
    uuid4: UUID4,
) -> OrderExpired {
    OrderExpiredSpec::builder()
        .trader_id(trader_id)
        .strategy_id(strategy_id_ema_cross)
        .instrument_id(instrument_id_btc_usdt)
        .client_order_id(client_order_id)
        .event_id(uuid4)
        .venue_order_id(venue_order_id)
        .account_id(account_id)
        .build()
}

impl TestDefault for OrderAccepted {
    fn test_default() -> Self {
        OrderAcceptedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderAccepted {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderCanceled {
    fn test_default() -> Self {
        OrderCanceledSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderCanceled {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderCancelRejected {
    fn test_default() -> Self {
        OrderCancelRejectedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderCancelRejected {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderDenied {
    fn test_default() -> Self {
        OrderDeniedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderDenied {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderEmulated {
    fn test_default() -> Self {
        OrderEmulatedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderEmulated {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderExpired {
    fn test_default() -> Self {
        OrderExpiredSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderExpired {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderInitialized {
    fn test_default() -> Self {
        OrderInitializedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderInitialized {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderModifyRejected {
    fn test_default() -> Self {
        OrderModifyRejectedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderModifyRejected {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderPendingCancel {
    fn test_default() -> Self {
        OrderPendingCancelSpec::builder()
            .event_id(UUID4::default())
            .account_id(AccountId::test_default())
            .build()
    }
}

impl Default for OrderPendingCancel {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderPendingUpdate {
    fn test_default() -> Self {
        OrderPendingUpdateSpec::builder()
            .event_id(UUID4::default())
            .account_id(AccountId::test_default())
            .build()
    }
}

impl Default for OrderPendingUpdate {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderRejected {
    fn test_default() -> Self {
        OrderRejectedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderRejected {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderReleased {
    fn test_default() -> Self {
        OrderReleasedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderReleased {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderSubmitted {
    fn test_default() -> Self {
        OrderSubmittedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderSubmitted {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderTriggered {
    fn test_default() -> Self {
        OrderTriggeredSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderTriggered {
    fn default() -> Self {
        Self::test_default()
    }
}

impl TestDefault for OrderUpdated {
    fn test_default() -> Self {
        OrderUpdatedSpec::builder()
            .event_id(UUID4::default())
            .build()
    }
}

impl Default for OrderUpdated {
    fn default() -> Self {
        Self::test_default()
    }
}