1use std::fmt::Display;
17
18use enum_dispatch::enum_dispatch;
19use serde::{Deserialize, Serialize};
20use thiserror::Error;
21
22use super::{
23 Order, OrderCore, OrderError, limit::LimitOrder, limit_if_touched::LimitIfTouchedOrder,
24 market::MarketOrder, market_if_touched::MarketIfTouchedOrder,
25 market_to_limit::MarketToLimitOrder, stop_limit::StopLimitOrder, stop_market::StopMarketOrder,
26 trailing_stop_limit::TrailingStopLimitOrder, trailing_stop_market::TrailingStopMarketOrder,
27};
28use crate::{events::OrderEventAny, identifiers::OrderListId, types::Price};
29
30#[derive(Debug, Error)]
32pub enum OrderReplayError {
33 #[error("No order events provided to create OrderAny")]
35 EmptyInput,
36 #[error("First event must be `OrderInitialized`")]
38 WrongFirstEvent,
39 #[error("Invalid `OrderInitialized` event: {source}")]
41 InvalidInitialization {
42 #[source]
44 source: OrderError,
45 },
46 #[error("{source}")]
48 ApplyFailed {
49 #[source]
51 source: OrderError,
52 },
53}
54
55#[derive(Clone, Debug, Serialize, Deserialize)]
56#[enum_dispatch(Order)]
57pub enum OrderAny {
58 Limit(LimitOrder),
59 LimitIfTouched(LimitIfTouchedOrder),
60 Market(MarketOrder),
61 MarketIfTouched(MarketIfTouchedOrder),
62 MarketToLimit(MarketToLimitOrder),
63 StopLimit(StopLimitOrder),
64 StopMarket(StopMarketOrder),
65 TrailingStopLimit(TrailingStopLimitOrder),
66 TrailingStopMarket(TrailingStopMarketOrder),
67}
68
69impl OrderAny {
70 pub fn from_events(events: Vec<OrderEventAny>) -> Result<Self, OrderReplayError> {
81 let Some(init_event) = events.first() else {
82 return Err(OrderReplayError::EmptyInput);
83 };
84
85 let OrderEventAny::Initialized(init) = init_event else {
86 return Err(OrderReplayError::WrongFirstEvent);
87 };
88
89 let mut order = Self::try_from(init.clone())
90 .map_err(|source| OrderReplayError::InvalidInitialization { source })?;
91
92 for event in events.into_iter().skip(1) {
93 order
94 .apply(event)
95 .map_err(|source| OrderReplayError::ApplyFailed { source })?;
96 }
97
98 Ok(order)
99 }
100
101 #[must_use]
109 pub fn init_event(&self) -> &crate::events::OrderInitialized {
110 match self
111 .events()
112 .first()
113 .expect("Order invariant violated: no events")
114 {
115 OrderEventAny::Initialized(init) => init,
116 _ => panic!("Order invariant violated: first event must be OrderInitialized"),
117 }
118 }
119
120 pub fn set_order_list_id(&mut self, id: OrderListId) {
126 let order: &mut OrderCore = match self {
127 Self::Limit(order) => order,
128 Self::LimitIfTouched(order) => order,
129 Self::Market(order) => order,
130 Self::MarketIfTouched(order) => order,
131 Self::MarketToLimit(order) => order,
132 Self::StopLimit(order) => order,
133 Self::StopMarket(order) => order,
134 Self::TrailingStopLimit(order) => order,
135 Self::TrailingStopMarket(order) => order,
136 };
137 let init = match order
138 .events
139 .first_mut()
140 .expect("Order invariant violated: no events")
141 {
142 OrderEventAny::Initialized(init) => init,
143 _ => panic!("Order invariant violated: first event must be OrderInitialized"),
144 };
145
146 order.order_list_id = Some(id);
147 init.order_list_id = Some(id);
148 }
149}
150
151impl PartialEq for OrderAny {
152 fn eq(&self, other: &Self) -> bool {
153 self.client_order_id() == other.client_order_id()
154 }
155}
156
157impl Eq for OrderAny {}
159
160impl Display for OrderAny {
161 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
162 write!(
163 f,
164 "{}",
165 match self {
166 Self::Limit(order) => order.to_string(),
167 Self::LimitIfTouched(order) => order.to_string(),
168 Self::Market(order) => order.to_string(),
169 Self::MarketIfTouched(order) => order.to_string(),
170 Self::MarketToLimit(order) => order.to_string(),
171 Self::StopLimit(order) => order.to_string(),
172 Self::StopMarket(order) => order.to_string(),
173 Self::TrailingStopLimit(order) => order.to_string(),
174 Self::TrailingStopMarket(order) => order.to_string(),
175 }
176 )
177 }
178}
179
180impl TryFrom<OrderAny> for PassiveOrderAny {
181 type Error = String;
182
183 fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
184 match order {
185 OrderAny::Limit(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
186 OrderAny::LimitIfTouched(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
187 OrderAny::MarketIfTouched(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
188 OrderAny::StopLimit(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
189 OrderAny::StopMarket(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
190 OrderAny::TrailingStopLimit(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
191 OrderAny::TrailingStopMarket(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
192 OrderAny::MarketToLimit(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
193 OrderAny::Market(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
194 }
195 }
196}
197
198impl From<PassiveOrderAny> for OrderAny {
199 fn from(order: PassiveOrderAny) -> Self {
200 match order {
201 PassiveOrderAny::Limit(order) => order.into(),
202 PassiveOrderAny::Stop(order) => order.into(),
203 }
204 }
205}
206
207impl TryFrom<OrderAny> for StopOrderAny {
208 type Error = String;
209
210 fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
211 match order {
212 OrderAny::LimitIfTouched(order) => Ok(Self::LimitIfTouched(order)),
213 OrderAny::MarketIfTouched(order) => Ok(Self::MarketIfTouched(order)),
214 OrderAny::StopLimit(order) => Ok(Self::StopLimit(order)),
215 OrderAny::StopMarket(order) => Ok(Self::StopMarket(order)),
216 OrderAny::TrailingStopLimit(order) => Ok(Self::TrailingStopLimit(order)),
217 OrderAny::TrailingStopMarket(order) => Ok(Self::TrailingStopMarket(order)),
218 _ => Err(format!(
219 "Cannot convert {:?} order to StopOrderAny: order type does not have a stop/trigger price",
220 order.order_type()
221 )),
222 }
223 }
224}
225
226impl From<StopOrderAny> for OrderAny {
227 fn from(order: StopOrderAny) -> Self {
228 match order {
229 StopOrderAny::LimitIfTouched(order) => Self::LimitIfTouched(order),
230 StopOrderAny::MarketIfTouched(order) => Self::MarketIfTouched(order),
231 StopOrderAny::StopLimit(order) => Self::StopLimit(order),
232 StopOrderAny::StopMarket(order) => Self::StopMarket(order),
233 StopOrderAny::TrailingStopLimit(order) => Self::TrailingStopLimit(order),
234 StopOrderAny::TrailingStopMarket(order) => Self::TrailingStopMarket(order),
235 }
236 }
237}
238
239impl TryFrom<OrderAny> for LimitOrderAny {
240 type Error = String;
241
242 fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
243 match order {
244 OrderAny::Limit(order) => Ok(Self::Limit(order)),
245 OrderAny::MarketToLimit(order) => Ok(Self::MarketToLimit(order)),
246 OrderAny::StopLimit(order) => Ok(Self::StopLimit(order)),
247 OrderAny::TrailingStopLimit(order) => Ok(Self::TrailingStopLimit(order)),
248 OrderAny::Market(order) => Ok(Self::MarketOrderWithProtection(order)),
249 _ => Err(format!(
250 "Cannot convert {:?} order to LimitOrderAny: order type does not have a limit price",
251 order.order_type()
252 )),
253 }
254 }
255}
256
257impl From<LimitOrderAny> for OrderAny {
258 fn from(order: LimitOrderAny) -> Self {
259 match order {
260 LimitOrderAny::Limit(order) => Self::Limit(order),
261 LimitOrderAny::MarketToLimit(order) => Self::MarketToLimit(order),
262 LimitOrderAny::StopLimit(order) => Self::StopLimit(order),
263 LimitOrderAny::TrailingStopLimit(order) => Self::TrailingStopLimit(order),
264 LimitOrderAny::MarketOrderWithProtection(order) => Self::Market(order),
265 }
266 }
267}
268
269#[derive(Clone, Debug)]
270#[enum_dispatch(Order)]
271pub enum PassiveOrderAny {
272 Limit(LimitOrderAny),
273 Stop(StopOrderAny),
274}
275
276impl PassiveOrderAny {
277 #[must_use]
278 pub fn to_any(&self) -> OrderAny {
279 match self {
280 Self::Limit(order) => order.clone().into(),
281 Self::Stop(order) => order.clone().into(),
282 }
283 }
284}
285
286impl PartialEq for PassiveOrderAny {
288 fn eq(&self, rhs: &Self) -> bool {
289 match self {
290 Self::Limit(order) => order.client_order_id() == rhs.client_order_id(),
291 Self::Stop(order) => order.client_order_id() == rhs.client_order_id(),
292 }
293 }
294}
295
296#[derive(Clone, Debug)]
297#[enum_dispatch(Order)]
298pub enum LimitOrderAny {
299 Limit(LimitOrder),
300 MarketToLimit(MarketToLimitOrder),
301 StopLimit(StopLimitOrder),
302 TrailingStopLimit(TrailingStopLimitOrder),
303 MarketOrderWithProtection(MarketOrder),
304}
305
306impl LimitOrderAny {
307 #[must_use]
313 pub fn limit_px(&self) -> Price {
314 match self {
315 Self::Limit(order) => order.price,
316 Self::MarketToLimit(order) => order.price.expect("MarketToLimit order price not set"),
317 Self::StopLimit(order) => order.price,
318 Self::TrailingStopLimit(order) => {
319 order.price.expect("TrailingStopLimit order price not set")
320 }
321 Self::MarketOrderWithProtection(order) => {
322 order.protection_price.expect("No price for order")
323 }
324 }
325 }
326}
327
328impl PartialEq for LimitOrderAny {
329 fn eq(&self, rhs: &Self) -> bool {
330 match self {
331 Self::Limit(order) => order.client_order_id == rhs.client_order_id(),
332 Self::MarketToLimit(order) => order.client_order_id == rhs.client_order_id(),
333 Self::StopLimit(order) => order.client_order_id == rhs.client_order_id(),
334 Self::TrailingStopLimit(order) => order.client_order_id == rhs.client_order_id(),
335 Self::MarketOrderWithProtection(order) => {
336 order.client_order_id == rhs.client_order_id()
337 }
338 }
339 }
340}
341
342#[derive(Clone, Debug)]
343#[enum_dispatch(Order)]
344pub enum StopOrderAny {
345 LimitIfTouched(LimitIfTouchedOrder),
346 MarketIfTouched(MarketIfTouchedOrder),
347 StopLimit(StopLimitOrder),
348 StopMarket(StopMarketOrder),
349 TrailingStopLimit(TrailingStopLimitOrder),
350 TrailingStopMarket(TrailingStopMarketOrder),
351}
352
353impl StopOrderAny {
354 #[must_use]
355 pub fn stop_px(&self) -> Option<Price> {
356 match self {
357 Self::LimitIfTouched(o) => Some(o.trigger_price),
358 Self::MarketIfTouched(o) => Some(o.trigger_price),
359 Self::StopLimit(o) => Some(o.trigger_price),
360 Self::StopMarket(o) => Some(o.trigger_price),
361 Self::TrailingStopLimit(o) => o.activation_price.or(o.trigger_price),
362 Self::TrailingStopMarket(o) => o.activation_price.or(o.trigger_price),
363 }
364 }
365}
366
367impl PartialEq for StopOrderAny {
369 fn eq(&self, rhs: &Self) -> bool {
370 match self {
371 Self::LimitIfTouched(order) => order.client_order_id == rhs.client_order_id(),
372 Self::StopLimit(order) => order.client_order_id == rhs.client_order_id(),
373 Self::StopMarket(order) => order.client_order_id == rhs.client_order_id(),
374 Self::MarketIfTouched(order) => order.client_order_id == rhs.client_order_id(),
375 Self::TrailingStopLimit(order) => order.client_order_id == rhs.client_order_id(),
376 Self::TrailingStopMarket(order) => order.client_order_id == rhs.client_order_id(),
377 }
378 }
379}
380
381#[cfg(test)]
382mod tests {
383 use nautilus_core::{UUID4, UnixNanos};
384 use rstest::rstest;
385 use rust_decimal::Decimal;
386 use rust_decimal_macros::dec;
387
388 use super::*;
389 use crate::{
390 enums::{OrderSide, OrderType, TrailingOffsetType, TriggerType},
391 events::{
392 OrderEventAny, OrderInitialized, OrderUpdated, order::spec::OrderInitializedSpec,
393 },
394 identifiers::{ClientOrderId, InstrumentId, StrategyId},
395 orders::{OrderError, builder::OrderTestBuilder},
396 types::{Price, Quantity},
397 };
398
399 #[rstest]
400 #[should_panic(expected = "Order invariant violated: first event must be OrderInitialized")]
401 fn test_init_event_panics_when_first_event_is_not_initialized() {
402 let mut order = OrderTestBuilder::new(OrderType::Market)
403 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
404 .quantity(Quantity::from(10))
405 .build();
406
407 let OrderAny::Market(inner) = &mut order else {
408 panic!("expected a market order");
409 };
410
411 inner.events[0] =
412 OrderEventAny::Denied(crate::events::order::spec::OrderDeniedSpec::builder().build());
413
414 let _ = order.init_event();
415 }
416
417 #[rstest]
418 fn test_order_any_equality() {
419 let client_order_id = ClientOrderId::from("ORDER-001");
421
422 let market_order = OrderTestBuilder::new(OrderType::Market)
423 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
424 .quantity(Quantity::from(10))
425 .client_order_id(client_order_id)
426 .build();
427
428 let limit_order = OrderTestBuilder::new(OrderType::Limit)
429 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
430 .quantity(Quantity::from(10))
431 .price(Price::new(100.0, 2))
432 .client_order_id(client_order_id)
433 .build();
434
435 assert_eq!(market_order, limit_order);
437 }
438
439 #[rstest]
440 fn test_order_any_conversion_from_events() {
441 let init_event = OrderInitializedSpec::builder()
443 .order_type(OrderType::Market)
444 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
445 .quantity(Quantity::from(10))
446 .build();
447
448 let events = vec![OrderEventAny::Initialized(init_event.clone())];
450
451 let order = OrderAny::from_events(events).unwrap();
453
454 assert_eq!(order.order_type(), OrderType::Market);
456 assert_eq!(order.instrument_id(), init_event.instrument_id);
457 assert_eq!(order.quantity(), init_event.quantity);
458 }
459
460 #[rstest]
461 #[case::limit(OrderType::Limit)]
462 #[case::limit_if_touched(OrderType::LimitIfTouched)]
463 #[case::market(OrderType::Market)]
464 #[case::market_if_touched(OrderType::MarketIfTouched)]
465 #[case::market_to_limit(OrderType::MarketToLimit)]
466 #[case::stop_limit(OrderType::StopLimit)]
467 #[case::stop_market(OrderType::StopMarket)]
468 #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
469 #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
470 fn test_set_order_list_id_updates_init_event_and_replay(#[case] order_type: OrderType) {
471 let mut order = order_for_list_id_test(order_type);
472 let init_before = order.init_event().clone();
473 let event_count = order.event_count();
474 let order_list_id = OrderListId::from("OL-SET-LIST-001");
475
476 order.set_order_list_id(order_list_id);
477
478 let mut expected_init = init_before;
479 expected_init.order_list_id = Some(order_list_id);
480 assert_eq!(order.order_list_id(), Some(order_list_id));
481 assert_eq!(order.init_event(), &expected_init);
482 assert_eq!(order.event_count(), event_count);
483
484 let persisted_events: Vec<_> = order.events().into_iter().cloned().collect();
485 assert_eq!(
486 persisted_events,
487 vec![OrderEventAny::Initialized(expected_init.clone())]
488 );
489
490 let replayed = OrderAny::from_events(persisted_events).unwrap();
491 assert_eq!(replayed.order_list_id(), Some(order_list_id));
492 assert_eq!(replayed.init_event(), &expected_init);
493 }
494
495 #[rstest]
496 #[case::limit(OrderType::Limit)]
497 #[case::limit_if_touched(OrderType::LimitIfTouched)]
498 #[case::market(OrderType::Market)]
499 #[case::market_if_touched(OrderType::MarketIfTouched)]
500 #[case::market_to_limit(OrderType::MarketToLimit)]
501 #[case::stop_limit(OrderType::StopLimit)]
502 #[case::stop_market(OrderType::StopMarket)]
503 #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
504 #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
505 fn test_order_any_from_events_preserves_init_metadata(
506 #[case] order_type: OrderType,
507 #[values(false, true)] reconciliation: bool,
508 #[values(None, Some(UUID4::from("775e3ce7-e768-43ad-859a-14b42d8a4ab0")))]
509 causation_id: Option<UUID4>,
510 ) {
511 let mut init = order_for_list_id_test(order_type).init_event().clone();
512 init.ts_init = UnixNanos::from(987_654_321);
513 init.reconciliation = reconciliation;
514 init.causation_id = causation_id;
515
516 let converted = OrderAny::try_from(init.clone()).unwrap();
517 let order = OrderAny::from_events(vec![OrderEventAny::Initialized(init.clone())]).unwrap();
518
519 assert_eq!(converted.init_event(), &init);
520 assert_eq!(order.init_event(), &init);
521 assert_eq!(converted.ts_init(), init.ts_event);
522 assert_eq!(order.ts_init(), init.ts_event);
523 assert_eq!(converted.ts_last(), init.ts_event);
524 assert_eq!(order.ts_last(), init.ts_event);
525 }
526
527 fn assert_last_event_views(order: &OrderAny) {
528 fn generic_last_event<T: Order + ?Sized>(order: &T) -> &OrderEventAny {
529 order.last_event()
530 }
531
532 let events = order.events();
533 let expected = *events.last().unwrap();
534 assert!(std::ptr::eq(order.last_event(), expected));
535 assert!(std::ptr::eq(generic_last_event(order), expected));
536
537 let concrete: &dyn Order = match order {
538 OrderAny::Limit(order) => order,
539 OrderAny::LimitIfTouched(order) => order,
540 OrderAny::Market(order) => order,
541 OrderAny::MarketIfTouched(order) => order,
542 OrderAny::MarketToLimit(order) => order,
543 OrderAny::StopLimit(order) => order,
544 OrderAny::StopMarket(order) => order,
545 OrderAny::TrailingStopLimit(order) => order,
546 OrderAny::TrailingStopMarket(order) => order,
547 };
548 assert!(std::ptr::eq(concrete.last_event(), expected));
549 }
550
551 #[rstest]
552 #[case::limit(OrderType::Limit)]
553 #[case::limit_if_touched(OrderType::LimitIfTouched)]
554 #[case::market(OrderType::Market)]
555 #[case::market_if_touched(OrderType::MarketIfTouched)]
556 #[case::market_to_limit(OrderType::MarketToLimit)]
557 #[case::stop_limit(OrderType::StopLimit)]
558 #[case::stop_market(OrderType::StopMarket)]
559 #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
560 #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
561 fn test_last_event_borrows_latest_native_event(#[case] order_type: OrderType) {
562 let mut order = order_for_list_id_test(order_type);
563 assert_last_event_views(&order);
564
565 let denied = crate::events::OrderDenied::new(
566 order.trader_id(),
567 order.strategy_id(),
568 order.instrument_id(),
569 order.client_order_id(),
570 "Risk denied".into(),
571 UUID4::new(),
572 UnixNanos::from(1),
573 UnixNanos::from(1),
574 );
575 order.apply(OrderEventAny::Denied(denied)).unwrap();
576 assert_last_event_views(&order);
577 }
578
579 #[rstest]
580 #[case::limit(OrderType::Limit)]
581 #[case::limit_if_touched(OrderType::LimitIfTouched)]
582 #[case::market(OrderType::Market)]
583 #[case::market_if_touched(OrderType::MarketIfTouched)]
584 #[case::market_to_limit(OrderType::MarketToLimit)]
585 #[case::stop_limit(OrderType::StopLimit)]
586 #[case::stop_market(OrderType::StopMarket)]
587 #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
588 #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
589 #[should_panic(expected = "Order invariant violated: no events")]
590 fn test_last_event_preserves_empty_history_panic(#[case] order_type: OrderType) {
591 let mut order = order_for_list_id_test(order_type);
592 let core: &mut OrderCore = match &mut order {
593 OrderAny::Limit(order) => order,
594 OrderAny::LimitIfTouched(order) => order,
595 OrderAny::Market(order) => order,
596 OrderAny::MarketIfTouched(order) => order,
597 OrderAny::MarketToLimit(order) => order,
598 OrderAny::StopLimit(order) => order,
599 OrderAny::StopMarket(order) => order,
600 OrderAny::TrailingStopLimit(order) => order,
601 OrderAny::TrailingStopMarket(order) => order,
602 };
603 core.events.clear();
604
605 let _ = Order::last_event(&order);
606 }
607
608 fn order_for_list_id_test(order_type: OrderType) -> OrderAny {
609 OrderTestBuilder::new(order_type)
610 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
611 .client_order_id(ClientOrderId::from("ORDER-LIST-001"))
612 .quantity(Quantity::from(10))
613 .price(Price::from("101.00"))
614 .trigger_price(Price::from("100.00"))
615 .trigger_type(TriggerType::LastPrice)
616 .limit_offset(dec!(1))
617 .trailing_offset(dec!(1))
618 .trailing_offset_type(TrailingOffsetType::Price)
619 .init_id(UUID4::from("16578139-a945-4b65-b46c-bc131a15d8e7"))
620 .ts_init(UnixNanos::from(123_456_789))
621 .build()
622 }
623
624 #[rstest]
625 fn test_order_any_from_events_empty_error() {
626 let events: Vec<OrderEventAny> = vec![];
627 let err = OrderAny::from_events(events).expect_err("empty events should fail");
628
629 assert!(matches!(err, OrderReplayError::EmptyInput));
630 assert_eq!(
631 err.to_string(),
632 "No order events provided to create OrderAny"
633 );
634 }
635
636 #[rstest]
637 fn test_order_any_from_events_invalid_init_returns_error() {
638 let init_event = OrderInitializedSpec::builder()
641 .order_type(OrderType::Limit)
642 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
643 .quantity(Quantity::from(10))
644 .build();
645
646 let events = vec![OrderEventAny::Initialized(init_event)];
647 let err =
648 OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
649
650 match &err {
651 OrderReplayError::InvalidInitialization { source } => {
652 assert_eq!(
653 source.to_string(),
654 "`price` is required for `LimitOrder` initialization",
655 );
656 }
657 _ => panic!("expected InvalidInitialization, was {err:?}"),
658 }
659 assert_eq!(
660 err.to_string(),
661 "Invalid `OrderInitialized` event: `price` is required for `LimitOrder` initialization",
662 );
663 }
664
665 #[rstest]
666 #[case::buy(
667 OrderSide::Buy,
668 Price::from("100.00"),
669 Price::from("101.00"),
670 "BUY Limit-If-Touched"
671 )]
672 #[case::sell(
673 OrderSide::Sell,
674 Price::from("100.00"),
675 Price::from("99.00"),
676 "SELL Limit-If-Touched"
677 )]
678 fn test_order_any_from_events_invalid_predicate_returns_error(
679 #[case] side: OrderSide,
680 #[case] price: Price,
681 #[case] trigger_price: Price,
682 #[case] expected_msg: &str,
683 ) {
684 let init_event = OrderInitializedSpec::builder()
688 .order_type(OrderType::LimitIfTouched)
689 .order_side(side)
690 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
691 .quantity(Quantity::from(10))
692 .price(price)
693 .trigger_price(trigger_price)
694 .trigger_type(TriggerType::LastPrice)
695 .build();
696
697 let events = vec![OrderEventAny::Initialized(init_event)];
698 let err =
699 OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
700
701 assert!(matches!(
702 err,
703 OrderReplayError::InvalidInitialization { .. }
704 ));
705 let msg = err.to_string();
706 assert!(
707 msg.contains("Invalid `OrderInitialized` event") && msg.contains(expected_msg),
708 "unexpected error message: {msg}"
709 );
710 }
711
712 fn make_init_with_optional_fields(
713 order_type: OrderType,
714 price: Option<Price>,
715 trigger_price: Option<Price>,
716 trigger_type: Option<TriggerType>,
717 limit_offset: Option<Decimal>,
718 trailing_offset: Option<Decimal>,
719 trailing_offset_type: Option<TrailingOffsetType>,
720 ) -> OrderInitialized {
721 OrderInitializedSpec::builder()
722 .order_type(order_type)
723 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
724 .quantity(Quantity::from(10))
725 .maybe_price(price)
726 .maybe_trigger_price(trigger_price)
727 .maybe_trigger_type(trigger_type)
728 .maybe_limit_offset(limit_offset)
729 .maybe_trailing_offset(trailing_offset)
730 .maybe_trailing_offset_type(trailing_offset_type)
731 .build()
732 }
733
734 #[rstest]
735 #[case::lit_missing_price(
736 make_init_with_optional_fields(
737 OrderType::LimitIfTouched,
738 None,
739 Some(Price::from("100.00")),
740 Some(TriggerType::LastPrice),
741 None,
742 None,
743 None,
744 ),
745 "`price` is required for `LimitIfTouchedOrder`"
746 )]
747 #[case::lit_missing_trigger_price(
748 make_init_with_optional_fields(
749 OrderType::LimitIfTouched,
750 Some(Price::from("100.00")),
751 None,
752 Some(TriggerType::LastPrice),
753 None,
754 None,
755 None,
756 ),
757 "`trigger_price` is required for `LimitIfTouchedOrder`"
758 )]
759 #[case::lit_missing_trigger_type(
760 make_init_with_optional_fields(
761 OrderType::LimitIfTouched,
762 Some(Price::from("100.00")),
763 Some(Price::from("99.00")),
764 None,
765 None,
766 None,
767 None,
768 ),
769 "`trigger_type` is required for `LimitIfTouchedOrder`"
770 )]
771 #[case::stop_limit_missing_price(
772 make_init_with_optional_fields(
773 OrderType::StopLimit,
774 None,
775 Some(Price::from("100.00")),
776 Some(TriggerType::LastPrice),
777 None,
778 None,
779 None,
780 ),
781 "`price` is required for `StopLimitOrder`"
782 )]
783 #[case::stop_limit_missing_trigger_price(
784 make_init_with_optional_fields(
785 OrderType::StopLimit,
786 Some(Price::from("100.00")),
787 None,
788 Some(TriggerType::LastPrice),
789 None,
790 None,
791 None,
792 ),
793 "`trigger_price` is required for `StopLimitOrder`"
794 )]
795 #[case::stop_limit_missing_trigger_type(
796 make_init_with_optional_fields(
797 OrderType::StopLimit,
798 Some(Price::from("100.00")),
799 Some(Price::from("99.00")),
800 None,
801 None,
802 None,
803 None,
804 ),
805 "`trigger_type` is required for `StopLimitOrder`"
806 )]
807 #[case::stop_market_missing_trigger_price(
808 make_init_with_optional_fields(
809 OrderType::StopMarket,
810 None,
811 None,
812 Some(TriggerType::LastPrice),
813 None,
814 None,
815 None,
816 ),
817 "`trigger_price` is required for `StopMarketOrder`"
818 )]
819 #[case::stop_market_missing_trigger_type(
820 make_init_with_optional_fields(
821 OrderType::StopMarket,
822 None,
823 Some(Price::from("100.00")),
824 None,
825 None,
826 None,
827 None,
828 ),
829 "`trigger_type` is required for `StopMarketOrder`"
830 )]
831 #[case::mit_missing_trigger_price(
832 make_init_with_optional_fields(
833 OrderType::MarketIfTouched,
834 None,
835 None,
836 Some(TriggerType::LastPrice),
837 None,
838 None,
839 None,
840 ),
841 "`trigger_price` is required for `MarketIfTouchedOrder`"
842 )]
843 #[case::mit_missing_trigger_type(
844 make_init_with_optional_fields(
845 OrderType::MarketIfTouched,
846 None,
847 Some(Price::from("100.00")),
848 None,
849 None,
850 None,
851 None,
852 ),
853 "`trigger_type` is required for `MarketIfTouchedOrder`"
854 )]
855 #[case::tsl_missing_trigger_type(
856 make_init_with_optional_fields(
857 OrderType::TrailingStopLimit,
858 Some(Price::from("100.00")), Some(Price::from("99.00")), None,
859 Some(dec!(1)), Some(dec!(1)), Some(TrailingOffsetType::Price),
860 ),
861 "`trigger_type` is required for `TrailingStopLimitOrder`",
862 )]
863 #[case::tsl_missing_limit_offset(
864 make_init_with_optional_fields(
865 OrderType::TrailingStopLimit,
866 Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
867 None, Some(dec!(1)), Some(TrailingOffsetType::Price),
868 ),
869 "`limit_offset` is required for `TrailingStopLimitOrder`",
870 )]
871 #[case::tsl_missing_trailing_offset(
872 make_init_with_optional_fields(
873 OrderType::TrailingStopLimit,
874 Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
875 Some(dec!(1)), None, Some(TrailingOffsetType::Price),
876 ),
877 "`trailing_offset` is required for `TrailingStopLimitOrder`",
878 )]
879 #[case::tsl_missing_trailing_offset_type(
880 make_init_with_optional_fields(
881 OrderType::TrailingStopLimit,
882 Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
883 Some(dec!(1)), Some(dec!(1)), None,
884 ),
885 "`trailing_offset_type` is required for `TrailingStopLimitOrder`",
886 )]
887 #[case::tsm_missing_trigger_type(
888 make_init_with_optional_fields(
889 OrderType::TrailingStopMarket,
890 None, Some(Price::from("100.00")), None,
891 None, Some(dec!(1)), Some(TrailingOffsetType::Price),
892 ),
893 "`trigger_type` is required for `TrailingStopMarketOrder`",
894 )]
895 #[case::tsm_missing_trailing_offset(
896 make_init_with_optional_fields(
897 OrderType::TrailingStopMarket,
898 None,
899 Some(Price::from("100.00")),
900 Some(TriggerType::LastPrice),
901 None,
902 None,
903 Some(TrailingOffsetType::Price),
904 ),
905 "`trailing_offset` is required for `TrailingStopMarketOrder`"
906 )]
907 #[case::tsm_missing_trailing_offset_type(
908 make_init_with_optional_fields(
909 OrderType::TrailingStopMarket,
910 None, Some(Price::from("100.00")), Some(TriggerType::LastPrice),
911 None, Some(dec!(1)), None,
912 ),
913 "`trailing_offset_type` is required for `TrailingStopMarketOrder`",
914 )]
915 fn test_order_any_from_events_missing_required_field_returns_error(
916 #[case] init: OrderInitialized,
917 #[case] expected_field_msg: &str,
918 ) {
919 let events = vec![OrderEventAny::Initialized(init)];
922 let err =
923 OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
924
925 assert!(matches!(
926 err,
927 OrderReplayError::InvalidInitialization { .. }
928 ));
929 let msg = err.to_string();
930 assert!(
931 msg.contains("Invalid `OrderInitialized` event") && msg.contains(expected_field_msg),
932 "unexpected error message: {msg}"
933 );
934 }
935
936 #[rstest]
937 fn test_order_any_from_events_wrong_first_event() {
938 let client_order_id = ClientOrderId::from("ORDER-001");
940 let strategy_id = StrategyId::from("STRATEGY-001");
941
942 let update_event = OrderUpdated {
943 client_order_id,
944 strategy_id,
945 quantity: Quantity::from(20),
946 ..Default::default()
947 };
948
949 let events = vec![OrderEventAny::Updated(update_event)];
951
952 let err = OrderAny::from_events(events).expect_err("wrong first event should fail replay");
954 assert!(matches!(err, OrderReplayError::WrongFirstEvent));
955 assert_eq!(err.to_string(), "First event must be `OrderInitialized`");
956 }
957
958 #[rstest]
959 fn test_order_any_from_events_apply_failure() {
960 let init_event = OrderInitializedSpec::builder()
961 .order_type(OrderType::Market)
962 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
963 .quantity(Quantity::from(10))
964 .build();
965
966 let events = vec![
967 OrderEventAny::Initialized(init_event.clone()),
968 OrderEventAny::Initialized(init_event),
969 ];
970 let err =
971 OrderAny::from_events(events).expect_err("later invalid event should fail replay");
972
973 match &err {
974 OrderReplayError::ApplyFailed { source } => {
975 assert!(matches!(source, OrderError::AlreadyInitialized));
976 }
977 _ => panic!("expected ApplyFailed, was {err:?}"),
978 }
979 assert_eq!(err.to_string(), "Order was already initialized");
980 }
981
982 #[rstest]
983 fn test_passive_order_any_conversion() {
984 let limit_order = OrderTestBuilder::new(OrderType::Limit)
986 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
987 .quantity(Quantity::from(10))
988 .price(Price::new(100.0, 2))
989 .build();
990
991 let passive_order = PassiveOrderAny::try_from(limit_order).unwrap();
993 let order_any: OrderAny = passive_order.into();
994
995 assert_eq!(order_any.order_type(), OrderType::Limit);
997 assert_eq!(order_any.quantity(), Quantity::from(10));
998 }
999
1000 #[rstest]
1001 fn test_stop_order_any_conversion() {
1002 let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
1004 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1005 .quantity(Quantity::from(10))
1006 .trigger_price(Price::new(100.0, 2))
1007 .build();
1008
1009 let stop_order_any = StopOrderAny::try_from(stop_order).unwrap();
1011 let order_any: OrderAny = stop_order_any.into();
1012
1013 assert_eq!(order_any.order_type(), OrderType::StopMarket);
1015 assert_eq!(order_any.quantity(), Quantity::from(10));
1016 assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1017 }
1018
1019 #[rstest]
1020 fn test_limit_order_any_conversion() {
1021 let limit_order = OrderTestBuilder::new(OrderType::Limit)
1023 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1024 .quantity(Quantity::from(10))
1025 .price(Price::new(100.0, 2))
1026 .build();
1027
1028 let limit_order_any = LimitOrderAny::try_from(limit_order).unwrap();
1030 let order_any: OrderAny = limit_order_any.into();
1031
1032 assert_eq!(order_any.order_type(), OrderType::Limit);
1034 assert_eq!(order_any.quantity(), Quantity::from(10));
1035 }
1036
1037 #[rstest]
1038 fn test_limit_order_any_limit_price() {
1039 let limit_order = OrderTestBuilder::new(OrderType::Limit)
1041 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1042 .quantity(Quantity::from(10))
1043 .price(Price::new(100.0, 2))
1044 .build();
1045
1046 let limit_order_any = LimitOrderAny::try_from(limit_order).unwrap();
1048
1049 let limit_px = limit_order_any.limit_px();
1051 assert_eq!(limit_px, Price::new(100.0, 2));
1052 }
1053
1054 #[rstest]
1055 fn test_stop_order_any_stop_price() {
1056 let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
1058 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1059 .quantity(Quantity::from(10))
1060 .trigger_price(Price::new(100.0, 2))
1061 .build();
1062
1063 let stop_order_any = StopOrderAny::try_from(stop_order).unwrap();
1065
1066 let stop_px = stop_order_any.stop_px();
1068 assert_eq!(stop_px, Some(Price::new(100.0, 2)));
1069 }
1070
1071 #[rstest]
1072 fn test_trailing_stop_market_order_conversion() {
1073 let trailing_stop_order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
1075 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1076 .quantity(Quantity::from(10))
1077 .trigger_price(Price::new(100.0, 2))
1078 .trailing_offset(Decimal::new(5, 1)) .trailing_offset_type(TrailingOffsetType::Price)
1080 .build();
1081
1082 let stop_order_any = StopOrderAny::try_from(trailing_stop_order).unwrap();
1084
1085 let order_any: OrderAny = stop_order_any.into();
1087
1088 assert_eq!(order_any.order_type(), OrderType::TrailingStopMarket);
1090 assert_eq!(order_any.quantity(), Quantity::from(10));
1091 assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1092 assert_eq!(order_any.trailing_offset(), Some(dec!(0.5)));
1093 assert_eq!(
1094 order_any.trailing_offset_type(),
1095 Some(TrailingOffsetType::Price)
1096 );
1097 }
1098
1099 #[rstest]
1100 fn test_trailing_stop_limit_order_conversion() {
1101 let trailing_stop_limit = OrderTestBuilder::new(OrderType::TrailingStopLimit)
1103 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1104 .quantity(Quantity::from(10))
1105 .price(Price::new(99.0, 2))
1106 .trigger_price(Price::new(100.0, 2))
1107 .limit_offset(Decimal::new(10, 1)) .trailing_offset(Decimal::new(5, 1)) .trailing_offset_type(TrailingOffsetType::Price)
1110 .build();
1111
1112 let limit_order_any = LimitOrderAny::try_from(trailing_stop_limit).unwrap();
1114
1115 assert_eq!(limit_order_any.limit_px(), Price::new(99.0, 2));
1117
1118 let order_any: OrderAny = limit_order_any.into();
1120
1121 assert_eq!(order_any.order_type(), OrderType::TrailingStopLimit);
1123 assert_eq!(order_any.quantity(), Quantity::from(10));
1124 assert_eq!(order_any.price(), Some(Price::new(99.0, 2)));
1125 assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1126 assert_eq!(order_any.trailing_offset(), Some(dec!(0.5)));
1127 }
1128
1129 #[rstest]
1130 fn test_passive_order_any_to_any() {
1131 let limit_order = OrderTestBuilder::new(OrderType::Limit)
1133 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1134 .quantity(Quantity::from(10))
1135 .price(Price::new(100.0, 2))
1136 .build();
1137
1138 let passive_order = PassiveOrderAny::try_from(limit_order).unwrap();
1140
1141 let order_any = passive_order.to_any();
1143
1144 assert_eq!(order_any.order_type(), OrderType::Limit);
1146 assert_eq!(order_any.quantity(), Quantity::from(10));
1147 assert_eq!(order_any.price(), Some(Price::new(100.0, 2)));
1148 }
1149}