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