1use nautilus_core::{Params, UUID4, UnixNanos};
19use nautilus_model::{
20 enums::{AccountType, LiquiditySide},
21 events::{
22 AccountState, OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled,
23 OrderDenied, OrderEventAny, OrderExpired, OrderFilled, OrderModifyDenied,
24 OrderModifyRejected, OrderRejected, OrderSubmitted, OrderTriggered, OrderUpdated,
25 },
26 identifiers::{AccountId, PositionId, TradeId, TraderId, VenueOrderId},
27 orders::{Order, OrderAny},
28 types::{AccountBalance, Currency, MarginBalance, Money, Price, Quantity},
29};
30
31#[derive(Debug, Clone)]
37pub struct OrderEventFactory {
38 trader_id: TraderId,
39 account_id: AccountId,
40 account_type: AccountType,
41 base_currency: Option<Currency>,
42}
43
44impl OrderEventFactory {
45 #[must_use]
47 pub fn new(
48 trader_id: TraderId,
49 account_id: AccountId,
50 account_type: AccountType,
51 base_currency: Option<Currency>,
52 ) -> Self {
53 Self {
54 trader_id,
55 account_id,
56 account_type,
57 base_currency,
58 }
59 }
60
61 #[must_use]
63 pub fn trader_id(&self) -> TraderId {
64 self.trader_id
65 }
66
67 #[must_use]
69 pub fn account_id(&self) -> AccountId {
70 self.account_id
71 }
72
73 pub const fn set_account_id(&mut self, account_id: AccountId) {
75 self.account_id = account_id;
76 }
77
78 #[must_use]
80 pub fn generate_account_state(
81 &self,
82 balances: Vec<AccountBalance>,
83 margins: Vec<MarginBalance>,
84 reported: bool,
85 ts_event: UnixNanos,
86 ts_init: UnixNanos,
87 info: Option<Params>,
88 ) -> AccountState {
89 AccountState::new(
90 self.account_id,
91 self.account_type,
92 balances,
93 margins,
94 reported,
95 UUID4::new(),
96 ts_event,
97 ts_init,
98 self.base_currency,
99 )
100 .with_info(info)
101 }
102
103 #[must_use]
107 pub fn generate_order_denied(
108 &self,
109 order: &OrderAny,
110 reason: &str,
111 ts_init: UnixNanos,
112 ) -> OrderEventAny {
113 let event = OrderDenied::new(
114 self.trader_id,
115 order.strategy_id(),
116 order.instrument_id(),
117 order.client_order_id(),
118 reason.into(),
119 UUID4::new(),
120 ts_init,
121 ts_init,
122 );
123 OrderEventAny::Denied(event)
124 }
125
126 #[must_use]
130 pub fn generate_order_submitted(&self, order: &OrderAny, ts_init: UnixNanos) -> OrderEventAny {
131 let event = OrderSubmitted::new(
132 self.trader_id,
133 order.strategy_id(),
134 order.instrument_id(),
135 order.client_order_id(),
136 self.account_id,
137 UUID4::new(),
138 ts_init,
139 ts_init,
140 );
141 OrderEventAny::Submitted(event)
142 }
143
144 #[must_use]
146 pub fn generate_order_rejected(
147 &self,
148 order: &OrderAny,
149 reason: &str,
150 ts_event: UnixNanos,
151 ts_init: UnixNanos,
152 due_post_only: bool,
153 ) -> OrderEventAny {
154 let event = OrderRejected::new(
155 self.trader_id,
156 order.strategy_id(),
157 order.instrument_id(),
158 order.client_order_id(),
159 self.account_id,
160 reason.into(),
161 UUID4::new(),
162 ts_event,
163 ts_init,
164 false,
165 due_post_only,
166 );
167 OrderEventAny::Rejected(event)
168 }
169
170 #[must_use]
172 pub fn generate_order_accepted(
173 &self,
174 order: &OrderAny,
175 venue_order_id: VenueOrderId,
176 ts_event: UnixNanos,
177 ts_init: UnixNanos,
178 ) -> OrderEventAny {
179 let event = OrderAccepted::new(
180 self.trader_id,
181 order.strategy_id(),
182 order.instrument_id(),
183 order.client_order_id(),
184 venue_order_id,
185 self.account_id,
186 UUID4::new(),
187 ts_event,
188 ts_init,
189 false,
190 );
191 OrderEventAny::Accepted(event)
192 }
193
194 #[must_use]
196 pub fn generate_order_modify_denied(
197 &self,
198 order: &OrderAny,
199 reason: &str,
200 causation_id: Option<UUID4>,
201 ts_event: UnixNanos,
202 ts_init: UnixNanos,
203 ) -> OrderEventAny {
204 let mut event = OrderModifyDenied::new(
205 self.trader_id,
206 order.strategy_id(),
207 order.instrument_id(),
208 order.client_order_id(),
209 reason.into(),
210 UUID4::new(),
211 ts_event,
212 ts_init,
213 order.venue_order_id(),
214 Some(self.account_id),
215 );
216 event.causation_id = causation_id;
217 OrderEventAny::ModifyDenied(event)
218 }
219
220 #[must_use]
222 pub fn generate_order_modify_rejected(
223 &self,
224 order: &OrderAny,
225 venue_order_id: Option<VenueOrderId>,
226 reason: &str,
227 ts_event: UnixNanos,
228 ts_init: UnixNanos,
229 causation_id: Option<UUID4>,
230 ) -> OrderEventAny {
231 let mut event = OrderModifyRejected::new(
232 self.trader_id,
233 order.strategy_id(),
234 order.instrument_id(),
235 order.client_order_id(),
236 reason.into(),
237 UUID4::new(),
238 ts_event,
239 ts_init,
240 false,
241 venue_order_id,
242 Some(self.account_id),
243 );
244 event.causation_id = causation_id;
245 OrderEventAny::ModifyRejected(event)
246 }
247
248 #[must_use]
250 pub fn generate_order_cancel_denied(
251 &self,
252 order: &OrderAny,
253 reason: &str,
254 causation_id: Option<UUID4>,
255 ts_event: UnixNanos,
256 ts_init: UnixNanos,
257 ) -> OrderEventAny {
258 let mut event = OrderCancelDenied::new(
259 self.trader_id,
260 order.strategy_id(),
261 order.instrument_id(),
262 order.client_order_id(),
263 reason.into(),
264 UUID4::new(),
265 ts_event,
266 ts_init,
267 order.venue_order_id(),
268 Some(self.account_id),
269 );
270 event.causation_id = causation_id;
271 OrderEventAny::CancelDenied(event)
272 }
273
274 #[must_use]
276 pub fn generate_order_cancel_rejected(
277 &self,
278 order: &OrderAny,
279 venue_order_id: Option<VenueOrderId>,
280 reason: &str,
281 ts_event: UnixNanos,
282 ts_init: UnixNanos,
283 causation_id: Option<UUID4>,
284 ) -> OrderEventAny {
285 let mut event = OrderCancelRejected::new(
286 self.trader_id,
287 order.strategy_id(),
288 order.instrument_id(),
289 order.client_order_id(),
290 reason.into(),
291 UUID4::new(),
292 ts_event,
293 ts_init,
294 false,
295 venue_order_id,
296 Some(self.account_id),
297 );
298 event.causation_id = causation_id;
299 OrderEventAny::CancelRejected(event)
300 }
301
302 #[expect(clippy::too_many_arguments)]
304 #[must_use]
305 pub fn generate_order_updated(
306 &self,
307 order: &OrderAny,
308 venue_order_id: VenueOrderId,
309 quantity: Quantity,
310 price: Option<Price>,
311 trigger_price: Option<Price>,
312 protection_price: Option<Price>,
313 ts_event: UnixNanos,
314 ts_init: UnixNanos,
315 ) -> OrderEventAny {
316 let event = OrderUpdated::new(
317 self.trader_id,
318 order.strategy_id(),
319 order.instrument_id(),
320 order.client_order_id(),
321 quantity,
322 UUID4::new(),
323 ts_event,
324 ts_init,
325 false,
326 Some(venue_order_id),
327 Some(self.account_id),
328 price,
329 trigger_price,
330 protection_price,
331 false, );
333 OrderEventAny::Updated(event)
334 }
335
336 #[must_use]
338 pub fn generate_order_canceled(
339 &self,
340 order: &OrderAny,
341 venue_order_id: Option<VenueOrderId>,
342 ts_event: UnixNanos,
343 ts_init: UnixNanos,
344 ) -> OrderEventAny {
345 let event = OrderCanceled::new(
346 self.trader_id,
347 order.strategy_id(),
348 order.instrument_id(),
349 order.client_order_id(),
350 UUID4::new(),
351 ts_event,
352 ts_init,
353 false,
354 venue_order_id,
355 Some(self.account_id),
356 None,
357 );
358 OrderEventAny::Canceled(event)
359 }
360
361 #[must_use]
363 pub fn generate_order_triggered(
364 &self,
365 order: &OrderAny,
366 venue_order_id: Option<VenueOrderId>,
367 ts_event: UnixNanos,
368 ts_init: UnixNanos,
369 ) -> OrderEventAny {
370 let event = OrderTriggered::new(
371 self.trader_id,
372 order.strategy_id(),
373 order.instrument_id(),
374 order.client_order_id(),
375 UUID4::new(),
376 ts_event,
377 ts_init,
378 false,
379 venue_order_id,
380 Some(self.account_id),
381 );
382 OrderEventAny::Triggered(event)
383 }
384
385 #[must_use]
387 pub fn generate_order_expired(
388 &self,
389 order: &OrderAny,
390 venue_order_id: Option<VenueOrderId>,
391 ts_event: UnixNanos,
392 ts_init: UnixNanos,
393 ) -> OrderEventAny {
394 let event = OrderExpired::new(
395 self.trader_id,
396 order.strategy_id(),
397 order.instrument_id(),
398 order.client_order_id(),
399 UUID4::new(),
400 ts_event,
401 ts_init,
402 false,
403 venue_order_id,
404 Some(self.account_id),
405 );
406 OrderEventAny::Expired(event)
407 }
408
409 #[expect(clippy::too_many_arguments)]
411 #[must_use]
412 pub fn generate_order_filled(
413 &self,
414 order: &OrderAny,
415 venue_order_id: VenueOrderId,
416 venue_position_id: Option<PositionId>,
417 trade_id: TradeId,
418 last_qty: Quantity,
419 last_px: Price,
420 quote_currency: Currency,
421 commission: Option<Money>,
422 liquidity_side: LiquiditySide,
423 ts_event: UnixNanos,
424 ts_init: UnixNanos,
425 ) -> OrderEventAny {
426 let event = OrderFilled::new(
427 self.trader_id,
428 order.strategy_id(),
429 order.instrument_id(),
430 order.client_order_id(),
431 venue_order_id,
432 self.account_id,
433 trade_id,
434 order.order_side(),
435 order.order_type(),
436 last_qty,
437 last_px,
438 quote_currency,
439 liquidity_side,
440 UUID4::new(),
441 ts_event,
442 ts_init,
443 false,
444 venue_position_id,
445 commission,
446 None,
447 );
448 OrderEventAny::Filled(event)
449 }
450}
451
452#[cfg(test)]
453mod tests {
454 use nautilus_model::{
455 enums::{OrderSide, OrderType},
456 identifiers::{ClientOrderId, InstrumentId},
457 orders::OrderTestBuilder,
458 types::Quantity,
459 };
460 use rstest::{fixture, rstest};
461
462 use super::*;
463
464 const TRADER_ID: &str = "TESTER-001";
465 const ACCOUNT_ID: &str = "SIM-002";
466
467 #[fixture]
468 fn factory() -> OrderEventFactory {
469 OrderEventFactory::new(
470 TraderId::from(TRADER_ID),
471 AccountId::from(ACCOUNT_ID),
472 AccountType::Margin,
473 Some(Currency::USD()),
474 )
475 }
476
477 #[fixture]
478 fn order() -> OrderAny {
479 OrderTestBuilder::new(OrderType::Limit)
480 .instrument_id(InstrumentId::from("ETHUSDT.BINANCE"))
481 .client_order_id(ClientOrderId::from("O-19700101-000000-001-001-1"))
482 .side(OrderSide::Sell)
483 .quantity(Quantity::from("3.000"))
484 .price(Price::from("2500.00"))
485 .build()
486 }
487
488 #[rstest]
489 fn test_identity_accessors_and_account_id_override(mut factory: OrderEventFactory) {
490 assert_eq!(factory.trader_id(), TraderId::from(TRADER_ID));
491 assert_eq!(factory.account_id(), AccountId::from(ACCOUNT_ID));
492
493 factory.set_account_id(AccountId::from("SIM-999"));
494
495 assert_eq!(factory.account_id(), AccountId::from("SIM-999"));
496 assert_eq!(factory.trader_id(), TraderId::from(TRADER_ID));
497 }
498
499 #[rstest]
500 fn test_generate_account_state_carries_factory_identity(factory: OrderEventFactory) {
501 let balance = AccountBalance::new(
502 Money::new(1_500.0, Currency::USD()),
503 Money::new(500.0, Currency::USD()),
504 Money::new(1_000.0, Currency::USD()),
505 );
506
507 let margin = MarginBalance::new(
508 Money::new(10.0, Currency::USD()),
509 Money::new(20.0, Currency::USD()),
510 Some(InstrumentId::from("ETHUSDT.BINANCE")),
511 );
512
513 let event = factory.generate_account_state(
514 vec![balance],
515 vec![margin],
516 true,
517 UnixNanos::from(3),
518 UnixNanos::from(5),
519 None,
520 );
521
522 assert_eq!(event.account_id, AccountId::from(ACCOUNT_ID));
523 assert_eq!(event.account_type, AccountType::Margin);
524 assert_eq!(event.base_currency, Some(Currency::USD()));
525 assert_eq!(event.balances, vec![balance]);
526 assert_eq!(event.margins, vec![margin]);
527 assert!(event.is_reported);
528 assert_eq!(event.ts_event, UnixNanos::from(3));
529 assert_eq!(event.ts_init, UnixNanos::from(5));
530 assert_eq!(event.info, None);
531 }
532
533 #[rstest]
534 fn test_generate_account_state_attaches_info(factory: OrderEventFactory) {
535 let info = Params::new([("source".into(), "unit-test".into())].into());
536
537 let event = factory.generate_account_state(
538 Vec::new(),
539 Vec::new(),
540 false,
541 UnixNanos::from(3),
542 UnixNanos::from(5),
543 Some(info.clone()),
544 );
545
546 assert!(!event.is_reported);
547 assert_eq!(event.info, Some(info));
548 }
549
550 #[rstest]
551 fn test_generate_order_denied_uses_ts_init_for_both_timestamps(
552 factory: OrderEventFactory,
553 order: OrderAny,
554 ) {
555 let OrderEventAny::Denied(event) =
556 factory.generate_order_denied(&order, "Risk limit exceeded", UnixNanos::from(11))
557 else {
558 panic!("expected a denied event");
559 };
560
561 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
562 assert_eq!(event.strategy_id, order.strategy_id());
563 assert_eq!(event.instrument_id, order.instrument_id());
564 assert_eq!(event.client_order_id, order.client_order_id());
565 assert_eq!(event.reason.as_str(), "Risk limit exceeded");
566 assert_eq!(event.ts_event, UnixNanos::from(11));
567 assert_eq!(event.ts_init, UnixNanos::from(11));
568 }
569
570 #[rstest]
571 fn test_generate_order_submitted_uses_ts_init_for_both_timestamps(
572 factory: OrderEventFactory,
573 order: OrderAny,
574 ) {
575 let OrderEventAny::Submitted(event) =
576 factory.generate_order_submitted(&order, UnixNanos::from(13))
577 else {
578 panic!("expected a submitted event");
579 };
580
581 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
582 assert_eq!(event.strategy_id, order.strategy_id());
583 assert_eq!(event.instrument_id, order.instrument_id());
584 assert_eq!(event.client_order_id, order.client_order_id());
585 assert_eq!(event.account_id, AccountId::from(ACCOUNT_ID));
586 assert_eq!(event.ts_event, UnixNanos::from(13));
587 assert_eq!(event.ts_init, UnixNanos::from(13));
588 }
589
590 #[rstest]
591 #[case(true)]
592 #[case(false)]
593 fn test_generate_order_rejected_carries_reason_and_post_only_flag(
594 factory: OrderEventFactory,
595 order: OrderAny,
596 #[case] due_post_only: bool,
597 ) {
598 let OrderEventAny::Rejected(event) = factory.generate_order_rejected(
599 &order,
600 "Insufficient margin",
601 UnixNanos::from(17),
602 UnixNanos::from(19),
603 due_post_only,
604 ) else {
605 panic!("expected a rejected event");
606 };
607
608 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
609 assert_eq!(event.strategy_id, order.strategy_id());
610 assert_eq!(event.instrument_id, order.instrument_id());
611 assert_eq!(event.client_order_id, order.client_order_id());
612 assert_eq!(event.account_id, AccountId::from(ACCOUNT_ID));
613 assert_eq!(event.reason.as_str(), "Insufficient margin");
614 assert_eq!(event.ts_event, UnixNanos::from(17));
615 assert_eq!(event.ts_init, UnixNanos::from(19));
616 assert!(!event.reconciliation);
617 assert_eq!(event.due_post_only, due_post_only);
618 }
619
620 #[rstest]
621 fn test_generate_order_accepted_carries_venue_order_id(
622 factory: OrderEventFactory,
623 order: OrderAny,
624 ) {
625 let OrderEventAny::Accepted(event) = factory.generate_order_accepted(
626 &order,
627 VenueOrderId::from("V-1"),
628 UnixNanos::from(23),
629 UnixNanos::from(29),
630 ) else {
631 panic!("expected an accepted event");
632 };
633
634 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
635 assert_eq!(event.client_order_id, order.client_order_id());
636 assert_eq!(event.venue_order_id, VenueOrderId::from("V-1"));
637 assert_eq!(event.account_id, AccountId::from(ACCOUNT_ID));
638 assert_eq!(event.ts_event, UnixNanos::from(23));
639 assert_eq!(event.ts_init, UnixNanos::from(29));
640 assert!(!event.reconciliation);
641 }
642
643 #[rstest]
644 #[case(false)]
645 #[case(true)]
646 fn test_generate_order_modify_rejected_carries_optional_venue_order_id(
647 factory: OrderEventFactory,
648 order: OrderAny,
649 #[case] with_cause: bool,
650 ) {
651 let cause = with_cause.then(UUID4::new);
652
653 let OrderEventAny::ModifyRejected(event) = factory.generate_order_modify_rejected(
654 &order,
655 Some(VenueOrderId::from("V-2")),
656 "Unknown order",
657 UnixNanos::from(31),
658 UnixNanos::from(37),
659 cause,
660 ) else {
661 panic!("expected a modify rejected event");
662 };
663
664 assert_eq!(event.causation_id, cause);
665 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
666 assert_eq!(event.client_order_id, order.client_order_id());
667 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("V-2")));
668 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
669 assert_eq!(event.reason.as_str(), "Unknown order");
670 assert_eq!(event.ts_event, UnixNanos::from(31));
671 assert_eq!(event.ts_init, UnixNanos::from(37));
672 }
673
674 #[rstest]
675 #[case(false)]
676 #[case(true)]
677 fn test_generate_order_cancel_rejected_allows_absent_venue_order_id(
678 factory: OrderEventFactory,
679 order: OrderAny,
680 #[case] with_cause: bool,
681 ) {
682 let cause = with_cause.then(UUID4::new);
683
684 let OrderEventAny::CancelRejected(event) = factory.generate_order_cancel_rejected(
685 &order,
686 None,
687 "Already closed",
688 UnixNanos::from(41),
689 UnixNanos::from(43),
690 cause,
691 ) else {
692 panic!("expected a cancel rejected event");
693 };
694
695 assert_eq!(event.causation_id, cause);
696 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
697 assert_eq!(event.client_order_id, order.client_order_id());
698 assert_eq!(event.venue_order_id, None);
699 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
700 assert_eq!(event.reason.as_str(), "Already closed");
701 assert_eq!(event.ts_event, UnixNanos::from(41));
702 assert_eq!(event.ts_init, UnixNanos::from(43));
703 }
704
705 #[rstest]
706 #[case::modify(false)]
707 #[case::cancel(true)]
708 fn test_generate_order_command_denied_preserves_identity(
709 factory: OrderEventFactory,
710 order: OrderAny,
711 #[case] cancel: bool,
712 ) {
713 let cause = UUID4::new();
714
715 let event = if cancel {
716 factory.generate_order_cancel_denied(
717 &order,
718 "Unsent command",
719 Some(cause),
720 UnixNanos::from(47),
721 UnixNanos::from(53),
722 )
723 } else {
724 factory.generate_order_modify_denied(
725 &order,
726 "Unsent command",
727 Some(cause),
728 UnixNanos::from(47),
729 UnixNanos::from(53),
730 )
731 };
732
733 let (actual_cause, reason, ts_init) = match &event {
734 OrderEventAny::CancelDenied(event) if cancel => {
735 (event.causation_id, event.reason.as_str(), event.ts_init)
736 }
737 OrderEventAny::ModifyDenied(event) if !cancel => {
738 (event.causation_id, event.reason.as_str(), event.ts_init)
739 }
740 _ => panic!("unexpected command outcome {event:?}"),
741 };
742
743 assert_eq!(actual_cause, Some(cause));
744 assert_eq!(reason, "Unsent command");
745 assert_eq!(event.trader_id(), TraderId::from(TRADER_ID));
746 assert_eq!(event.strategy_id(), order.strategy_id());
747 assert_eq!(event.instrument_id(), order.instrument_id());
748 assert_eq!(event.client_order_id(), order.client_order_id());
749 assert_eq!(event.venue_order_id(), order.venue_order_id());
750 assert_eq!(event.account_id(), Some(AccountId::from(ACCOUNT_ID)));
751 assert_eq!(event.ts_event(), UnixNanos::from(47));
752 assert_eq!(ts_init, UnixNanos::from(53));
753 }
754
755 #[rstest]
756 fn test_generate_order_updated_carries_every_revised_field(
757 factory: OrderEventFactory,
758 order: OrderAny,
759 ) {
760 let OrderEventAny::Updated(event) = factory.generate_order_updated(
761 &order,
762 VenueOrderId::from("V-3"),
763 Quantity::from("2.000"),
764 Some(Price::from("2400.00")),
765 Some(Price::from("2450.00")),
766 Some(Price::from("2350.00")),
767 UnixNanos::from(47),
768 UnixNanos::from(53),
769 ) else {
770 panic!("expected an updated event");
771 };
772
773 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
774 assert_eq!(event.client_order_id, order.client_order_id());
775 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("V-3")));
776 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
777 assert_eq!(event.quantity, Quantity::from("2.000"));
778 assert_eq!(event.price, Some(Price::from("2400.00")));
779 assert_eq!(event.trigger_price, Some(Price::from("2450.00")));
780 assert_eq!(event.protection_price, Some(Price::from("2350.00")));
781 assert!(!event.is_quote_quantity);
782 assert_eq!(event.ts_event, UnixNanos::from(47));
783 assert_eq!(event.ts_init, UnixNanos::from(53));
784 }
785
786 #[rstest]
787 fn test_generate_order_canceled_carries_identity(factory: OrderEventFactory, order: OrderAny) {
788 let OrderEventAny::Canceled(event) = factory.generate_order_canceled(
789 &order,
790 Some(VenueOrderId::from("V-4")),
791 UnixNanos::from(59),
792 UnixNanos::from(61),
793 ) else {
794 panic!("expected a canceled event");
795 };
796
797 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
798 assert_eq!(event.client_order_id, order.client_order_id());
799 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("V-4")));
800 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
801 assert_eq!(event.ts_event, UnixNanos::from(59));
802 assert_eq!(event.ts_init, UnixNanos::from(61));
803 }
804
805 #[rstest]
806 fn test_generate_order_triggered_carries_identity(factory: OrderEventFactory, order: OrderAny) {
807 let OrderEventAny::Triggered(event) = factory.generate_order_triggered(
808 &order,
809 Some(VenueOrderId::from("V-5")),
810 UnixNanos::from(67),
811 UnixNanos::from(71),
812 ) else {
813 panic!("expected a triggered event");
814 };
815
816 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
817 assert_eq!(event.client_order_id, order.client_order_id());
818 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("V-5")));
819 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
820 assert_eq!(event.ts_event, UnixNanos::from(67));
821 assert_eq!(event.ts_init, UnixNanos::from(71));
822 }
823
824 #[rstest]
825 fn test_generate_order_expired_carries_identity(factory: OrderEventFactory, order: OrderAny) {
826 let OrderEventAny::Expired(event) = factory.generate_order_expired(
827 &order,
828 Some(VenueOrderId::from("V-6")),
829 UnixNanos::from(73),
830 UnixNanos::from(79),
831 ) else {
832 panic!("expected an expired event");
833 };
834
835 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
836 assert_eq!(event.client_order_id, order.client_order_id());
837 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("V-6")));
838 assert_eq!(event.account_id, Some(AccountId::from(ACCOUNT_ID)));
839 assert_eq!(event.ts_event, UnixNanos::from(73));
840 assert_eq!(event.ts_init, UnixNanos::from(79));
841 }
842
843 #[rstest]
844 fn test_generate_order_filled_takes_side_and_type_from_the_order(
845 factory: OrderEventFactory,
846 order: OrderAny,
847 ) {
848 let commission = Money::new(1.25, Currency::USD());
849
850 let OrderEventAny::Filled(event) = factory.generate_order_filled(
851 &order,
852 VenueOrderId::from("V-7"),
853 Some(PositionId::from("P-1")),
854 TradeId::from("T-1"),
855 Quantity::from("1.500"),
856 Price::from("2499.50"),
857 Currency::USDT(),
858 Some(commission),
859 LiquiditySide::Maker,
860 UnixNanos::from(83),
861 UnixNanos::from(89),
862 ) else {
863 panic!("expected a filled event");
864 };
865
866 assert_eq!(event.trader_id, TraderId::from(TRADER_ID));
867 assert_eq!(event.strategy_id, order.strategy_id());
868 assert_eq!(event.instrument_id, order.instrument_id());
869 assert_eq!(event.client_order_id, order.client_order_id());
870 assert_eq!(event.venue_order_id, VenueOrderId::from("V-7"));
871 assert_eq!(event.account_id, AccountId::from(ACCOUNT_ID));
872 assert_eq!(event.trade_id, TradeId::from("T-1"));
873 assert_eq!(event.position_id, Some(PositionId::from("P-1")));
874 assert_eq!(event.order_side, OrderSide::Sell);
875 assert_eq!(event.order_type, OrderType::Limit);
876 assert_eq!(event.last_qty, Quantity::from("1.500"));
877 assert_eq!(event.last_px, Price::from("2499.50"));
878 assert_eq!(event.currency, Currency::USDT());
879 assert_eq!(event.liquidity_side, LiquiditySide::Maker);
880 assert_eq!(event.commission, Some(commission));
881 assert_eq!(event.ts_event, UnixNanos::from(83));
882 assert_eq!(event.ts_init, UnixNanos::from(89));
883 }
884
885 #[rstest]
886 fn test_generate_order_filled_allows_absent_position_and_commission(
887 factory: OrderEventFactory,
888 order: OrderAny,
889 ) {
890 let OrderEventAny::Filled(event) = factory.generate_order_filled(
891 &order,
892 VenueOrderId::from("V-8"),
893 None,
894 TradeId::from("T-2"),
895 Quantity::from("3.000"),
896 Price::from("2501.00"),
897 Currency::USDT(),
898 None,
899 LiquiditySide::Taker,
900 UnixNanos::from(97),
901 UnixNanos::from(101),
902 ) else {
903 panic!("expected a filled event");
904 };
905
906 assert_eq!(event.position_id, None);
907 assert_eq!(event.commission, None);
908 assert_eq!(event.liquidity_side, LiquiditySide::Taker);
909 }
910
911 #[rstest]
912 fn test_generated_events_carry_distinct_event_ids(factory: OrderEventFactory, order: OrderAny) {
913 let (OrderEventAny::Submitted(first), OrderEventAny::Submitted(second)) = (
914 factory.generate_order_submitted(&order, UnixNanos::from(1)),
915 factory.generate_order_submitted(&order, UnixNanos::from(1)),
916 ) else {
917 panic!("expected submitted events");
918 };
919
920 assert_ne!(first.event_id, second.event_id);
921 }
922
923 #[rstest]
924 fn test_factory_clone_preserves_identity(factory: OrderEventFactory) {
925 let mut clone = factory.clone();
926 clone.set_account_id(AccountId::from("SIM-003"));
927
928 assert_eq!(factory.account_id(), AccountId::from(ACCOUNT_ID));
929 assert_eq!(clone.account_id(), AccountId::from("SIM-003"));
930 assert_eq!(clone.trader_id(), factory.trader_id());
931 }
932}