Skip to main content

nautilus_common/factories/
event.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Factory for generating order and account events.
17
18use 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/// Factory for generating order and account events.
32///
33/// This struct holds the identity information needed to construct events and provides
34/// methods to generate all order event types. It is `Clone` and `Send`, allowing it
35/// to be used in async contexts.
36#[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    /// Creates a new [`OrderEventFactory`] instance.
46    #[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    /// Returns the trader ID.
62    #[must_use]
63    pub fn trader_id(&self) -> TraderId {
64        self.trader_id
65    }
66
67    /// Returns the account ID.
68    #[must_use]
69    pub fn account_id(&self) -> AccountId {
70        self.account_id
71    }
72
73    /// Sets the account ID.
74    pub const fn set_account_id(&mut self, account_id: AccountId) {
75        self.account_id = account_id;
76    }
77
78    /// Generates an account state event.
79    #[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    /// Generates an order denied event.
104    ///
105    /// The event timestamp `ts_event` is the same as the initialized timestamp `ts_init`.
106    #[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    /// Generates an order submitted event.
127    ///
128    /// The event timestamp `ts_event` is the same as the initialized timestamp `ts_init`.
129    #[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    /// Generates an order rejected event.
145    #[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    /// Generates an order accepted event.
171    #[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    /// Generates an order modify denied event for a command proven not sent.
195    #[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    /// Generates an order modify rejected event.
221    #[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    /// Generates an order cancel denied event for a command proven not sent.
249    #[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    /// Generates an order cancel rejected event.
275    #[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    /// Generates an order updated event.
303    #[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, // is_quote_quantity
332        );
333        OrderEventAny::Updated(event)
334    }
335
336    /// Generates an order canceled event.
337    #[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    /// Generates an order triggered event.
362    #[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    /// Generates an order expired event.
386    #[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    /// Generates an order filled event.
410    #[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}