Skip to main content

nautilus_system/
trader.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//! Central orchestrator for managing actors, strategies, and execution algorithms.
17//!
18//! The `Trader` component serves as the primary coordination layer between the kernel
19//! and individual trading components. It manages component lifecycles, provides
20//! unique identification, and coordinates with system engines.
21
22use std::{
23    cell::{OnceCell, RefCell},
24    fmt::Debug,
25    rc::Rc,
26};
27
28use ahash::AHashMap;
29use indexmap::IndexMap;
30#[cfg(feature = "python")]
31use nautilus_common::python::wrappers::release_python_wrapper;
32use nautilus_common::{
33    actor::{
34        DataActor, DataActorNative,
35        registry::{deregister_actor, try_get_actor_unchecked},
36    },
37    cache::Cache,
38    clock::Clock,
39    component::{
40        Component, component_state, deregister_component, dispose_component,
41        register_component_actor, release_component_subscriptions, reset_component,
42        start_component, stop_component,
43    },
44    enums::{ComponentState, ComponentTrigger, Environment},
45    logging::RECV,
46    messages::execution::TradingCommand,
47    msgbus,
48    msgbus::{
49        ShareableMessageHandler, TypedHandler, get_message_bus,
50        switchboard::{get_event_order_topic, get_event_position_topic},
51    },
52    timer::{TimeEvent, TimeEventCallback},
53};
54use nautilus_core::{UUID4, UnixNanos};
55use nautilus_model::{
56    events::{OrderEventAny, PositionEvent},
57    identifiers::{
58        ActorId, ComponentId, ExecAlgorithmId, StrategyId, TraderId, check_order_id_tag,
59        normalize_order_id_tag,
60    },
61    orders::Order,
62};
63use nautilus_portfolio::portfolio::Portfolio;
64use nautilus_trading::{
65    ExecutionAlgorithm, ExecutionAlgorithmNative,
66    strategy::{Strategy, StrategyNative, route_time_event},
67};
68use ustr::Ustr;
69
70use crate::{
71    clock_factory::ClockFactory,
72    registration::{
73        base_strategy_id, ensure_unique_order_id_tag, next_order_id_tag, strategy_control_endpoint,
74        strategy_registration_id,
75    },
76};
77
78#[derive(Debug, Clone, Copy, PartialEq, Eq)]
79pub(crate) enum StrategyCommand {
80    ExitMarket,
81}
82
83type ExecutionAlgorithmSubscriptionFn = Box<dyn FnMut() -> anyhow::Result<()>>;
84type PersistedComponentState = IndexMap<String, Vec<u8>>;
85type ComponentStateLoadFn = fn(Ustr, PersistedComponentState) -> anyhow::Result<()>;
86type ComponentStateSaveFn = fn(Ustr) -> anyhow::Result<PersistedComponentState>;
87
88#[derive(Clone, Copy)]
89struct ComponentStateCallbacks {
90    load: ComponentStateLoadFn,
91    save: ComponentStateSaveFn,
92}
93
94/// Central orchestrator for managing trading components.
95///
96/// The `Trader` manages the lifecycle and coordination of actors, strategies,
97/// and execution algorithms within the trading system. It provides component
98/// registration, state management, and integration with system engines.
99///
100/// # Notes
101///
102/// Strategies implement `Strategy::stop() -> bool` which returns whether to proceed
103/// with the component stop. This enables `manage_stop` behavior where the strategy
104/// can defer stopping until a market exit completes.
105///
106/// We store type-erased closures because the component registry stores trait objects
107/// and we need to call `Strategy::stop()` which requires the concrete type. The
108/// closure is created during `add_strategy` when the concrete type `T` is known.
109pub struct Trader {
110    /// The unique trader identifier.
111    pub trader_id: TraderId,
112    /// The unique instance identifier.
113    pub instance_id: UUID4,
114    /// The trading environment context.
115    pub environment: Environment,
116    /// Component state for lifecycle management.
117    state: ComponentState,
118    /// Clock source for trader timestamps and component clocks.
119    clock_factory: ClockFactory,
120    /// System cache for data storage.
121    pub(crate) cache: Rc<RefCell<Cache>>,
122    /// Portfolio reference for strategy registration.
123    pub(crate) portfolio: Rc<RefCell<Portfolio>>,
124    /// Registered actor IDs (actors stored in global registry).
125    pub(crate) actor_ids: Vec<ActorId>,
126    /// Type-erased state callbacks for registered actors.
127    actor_state_callbacks: AHashMap<ActorId, ComponentStateCallbacks>,
128    /// Registered strategy IDs (strategies stored in global registry).
129    pub(crate) strategy_ids: Vec<StrategyId>,
130    /// Type-erased state callbacks for registered strategies.
131    strategy_state_callbacks: AHashMap<StrategyId, ComponentStateCallbacks>,
132    /// Strategy stop functions for managed stop behavior.
133    strategy_stop_fns: AHashMap<StrategyId, Box<dyn FnMut() -> bool>>,
134    /// Msgbus handler IDs for strategy event subscriptions (order, position).
135    strategy_handler_ids: AHashMap<StrategyId, (Ustr, Ustr)>,
136    /// Registered exec algorithm IDs (algorithms stored in global registry).
137    pub(crate) exec_algorithm_ids: Vec<ExecAlgorithmId>,
138    /// Restores strategy event subscriptions for concrete execution algorithms.
139    exec_algorithm_restore_fns: AHashMap<ExecAlgorithmId, ExecutionAlgorithmSubscriptionFn>,
140    /// Removes strategy event subscriptions for concrete execution algorithms.
141    exec_algorithm_cleanup_fns: AHashMap<ExecAlgorithmId, ExecutionAlgorithmSubscriptionFn>,
142    /// Component clocks for individual components.
143    pub(crate) clocks: IndexMap<ComponentId, Rc<RefCell<dyn Clock>>>,
144    clocks_snapshot: OnceCell<ComponentClockSnapshot>,
145    /// Timestamp when the trader was created.
146    ts_created: UnixNanos,
147    /// Timestamp when the trader was last started.
148    ts_started: Option<UnixNanos>,
149    /// Timestamp when the trader was last stopped.
150    ts_stopped: Option<UnixNanos>,
151}
152
153impl Debug for Trader {
154    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
155        write!(f, "{:?}", stringify!(TraderId)) // TODO
156    }
157}
158
159impl Trader {
160    /// Creates a new [`Trader`] instance.
161    #[must_use]
162    pub fn new(
163        trader_id: TraderId,
164        instance_id: UUID4,
165        environment: Environment,
166        clock_factory: ClockFactory,
167        cache: Rc<RefCell<Cache>>,
168        portfolio: Rc<RefCell<Portfolio>>,
169    ) -> Self {
170        let clock = clock_factory.clock();
171        let ts_created = clock.borrow().timestamp_ns();
172
173        Self {
174            trader_id,
175            instance_id,
176            environment,
177            state: ComponentState::PreInitialized,
178            clock_factory,
179            cache,
180            portfolio,
181            actor_ids: Vec::new(),
182            actor_state_callbacks: AHashMap::new(),
183            strategy_ids: Vec::new(),
184            strategy_state_callbacks: AHashMap::new(),
185            strategy_stop_fns: AHashMap::new(),
186            strategy_handler_ids: AHashMap::new(),
187            exec_algorithm_ids: Vec::new(),
188            exec_algorithm_restore_fns: AHashMap::new(),
189            exec_algorithm_cleanup_fns: AHashMap::new(),
190            clocks: IndexMap::new(),
191            clocks_snapshot: OnceCell::new(),
192            ts_created,
193            ts_started: None,
194            ts_stopped: None,
195        }
196    }
197
198    /// Returns the trader ID.
199    #[must_use]
200    pub const fn trader_id(&self) -> TraderId {
201        self.trader_id
202    }
203
204    /// Returns the instance ID.
205    #[must_use]
206    pub const fn instance_id(&self) -> UUID4 {
207        self.instance_id
208    }
209
210    /// Returns the trading environment.
211    #[must_use]
212    pub const fn environment(&self) -> Environment {
213        self.environment
214    }
215
216    /// Returns the current component state.
217    #[must_use]
218    pub const fn state(&self) -> ComponentState {
219        self.state
220    }
221
222    /// Returns the timestamp when the trader was created (UNIX nanoseconds).
223    #[must_use]
224    pub const fn ts_created(&self) -> UnixNanos {
225        self.ts_created
226    }
227
228    /// Returns the timestamp when the trader was last started (UNIX nanoseconds).
229    #[must_use]
230    pub const fn ts_started(&self) -> Option<UnixNanos> {
231        self.ts_started
232    }
233
234    /// Returns the timestamp when the trader was last stopped (UNIX nanoseconds).
235    #[must_use]
236    pub const fn ts_stopped(&self) -> Option<UnixNanos> {
237        self.ts_stopped
238    }
239
240    /// Returns the number of registered actors.
241    #[must_use]
242    pub const fn actor_count(&self) -> usize {
243        self.actor_ids.len()
244    }
245
246    /// Returns the number of registered strategies.
247    #[must_use]
248    pub const fn strategy_count(&self) -> usize {
249        self.strategy_ids.len()
250    }
251
252    /// Returns the number of registered execution algorithms.
253    #[must_use]
254    pub const fn exec_algorithm_count(&self) -> usize {
255        self.exec_algorithm_ids.len()
256    }
257
258    /// Returns references to all component clocks for backtest time advancement.
259    #[must_use]
260    pub fn get_component_clocks(&self) -> Vec<Rc<RefCell<dyn Clock>>> {
261        self.get_component_clocks_snapshot().to_vec()
262    }
263
264    /// Returns a shared snapshot of component clocks in registration order.
265    ///
266    /// Reuses the snapshot until a clock is added, replaced, or removed. Existing snapshots retain
267    /// their membership while sharing the clocks' current state.
268    #[must_use]
269    pub fn get_component_clocks_snapshot(&self) -> Rc<[Rc<RefCell<dyn Clock>>]> {
270        self.clocks_snapshot
271            .get_or_init(|| self.clocks.values().cloned().collect())
272            .clone()
273    }
274
275    /// Returns the total number of registered components.
276    #[must_use]
277    pub const fn component_count(&self) -> usize {
278        self.actor_ids.len() + self.strategy_ids.len() + self.exec_algorithm_ids.len()
279    }
280
281    /// Returns a list of all registered actor IDs.
282    #[must_use]
283    pub fn actor_ids(&self) -> Vec<ActorId> {
284        self.actor_ids.clone()
285    }
286
287    /// Returns a list of all registered strategy IDs.
288    #[must_use]
289    pub fn strategy_ids(&self) -> Vec<StrategyId> {
290        self.strategy_ids.clone()
291    }
292
293    /// Returns a list of all registered execution algorithm IDs.
294    #[must_use]
295    pub fn exec_algorithm_ids(&self) -> Vec<ExecAlgorithmId> {
296        self.exec_algorithm_ids.clone()
297    }
298
299    /// Creates a clock for a component and registers it for time advancement.
300    ///
301    /// Each component gets its own clock instance so that the default time event
302    /// callback registered on each clock is independent. In backtest mode, the
303    /// clocks are also used for deterministic time advancement by the engine.
304    pub fn create_component_clock(&mut self, component_id: ComponentId) -> Rc<RefCell<dyn Clock>> {
305        let clock = self.clock_factory.create_component_clock();
306        self.clocks_snapshot.take();
307        self.clocks.insert(component_id, clock.clone());
308        clock
309    }
310
311    /// Adds an actor to the trader.
312    ///
313    /// # Errors
314    ///
315    /// Returns an error if:
316    /// - The trader is not in a valid state for adding components.
317    /// - The trader already tracks a component under the actor's ID.
318    pub fn add_actor<T>(&mut self, actor: T) -> anyhow::Result<()>
319    where
320        T: DataActor + DataActorNative + Component + Debug + 'static,
321    {
322        self.validate_actor_or_strategy_registration()?;
323
324        let actor_id = actor.actor_id();
325
326        // Check for duplicate registration
327        if self.actor_ids.contains(&actor_id) {
328            anyhow::bail!("Actor {actor_id} is already registered");
329        }
330
331        let component_id = ComponentId::from(actor_id);
332        self.ensure_component_id_available(component_id)?;
333        let clock = self.create_component_clock(component_id);
334
335        let mut actor_mut = actor;
336        if let Err(e) = actor_mut.register(self.trader_id, clock, self.cache.clone()) {
337            self.release_component_clock(component_id);
338            return Err(e);
339        }
340
341        self.add_registered_actor(actor_mut)
342    }
343
344    /// Adds an actor to the trader using a factory function.
345    ///
346    /// The factory function is called at registration time to create the actor,
347    /// avoiding cloning issues with non-cloneable actor types.
348    ///
349    /// # Errors
350    ///
351    /// Returns an error if:
352    /// - The factory function fails to create the actor.
353    /// - The trader is not in a valid state for adding components.
354    /// - The trader already tracks a component under the actor's ID.
355    pub fn add_actor_from_factory<F, T>(&mut self, factory: F) -> anyhow::Result<()>
356    where
357        F: FnOnce() -> anyhow::Result<T>,
358        T: DataActor + DataActorNative + Component + Debug + 'static,
359    {
360        let actor = factory()?;
361
362        self.add_actor(actor)
363    }
364
365    /// Adds an already registered actor to the trader's component registry.
366    ///
367    /// # Errors
368    ///
369    /// Returns an error if the actor cannot be registered in the component registry.
370    pub fn add_registered_actor<T>(&mut self, actor: T) -> anyhow::Result<()>
371    where
372        T: DataActor + DataActorNative + Component + Debug + 'static,
373    {
374        let actor_id = actor.actor_id();
375
376        // Register in both component and actor registries (this consumes the actor)
377        register_component_actor(actor);
378
379        // Store actor ID for lifecycle management
380        self.actor_ids.push(actor_id);
381        self.actor_state_callbacks.insert(
382            actor_id,
383            ComponentStateCallbacks {
384                load: Self::load_component_state::<T>,
385                save: Self::save_component_state::<T>,
386            },
387        );
388
389        log::info!("Registered actor {actor_id} with trader {}", self.trader_id);
390
391        Ok(())
392    }
393
394    /// Adds an actor ID to the trader's lifecycle management without consuming the actor.
395    ///
396    /// This is useful when the actor is already registered in the global component registry
397    /// but the trader needs to track it for lifecycle management. The caller is responsible
398    /// for ensuring the actor is properly registered in the global registries.
399    ///
400    /// # Errors
401    ///
402    /// Returns an error if the actor ID is already tracked by this trader.
403    pub fn add_actor_id_for_lifecycle<T>(&mut self, actor_id: ActorId) -> anyhow::Result<()>
404    where
405        T: DataActor + DataActorNative + Debug + 'static,
406    {
407        // Check for duplicate registration
408        if self.actor_ids.contains(&actor_id) {
409            anyhow::bail!("Actor '{actor_id}' is already tracked by trader");
410        }
411
412        // Store actor ID for lifecycle management
413        self.actor_ids.push(actor_id);
414        self.actor_state_callbacks.insert(
415            actor_id,
416            ComponentStateCallbacks {
417                load: Self::load_component_state::<T>,
418                save: Self::save_component_state::<T>,
419            },
420        );
421
422        log::debug!(
423            "Added actor ID '{actor_id}' to trader {} for lifecycle management",
424            self.trader_id
425        );
426
427        Ok(())
428    }
429
430    /// Adds an externally-registered execution algorithm ID to the trader for lifecycle management.
431    ///
432    /// The execution algorithm must already be registered in the global component and actor
433    /// registries. This method only tracks the ID so the trader can manage the algorithm's
434    /// lifecycle (start/stop/dispose).
435    ///
436    /// # Errors
437    ///
438    /// Returns an error if an execution algorithm with the same ID is already tracked.
439    pub fn add_exec_algorithm_id_for_lifecycle(
440        &mut self,
441        exec_algorithm_id: ExecAlgorithmId,
442    ) -> anyhow::Result<()> {
443        if self.exec_algorithm_ids.contains(&exec_algorithm_id) {
444            anyhow::bail!("Execution algorithm '{exec_algorithm_id}' is already tracked by trader");
445        }
446
447        self.exec_algorithm_ids.push(exec_algorithm_id);
448
449        log::debug!(
450            "Added exec algorithm ID '{exec_algorithm_id}' to trader {} for lifecycle management",
451            self.trader_id
452        );
453
454        Ok(())
455    }
456
457    /// Adds an externally-registered strategy to the trader for lifecycle management
458    /// and installs its order/position event subscriptions, stop hook, and control endpoint.
459    ///
460    /// The strategy must already be registered in the global component and actor
461    /// registries. The generic parameter `T` must match the concrete type stored
462    /// in those registries so that the typed event handlers can retrieve it.
463    ///
464    /// # Errors
465    ///
466    /// Returns an error if the strategy ID is already tracked by this trader.
467    pub fn add_strategy_id_with_subscriptions<T>(
468        &mut self,
469        strategy_id: StrategyId,
470    ) -> anyhow::Result<()>
471    where
472        T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
473    {
474        if self.strategy_ids.contains(&strategy_id) {
475            anyhow::bail!("Strategy '{strategy_id}' is already tracked by trader");
476        }
477
478        let existing_order_id_tags: Vec<&str> =
479            self.strategy_ids.iter().map(StrategyId::get_tag).collect();
480        ensure_unique_order_id_tag(&existing_order_id_tags, strategy_id.get_tag())?;
481
482        let actor_id = strategy_id.inner();
483
484        // Subscribe to order events for this strategy
485        let order_topic = get_event_order_topic(strategy_id);
486        let order_actor_id = actor_id;
487        let order_handler = TypedHandler::from(move |event: &OrderEventAny| {
488            if let Some(mut strategy) = try_get_actor_unchecked::<T>(&order_actor_id) {
489                strategy.handle_order_event(event.clone());
490            } else {
491                log::error!("Strategy {order_actor_id} not found for order event handling");
492            }
493        });
494        let order_handler_id = order_handler.id();
495        msgbus::subscribe_order_events(order_topic.into(), order_handler, None);
496
497        // Subscribe to position events for this strategy
498        let position_topic = get_event_position_topic(strategy_id);
499        let position_handler = TypedHandler::from(move |event: &PositionEvent| {
500            if let Some(mut strategy) = try_get_actor_unchecked::<T>(&actor_id) {
501                strategy.handle_position_event(event.clone());
502            } else {
503                log::error!("Strategy {actor_id} not found for position event handling");
504            }
505        });
506        let position_handler_id = position_handler.id();
507        msgbus::subscribe_position_events(position_topic.into(), position_handler, None);
508
509        let control_actor_id = actor_id;
510        let control_handler = TypedHandler::from(move |command: &StrategyCommand| {
511            if let Some(mut strategy) = try_get_actor_unchecked::<T>(&control_actor_id) {
512                match command {
513                    StrategyCommand::ExitMarket => {
514                        if let Err(e) = strategy.market_exit() {
515                            log::error!(
516                                "Error handling strategy command for {control_actor_id}: {e}"
517                            );
518                        }
519                    }
520                }
521            } else {
522                log::error!("Strategy {control_actor_id} not found for control handling");
523            }
524        });
525        get_message_bus()
526            .borrow_mut()
527            .endpoint_map::<StrategyCommand>()
528            .register(strategy_control_endpoint(strategy_id), control_handler);
529
530        self.strategy_ids.push(strategy_id);
531        self.strategy_state_callbacks.insert(
532            strategy_id,
533            ComponentStateCallbacks {
534                load: Self::load_component_state::<T>,
535                save: Self::save_component_state::<T>,
536            },
537        );
538        self.strategy_handler_ids
539            .insert(strategy_id, (order_handler_id, position_handler_id));
540
541        // Register stop hook
542        let stop_actor_id = actor_id;
543        let stop_fn = Box::new(move || -> bool {
544            if let Some(mut strategy) = try_get_actor_unchecked::<T>(&stop_actor_id) {
545                Strategy::stop(&mut *strategy)
546            } else {
547                log::error!("Strategy {stop_actor_id} not found for stop");
548                true
549            }
550        });
551        self.strategy_stop_fns.insert(strategy_id, stop_fn);
552
553        log::debug!(
554            "Added strategy '{strategy_id}' to trader {} with event subscriptions",
555            self.trader_id
556        );
557
558        Ok(())
559    }
560
561    /// Prepares a strategy ID and order ID tag before registration.
562    ///
563    /// # Errors
564    ///
565    /// Returns an error if the configured order ID tag contains the '-' strategy ID separator,
566    /// if composing it into a strategy ID does not produce a valid [`StrategyId`],
567    /// or if the strategy ID or order ID tag is already registered.
568    pub fn prepare_strategy_for_registration<T>(
569        &self,
570        strategy: &mut T,
571    ) -> anyhow::Result<StrategyId>
572    where
573        T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
574    {
575        // Guards a config built without `StrategyConfig::validate`, such as a struct literal
576        if let Some(order_id_tag) = StrategyNative::strategy_core(strategy)
577            .config
578            .order_id_tag
579            .as_deref()
580        {
581            check_order_id_tag(order_id_tag)?;
582        }
583
584        let existing_order_id_tags: Vec<&str> =
585            self.strategy_ids.iter().map(StrategyId::get_tag).collect();
586
587        let configured_strategy_id = StrategyNative::strategy_core(strategy).strategy_id();
588        let runtime_order_id_tag =
589            normalize_order_id_tag(StrategyNative::strategy_core(strategy).order_id_tag());
590
591        let strategy_id = if let Some(strategy_id) = configured_strategy_id {
592            ensure_unique_order_id_tag(&existing_order_id_tags, strategy_id.get_tag())?;
593            StrategyNative::strategy_core_mut(strategy).change_id(strategy_id)?;
594            strategy_id
595        } else {
596            let order_id_tag = runtime_order_id_tag.map_or_else(
597                || next_order_id_tag(&existing_order_id_tags),
598                str::to_string,
599            );
600            ensure_unique_order_id_tag(&existing_order_id_tags, &order_id_tag)?;
601
602            let base_id = strategy_registration_id::<T>(strategy);
603            let strategy_id =
604                StrategyId::new_checked(format!("{}-{order_id_tag}", base_strategy_id(&base_id)))?;
605            StrategyNative::strategy_core_mut(strategy).change_id(strategy_id)?;
606            strategy_id
607        };
608
609        if self.strategy_ids.contains(&strategy_id) {
610            anyhow::bail!("Strategy {strategy_id} is already registered");
611        }
612
613        Ok(strategy_id)
614    }
615
616    /// Adds a strategy to the trader.
617    ///
618    /// Strategies are registered in both the component registry (for lifecycle management)
619    /// and the actor registry (for data callbacks via msgbus). The strategy's `StrategyCore`
620    /// is also registered with the portfolio for order management.
621    ///
622    /// # Errors
623    ///
624    /// Returns an error if:
625    /// - The trader is not in a valid state for adding components.
626    /// - The trader already tracks a component under the strategy's ID.
627    pub fn add_strategy<T>(&mut self, mut strategy: T) -> anyhow::Result<()>
628    where
629        T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
630    {
631        self.validate_actor_or_strategy_registration()?;
632
633        let strategy_id = self.prepare_strategy_for_registration(&mut strategy)?;
634
635        let component_id = strategy.component_id();
636        self.ensure_component_id_available(component_id)?;
637        let clock = self.create_component_clock(component_id);
638
639        // Register strategy core with portfolio for order management
640        if let Err(e) = StrategyNative::strategy_core_mut(&mut strategy).register(
641            self.trader_id,
642            clock.clone(),
643            self.cache.clone(),
644            self.portfolio.clone(),
645        ) {
646            self.release_component_clock(component_id);
647            return Err(e);
648        }
649
650        // Register default time event handler for this strategy
651        let actor_id = strategy.actor_id().inner();
652        let callback = TimeEventCallback::from(move |event: TimeEvent| {
653            if let Some(mut strategy) = try_get_actor_unchecked::<T>(&actor_id) {
654                log::debug!("{RECV} {event}");
655
656                if strategy.not_running() {
657                    log::trace!("Received message when not running - skipping {event}");
658                    return;
659                }
660
661                route_time_event(&mut *strategy, &event);
662                if let Err(e) = DataActor::on_time_event(&mut *strategy, &event) {
663                    log::error!("{e}");
664                }
665            } else {
666                log::error!("Strategy {actor_id} not found for time event handling");
667            }
668        });
669        clock.borrow_mut().register_default_handler(callback);
670
671        // Transition to Ready state
672        if let Err(e) = strategy.initialize() {
673            self.release_component_clock(component_id);
674            return Err(e);
675        }
676
677        // Register in both component and actor registries
678        register_component_actor(strategy);
679
680        self.add_strategy_id_with_subscriptions::<T>(strategy_id)?;
681
682        log::info!(
683            "Registered strategy {strategy_id} with trader {}",
684            self.trader_id
685        );
686
687        Ok(())
688    }
689
690    /// Adds an execution algorithm to the trader.
691    ///
692    /// Execution algorithms are registered in both the component registry (for lifecycle
693    /// management) and the actor registry (for data callbacks via msgbus).
694    ///
695    /// # Errors
696    ///
697    /// Returns an error if:
698    /// - The trader is not in a valid state for adding components.
699    /// - The trader already tracks a component under the execution algorithm's ID.
700    pub fn add_exec_algorithm<T>(&mut self, mut exec_algorithm: T) -> anyhow::Result<()>
701    where
702        T: ExecutionAlgorithm + ExecutionAlgorithmNative + Component + Debug + 'static,
703    {
704        self.validate_exec_algorithm_registration()?;
705
706        let exec_algorithm_id = ExecAlgorithmId::new(exec_algorithm.component_id().inner());
707
708        if self.exec_algorithm_ids.contains(&exec_algorithm_id) {
709            anyhow::bail!("Execution algorithm '{exec_algorithm_id}' is already registered");
710        }
711
712        let component_id = exec_algorithm.component_id();
713        self.ensure_component_id_available(component_id)?;
714        let clock = self.create_component_clock(component_id);
715        if let Err(e) = exec_algorithm.register(self.trader_id, clock, self.cache.clone()) {
716            self.release_component_clock(component_id);
717            return Err(e);
718        }
719
720        exec_algorithm
721            .exec_algorithm_core_mut()
722            .set_portfolio(self.portfolio.clone());
723
724        register_component_actor(exec_algorithm);
725
726        // Register the {id}.execute endpoint so the order manager can
727        // route TradingCommands to this algorithm via msgbus::send_any
728        let actor_id = exec_algorithm_id.inner();
729        let restore_actor_id = actor_id;
730        let restore_fn: ExecutionAlgorithmSubscriptionFn = Box::new(move || {
731            let Some(mut algo) = try_get_actor_unchecked::<T>(&restore_actor_id) else {
732                anyhow::bail!(
733                    "Execution algorithm {restore_actor_id} not found while restoring subscriptions"
734                );
735            };
736
737            let mut strategy_ids = {
738                let cache = algo.exec_algorithm_core_mut().cache_ref();
739                cache
740                    .orders_for_exec_algorithm(&exec_algorithm_id, None, None, None, None, None)
741                    .into_iter()
742                    .filter(|order| {
743                        !order.is_closed() && order.exec_algorithm_id() == Some(exec_algorithm_id)
744                    })
745                    .map(|order| order.strategy_id())
746                    .collect::<Vec<_>>()
747            };
748            strategy_ids.sort_unstable();
749            strategy_ids.dedup();
750
751            for strategy_id in strategy_ids {
752                algo.subscribe_to_strategy_events(strategy_id);
753            }
754
755            Ok(())
756        });
757        let cleanup_actor_id = actor_id;
758        let cleanup_fn: ExecutionAlgorithmSubscriptionFn = Box::new(move || {
759            let Some(mut algo) = try_get_actor_unchecked::<T>(&cleanup_actor_id) else {
760                anyhow::bail!(
761                    "Execution algorithm {cleanup_actor_id} not found while cleaning subscriptions"
762                );
763            };
764            algo.unsubscribe_all_strategy_events();
765            Ok(())
766        });
767        let endpoint: Ustr = format!("{exec_algorithm_id}.execute").into();
768        let handler = ShareableMessageHandler::from_typed(move |command: &TradingCommand| {
769            if let Some(mut algo) = try_get_actor_unchecked::<T>(&actor_id) {
770                if let Err(e) = algo.execute(command.clone()) {
771                    log::error!("Error executing command on algorithm {actor_id}: {e}");
772                }
773            } else {
774                log::error!("Execution algorithm {actor_id} not found in registry");
775            }
776        });
777        msgbus::register_any(endpoint.into(), handler);
778
779        self.exec_algorithm_ids.push(exec_algorithm_id);
780        self.exec_algorithm_restore_fns
781            .insert(exec_algorithm_id, restore_fn);
782        self.exec_algorithm_cleanup_fns
783            .insert(exec_algorithm_id, cleanup_fn);
784
785        log::info!(
786            "Registered execution algorithm {exec_algorithm_id} with trader {}",
787            self.trader_id
788        );
789
790        Ok(())
791    }
792
793    /// Rejects a component ID this trader already tracks, whatever kind registered it.
794    ///
795    /// Lifecycle collections also cover externally registered components without trader-owned
796    /// clocks. Reject collisions before replacing a clock, registry entry, or Python wrapper.
797    pub(crate) fn ensure_component_id_available(
798        &self,
799        component_id: ComponentId,
800    ) -> anyhow::Result<()> {
801        let id = component_id.inner();
802        let tracked = self.clocks.contains_key(&component_id)
803            || self.actor_ids.iter().any(|actor_id| actor_id.inner() == id)
804            || self
805                .strategy_ids
806                .iter()
807                .any(|strategy_id| strategy_id.inner() == id)
808            || self
809                .exec_algorithm_ids
810                .iter()
811                .any(|exec_algorithm_id| exec_algorithm_id.inner() == id);
812
813        if tracked {
814            anyhow::bail!(
815                "Component {component_id} is already registered with trader {}",
816                self.trader_id
817            );
818        }
819
820        Ok(())
821    }
822
823    /// Validates that the trader is in a valid state for actor and strategy registration.
824    ///
825    /// Actors and strategies can be added while the trader is `PreInitialized`, `Ready`,
826    /// `Stopped`, or `Running`. This enables the [`Controller`](crate::controller::Controller)
827    /// to add them at runtime.
828    pub(crate) fn validate_actor_or_strategy_registration(&self) -> anyhow::Result<()> {
829        match self.state {
830            ComponentState::PreInitialized
831            | ComponentState::Ready
832            | ComponentState::Starting
833            | ComponentState::Stopped
834            | ComponentState::Running => Ok(()),
835            ComponentState::Disposed => {
836                anyhow::bail!("Cannot add components to disposed trader")
837            }
838            _ => anyhow::bail!("Cannot add components in current state: {}", self.state),
839        }
840    }
841
842    /// Validates that the trader is in a valid state for execution algorithm registration.
843    pub(crate) fn validate_exec_algorithm_registration(&self) -> anyhow::Result<()> {
844        match self.state {
845            ComponentState::PreInitialized | ComponentState::Ready | ComponentState::Stopped => {
846                Ok(())
847            }
848            ComponentState::Running => {
849                anyhow::bail!("Cannot add execution algorithms to running trader")
850            }
851            ComponentState::Disposed => {
852                anyhow::bail!("Cannot add components to disposed trader")
853            }
854            _ => anyhow::bail!(
855                "Cannot add execution algorithms in current state: {}",
856                self.state
857            ),
858        }
859    }
860
861    /// Starts all registered components.
862    ///
863    /// # Errors
864    ///
865    /// Returns an error if any component fails to start.
866    pub fn start_components(&mut self) -> anyhow::Result<()> {
867        let actor_ids = self.actor_ids.clone();
868        let strategy_ids = self.strategy_ids.clone();
869        let exec_algorithm_ids = self.exec_algorithm_ids.clone();
870
871        for actor_id in actor_ids {
872            log::debug!("Starting actor {actor_id}");
873            Self::start_component_if_not_running(actor_id.inner())?;
874        }
875
876        for strategy_id in strategy_ids {
877            log::debug!("Starting strategy {strategy_id}");
878            Self::start_component_if_not_running(strategy_id.inner())?;
879        }
880
881        let mut restored_exec_algorithm_ids = Vec::new();
882
883        for exec_algorithm_id in exec_algorithm_ids {
884            log::debug!("Starting execution algorithm {exec_algorithm_id}");
885            match self.start_exec_algorithm_if_not_running(exec_algorithm_id) {
886                Ok(true) => restored_exec_algorithm_ids.push(exec_algorithm_id),
887                Ok(false) => {}
888                Err(start_err) => {
889                    return Err(self.exec_algorithm_start_error_with_rollback(
890                        exec_algorithm_id,
891                        &restored_exec_algorithm_ids,
892                        start_err,
893                    ));
894                }
895            }
896        }
897
898        Ok(())
899    }
900
901    /// Starts the trader while releasing the trader borrow before component callbacks run.
902    ///
903    /// # Errors
904    ///
905    /// Returns an error if the trader state transition or any component startup fails.
906    pub fn start_with_component_callbacks(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
907        trader
908            .borrow_mut()
909            .transition_state(ComponentTrigger::Start)?;
910
911        let (actor_ids, strategy_ids, exec_algorithm_ids) = {
912            let trader_ref = trader.borrow();
913            (
914                trader_ref.actor_ids.clone(),
915                trader_ref.strategy_ids.clone(),
916                trader_ref.exec_algorithm_ids.clone(),
917            )
918        };
919
920        for actor_id in actor_ids {
921            log::debug!("Starting actor {actor_id}");
922            Self::start_component_if_not_running(actor_id.inner())?;
923        }
924
925        for strategy_id in strategy_ids {
926            log::debug!("Starting strategy {strategy_id}");
927            Self::start_component_if_not_running(strategy_id.inner())?;
928        }
929
930        let mut restored_exec_algorithm_ids = Vec::new();
931
932        for exec_algorithm_id in exec_algorithm_ids {
933            log::debug!("Starting execution algorithm {exec_algorithm_id}");
934            let component_state = match component_state(&exec_algorithm_id.inner()) {
935                Ok(state) => state,
936                Err(start_err) => {
937                    let e = trader
938                        .borrow_mut()
939                        .exec_algorithm_start_error_with_rollback(
940                            exec_algorithm_id,
941                            &restored_exec_algorithm_ids,
942                            start_err,
943                        );
944                    return Err(e);
945                }
946            };
947
948            if component_state == ComponentState::Running {
949                continue;
950            }
951
952            if let Err(start_err) = trader
953                .borrow_mut()
954                .restore_exec_algorithm_subscriptions(exec_algorithm_id)
955            {
956                let e = trader
957                    .borrow_mut()
958                    .exec_algorithm_start_error_with_rollback(
959                        exec_algorithm_id,
960                        &restored_exec_algorithm_ids,
961                        start_err,
962                    );
963                return Err(e);
964            }
965            restored_exec_algorithm_ids.push(exec_algorithm_id);
966
967            if let Err(start_err) = start_component(&exec_algorithm_id.inner()) {
968                let e = trader
969                    .borrow_mut()
970                    .exec_algorithm_start_error_with_rollback(
971                        exec_algorithm_id,
972                        &restored_exec_algorithm_ids,
973                        start_err,
974                    );
975                return Err(e);
976            }
977        }
978
979        let mut trader_ref = trader.borrow_mut();
980        let clock = trader_ref.clock_factory.clock();
981        trader_ref.ts_started = Some(clock.borrow().timestamp_ns());
982        trader_ref.transition_state(ComponentTrigger::StartCompleted)?;
983
984        Ok(())
985    }
986
987    fn start_component_if_not_running(component_id: Ustr) -> anyhow::Result<()> {
988        if component_state(&component_id)? == ComponentState::Running {
989            return Ok(());
990        }
991
992        start_component(&component_id)
993    }
994
995    fn start_exec_algorithm_if_not_running(
996        &mut self,
997        exec_algorithm_id: ExecAlgorithmId,
998    ) -> anyhow::Result<bool> {
999        if component_state(&exec_algorithm_id.inner())? == ComponentState::Running {
1000            return Ok(false);
1001        }
1002
1003        self.restore_exec_algorithm_subscriptions(exec_algorithm_id)?;
1004        if let Err(start_err) = start_component(&exec_algorithm_id.inner()) {
1005            return match self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id) {
1006                Ok(()) => Err(start_err),
1007                Err(cleanup_err) => anyhow::bail!(
1008                    "Failed to start execution algorithm {exec_algorithm_id}: {start_err:#}; \
1009                     failed to roll back subscriptions: {cleanup_err:#}"
1010                ),
1011            };
1012        }
1013
1014        Ok(true)
1015    }
1016
1017    fn restore_exec_algorithm_subscriptions(
1018        &mut self,
1019        exec_algorithm_id: ExecAlgorithmId,
1020    ) -> anyhow::Result<()> {
1021        if let Some(restore_fn) = self.exec_algorithm_restore_fns.get_mut(&exec_algorithm_id) {
1022            restore_fn()?;
1023        }
1024        Ok(())
1025    }
1026
1027    fn cleanup_exec_algorithm_subscriptions(
1028        &mut self,
1029        exec_algorithm_id: ExecAlgorithmId,
1030    ) -> anyhow::Result<()> {
1031        if let Some(cleanup_fn) = self.exec_algorithm_cleanup_fns.get_mut(&exec_algorithm_id) {
1032            cleanup_fn()?;
1033        }
1034        Ok(())
1035    }
1036
1037    fn cleanup_exec_algorithm_subscriptions_for(
1038        &mut self,
1039        exec_algorithm_ids: &[ExecAlgorithmId],
1040    ) -> anyhow::Result<()> {
1041        let mut errors = Vec::new();
1042
1043        for exec_algorithm_id in exec_algorithm_ids {
1044            if let Err(e) = self.cleanup_exec_algorithm_subscriptions(*exec_algorithm_id) {
1045                errors.push(format!("{exec_algorithm_id}: {e:#}"));
1046            }
1047        }
1048
1049        if errors.is_empty() {
1050            Ok(())
1051        } else {
1052            anyhow::bail!("{}", errors.join("; "))
1053        }
1054    }
1055
1056    fn exec_algorithm_start_error_with_rollback(
1057        &mut self,
1058        exec_algorithm_id: ExecAlgorithmId,
1059        restored_exec_algorithm_ids: &[ExecAlgorithmId],
1060        start_err: anyhow::Error,
1061    ) -> anyhow::Error {
1062        match self.cleanup_exec_algorithm_subscriptions_for(restored_exec_algorithm_ids) {
1063            Ok(()) => start_err,
1064            Err(cleanup_err) => anyhow::anyhow!(
1065                "Failed while starting execution algorithm {exec_algorithm_id}: {start_err:#}; \
1066                 failed to roll back restored subscriptions: {cleanup_err:#}"
1067            ),
1068        }
1069    }
1070
1071    /// Stops all registered components.
1072    ///
1073    /// Attempts every active component before returning collected errors. Managed strategy stops
1074    /// can remain deferred until market exit completes.
1075    ///
1076    /// # Errors
1077    ///
1078    /// Returns an error if any component fails to stop.
1079    pub fn stop_components(&mut self) -> anyhow::Result<()> {
1080        let mut errors = Vec::new();
1081
1082        for actor_id in &self.actor_ids {
1083            log::debug!("Stopping actor {actor_id}");
1084
1085            if let Err(e) = Self::stop_component_if_active(actor_id.inner()) {
1086                errors.push(format!("actor {actor_id}: {e:#}"));
1087            }
1088        }
1089
1090        for exec_algorithm_id in &self.exec_algorithm_ids {
1091            log::debug!("Stopping execution algorithm {exec_algorithm_id}");
1092
1093            if let Err(e) = Self::stop_component_if_active(exec_algorithm_id.inner()) {
1094                errors.push(format!("execution algorithm {exec_algorithm_id}: {e:#}"));
1095            }
1096        }
1097
1098        for strategy_id in self.strategy_ids.clone() {
1099            log::debug!("Stopping strategy {strategy_id}");
1100            let should_proceed = self
1101                .strategy_stop_fns
1102                .get_mut(&strategy_id)
1103                .is_none_or(|stop_fn| stop_fn());
1104
1105            if should_proceed && let Err(e) = Self::stop_component_if_active(strategy_id.inner()) {
1106                errors.push(format!("strategy {strategy_id}: {e:#}"));
1107            }
1108        }
1109
1110        if errors.is_empty() {
1111            Ok(())
1112        } else {
1113            anyhow::bail!("Failed to stop trader components: {}", errors.join("; "))
1114        }
1115    }
1116
1117    /// Stops a partially started trader without deferring managed strategy shutdown.
1118    ///
1119    /// # Errors
1120    ///
1121    /// Returns an error if the trader transition or any component stop fails. All registered
1122    /// components still receive a stop attempt before the error is returned.
1123    pub fn stop_after_start_failure(&mut self) -> anyhow::Result<()> {
1124        self.transition_state(ComponentTrigger::Stop)?;
1125
1126        let stop_result = self.stop_components_after_start_failure();
1127        self.complete_stop(stop_result)
1128    }
1129
1130    fn complete_stop(&mut self, stop_result: anyhow::Result<()>) -> anyhow::Result<()> {
1131        let clock = self.clock_factory.clock();
1132        self.ts_stopped = Some(clock.borrow().timestamp_ns());
1133        let transition_result = self.transition_state(ComponentTrigger::StopCompleted);
1134
1135        match (stop_result, transition_result) {
1136            (Ok(()), Ok(())) => Ok(()),
1137            (Err(stop_err), Ok(())) => Err(stop_err),
1138            (Ok(()), Err(transition_err)) => Err(transition_err),
1139            (Err(stop_err), Err(transition_err)) => anyhow::bail!(
1140                "Failed to stop trader components: {stop_err}; failed to complete trader stop: \
1141                 {transition_err}"
1142            ),
1143        }
1144    }
1145
1146    fn stop_components_after_start_failure(&mut self) -> anyhow::Result<()> {
1147        let mut errors = Vec::new();
1148
1149        for actor_id in &self.actor_ids {
1150            log::debug!("Stopping actor {actor_id} after startup failure");
1151            if let Err(e) = Self::stop_component_if_active(actor_id.inner()) {
1152                errors.push(format!("actor {actor_id}: {e:#}"));
1153            }
1154        }
1155
1156        for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1157            log::debug!("Stopping execution algorithm {exec_algorithm_id} after startup failure");
1158            if let Err(e) = Self::stop_component_if_active(exec_algorithm_id.inner()) {
1159                errors.push(format!("execution algorithm {exec_algorithm_id}: {e:#}"));
1160            }
1161
1162            if let Err(e) = self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id) {
1163                errors.push(format!(
1164                    "execution algorithm {exec_algorithm_id} subscription cleanup: {e:#}"
1165                ));
1166            }
1167        }
1168
1169        for strategy_id in &self.strategy_ids {
1170            log::debug!("Stopping strategy {strategy_id} after startup failure");
1171            if let Err(e) = Self::stop_component_if_active(strategy_id.inner()) {
1172                errors.push(format!("strategy {strategy_id}: {e:#}"));
1173            }
1174        }
1175
1176        if errors.is_empty() {
1177            Ok(())
1178        } else {
1179            anyhow::bail!(
1180                "Failed to stop one or more trader components after startup failure: {}",
1181                errors.join("; ")
1182            )
1183        }
1184    }
1185
1186    fn stop_component_if_active(component_id: Ustr) -> anyhow::Result<()> {
1187        if !matches!(
1188            component_state(&component_id)?,
1189            ComponentState::Starting | ComponentState::Running | ComponentState::Degraded
1190        ) {
1191            return Ok(());
1192        }
1193
1194        stop_component(&component_id)
1195    }
1196
1197    /// Resets all registered components.
1198    ///
1199    /// # Errors
1200    ///
1201    /// Returns an error if any component fails to reset.
1202    pub fn reset_components(&mut self) -> anyhow::Result<()> {
1203        for actor_id in &self.actor_ids {
1204            log::debug!("Resetting actor {actor_id}");
1205            reset_component(&actor_id.inner())?;
1206        }
1207
1208        for strategy_id in &self.strategy_ids {
1209            log::debug!("Resetting strategy {strategy_id}");
1210            reset_component(&strategy_id.inner())?;
1211        }
1212
1213        for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1214            log::debug!("Resetting execution algorithm {exec_algorithm_id}");
1215            self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id)?;
1216            reset_component(&exec_algorithm_id.inner())?;
1217        }
1218
1219        Ok(())
1220    }
1221
1222    /// Disposes of all registered components.
1223    ///
1224    /// # Errors
1225    ///
1226    /// Returns an error if any component fails to dispose or the cache is already borrowed while
1227    /// retiring a strategy.
1228    pub fn dispose_components(&mut self) -> anyhow::Result<()> {
1229        for actor_id in self.actor_ids.clone() {
1230            log::debug!("Disposing actor {actor_id}");
1231            self.retire_actor(actor_id)?;
1232        }
1233
1234        for strategy_id in self.strategy_ids.clone() {
1235            log::debug!("Disposing strategy {strategy_id}");
1236            self.retire_strategy(strategy_id)?;
1237        }
1238
1239        for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1240            log::debug!("Disposing execution algorithm {exec_algorithm_id}");
1241            self.retire_exec_algorithm(exec_algorithm_id)?;
1242        }
1243
1244        // Clocks created for components which never completed registration
1245        for clock in self.clocks.values() {
1246            clock.borrow_mut().cancel_timers();
1247        }
1248
1249        if !self.clocks.is_empty() {
1250            self.clocks.clear();
1251            self.clocks_snapshot.take();
1252        }
1253
1254        Ok(())
1255    }
1256
1257    /// Clears all registered strategies, disposing each and removing their clocks.
1258    ///
1259    /// # Errors
1260    ///
1261    /// Returns an error if any strategy fails to dispose or the cache is already borrowed.
1262    pub fn clear_strategies(&mut self) -> anyhow::Result<()> {
1263        for strategy_id in self.strategy_ids.clone() {
1264            log::debug!("Disposing strategy {strategy_id}");
1265            self.retire_strategy(strategy_id)?;
1266        }
1267
1268        Ok(())
1269    }
1270
1271    /// Clears all registered actors, disposing each and removing their clocks.
1272    ///
1273    /// # Errors
1274    ///
1275    /// Returns an error if any actor fails to dispose.
1276    pub fn clear_actors(&mut self) -> anyhow::Result<()> {
1277        for actor_id in self.actor_ids.clone() {
1278            log::debug!("Disposing actor {actor_id}");
1279            Self::stop_before_disposal(actor_id.inner())?;
1280            self.retire_actor(actor_id)?;
1281        }
1282
1283        Ok(())
1284    }
1285
1286    /// Clears all registered execution algorithms, disposing each and removing their clocks.
1287    ///
1288    /// # Errors
1289    ///
1290    /// Returns an error if any execution algorithm fails to dispose.
1291    pub fn clear_exec_algorithms(&mut self) -> anyhow::Result<()> {
1292        for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1293            log::debug!("Disposing execution algorithm {exec_algorithm_id}");
1294            self.retire_exec_algorithm(exec_algorithm_id)?;
1295        }
1296
1297        Ok(())
1298    }
1299
1300    // -- Individual component management ----------------------------------------
1301
1302    /// Starts the actor with the given `actor_id`.
1303    ///
1304    /// # Errors
1305    ///
1306    /// Returns an error if the actor is not registered or cannot be started.
1307    pub fn start_actor(&self, actor_id: &ActorId) -> anyhow::Result<()> {
1308        if !self.actor_ids.contains(actor_id) {
1309            anyhow::bail!("Cannot start actor, {actor_id} not found");
1310        }
1311        start_component(&actor_id.inner())
1312    }
1313
1314    /// Stops the actor with the given `actor_id`.
1315    ///
1316    /// # Errors
1317    ///
1318    /// Returns an error if the actor is not registered or cannot be stopped.
1319    pub fn stop_actor(&self, actor_id: &ActorId) -> anyhow::Result<()> {
1320        if !self.actor_ids.contains(actor_id) {
1321            anyhow::bail!("Cannot stop actor, {actor_id} not found");
1322        }
1323        stop_component(&actor_id.inner())
1324    }
1325
1326    /// Removes the actor with the given `actor_id`.
1327    ///
1328    /// Will stop the actor first if it is currently running. Disposes the actor
1329    /// and removes it from the trader's tracking.
1330    ///
1331    /// # Errors
1332    ///
1333    /// Returns an error if the actor is not registered, or if disposal fails. A failed disposal
1334    /// keeps the actor registered and tracked, and leaves it `Faulted`; see [`Component::dispose`].
1335    /// Calling this again retires the actor.
1336    pub fn remove_actor(&mut self, actor_id: &ActorId) -> anyhow::Result<()> {
1337        if !self.actor_ids.contains(actor_id) {
1338            anyhow::bail!("Cannot remove actor, {actor_id} not found");
1339        }
1340
1341        Self::stop_before_disposal(actor_id.inner())?;
1342        self.retire_actor(*actor_id)?;
1343
1344        log::info!("Removed actor {actor_id} from trader {}", self.trader_id);
1345        Ok(())
1346    }
1347
1348    /// Starts the strategy with the given `strategy_id`.
1349    ///
1350    /// # Errors
1351    ///
1352    /// Returns an error if the strategy is not registered or cannot be started.
1353    pub fn start_strategy(&self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1354        if !self.strategy_ids.contains(strategy_id) {
1355            anyhow::bail!("Cannot start strategy, {strategy_id} not found");
1356        }
1357        start_component(&strategy_id.inner())
1358    }
1359
1360    /// Stops the strategy with the given `strategy_id`.
1361    ///
1362    /// Respects the `manage_stop` behavior - if the strategy's stop function
1363    /// returns `false`, the component stop is deferred until market exit completes.
1364    ///
1365    /// # Errors
1366    ///
1367    /// Returns an error if the strategy is not registered or cannot be stopped.
1368    pub fn stop_strategy(&mut self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1369        if !self.strategy_ids.contains(strategy_id) {
1370            anyhow::bail!("Cannot stop strategy, {strategy_id} not found");
1371        }
1372
1373        let should_proceed = self
1374            .strategy_stop_fns
1375            .get_mut(strategy_id)
1376            .is_none_or(|stop_fn| stop_fn());
1377
1378        if should_proceed {
1379            stop_component(&strategy_id.inner())?;
1380        }
1381
1382        Ok(())
1383    }
1384
1385    /// Exits the market for the strategy with the given `strategy_id`.
1386    ///
1387    /// Sends a strategy command to the strategy's control endpoint. The strategy
1388    /// then performs its own managed market exit.
1389    ///
1390    /// # Errors
1391    ///
1392    /// Returns an error if the strategy is not registered or its control endpoint is missing.
1393    pub fn market_exit_strategy(
1394        trader: &Rc<RefCell<Self>>,
1395        strategy_id: &StrategyId,
1396    ) -> anyhow::Result<()> {
1397        let handler = trader.borrow().strategy_command_handler(*strategy_id)?;
1398        handler.handle(&StrategyCommand::ExitMarket);
1399        Ok(())
1400    }
1401
1402    fn strategy_command_handler(
1403        &self,
1404        strategy_id: StrategyId,
1405    ) -> anyhow::Result<TypedHandler<StrategyCommand>> {
1406        if !self.strategy_ids.contains(&strategy_id) {
1407            anyhow::bail!("Cannot market exit strategy, {strategy_id} not found");
1408        }
1409
1410        let endpoint = strategy_control_endpoint(strategy_id);
1411        let handler = {
1412            let msgbus = get_message_bus();
1413            msgbus
1414                .borrow_mut()
1415                .endpoint_map::<StrategyCommand>()
1416                .get(endpoint)
1417                .cloned()
1418        };
1419
1420        let Some(handler) = handler else {
1421            anyhow::bail!(
1422                "Cannot exit market for strategy {strategy_id}: control endpoint '{}' not registered",
1423                endpoint.as_str()
1424            );
1425        };
1426
1427        Ok(handler)
1428    }
1429
1430    /// Removes the strategy with the given `strategy_id`.
1431    ///
1432    /// Will stop the strategy first if it is currently running. Disposes the strategy
1433    /// and removes it from the trader's tracking along with its event subscriptions.
1434    ///
1435    /// # Errors
1436    ///
1437    /// Returns an error if the strategy is not registered, the cache is already borrowed, or
1438    /// disposal fails. A cache borrow failure preserves the strategy registration and its external
1439    /// order claims. A failed disposal keeps the strategy registered and tracked, and leaves it
1440    /// `Faulted`; see [`Component::dispose`]. Calling this again retires the strategy.
1441    pub fn remove_strategy(&mut self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1442        if !self.strategy_ids.contains(strategy_id) {
1443            anyhow::bail!("Cannot remove strategy, {strategy_id} not found");
1444        }
1445
1446        Self::stop_before_disposal(strategy_id.inner())?;
1447        self.retire_strategy(*strategy_id)?;
1448
1449        log::info!(
1450            "Removed strategy {strategy_id} from trader {}",
1451            self.trader_id
1452        );
1453        Ok(())
1454    }
1455
1456    fn stop_before_disposal(id: Ustr) -> anyhow::Result<()> {
1457        let mut state = component_state(&id)?;
1458        if state.transition(&ComponentTrigger::Stop).is_err() {
1459            return Ok(());
1460        }
1461
1462        // A failed stop hook must not prevent disposal or leave later actors uncleared
1463        if let Err(e) = stop_component(&id) {
1464            log::error!(component = id.as_str(); "{e}");
1465        }
1466
1467        Ok(())
1468    }
1469
1470    /// Disposes an actor, then releases everything its registration created.
1471    ///
1472    /// Each component is retired completely before the next one starts, so a failure part way
1473    /// through a bulk operation leaves the trader's bookkeeping consistent with the registries.
1474    fn retire_actor(&mut self, actor_id: ActorId) -> anyhow::Result<()> {
1475        Self::dispose_registered_component(actor_id.inner())?;
1476
1477        self.release_component(ComponentId::from(actor_id));
1478        self.actor_ids.retain(|id| id != &actor_id);
1479        self.actor_state_callbacks.remove(&actor_id);
1480
1481        Ok(())
1482    }
1483
1484    /// Disposes a strategy, then releases everything its registration created.
1485    fn retire_strategy(&mut self, strategy_id: StrategyId) -> anyhow::Result<()> {
1486        // Check before disposal so a borrow failure cannot leave a disposed strategy registered.
1487        {
1488            let _cache = self
1489                .cache
1490                .try_borrow_mut()
1491                .map_err(|e| anyhow::anyhow!("Cannot clear external order claims: {e}"))?;
1492        }
1493
1494        Self::dispose_registered_component(strategy_id.inner())?;
1495
1496        self.cache
1497            .try_borrow_mut()
1498            .map_err(|e| anyhow::anyhow!("Cannot clear external order claims: {e}"))?
1499            .set_external_order_claims(strategy_id, &[])?;
1500
1501        self.remove_strategy_subscriptions(strategy_id);
1502        self.release_component(ComponentId::from(strategy_id));
1503        self.strategy_ids.retain(|id| id != &strategy_id);
1504        self.strategy_state_callbacks.remove(&strategy_id);
1505        self.strategy_stop_fns.remove(&strategy_id);
1506
1507        Ok(())
1508    }
1509
1510    /// Disposes an execution algorithm, then releases everything its registration created.
1511    fn retire_exec_algorithm(&mut self, exec_algorithm_id: ExecAlgorithmId) -> anyhow::Result<()> {
1512        Self::dispose_registered_component(exec_algorithm_id.inner())?;
1513        self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id)?;
1514
1515        let endpoint: Ustr = format!("{exec_algorithm_id}.execute").into();
1516        msgbus::deregister_any(endpoint.into());
1517        self.release_component(ComponentId::from(exec_algorithm_id));
1518        self.exec_algorithm_ids
1519            .retain(|id| id != &exec_algorithm_id);
1520        self.exec_algorithm_restore_fns.remove(&exec_algorithm_id);
1521        self.exec_algorithm_cleanup_fns.remove(&exec_algorithm_id);
1522
1523        Ok(())
1524    }
1525
1526    /// Disposes the component `id` unless it has already reached a terminal state.
1527    ///
1528    /// A component disposed from Python has already run `on_dispose`, so a second disposal
1529    /// transition would fail and strand the trader's bookkeeping. A `Faulted` component may have
1530    /// retained subscriptions after `on_dispose` failed, so release them idempotently without
1531    /// invoking the failed hook again.
1532    fn dispose_registered_component(id: Ustr) -> anyhow::Result<()> {
1533        let state = component_state(&id)?;
1534
1535        if state == ComponentState::Disposed {
1536            log::debug!("Component {id} already {state}, skipping disposal transition");
1537            return Ok(());
1538        }
1539
1540        if state == ComponentState::Faulted {
1541            return release_component_subscriptions(&id);
1542        }
1543
1544        dispose_component(&id)
1545    }
1546
1547    /// Removes the msgbus registrations the trader installed for `strategy_id`.
1548    fn remove_strategy_subscriptions(&mut self, strategy_id: StrategyId) {
1549        if let Some((order_handler_id, position_handler_id)) =
1550            self.strategy_handler_ids.remove(&strategy_id)
1551        {
1552            let order_topic = get_event_order_topic(strategy_id);
1553            let position_topic = get_event_position_topic(strategy_id);
1554            msgbus::remove_order_event_handler(order_topic.into(), order_handler_id);
1555            msgbus::remove_position_event_handler(position_topic.into(), position_handler_id);
1556        }
1557
1558        get_message_bus()
1559            .borrow_mut()
1560            .endpoint_map::<StrategyCommand>()
1561            .deregister(strategy_control_endpoint(strategy_id));
1562    }
1563
1564    /// Releases the clock, registry entries, and Python wrapper registered for a component.
1565    ///
1566    /// Called once a component has disposed successfully, to retire a `Faulted` component, or to
1567    /// roll back a failed registration. A failed disposal does not reach here on the attempt that
1568    /// failed, so the component stays registered and reachable for inspection or retry; a later
1569    /// attempt retires it through the `Faulted` route.
1570    ///
1571    /// A rollback only removes what the failed attempt created, because the Python registration
1572    /// path rejects a component ID this trader already tracks before it mutates anything.
1573    pub(crate) fn release_component(&mut self, component_id: ComponentId) {
1574        self.release_component_clock(component_id);
1575
1576        let id = component_id.inner();
1577        deregister_component(&id);
1578        deregister_actor(&id);
1579
1580        // Runs last because dropping the wrapper can trigger Python finalization which re-enters
1581        // Rust, and by then nothing is registered
1582        #[cfg(feature = "python")]
1583        release_python_wrapper(component_id);
1584    }
1585
1586    fn release_component_clock(&mut self, component_id: ComponentId) {
1587        if let Some(clock) = self.clocks.shift_remove(&component_id) {
1588            self.clocks_snapshot.take();
1589            let mut clock = clock.borrow_mut();
1590            clock.cancel_timers();
1591            clock.cancel_default_handler();
1592            clock.cancel_callbacks();
1593        }
1594    }
1595
1596    // -- Lifecycle management ---------------------------------------------------
1597
1598    /// Loads persisted actor and strategy state in registration order.
1599    ///
1600    /// Empty state and a cache without database backing do not invoke component callbacks.
1601    ///
1602    /// # Errors
1603    ///
1604    /// Returns an error if state cannot be loaded or a component callback fails.
1605    pub(crate) fn load_state(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
1606        let (cache, actor_callbacks, strategy_callbacks) = {
1607            let trader = trader.borrow();
1608            let actor_callbacks = trader.actor_state_callbacks()?;
1609            let strategy_callbacks = trader.strategy_state_callbacks()?;
1610
1611            (trader.cache.clone(), actor_callbacks, strategy_callbacks)
1612        };
1613
1614        if !cache.borrow().has_backing() {
1615            return Ok(());
1616        }
1617
1618        for (actor_id, callbacks) in actor_callbacks {
1619            let state = cache
1620                .borrow()
1621                .load_actor_state(&actor_id)
1622                .map_err(|e| anyhow::anyhow!("Failed to load actor {actor_id} state: {e:#}"))?;
1623            let Some(state) = state.filter(|state| !state.is_empty()) else {
1624                continue;
1625            };
1626
1627            (callbacks.load)(actor_id.inner(), state)
1628                .map_err(|e| anyhow::anyhow!("Failed to restore actor {actor_id} state: {e:#}"))?;
1629        }
1630
1631        for (strategy_id, callbacks) in strategy_callbacks {
1632            let state = cache
1633                .borrow()
1634                .load_strategy_state(&strategy_id)
1635                .map_err(|e| {
1636                    anyhow::anyhow!("Failed to load strategy {strategy_id} state: {e:#}")
1637                })?;
1638            let Some(state) = state.filter(|state| !state.is_empty()) else {
1639                continue;
1640            };
1641
1642            (callbacks.load)(strategy_id.inner(), state).map_err(|e| {
1643                anyhow::anyhow!("Failed to restore strategy {strategy_id} state: {e:#}")
1644            })?;
1645        }
1646
1647        Ok(())
1648    }
1649
1650    /// Collects actor and strategy state in registration order and attempts persistence.
1651    ///
1652    /// Empty state is submitted too, while a cache without database backing does not invoke
1653    /// component callbacks. All callbacks and updates receive an attempt before collected errors
1654    /// return. Persistence write failures are logged by the cache.
1655    ///
1656    /// # Errors
1657    ///
1658    /// Returns an error if preparing callbacks or collecting component state fails, or the backing
1659    /// reports a DeFi currency integrity error. Save-time errors are aggregated across all attempted
1660    /// components.
1661    pub(crate) fn save_state(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
1662        let (cache, actor_callbacks, strategy_callbacks) = {
1663            let trader = trader.borrow();
1664            let actor_callbacks = trader.actor_state_callbacks()?;
1665            let strategy_callbacks = trader.strategy_state_callbacks()?;
1666
1667            (trader.cache.clone(), actor_callbacks, strategy_callbacks)
1668        };
1669
1670        if !cache.borrow().has_backing() {
1671            return Ok(());
1672        }
1673
1674        let mut errors = Vec::new();
1675
1676        for (actor_id, callbacks) in actor_callbacks {
1677            match (callbacks.save)(actor_id.inner()) {
1678                Ok(state) => {
1679                    if let Err(e) = cache.borrow().update_actor_state(&actor_id, &state) {
1680                        errors.push(format!("actor {actor_id} persistence: {e:#}"));
1681                    }
1682                }
1683                Err(e) => errors.push(format!("actor {actor_id} callback: {e:#}")),
1684            }
1685        }
1686
1687        for (strategy_id, callbacks) in strategy_callbacks {
1688            match (callbacks.save)(strategy_id.inner()) {
1689                Ok(state) => {
1690                    if let Err(e) = cache.borrow().update_strategy_state(&strategy_id, &state) {
1691                        errors.push(format!("strategy {strategy_id} persistence: {e:#}"));
1692                    }
1693                }
1694                Err(e) => errors.push(format!("strategy {strategy_id} callback: {e:#}")),
1695            }
1696        }
1697
1698        if errors.is_empty() {
1699            Ok(())
1700        } else {
1701            anyhow::bail!("Failed to save component state: {}", errors.join("; "))
1702        }
1703    }
1704
1705    fn actor_state_callbacks(&self) -> anyhow::Result<Vec<(ActorId, ComponentStateCallbacks)>> {
1706        self.actor_ids
1707            .iter()
1708            .map(|actor_id| {
1709                self.actor_state_callbacks
1710                    .get(actor_id)
1711                    .copied()
1712                    .map(|callbacks| (*actor_id, callbacks))
1713                    .ok_or_else(|| anyhow::anyhow!("Actor {actor_id} state callback not found"))
1714            })
1715            .collect()
1716    }
1717
1718    fn strategy_state_callbacks(
1719        &self,
1720    ) -> anyhow::Result<Vec<(StrategyId, ComponentStateCallbacks)>> {
1721        self.strategy_ids
1722            .iter()
1723            .map(|strategy_id| {
1724                self.strategy_state_callbacks
1725                    .get(strategy_id)
1726                    .copied()
1727                    .map(|callbacks| (*strategy_id, callbacks))
1728                    .ok_or_else(|| {
1729                        anyhow::anyhow!("Strategy {strategy_id} state callback not found")
1730                    })
1731            })
1732            .collect()
1733    }
1734
1735    fn load_component_state<T>(
1736        component_id: Ustr,
1737        state: PersistedComponentState,
1738    ) -> anyhow::Result<()>
1739    where
1740        T: DataActor + DataActorNative + Debug + 'static,
1741    {
1742        let mut component = try_get_actor_unchecked::<T>(&component_id).ok_or_else(|| {
1743            anyhow::anyhow!("Component {component_id} not found in actor registry")
1744        })?;
1745        component.on_load(state)
1746    }
1747
1748    fn save_component_state<T>(component_id: Ustr) -> anyhow::Result<PersistedComponentState>
1749    where
1750        T: DataActor + DataActorNative + Debug + 'static,
1751    {
1752        let component = try_get_actor_unchecked::<T>(&component_id).ok_or_else(|| {
1753            anyhow::anyhow!("Component {component_id} not found in actor registry")
1754        })?;
1755        component.on_save()
1756    }
1757
1758    /// Initializes the trader, transitioning from `PreInitialized` to `Ready` state.
1759    ///
1760    /// This method must be called before starting the trader.
1761    ///
1762    /// # Errors
1763    ///
1764    /// Returns an error if the trader cannot be initialized from its current state.
1765    pub fn initialize(&mut self) -> anyhow::Result<()> {
1766        let new_state = self.state.transition(&ComponentTrigger::Initialize)?;
1767        self.state = new_state;
1768
1769        Ok(())
1770    }
1771
1772    fn on_start(&mut self) -> anyhow::Result<()> {
1773        self.start_components()?;
1774
1775        // Transition to running state
1776        let clock = self.clock_factory.clock();
1777        self.ts_started = Some(clock.borrow().timestamp_ns());
1778
1779        Ok(())
1780    }
1781
1782    fn on_reset(&mut self) -> anyhow::Result<()> {
1783        self.reset_components()?;
1784
1785        self.ts_started = None;
1786        self.ts_stopped = None;
1787
1788        Ok(())
1789    }
1790
1791    fn on_dispose(&mut self) -> anyhow::Result<()> {
1792        if self.is_running() {
1793            self.stop()?;
1794        }
1795
1796        self.dispose_components()?;
1797
1798        Ok(())
1799    }
1800}
1801
1802impl Component for Trader {
1803    fn component_id(&self) -> ComponentId {
1804        ComponentId::new(format!("Trader-{}", self.trader_id))
1805    }
1806
1807    fn state(&self) -> ComponentState {
1808        self.state
1809    }
1810
1811    fn transition_state(&mut self, trigger: ComponentTrigger) -> anyhow::Result<()> {
1812        self.state = self.state.transition(&trigger)?;
1813        log::info!("{}", self.state.variant_name());
1814        Ok(())
1815    }
1816
1817    fn register(
1818        &mut self,
1819        _trader_id: TraderId,
1820        _clock: Rc<RefCell<dyn Clock>>,
1821        _cache: Rc<RefCell<Cache>>,
1822    ) -> anyhow::Result<()> {
1823        anyhow::bail!("Trader cannot register with itself")
1824    }
1825
1826    fn on_start(&mut self) -> anyhow::Result<()> {
1827        Self::on_start(self)
1828    }
1829
1830    fn stop(&mut self) -> anyhow::Result<()> {
1831        self.transition_state(ComponentTrigger::Stop)?;
1832
1833        let stop_result = self.on_stop();
1834        self.complete_stop(stop_result)
1835    }
1836
1837    fn on_stop(&mut self) -> anyhow::Result<()> {
1838        self.stop_components()
1839    }
1840
1841    fn on_reset(&mut self) -> anyhow::Result<()> {
1842        Self::on_reset(self)
1843    }
1844
1845    fn on_dispose(&mut self) -> anyhow::Result<()> {
1846        Self::on_dispose(self)
1847    }
1848}
1849
1850type ComponentClockSnapshot = Rc<[Rc<RefCell<dyn Clock>>]>;
1851
1852#[cfg(test)]
1853mod tests {
1854    use std::{
1855        cell::{Cell, RefCell},
1856        rc::Rc,
1857        sync::{
1858            Arc,
1859            atomic::{AtomicUsize, Ordering},
1860        },
1861    };
1862
1863    #[cfg(feature = "python")]
1864    use nautilus_common::{
1865        actor::data_actor::ImportableActorConfig,
1866        python::{
1867            actor::{PyDataActor, PyDataActorInner},
1868            wrappers::get_python_wrapper,
1869        },
1870    };
1871    use nautilus_common::{
1872        actor::{
1873            DataActorCore,
1874            data_actor::DataActorConfig,
1875            registry::{actor_exists, get_actor_unchecked, try_get_actor_unchecked},
1876        },
1877        cache::Cache,
1878        clock::VirtualClock,
1879        component::get_component,
1880        enums::{ComponentState, Environment},
1881        logging::{
1882            arm_shutdown_on_error, disarm_shutdown_on_error, init_logging, logger::LoggerConfig,
1883            take_shutdown_on_error_trigger, writer::FileWriterConfig,
1884        },
1885        messages::execution::SubmitOrder,
1886        msgbus,
1887        msgbus::{
1888            MessageBus, MessagingSwitchboard, TypedHandler, set_message_bus,
1889            switchboard::{
1890                get_bars_topic, get_book_deltas_topic, get_book_depth_topic, get_custom_topic,
1891                get_event_order_topic,
1892            },
1893        },
1894        nautilus_actor,
1895        runner::{
1896            SyncDataCommandSender, SyncTradingCommandSender, drain_data_cmd_queue,
1897            drain_trading_cmd_queue, replace_data_cmd_sender, replace_exec_cmd_sender,
1898            trading_cmd_queue_is_empty,
1899        },
1900        timer::TimeEventHandler,
1901    };
1902    use nautilus_core::{DurationNanos, UUID4};
1903    use nautilus_data::engine::{DataEngine, config::DataEngineConfig};
1904    use nautilus_execution::engine::{ExecutionEngine, config::ExecutionEngineConfig};
1905    use nautilus_model::{
1906        data::{Bar, BarType, DataType, stubs::stub_bar},
1907        enums::{BookType, OrderSide, OrderStatus, OrderType, PositionAdjustmentType, TimeInForce},
1908        events::{
1909            OrderAccepted, OrderDenied, OrderFilled, OrderRejected, OrderUpdated, PositionAdjusted,
1910            order::spec::{
1911                OrderAcceptedSpec, OrderFilledSpec, OrderRejectedSpec, OrderSubmittedSpec,
1912                OrderUpdatedSpec,
1913            },
1914        },
1915        identifiers::{
1916            AccountId, ActorId, ClientOrderId, ComponentId, InstrumentId, PositionId, TraderId,
1917            VenueOrderId,
1918        },
1919        instruments::{Instrument, InstrumentAny, stubs::audusd_sim},
1920        orders::{OrderAny, OrderTestBuilder},
1921        stubs::TestDefault,
1922        types::{Price, Quantity},
1923    };
1924    use nautilus_portfolio::portfolio::Portfolio;
1925    use nautilus_risk::engine::{RiskEngine, config::RiskEngineConfig};
1926    #[cfg(feature = "python")]
1927    use nautilus_testkit::cache::TestCacheDatabaseControl;
1928    #[cfg(feature = "python")]
1929    use nautilus_trading::python::strategy::{PyStrategy, PyStrategyInner};
1930    use nautilus_trading::{
1931        ExecutionAlgorithmConfig, ExecutionAlgorithmCore, StrategyNative,
1932        nautilus_execution_algorithm, nautilus_strategy,
1933        strategy::{config::StrategyConfig, core::StrategyCore},
1934    };
1935    #[cfg(feature = "python")]
1936    use pyo3::{
1937        ffi::c_str,
1938        prelude::*,
1939        types::{PyDict, PyModule},
1940    };
1941    use rstest::rstest;
1942
1943    use super::*;
1944    use crate::clock_factory::ClockFactory;
1945
1946    // Simple DataActor wrapper for testing
1947    #[derive(Debug)]
1948    struct TestDataActor {
1949        core: DataActorCore,
1950        fail_stop: bool,
1951        fail_fault: bool,
1952        fail_dispose: bool,
1953        bars_received: usize,
1954        time_events: usize,
1955    }
1956
1957    impl TestDataActor {
1958        fn new(config: DataActorConfig) -> Self {
1959            Self {
1960                core: DataActorCore::new(config),
1961                fail_stop: false,
1962                fail_fault: false,
1963                fail_dispose: false,
1964                bars_received: 0,
1965                time_events: 0,
1966            }
1967        }
1968    }
1969
1970    impl DataActor for TestDataActor {
1971        fn on_time_event(&mut self, _event: &TimeEvent) -> anyhow::Result<()> {
1972            self.time_events += 1;
1973            Ok(())
1974        }
1975
1976        fn on_stop(&mut self) -> anyhow::Result<()> {
1977            if self.fail_stop {
1978                anyhow::bail!("test actor stop failure");
1979            }
1980            Ok(())
1981        }
1982
1983        fn on_dispose(&mut self) -> anyhow::Result<()> {
1984            if self.fail_dispose {
1985                anyhow::bail!("test actor dispose failure");
1986            }
1987            Ok(())
1988        }
1989
1990        fn on_fault(&mut self) -> anyhow::Result<()> {
1991            if self.fail_fault {
1992                anyhow::bail!("test actor fault failure");
1993            }
1994            Ok(())
1995        }
1996
1997        fn on_bar(&mut self, _bar: &Bar) -> anyhow::Result<()> {
1998            self.bars_received += 1;
1999            Ok(())
2000        }
2001    }
2002
2003    nautilus_actor!(TestDataActor);
2004
2005    // Simple ExecutionAlgorithm wrapper for testing
2006    #[derive(Debug)]
2007    struct TestExecutionAlgorithm {
2008        core: ExecutionAlgorithmCore,
2009        fail_start: bool,
2010        fail_stop: bool,
2011        submit_on_accept: Option<OrderAny>,
2012        accepted_events: usize,
2013        denied_events: usize,
2014        rejected_events: usize,
2015        updated_events: usize,
2016        filled_events: usize,
2017        position_events: usize,
2018    }
2019
2020    impl TestExecutionAlgorithm {
2021        fn new(config: ExecutionAlgorithmConfig) -> Self {
2022            Self {
2023                core: ExecutionAlgorithmCore::new(config),
2024                fail_start: false,
2025                fail_stop: false,
2026                submit_on_accept: None,
2027                accepted_events: 0,
2028                denied_events: 0,
2029                rejected_events: 0,
2030                updated_events: 0,
2031                filled_events: 0,
2032                position_events: 0,
2033            }
2034        }
2035    }
2036
2037    impl DataActor for TestExecutionAlgorithm {
2038        fn on_start(&mut self) -> anyhow::Result<()> {
2039            if self.fail_start {
2040                anyhow::bail!("test execution algorithm start failure");
2041            }
2042            Ok(())
2043        }
2044
2045        fn on_stop(&mut self) -> anyhow::Result<()> {
2046            if self.fail_stop {
2047                anyhow::bail!("test execution algorithm stop failure");
2048            }
2049
2050            Ok(())
2051        }
2052    }
2053
2054    nautilus_execution_algorithm!(TestExecutionAlgorithm, {
2055        fn on_order(&mut self, _order: OrderAny) -> anyhow::Result<()> {
2056            Ok(())
2057        }
2058
2059        fn on_order_rejected(&mut self, _event: OrderRejected) {
2060            self.rejected_events += 1;
2061        }
2062
2063        fn on_order_accepted(&mut self, _event: OrderAccepted) {
2064            self.accepted_events += 1;
2065
2066            if let Some(order) = self.submit_on_accept.take() {
2067                self.submit_order(order, None, None).unwrap();
2068            }
2069        }
2070
2071        fn on_order_denied(&mut self, _event: OrderDenied) {
2072            self.denied_events += 1;
2073        }
2074
2075        fn on_order_updated(&mut self, _event: OrderUpdated) {
2076            self.updated_events += 1;
2077        }
2078
2079        fn on_algo_order_filled(&mut self, _event: OrderFilled) {
2080            self.filled_events += 1;
2081        }
2082
2083        fn on_position_event(&mut self, _event: PositionEvent) {
2084            self.position_events += 1;
2085        }
2086    });
2087
2088    fn add_cached_exec_order(
2089        cache: &Rc<RefCell<Cache>>,
2090        client_order_id: ClientOrderId,
2091        strategy_id: StrategyId,
2092        exec_algorithm_id: Option<ExecAlgorithmId>,
2093        is_terminal: bool,
2094    ) -> OrderAny {
2095        let mut builder = OrderTestBuilder::new(OrderType::Market);
2096        builder
2097            .client_order_id(client_order_id)
2098            .strategy_id(strategy_id)
2099            .instrument_id(InstrumentId::test_default())
2100            .quantity(Quantity::from(1));
2101
2102        if let Some(exec_algorithm_id) = exec_algorithm_id {
2103            builder
2104                .exec_algorithm_id(exec_algorithm_id)
2105                .exec_spawn_id(client_order_id);
2106        }
2107
2108        let order = builder.build();
2109        cache
2110            .borrow_mut()
2111            .add_order(order.clone(), None, None, false)
2112            .unwrap();
2113
2114        if is_terminal {
2115            let event = OrderEventAny::Rejected(
2116                OrderRejectedSpec::builder()
2117                    .trader_id(order.trader_id())
2118                    .strategy_id(order.strategy_id())
2119                    .instrument_id(order.instrument_id())
2120                    .client_order_id(order.client_order_id())
2121                    .account_id(AccountId::test_default())
2122                    .reason("TEST_TERMINAL".into())
2123                    .build(),
2124            );
2125            cache.borrow_mut().update_order(&event).unwrap();
2126        }
2127
2128        order
2129    }
2130
2131    // Simple Strategy wrapper for testing
2132    #[derive(Debug)]
2133    struct TestStrategy {
2134        core: StrategyCore,
2135        fail_stop: bool,
2136    }
2137
2138    impl TestStrategy {
2139        fn new(config: StrategyConfig) -> Self {
2140            Self {
2141                core: StrategyCore::new(config),
2142                fail_stop: false,
2143            }
2144        }
2145    }
2146
2147    impl DataActor for TestStrategy {
2148        fn on_stop(&mut self) -> anyhow::Result<()> {
2149            if self.fail_stop {
2150                anyhow::bail!("test strategy stop failure");
2151            }
2152            Ok(())
2153        }
2154    }
2155
2156    nautilus_strategy!(TestStrategy);
2157
2158    #[derive(Debug)]
2159    struct TimerRoutingStrategy {
2160        core: StrategyCore,
2161        time_events: usize,
2162        strategy_time_events: usize,
2163        post_market_exits: usize,
2164        post_market_exits_on_callback: Option<usize>,
2165        gtd_timer_active_on_callback: Option<bool>,
2166    }
2167
2168    impl TimerRoutingStrategy {
2169        fn new(config: StrategyConfig) -> Self {
2170            Self {
2171                core: StrategyCore::new(config),
2172                time_events: 0,
2173                strategy_time_events: 0,
2174                post_market_exits: 0,
2175                post_market_exits_on_callback: None,
2176                gtd_timer_active_on_callback: None,
2177            }
2178        }
2179    }
2180
2181    impl DataActor for TimerRoutingStrategy {
2182        fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
2183            self.time_events += 1;
2184
2185            if event.name.starts_with("MARKET_EXIT_CHECK:") {
2186                self.post_market_exits_on_callback = Some(self.post_market_exits);
2187            }
2188
2189            if let Some(client_order_id) = event.name.strip_prefix("GTD-EXPIRY:") {
2190                self.gtd_timer_active_on_callback =
2191                    Some(self.has_gtd_expiry_timer(&ClientOrderId::from(client_order_id)));
2192            }
2193
2194            Ok(())
2195        }
2196    }
2197
2198    nautilus_strategy!(TimerRoutingStrategy, {
2199        fn on_time_event(&mut self, _event: &TimeEvent) -> anyhow::Result<()> {
2200            self.strategy_time_events += 1;
2201            Ok(())
2202        }
2203
2204        fn post_market_exit(&mut self) {
2205            self.post_market_exits += 1;
2206        }
2207    });
2208
2209    #[expect(clippy::type_complexity)]
2210    fn create_trader_components() -> (
2211        Rc<RefCell<MessageBus>>,
2212        Rc<RefCell<Cache>>,
2213        Rc<RefCell<Portfolio>>,
2214        Rc<RefCell<DataEngine>>,
2215        Rc<RefCell<RiskEngine>>,
2216        Rc<RefCell<ExecutionEngine>>,
2217        ClockFactory,
2218    ) {
2219        let trader_id = TraderId::test_default();
2220        let instance_id = UUID4::new();
2221        let clock_factory = ClockFactory::test_default();
2222        let clock = clock_factory.clock();
2223        let mut clock_ref = clock.borrow_mut();
2224        let test_clock = clock_ref
2225            .as_any_mut()
2226            .downcast_mut::<VirtualClock>()
2227            .expect("test default clock must be VirtualClock");
2228        test_clock.set_time(1_000_000_000u64.into());
2229        drop(clock_ref);
2230        let msgbus = Rc::new(RefCell::new(MessageBus::new(
2231            trader_id,
2232            instance_id,
2233            Some("test".to_string()),
2234            None,
2235        )));
2236        let cache = Rc::new(RefCell::new(Cache::new(None, None)));
2237        let portfolio = Rc::new(RefCell::new(Portfolio::new(
2238            clock.clone(),
2239            cache.clone(),
2240            None,
2241        )));
2242        let data_engine = Rc::new(RefCell::new(DataEngine::new(
2243            clock.clone(),
2244            cache.clone(),
2245            Some(DataEngineConfig::default()),
2246        )));
2247
2248        // Create separate cache and clock instances for RiskEngine to avoid borrowing conflicts
2249        let risk_cache = Rc::new(RefCell::new(Cache::new(None, None)));
2250        let risk_clock = Rc::new(RefCell::new(VirtualClock::new()));
2251        let risk_portfolio = Portfolio::new(
2252            risk_clock.clone() as Rc<RefCell<dyn Clock>>,
2253            risk_cache.clone(),
2254            None,
2255        );
2256        let risk_engine = Rc::new(RefCell::new(RiskEngine::new(
2257            RiskEngineConfig::default(),
2258            risk_portfolio,
2259            risk_clock as Rc<RefCell<dyn Clock>>,
2260            risk_cache,
2261        )));
2262        let exec_engine = Rc::new(RefCell::new(ExecutionEngine::new(
2263            clock.clone(),
2264            cache.clone(),
2265            Some(ExecutionEngineConfig::default()),
2266        )));
2267
2268        (
2269            msgbus,
2270            cache,
2271            portfolio,
2272            data_engine,
2273            risk_engine,
2274            exec_engine,
2275            clock_factory,
2276        )
2277    }
2278
2279    #[rstest]
2280    fn test_trader_creation() {
2281        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2282            create_trader_components();
2283        let trader_id = TraderId::test_default();
2284        let instance_id = UUID4::new();
2285
2286        let trader = Trader::new(
2287            trader_id,
2288            instance_id,
2289            Environment::Backtest,
2290            clock_factory,
2291            cache,
2292            portfolio,
2293        );
2294
2295        assert_eq!(trader.trader_id(), trader_id);
2296        assert_eq!(trader.instance_id(), instance_id);
2297        assert_eq!(trader.environment(), Environment::Backtest);
2298        assert_eq!(trader.state(), ComponentState::PreInitialized);
2299        assert_eq!(trader.actor_count(), 0);
2300        assert_eq!(trader.strategy_count(), 0);
2301        assert_eq!(trader.exec_algorithm_count(), 0);
2302        assert_eq!(trader.component_count(), 0);
2303        assert!(!trader.is_running());
2304        assert!(!trader.is_stopped());
2305        assert!(!trader.is_disposed());
2306        assert!(trader.ts_created() > 0);
2307        assert!(trader.ts_started().is_none());
2308        assert!(trader.ts_stopped().is_none());
2309    }
2310
2311    #[rstest]
2312    fn test_trader_component_id() {
2313        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2314            create_trader_components();
2315        let trader_id = TraderId::from("TRADER-001");
2316        let instance_id = UUID4::new();
2317
2318        let trader = Trader::new(
2319            trader_id,
2320            instance_id,
2321            Environment::Backtest,
2322            clock_factory,
2323            cache,
2324            portfolio,
2325        );
2326
2327        assert_eq!(
2328            trader.component_id(),
2329            ComponentId::from("Trader-TRADER-001")
2330        );
2331    }
2332
2333    #[rstest]
2334    fn test_add_actor_success() {
2335        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2336            create_trader_components();
2337        let trader_id = TraderId::test_default();
2338        let instance_id = UUID4::new();
2339
2340        let mut trader = Trader::new(
2341            trader_id,
2342            instance_id,
2343            Environment::Backtest,
2344            clock_factory,
2345            cache,
2346            portfolio,
2347        );
2348
2349        let actor = TestDataActor::new(DataActorConfig::default());
2350        let actor_id = actor.actor_id();
2351
2352        let result = trader.add_actor(actor);
2353        assert!(result.is_ok());
2354        assert_eq!(trader.actor_count(), 1);
2355        assert_eq!(trader.component_count(), 1);
2356        assert!(trader.actor_ids().contains(&actor_id));
2357    }
2358
2359    #[rstest]
2360    fn test_add_duplicate_actor_fails() {
2361        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2362            create_trader_components();
2363        let trader_id = TraderId::test_default();
2364        let instance_id = UUID4::new();
2365
2366        let mut trader = Trader::new(
2367            trader_id,
2368            instance_id,
2369            Environment::Backtest,
2370            clock_factory,
2371            cache,
2372            portfolio,
2373        );
2374
2375        let config = DataActorConfig {
2376            actor_id: Some(ActorId::from("TestActor")),
2377            ..Default::default()
2378        };
2379        let actor1 = TestDataActor::new(config.clone());
2380        let actor2 = TestDataActor::new(config);
2381
2382        // First addition should succeed
2383        assert!(trader.add_actor(actor1).is_ok());
2384        assert_eq!(trader.actor_count(), 1);
2385
2386        // Second addition should fail
2387        let result = trader.add_actor(actor2);
2388        assert!(result.is_err());
2389        assert!(
2390            result
2391                .unwrap_err()
2392                .to_string()
2393                .contains("already registered")
2394        );
2395        assert_eq!(trader.actor_count(), 1);
2396    }
2397
2398    #[rstest]
2399    fn test_add_strategy_success() {
2400        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2401            create_trader_components();
2402        let trader_id = TraderId::test_default();
2403        let instance_id = UUID4::new();
2404
2405        let mut trader = Trader::new(
2406            trader_id,
2407            instance_id,
2408            Environment::Backtest,
2409            clock_factory,
2410            cache,
2411            portfolio,
2412        );
2413
2414        let config = StrategyConfig {
2415            strategy_id: Some(StrategyId::from("Test-Strategy")),
2416            ..Default::default()
2417        };
2418        let strategy = TestStrategy::new(config);
2419
2420        let result = trader.add_strategy(strategy);
2421        assert!(result.is_ok());
2422        assert_eq!(trader.strategy_count(), 1);
2423        assert_eq!(trader.component_count(), 1);
2424        assert!(
2425            trader
2426                .strategy_ids()
2427                .contains(&StrategyId::from("Test-Strategy"))
2428        );
2429    }
2430
2431    #[rstest]
2432    fn test_add_strategy_rejects_order_id_tag_with_separator() {
2433        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2434            create_trader_components();
2435        let trader_id = TraderId::test_default();
2436        let instance_id = UUID4::new();
2437
2438        let mut trader = Trader::new(
2439            trader_id,
2440            instance_id,
2441            Environment::Backtest,
2442            clock_factory,
2443            cache,
2444            portfolio,
2445        );
2446
2447        let config = StrategyConfig {
2448            strategy_id: Some(StrategyId::from("HyphenTagStrategy-001")),
2449            order_id_tag: Some("001".to_string()),
2450            ..Default::default()
2451        };
2452        let mut strategy = TestStrategy::new(config);
2453        StrategyNative::strategy_core_mut(&mut strategy)
2454            .config
2455            .order_id_tag = Some("A-B".to_string());
2456
2457        let error = trader.add_strategy(strategy).unwrap_err();
2458
2459        assert_eq!(
2460            error.to_string(),
2461            "`order_id_tag` cannot contain the '-' strategy ID separator, was 'A-B'"
2462        );
2463        assert_eq!(trader.strategy_count(), 0);
2464        assert_eq!(trader.component_count(), 0);
2465    }
2466
2467    #[rstest]
2468    fn test_add_strategy_rejects_non_ascii_order_id_tag() {
2469        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2470            create_trader_components();
2471        let trader_id = TraderId::test_default();
2472        let instance_id = UUID4::new();
2473
2474        let mut trader = Trader::new(
2475            trader_id,
2476            instance_id,
2477            Environment::Backtest,
2478            clock_factory,
2479            cache,
2480            portfolio,
2481        );
2482
2483        let config = StrategyConfig {
2484            order_id_tag: Some("T01€".to_string()),
2485            ..Default::default()
2486        };
2487        let strategy = TestStrategy::new(config);
2488
2489        let error = trader.add_strategy(strategy).unwrap_err();
2490
2491        assert_eq!(
2492            error.to_string(),
2493            "invalid string for 'value' contained a non-ASCII char, was 'TestStrategy-T01€'"
2494        );
2495        assert_eq!(trader.strategy_count(), 0);
2496        assert_eq!(trader.component_count(), 0);
2497    }
2498
2499    #[rstest]
2500    fn test_add_strategy_preserves_explicit_instrument_strategy_id() {
2501        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2502            create_trader_components();
2503        let trader_id = TraderId::test_default();
2504        let instance_id = UUID4::new();
2505
2506        let mut trader = Trader::new(
2507            trader_id,
2508            instance_id,
2509            Environment::Backtest,
2510            clock_factory,
2511            cache,
2512            portfolio,
2513        );
2514
2515        let strategy_id = StrategyId::from("ExampleStrategy-XNAS");
2516        let config = StrategyConfig {
2517            strategy_id: Some(strategy_id),
2518            ..Default::default()
2519        };
2520        let strategy = TestStrategy::new(config);
2521
2522        trader.add_strategy(strategy).unwrap();
2523
2524        let mut registered = get_actor_unchecked::<TestStrategy>(&strategy_id.inner());
2525        let (client_order_id, order_list_id) = {
2526            let mut order_factory = registered.order_factory();
2527            (
2528                order_factory.generate_client_order_id(),
2529                order_factory.generate_order_list_id(),
2530            )
2531        };
2532
2533        assert_eq!(trader.strategy_ids(), vec![strategy_id]);
2534        assert_eq!(registered.strategy_id(), Some(strategy_id));
2535        assert!(client_order_id.as_str().ends_with("-001-XNAS-1"));
2536        assert!(order_list_id.as_str().ends_with("-001-XNAS-1"));
2537    }
2538
2539    #[rstest]
2540    fn test_add_strategy_appends_configured_order_id_tag_to_explicit_strategy_id() {
2541        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2542            create_trader_components();
2543        let trader_id = TraderId::test_default();
2544        let instance_id = UUID4::new();
2545
2546        let mut trader = Trader::new(
2547            trader_id,
2548            instance_id,
2549            Environment::Backtest,
2550            clock_factory,
2551            cache,
2552            portfolio,
2553        );
2554
2555        let strategy_id = StrategyId::from("ExampleStrategy-XNAS");
2556        let runtime_strategy_id = StrategyId::from("ExampleStrategy-XNAS-T01");
2557        let config = StrategyConfig {
2558            strategy_id: Some(strategy_id),
2559            order_id_tag: Some("T01".to_string()),
2560            ..Default::default()
2561        };
2562        let strategy = TestStrategy::new(config);
2563
2564        trader.add_strategy(strategy).unwrap();
2565
2566        assert!(try_get_actor_unchecked::<TestStrategy>(&strategy_id.inner()).is_none());
2567
2568        let mut registered = get_actor_unchecked::<TestStrategy>(&runtime_strategy_id.inner());
2569        let (client_order_id, order_list_id) = {
2570            let mut order_factory = registered.order_factory();
2571            (
2572                order_factory.generate_client_order_id(),
2573                order_factory.generate_order_list_id(),
2574            )
2575        };
2576
2577        assert_eq!(trader.strategy_ids(), vec![runtime_strategy_id]);
2578        assert_eq!(registered.strategy_id(), Some(runtime_strategy_id));
2579        assert!(client_order_id.as_str().ends_with("-001-T01-1"));
2580        assert!(order_list_id.as_str().ends_with("-001-T01-1"));
2581    }
2582
2583    #[rstest]
2584    fn test_add_strategies_with_no_order_id_tags_assigns_unique_tags() {
2585        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2586            create_trader_components();
2587        let trader_id = TraderId::test_default();
2588        let instance_id = UUID4::new();
2589
2590        let mut trader = Trader::new(
2591            trader_id,
2592            instance_id,
2593            Environment::Backtest,
2594            clock_factory,
2595            cache,
2596            portfolio,
2597        );
2598
2599        let strategy1 = TestStrategy::new(StrategyConfig::default());
2600        let strategy2 = TestStrategy::new(StrategyConfig::default());
2601
2602        assert!(trader.add_strategy(strategy1).is_ok());
2603        assert!(trader.add_strategy(strategy2).is_ok());
2604        assert_eq!(
2605            trader.strategy_ids(),
2606            vec![
2607                StrategyId::from("TestStrategy-000"),
2608                StrategyId::from("TestStrategy-001")
2609            ]
2610        );
2611    }
2612
2613    #[rstest]
2614    fn test_automatic_strategy_tag_skips_existing_tags(#[values(false, true)] remove_first: bool) {
2615        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2616            create_trader_components();
2617
2618        let mut trader = Trader::new(
2619            TraderId::test_default(),
2620            UUID4::new(),
2621            Environment::Backtest,
2622            clock_factory,
2623            cache,
2624            portfolio,
2625        );
2626
2627        if remove_first {
2628            trader
2629                .add_strategy(TestStrategy::new(StrategyConfig::default()))
2630                .unwrap();
2631        }
2632
2633        trader
2634            .add_strategy(TestStrategy::new(StrategyConfig {
2635                strategy_id: Some(StrategyId::from("TestStrategy-001")),
2636                ..Default::default()
2637            }))
2638            .unwrap();
2639
2640        if remove_first {
2641            trader
2642                .remove_strategy(&StrategyId::from("TestStrategy-000"))
2643                .unwrap();
2644        }
2645
2646        trader
2647            .add_strategy(TestStrategy::new(StrategyConfig::default()))
2648            .unwrap();
2649
2650        assert_eq!(
2651            trader.strategy_ids(),
2652            vec![
2653                StrategyId::from("TestStrategy-001"),
2654                StrategyId::from("TestStrategy-002"),
2655            ]
2656        );
2657    }
2658
2659    #[rstest]
2660    #[case("actor", "strategy")]
2661    #[case("actor", "algorithm")]
2662    #[case("strategy", "actor")]
2663    #[case("strategy", "algorithm")]
2664    #[case("algorithm", "actor")]
2665    #[case("algorithm", "strategy")]
2666    fn test_native_registration_preserves_colliding_component(
2667        #[case] first_kind: &str,
2668        #[case] second_kind: &str,
2669    ) {
2670        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2671            create_trader_components();
2672
2673        let mut trader = Trader::new(
2674            TraderId::test_default(),
2675            UUID4::new(),
2676            Environment::Backtest,
2677            clock_factory,
2678            cache,
2679            portfolio,
2680        );
2681
2682        let id = Ustr::from("Collision-001");
2683
2684        let mut add = |kind| match kind {
2685            "actor" => trader.add_actor(TestDataActor::new(DataActorConfig {
2686                actor_id: Some(ActorId::new(id)),
2687                ..Default::default()
2688            })),
2689            "strategy" => trader.add_strategy(TestStrategy::new(StrategyConfig {
2690                strategy_id: Some(StrategyId::new(id)),
2691                ..Default::default()
2692            })),
2693            "algorithm" => {
2694                trader.add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
2695                    exec_algorithm_id: Some(ExecAlgorithmId::new(id)),
2696                    ..Default::default()
2697                }))
2698            }
2699            _ => unreachable!(),
2700        };
2701
2702        add(first_kind).unwrap();
2703        let component = get_component(&id).unwrap();
2704        let clock = match first_kind {
2705            "actor" => get_actor_unchecked::<TestDataActor>(&id).clock_rc(),
2706            "strategy" => get_actor_unchecked::<TestStrategy>(&id).clock_rc(),
2707            "algorithm" => get_actor_unchecked::<TestExecutionAlgorithm>(&id).clock_rc(),
2708            _ => unreachable!(),
2709        };
2710
2711        let error = add(second_kind).unwrap_err();
2712
2713        assert_eq!(
2714            error.to_string(),
2715            format!(
2716                "Component {id} is already registered with trader {}",
2717                trader.trader_id()
2718            )
2719        );
2720        assert!(Rc::ptr_eq(&component, &get_component(&id).unwrap()));
2721        let clocks = trader.get_component_clocks();
2722        assert_eq!(clocks.len(), 1);
2723        assert!(Rc::ptr_eq(&clock, &clocks[0]));
2724        assert_eq!(trader.actor_count(), usize::from(first_kind == "actor"));
2725        assert_eq!(
2726            trader.strategy_count(),
2727            usize::from(first_kind == "strategy")
2728        );
2729        assert_eq!(
2730            trader.exec_algorithm_count(),
2731            usize::from(first_kind == "algorithm")
2732        );
2733    }
2734
2735    #[rstest]
2736    #[case::actor("actor", false)]
2737    #[case::strategy_initialized("strategy", false)]
2738    #[case::strategy_registered("strategy", true)]
2739    #[case::algorithm("algorithm", false)]
2740    fn test_failed_native_registration_keeps_id_reusable(
2741        #[case] kind: &str,
2742        #[case] registered: bool,
2743    ) {
2744        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2745            create_trader_components();
2746
2747        let mut trader = Trader::new(
2748            TraderId::test_default(),
2749            UUID4::new(),
2750            Environment::Backtest,
2751            clock_factory,
2752            cache,
2753            portfolio,
2754        );
2755
2756        let id = Ustr::from("Retry-001");
2757
2758        let add = |trader: &mut Trader, initialize: bool| match kind {
2759            "actor" => {
2760                let mut actor = TestDataActor::new(DataActorConfig {
2761                    actor_id: Some(ActorId::new(id)),
2762                    ..Default::default()
2763                });
2764
2765                if initialize {
2766                    actor.initialize().unwrap();
2767                }
2768
2769                trader.add_actor(actor)
2770            }
2771            "strategy" => {
2772                let mut strategy = TestStrategy::new(StrategyConfig {
2773                    strategy_id: Some(StrategyId::new(id)),
2774                    ..Default::default()
2775                });
2776
2777                if initialize && registered {
2778                    let clock = trader.clock_factory.create_component_clock();
2779                    StrategyNative::strategy_core_mut(&mut strategy)
2780                        .register(
2781                            trader.trader_id(),
2782                            clock,
2783                            trader.cache.clone(),
2784                            trader.portfolio.clone(),
2785                        )
2786                        .unwrap();
2787                } else if initialize {
2788                    strategy.initialize().unwrap();
2789                }
2790
2791                trader.add_strategy(strategy)
2792            }
2793            "algorithm" => {
2794                let mut algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
2795                    exec_algorithm_id: Some(ExecAlgorithmId::new(id)),
2796                    ..Default::default()
2797                });
2798
2799                if initialize {
2800                    algorithm.initialize().unwrap();
2801                }
2802
2803                trader.add_exec_algorithm(algorithm)
2804            }
2805            _ => unreachable!(),
2806        };
2807
2808        let error = add(&mut trader, true).unwrap_err();
2809
2810        let expected_error = if registered {
2811            format!(
2812                "DataActor {id} already registered with trader {}",
2813                trader.trader_id()
2814            )
2815        } else {
2816            format!(
2817                "Invalid state trigger {} -> {}",
2818                ComponentState::Ready,
2819                ComponentTrigger::Initialize,
2820            )
2821        };
2822
2823        assert_eq!(error.to_string(), expected_error);
2824        assert!(trader.get_component_clocks().is_empty());
2825
2826        add(&mut trader, false).unwrap();
2827
2828        assert_eq!(trader.get_component_clocks().len(), 1);
2829        assert_eq!(component_state(&id).unwrap(), ComponentState::Ready);
2830        assert_eq!(trader.actor_count(), usize::from(kind == "actor"));
2831        assert_eq!(trader.strategy_count(), usize::from(kind == "strategy"));
2832        assert_eq!(
2833            trader.exec_algorithm_count(),
2834            usize::from(kind == "algorithm")
2835        );
2836    }
2837
2838    #[rstest]
2839    fn test_native_collision_preserves_externally_registered_actor() {
2840        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2841            create_trader_components();
2842        let trader_id = TraderId::test_default();
2843        let clock = clock_factory.create_component_clock();
2844
2845        let mut actor = TestDataActor::new(DataActorConfig {
2846            actor_id: Some(ActorId::from("External-001")),
2847            ..Default::default()
2848        });
2849
2850        actor
2851            .register(trader_id, clock.clone(), cache.clone())
2852            .unwrap();
2853        register_component_actor(actor);
2854
2855        let mut trader = Trader::new(
2856            trader_id,
2857            UUID4::new(),
2858            Environment::Backtest,
2859            clock_factory,
2860            cache,
2861            portfolio,
2862        );
2863
2864        let actor_id = ActorId::from("External-001");
2865        trader
2866            .add_actor_id_for_lifecycle::<TestDataActor>(actor_id)
2867            .unwrap();
2868        let component = get_component(&actor_id.inner()).unwrap();
2869
2870        let error = trader
2871            .add_strategy(TestStrategy::new(StrategyConfig {
2872                strategy_id: Some(StrategyId::from("External-001")),
2873                ..Default::default()
2874            }))
2875            .unwrap_err();
2876
2877        assert_eq!(
2878            error.to_string(),
2879            format!("Component {actor_id} is already registered with trader {trader_id}")
2880        );
2881        assert!(Rc::ptr_eq(
2882            &component,
2883            &get_component(&actor_id.inner()).unwrap()
2884        ));
2885        assert!(Rc::ptr_eq(
2886            &clock,
2887            &get_actor_unchecked::<TestDataActor>(&actor_id.inner()).clock_rc(),
2888        ));
2889        assert_eq!(trader.actor_ids(), vec![actor_id]);
2890        assert!(trader.strategy_ids().is_empty());
2891        assert!(trader.get_component_clocks().is_empty());
2892    }
2893
2894    #[rstest]
2895    fn test_prepare_strategy_for_registration_is_idempotent() {
2896        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2897            create_trader_components();
2898        let trader_id = TraderId::test_default();
2899        let instance_id = UUID4::new();
2900
2901        let mut trader = Trader::new(
2902            trader_id,
2903            instance_id,
2904            Environment::Backtest,
2905            clock_factory,
2906            cache,
2907            portfolio,
2908        );
2909
2910        let mut strategy = TestStrategy::new(StrategyConfig::default());
2911
2912        let prepared_id = trader
2913            .prepare_strategy_for_registration(&mut strategy)
2914            .unwrap();
2915        assert_eq!(prepared_id, StrategyId::from("TestStrategy-000"));
2916        let core = StrategyNative::strategy_core(&strategy);
2917        assert_eq!(core.config.strategy_id, None);
2918        assert_eq!(core.config.order_id_tag, None);
2919        assert_eq!(core.strategy_id(), Some(prepared_id));
2920        assert_eq!(core.order_id_tag(), Some("000"));
2921
2922        assert!(trader.add_strategy(strategy).is_ok());
2923        assert_eq!(trader.strategy_ids(), vec![prepared_id]);
2924    }
2925
2926    #[rstest]
2927    fn test_add_strategy_with_duplicate_order_id_tag_fails() {
2928        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2929            create_trader_components();
2930        let trader_id = TraderId::test_default();
2931        let instance_id = UUID4::new();
2932
2933        let mut trader = Trader::new(
2934            trader_id,
2935            instance_id,
2936            Environment::Backtest,
2937            clock_factory,
2938            cache,
2939            portfolio,
2940        );
2941
2942        let config = StrategyConfig {
2943            order_id_tag: Some("001".to_string()),
2944            ..Default::default()
2945        };
2946
2947        let strategy1 = TestStrategy::new(config.clone());
2948        let strategy2 = TestStrategy::new(config);
2949
2950        assert!(trader.add_strategy(strategy1).is_ok());
2951        assert_eq!(
2952            trader.strategy_ids(),
2953            vec![StrategyId::from("TestStrategy-001")]
2954        );
2955
2956        let result = trader.add_strategy(strategy2);
2957
2958        assert!(result.is_err());
2959        assert!(
2960            result
2961                .unwrap_err()
2962                .to_string()
2963                .contains("order_id_tag conflict")
2964        );
2965    }
2966
2967    #[rstest]
2968    fn test_add_strategy_id_with_subscriptions_duplicate_order_id_tag_fails() {
2969        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2970            create_trader_components();
2971        let trader_id = TraderId::test_default();
2972        let instance_id = UUID4::new();
2973
2974        let mut trader = Trader::new(
2975            trader_id,
2976            instance_id,
2977            Environment::Backtest,
2978            clock_factory,
2979            cache,
2980            portfolio,
2981        );
2982
2983        assert!(
2984            trader
2985                .add_strategy_id_with_subscriptions::<TestStrategy>(StrategyId::from("Foo-001"))
2986                .is_ok()
2987        );
2988
2989        let result =
2990            trader.add_strategy_id_with_subscriptions::<TestStrategy>(StrategyId::from("Bar-001"));
2991
2992        assert!(result.is_err());
2993        assert!(
2994            result
2995                .unwrap_err()
2996                .to_string()
2997                .contains("order_id_tag conflict")
2998        );
2999        assert_eq!(trader.strategy_ids(), vec![StrategyId::from("Foo-001")]);
3000    }
3001
3002    #[rstest]
3003    fn test_add_strategy_with_mismatched_strategy_id_and_order_id_tag_appends_tag() {
3004        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3005            create_trader_components();
3006        let trader_id = TraderId::test_default();
3007        let instance_id = UUID4::new();
3008
3009        let mut trader = Trader::new(
3010            trader_id,
3011            instance_id,
3012            Environment::Backtest,
3013            clock_factory,
3014            cache,
3015            portfolio,
3016        );
3017
3018        let config = StrategyConfig {
3019            strategy_id: Some(StrategyId::from("TestStrategy-001")),
3020            order_id_tag: Some("002".to_string()),
3021            ..Default::default()
3022        };
3023        let strategy = TestStrategy::new(config);
3024
3025        assert!(trader.add_strategy(strategy).is_ok());
3026        assert_eq!(
3027            trader.strategy_ids(),
3028            vec![StrategyId::from("TestStrategy-001-002")]
3029        );
3030    }
3031
3032    #[rstest]
3033    fn test_add_exec_algorithm_success() {
3034        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3035            create_trader_components();
3036        let trader_id = TraderId::test_default();
3037        let instance_id = UUID4::new();
3038
3039        let mut trader = Trader::new(
3040            trader_id,
3041            instance_id,
3042            Environment::Backtest,
3043            clock_factory,
3044            cache,
3045            portfolio,
3046        );
3047
3048        let config = ExecutionAlgorithmConfig {
3049            exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3050            ..Default::default()
3051        };
3052        let exec_algorithm = TestExecutionAlgorithm::new(config);
3053        let exec_algorithm_id = exec_algorithm.id();
3054
3055        let result = trader.add_exec_algorithm(exec_algorithm);
3056        assert!(result.is_ok());
3057        assert_eq!(trader.exec_algorithm_count(), 1);
3058        assert_eq!(trader.component_count(), 1);
3059        assert!(trader.exec_algorithm_ids().contains(&exec_algorithm_id));
3060    }
3061
3062    #[rstest]
3063    fn test_exec_algorithm_submit_from_order_event_defers_risk_denial() {
3064        std::thread::spawn(|| {
3065            msgbus::get_message_bus().borrow_mut().dispose();
3066            replace_exec_cmd_sender(Arc::new(SyncTradingCommandSender));
3067
3068            let trader_id = TraderId::test_default();
3069            let instance_id = UUID4::new();
3070            let strategy_id = StrategyId::from("Callback-001");
3071            let exec_algorithm_id = ExecAlgorithmId::from("CALLBACK");
3072            let account_id = AccountId::from("SIM-001");
3073            let venue_order_id = VenueOrderId::from("V-PRIMARY-001");
3074            let parent_order_id = ClientOrderId::from("O-PRIMARY-001");
3075            let child_order_id = ClientOrderId::from("O-CHILD-001");
3076            let clock_factory = ClockFactory::test_default();
3077            let clock = clock_factory.clock();
3078            let msgbus = Rc::new(RefCell::new(MessageBus::new(
3079                trader_id,
3080                instance_id,
3081                Some("test".to_string()),
3082                None,
3083            )));
3084            set_message_bus(msgbus);
3085
3086            let cache = Rc::new(RefCell::new(Cache::default()));
3087            let instrument = InstrumentAny::CurrencyPair(audusd_sim());
3088            let instrument_id = instrument.id();
3089            cache.borrow_mut().add_instrument(instrument).unwrap();
3090            let portfolio = Rc::new(RefCell::new(Portfolio::new(
3091                clock.clone(),
3092                cache.clone(),
3093                None,
3094            )));
3095            let risk_engine = Rc::new(RefCell::new(RiskEngine::new(
3096                RiskEngineConfig::default(),
3097                portfolio.borrow().clone_shallow(),
3098                clock.clone(),
3099                cache.clone(),
3100            )));
3101            let exec_engine = Rc::new(RefCell::new(ExecutionEngine::new(
3102                clock.clone(),
3103                cache.clone(),
3104                Some(ExecutionEngineConfig::default()),
3105            )));
3106            RiskEngine::register_msgbus_handlers(&risk_engine);
3107            ExecutionEngine::register_msgbus_handlers(&exec_engine);
3108
3109            let parent = OrderTestBuilder::new(OrderType::Market)
3110                .trader_id(trader_id)
3111                .strategy_id(strategy_id)
3112                .instrument_id(instrument_id)
3113                .client_order_id(parent_order_id)
3114                .side(OrderSide::Buy)
3115                .quantity(Quantity::from("1000"))
3116                .exec_algorithm_id(exec_algorithm_id)
3117                .exec_spawn_id(parent_order_id)
3118                .build();
3119            let child = OrderTestBuilder::new(OrderType::Market)
3120                .trader_id(trader_id)
3121                .strategy_id(strategy_id)
3122                .instrument_id(instrument_id)
3123                .client_order_id(child_order_id)
3124                .side(OrderSide::Buy)
3125                .quantity(Quantity::from("100000000"))
3126                .exec_algorithm_id(exec_algorithm_id)
3127                .exec_spawn_id(child_order_id)
3128                .build();
3129
3130            let config = ExecutionAlgorithmConfig {
3131                exec_algorithm_id: Some(exec_algorithm_id),
3132                ..Default::default()
3133            };
3134            let mut exec_algorithm = TestExecutionAlgorithm::new(config);
3135            exec_algorithm.submit_on_accept = Some(child);
3136            let mut trader = Trader::new(
3137                trader_id,
3138                instance_id,
3139                Environment::Backtest,
3140                clock_factory,
3141                cache.clone(),
3142                portfolio,
3143            );
3144            trader.add_exec_algorithm(exec_algorithm).unwrap();
3145            trader.start_components().unwrap();
3146
3147            cache
3148                .borrow_mut()
3149                .add_order(parent.clone(), None, None, false)
3150                .unwrap();
3151            let submit = SubmitOrder::new(
3152                trader_id,
3153                None,
3154                strategy_id,
3155                instrument_id,
3156                parent.client_order_id(),
3157                parent.init_event().clone(),
3158                Some(exec_algorithm_id),
3159                None,
3160                None,
3161                UUID4::new(),
3162                clock.borrow().timestamp_ns(),
3163                None,
3164            );
3165            get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner())
3166                .execute(TradingCommand::SubmitOrder(submit))
3167                .unwrap();
3168
3169            let submitted = OrderEventAny::Submitted(
3170                OrderSubmittedSpec::builder()
3171                    .trader_id(trader_id)
3172                    .strategy_id(strategy_id)
3173                    .instrument_id(instrument_id)
3174                    .client_order_id(parent.client_order_id())
3175                    .account_id(account_id)
3176                    .build(),
3177            );
3178            let accepted = OrderEventAny::Accepted(
3179                OrderAcceptedSpec::builder()
3180                    .trader_id(trader_id)
3181                    .strategy_id(strategy_id)
3182                    .instrument_id(instrument_id)
3183                    .client_order_id(parent.client_order_id())
3184                    .venue_order_id(venue_order_id)
3185                    .account_id(account_id)
3186                    .build(),
3187            );
3188            msgbus::send_order_event(MessagingSwitchboard::exec_engine_process(), submitted);
3189            msgbus::send_order_event(MessagingSwitchboard::exec_engine_process(), accepted);
3190
3191            {
3192                let cache = cache.borrow();
3193                let parent = cache.order(&parent.client_order_id()).unwrap();
3194                let child = cache.order(&child_order_id).unwrap();
3195                let exec_algorithm =
3196                    get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3197
3198                assert!(!trading_cmd_queue_is_empty());
3199                assert_eq!(risk_engine.borrow().command_count(), 0);
3200                assert_eq!(exec_engine.borrow().event_count(), 2);
3201                assert_eq!(parent.status(), OrderStatus::Accepted);
3202                assert_eq!(parent.event_count(), 3);
3203                assert_eq!(child.status(), OrderStatus::Initialized);
3204                assert_eq!(child.event_count(), 1);
3205                assert_eq!(exec_algorithm.accepted_events, 1);
3206                assert_eq!(exec_algorithm.denied_events, 0);
3207                assert!(exec_algorithm.submit_on_accept.is_none());
3208            }
3209
3210            drain_trading_cmd_queue();
3211
3212            {
3213                let cache = cache.borrow();
3214                let parent = cache.order(&parent.client_order_id()).unwrap();
3215                let child = cache.order(&child_order_id).unwrap();
3216                let exec_algorithm =
3217                    get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3218
3219                assert!(trading_cmd_queue_is_empty());
3220                assert_eq!(risk_engine.borrow().command_count(), 1);
3221                assert_eq!(exec_engine.borrow().event_count(), 3);
3222                assert_eq!(parent.status(), OrderStatus::Accepted);
3223                assert_eq!(parent.event_count(), 3);
3224                assert_eq!(child.status(), OrderStatus::Denied);
3225                assert_eq!(child.event_count(), 2);
3226                assert_eq!(
3227                    child.last_event().message(),
3228                    Some("QUANTITY_EXCEEDS_MAXIMUM: effective=100000000, max=1000000".into())
3229                );
3230                assert_eq!(exec_algorithm.accepted_events, 1);
3231                assert_eq!(exec_algorithm.denied_events, 1);
3232                assert!(exec_algorithm.submit_on_accept.is_none());
3233            }
3234        })
3235        .join()
3236        .unwrap();
3237    }
3238
3239    #[rstest]
3240    fn test_exec_algorithm_restores_cached_strategy_subscriptions_on_start_and_restart() {
3241        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3242            create_trader_components();
3243        let trader_id = TraderId::test_default();
3244        let instance_id = UUID4::new();
3245        let unique = UUID4::new();
3246        let exec_algorithm_id = ExecAlgorithmId::from(format!("RECOVERY-{unique}"));
3247        let other_algorithm_id = ExecAlgorithmId::from(format!("OTHER-{unique}"));
3248        let strategy_a = StrategyId::from(format!("RecoveryA-{unique}"));
3249        let strategy_b = StrategyId::from(format!("RecoveryB-{unique}"));
3250        let terminal_strategy = StrategyId::from(format!("Terminal-{unique}"));
3251        let external_strategy = StrategyId::external();
3252
3253        let order_a = add_cached_exec_order(
3254            &cache,
3255            ClientOrderId::from(format!("O-A1-{unique}")),
3256            strategy_a,
3257            Some(exec_algorithm_id),
3258            false,
3259        );
3260        add_cached_exec_order(
3261            &cache,
3262            ClientOrderId::from(format!("O-A2-{unique}")),
3263            strategy_a,
3264            Some(exec_algorithm_id),
3265            false,
3266        );
3267        add_cached_exec_order(
3268            &cache,
3269            ClientOrderId::from(format!("O-B-{unique}")),
3270            strategy_b,
3271            Some(exec_algorithm_id),
3272            false,
3273        );
3274        add_cached_exec_order(
3275            &cache,
3276            ClientOrderId::from(format!("O-TERMINAL-{unique}")),
3277            terminal_strategy,
3278            Some(exec_algorithm_id),
3279            true,
3280        );
3281        add_cached_exec_order(
3282            &cache,
3283            ClientOrderId::from(format!("O-OTHER-{unique}")),
3284            StrategyId::from(format!("Other-{unique}")),
3285            Some(other_algorithm_id),
3286            false,
3287        );
3288        add_cached_exec_order(
3289            &cache,
3290            ClientOrderId::from(format!("O-EXTERNAL-{unique}")),
3291            external_strategy,
3292            None,
3293            false,
3294        );
3295
3296        let mut trader = Trader::new(
3297            trader_id,
3298            instance_id,
3299            Environment::Backtest,
3300            clock_factory,
3301            cache,
3302            portfolio,
3303        );
3304        let config = ExecutionAlgorithmConfig {
3305            exec_algorithm_id: Some(exec_algorithm_id),
3306            ..Default::default()
3307        };
3308        trader
3309            .add_exec_algorithm(TestExecutionAlgorithm::new(config))
3310            .unwrap();
3311
3312        trader.start_components().unwrap();
3313
3314        assert_eq!(order_a.exec_spawn_id(), Some(order_a.client_order_id()));
3315        {
3316            let registered =
3317                get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3318            assert!(registered.core.is_strategy_subscribed(&strategy_a));
3319            assert!(registered.core.is_strategy_subscribed(&strategy_b));
3320            assert!(!registered.core.is_strategy_subscribed(&terminal_strategy));
3321            assert!(!registered.core.is_strategy_subscribed(&external_strategy));
3322        }
3323
3324        let rejected = OrderEventAny::Rejected(
3325            OrderRejectedSpec::builder()
3326                .trader_id(order_a.trader_id())
3327                .strategy_id(strategy_a)
3328                .instrument_id(order_a.instrument_id())
3329                .client_order_id(order_a.client_order_id())
3330                .account_id(AccountId::test_default())
3331                .reason("TEST_REJECTED".into())
3332                .build(),
3333        );
3334        let updated = OrderEventAny::Updated(
3335            OrderUpdatedSpec::builder()
3336                .trader_id(order_a.trader_id())
3337                .strategy_id(strategy_a)
3338                .instrument_id(order_a.instrument_id())
3339                .client_order_id(order_a.client_order_id())
3340                .build(),
3341        );
3342        let filled = OrderEventAny::Filled(
3343            OrderFilledSpec::builder()
3344                .trader_id(order_a.trader_id())
3345                .strategy_id(strategy_a)
3346                .instrument_id(order_a.instrument_id())
3347                .client_order_id(order_a.client_order_id())
3348                .build(),
3349        );
3350        let position = PositionEvent::PositionAdjusted(PositionAdjusted::new(
3351            trader_id,
3352            strategy_a,
3353            InstrumentId::test_default(),
3354            PositionId::from(format!("P-{unique}")),
3355            AccountId::test_default(),
3356            PositionAdjustmentType::Funding,
3357            None,
3358            None,
3359            None,
3360            UUID4::new(),
3361            0.into(),
3362            0.into(),
3363        ));
3364
3365        let order_topic = format!("events.order.{strategy_a}");
3366        msgbus::publish_order_event(order_topic.clone().into(), &rejected);
3367        msgbus::publish_order_event(order_topic.clone().into(), &updated);
3368        msgbus::publish_order_event(order_topic.into(), &filled);
3369        msgbus::publish_position_event(format!("events.position.{strategy_a}").into(), &position);
3370
3371        {
3372            let registered =
3373                get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3374            assert_eq!(registered.rejected_events, 1);
3375            assert_eq!(registered.updated_events, 1);
3376            assert_eq!(registered.filled_events, 1);
3377            assert_eq!(registered.position_events, 1);
3378        }
3379
3380        trader.stop_components().unwrap();
3381        trader.reset_components().unwrap();
3382        {
3383            let registered =
3384                get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3385            assert!(!registered.core.is_strategy_subscribed(&strategy_a));
3386            assert!(!registered.core.is_strategy_subscribed(&strategy_b));
3387        }
3388
3389        trader.start_components().unwrap();
3390        {
3391            let registered =
3392                get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3393            assert!(registered.core.is_strategy_subscribed(&strategy_a));
3394            assert!(registered.core.is_strategy_subscribed(&strategy_b));
3395        }
3396
3397        trader.stop_components().unwrap();
3398        trader.clear_exec_algorithms().unwrap();
3399        assert!(trader.exec_algorithm_restore_fns.is_empty());
3400        assert!(trader.exec_algorithm_cleanup_fns.is_empty());
3401    }
3402
3403    #[rstest]
3404    fn test_exec_algorithm_start_failure_cleans_all_restored_subscriptions() {
3405        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3406            create_trader_components();
3407        let trader_id = TraderId::test_default();
3408        let instance_id = UUID4::new();
3409        let unique = UUID4::new();
3410        let running_algorithm_id = ExecAlgorithmId::from(format!("RUNNING-{unique}"));
3411        let failing_algorithm_id = ExecAlgorithmId::from(format!("FAIL-{unique}"));
3412        let running_strategy_id = StrategyId::from(format!("Running-{unique}"));
3413        let failing_strategy_id = StrategyId::from(format!("Failing-{unique}"));
3414        add_cached_exec_order(
3415            &cache,
3416            ClientOrderId::from(format!("O-RUNNING-{unique}")),
3417            running_strategy_id,
3418            Some(running_algorithm_id),
3419            false,
3420        );
3421        add_cached_exec_order(
3422            &cache,
3423            ClientOrderId::from(format!("O-FAILING-{unique}")),
3424            failing_strategy_id,
3425            Some(failing_algorithm_id),
3426            false,
3427        );
3428
3429        let mut trader = Trader::new(
3430            trader_id,
3431            instance_id,
3432            Environment::Backtest,
3433            clock_factory,
3434            cache,
3435            portfolio,
3436        );
3437        let running_config = ExecutionAlgorithmConfig {
3438            exec_algorithm_id: Some(running_algorithm_id),
3439            ..Default::default()
3440        };
3441        trader
3442            .add_exec_algorithm(TestExecutionAlgorithm::new(running_config))
3443            .unwrap();
3444        let failing_config = ExecutionAlgorithmConfig {
3445            exec_algorithm_id: Some(failing_algorithm_id),
3446            ..Default::default()
3447        };
3448        let mut failing_algorithm = TestExecutionAlgorithm::new(failing_config);
3449        failing_algorithm.fail_start = true;
3450        trader.add_exec_algorithm(failing_algorithm).unwrap();
3451        trader.initialize().unwrap();
3452        let trader = Rc::new(RefCell::new(trader));
3453
3454        let error = Trader::start_with_component_callbacks(&trader).unwrap_err();
3455
3456        assert!(
3457            error
3458                .to_string()
3459                .contains("test execution algorithm start failure")
3460        );
3461        {
3462            let running =
3463                get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3464            let failing =
3465                get_actor_unchecked::<TestExecutionAlgorithm>(&failing_algorithm_id.inner());
3466            assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3467            assert!(!failing.core.is_strategy_subscribed(&failing_strategy_id));
3468        }
3469
3470        trader.borrow_mut().stop_after_start_failure().unwrap();
3471
3472        let running = get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3473        assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3474    }
3475
3476    #[rstest]
3477    fn test_start_components_failure_cleans_previously_restored_subscriptions() {
3478        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3479            create_trader_components();
3480        let trader_id = TraderId::test_default();
3481        let instance_id = UUID4::new();
3482        let unique = UUID4::new();
3483        let running_algorithm_id = ExecAlgorithmId::from(format!("DIRECT-RUNNING-{unique}"));
3484        let failing_algorithm_id = ExecAlgorithmId::from(format!("DIRECT-FAIL-{unique}"));
3485        let running_strategy_id = StrategyId::from(format!("DirectRunning-{unique}"));
3486        let failing_strategy_id = StrategyId::from(format!("DirectFailing-{unique}"));
3487        add_cached_exec_order(
3488            &cache,
3489            ClientOrderId::from(format!("O-DIRECT-RUNNING-{unique}")),
3490            running_strategy_id,
3491            Some(running_algorithm_id),
3492            false,
3493        );
3494        add_cached_exec_order(
3495            &cache,
3496            ClientOrderId::from(format!("O-DIRECT-FAILING-{unique}")),
3497            failing_strategy_id,
3498            Some(failing_algorithm_id),
3499            false,
3500        );
3501
3502        let mut trader = Trader::new(
3503            trader_id,
3504            instance_id,
3505            Environment::Backtest,
3506            clock_factory,
3507            cache,
3508            portfolio,
3509        );
3510        trader
3511            .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3512                exec_algorithm_id: Some(running_algorithm_id),
3513                ..Default::default()
3514            }))
3515            .unwrap();
3516        let mut failing_algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3517            exec_algorithm_id: Some(failing_algorithm_id),
3518            ..Default::default()
3519        });
3520        failing_algorithm.fail_start = true;
3521        trader.add_exec_algorithm(failing_algorithm).unwrap();
3522
3523        let error = trader.start_components().unwrap_err();
3524
3525        assert!(
3526            error
3527                .to_string()
3528                .contains("test execution algorithm start failure")
3529        );
3530        let running = get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3531        let failing = get_actor_unchecked::<TestExecutionAlgorithm>(&failing_algorithm_id.inner());
3532        assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3533        assert!(!failing.core.is_strategy_subscribed(&failing_strategy_id));
3534    }
3535
3536    #[rstest]
3537    fn test_cannot_add_exec_algorithm_while_running() {
3538        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3539            create_trader_components();
3540        let trader_id = TraderId::test_default();
3541        let instance_id = UUID4::new();
3542
3543        let mut trader = Trader::new(
3544            trader_id,
3545            instance_id,
3546            Environment::Backtest,
3547            clock_factory,
3548            cache,
3549            portfolio,
3550        );
3551        trader.state = ComponentState::Running;
3552
3553        let config = ExecutionAlgorithmConfig {
3554            exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3555            ..Default::default()
3556        };
3557        let exec_algorithm = TestExecutionAlgorithm::new(config);
3558
3559        let result = trader.add_exec_algorithm(exec_algorithm);
3560        assert!(result.is_err());
3561        assert_eq!(
3562            result.unwrap_err().to_string(),
3563            "Cannot add execution algorithms to running trader"
3564        );
3565        assert_eq!(trader.exec_algorithm_count(), 0);
3566    }
3567
3568    #[rstest]
3569    fn test_component_lifecycle() {
3570        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3571            create_trader_components();
3572        let trader_id = TraderId::test_default();
3573        let instance_id = UUID4::new();
3574
3575        let mut trader = Trader::new(
3576            trader_id,
3577            instance_id,
3578            Environment::Backtest,
3579            clock_factory,
3580            cache,
3581            portfolio,
3582        );
3583
3584        // Add components
3585        let actor = TestDataActor::new(DataActorConfig::default());
3586
3587        let strategy_config = StrategyConfig {
3588            strategy_id: Some(StrategyId::from("Test-Strategy")),
3589            ..Default::default()
3590        };
3591        let strategy = TestStrategy::new(strategy_config);
3592
3593        let exec_algorithm_config = ExecutionAlgorithmConfig {
3594            exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3595            ..Default::default()
3596        };
3597        let exec_algorithm = TestExecutionAlgorithm::new(exec_algorithm_config);
3598
3599        assert!(trader.add_actor(actor).is_ok());
3600        assert!(trader.add_strategy(strategy).is_ok());
3601        assert!(trader.add_exec_algorithm(exec_algorithm).is_ok());
3602        assert_eq!(trader.component_count(), 3);
3603
3604        // Test start components
3605        let start_result = trader.start_components();
3606        assert!(start_result.is_ok(), "{:?}", start_result.unwrap_err());
3607
3608        // Test stop components
3609        assert!(trader.stop_components().is_ok());
3610
3611        // Test reset components
3612        assert!(trader.reset_components().is_ok());
3613
3614        // Test dispose components
3615        assert!(trader.dispose_components().is_ok());
3616        assert_eq!(trader.component_count(), 0);
3617    }
3618
3619    #[rstest]
3620    fn test_native_strategy_timer_routes_market_exit_before_user_callback() {
3621        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3622            create_trader_components();
3623        let mut trader = Trader::new(
3624            TraderId::test_default(),
3625            UUID4::new(),
3626            Environment::Backtest,
3627            clock_factory,
3628            cache,
3629            portfolio,
3630        );
3631        let strategy_id = StrategyId::from("TimerRouting-001");
3632        let strategy = TimerRoutingStrategy::new(StrategyConfig {
3633            strategy_id: Some(strategy_id),
3634            manage_stop: true,
3635            market_exit_interval_ms: 1,
3636            ..Default::default()
3637        });
3638
3639        trader.add_strategy(strategy).unwrap();
3640        trader.start_components().unwrap();
3641        trader.stop_components().unwrap();
3642
3643        let clock = trader.get_component_clocks().into_iter().next().unwrap();
3644        let deadline = clock.borrow().timestamp_ns() + DurationNanos::new(1_000_000);
3645        let dispatched = dispatch_component_time_events(&clock, deadline);
3646        let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3647
3648        assert_eq!(dispatched, 1);
3649        assert_eq!(strategy.time_events, 1);
3650        assert_eq!(strategy.strategy_time_events, 0);
3651        assert_eq!(strategy.post_market_exits, 1);
3652        assert_eq!(strategy.post_market_exits_on_callback, Some(1));
3653        assert!(!strategy.is_exiting());
3654        assert_eq!(strategy.state(), ComponentState::Stopped);
3655    }
3656
3657    #[rstest]
3658    fn test_native_strategy_timer_routes_gtd_expiry_before_user_callback() {
3659        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3660            create_trader_components();
3661        let trader_id = TraderId::test_default();
3662        let mut trader = Trader::new(
3663            trader_id,
3664            UUID4::new(),
3665            Environment::Backtest,
3666            clock_factory,
3667            cache.clone(),
3668            portfolio,
3669        );
3670
3671        let (strategy_id, client_order_id, deadline) =
3672            register_gtd_timer(&mut trader, &cache, trader_id);
3673
3674        let clock = trader.get_component_clocks().into_iter().next().unwrap();
3675        let dispatched = dispatch_component_time_events(&clock, deadline);
3676        let mut strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3677        let strategy_state = (
3678            strategy.time_events,
3679            strategy.strategy_time_events,
3680            strategy.gtd_timer_active_on_callback,
3681            strategy.has_gtd_expiry_timer(&client_order_id),
3682        );
3683        drop(strategy);
3684        let cache_ref = cache.borrow();
3685        let cached_order = cache_ref.order(&client_order_id).unwrap();
3686
3687        assert_eq!(dispatched, 1);
3688        assert_eq!(strategy_state, (1, 0, Some(false), false));
3689        assert_eq!(cached_order.status(), OrderStatus::PendingCancel);
3690        assert_eq!(cached_order.event_count(), 4);
3691    }
3692
3693    #[rstest]
3694    fn test_native_strategy_timer_skips_gtd_expiry_when_stopped() {
3695        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3696            create_trader_components();
3697        let trader_id = TraderId::test_default();
3698        let mut trader = Trader::new(
3699            trader_id,
3700            UUID4::new(),
3701            Environment::Backtest,
3702            clock_factory,
3703            cache.clone(),
3704            portfolio,
3705        );
3706
3707        let (strategy_id, client_order_id, deadline) =
3708            register_gtd_timer(&mut trader, &cache, trader_id);
3709        trader.stop_components().unwrap();
3710
3711        let clock = trader.get_component_clocks().into_iter().next().unwrap();
3712        let dispatched = dispatch_component_time_events(&clock, deadline);
3713        let mut strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3714        let strategy_state = (
3715            strategy.time_events,
3716            strategy.strategy_time_events,
3717            strategy.has_gtd_expiry_timer(&client_order_id),
3718            strategy.state(),
3719        );
3720        drop(strategy);
3721        let cache_ref = cache.borrow();
3722        let cached_order = cache_ref.order(&client_order_id).unwrap();
3723
3724        assert_eq!(dispatched, 1);
3725        assert_eq!(strategy_state, (0, 0, true, ComponentState::Stopped));
3726        assert_eq!(cached_order.status(), OrderStatus::Accepted);
3727        assert_eq!(cached_order.event_count(), 3);
3728    }
3729
3730    fn dispatch_component_time_events(
3731        clock: &Rc<RefCell<dyn Clock>>,
3732        to_time_ns: UnixNanos,
3733    ) -> usize {
3734        let handlers = queue_component_time_events(clock, to_time_ns);
3735        let dispatched = handlers.len();
3736        for handler in handlers {
3737            handler.run();
3738        }
3739
3740        dispatched
3741    }
3742
3743    fn queue_component_time_events(
3744        clock: &Rc<RefCell<dyn Clock>>,
3745        to_time_ns: UnixNanos,
3746    ) -> Vec<TimeEventHandler> {
3747        let mut clock_ref = clock.borrow_mut();
3748        let test_clock = clock_ref
3749            .as_any_mut()
3750            .downcast_mut::<VirtualClock>()
3751            .expect("component clock must be VirtualClock");
3752        let events = test_clock.advance_time(to_time_ns, true);
3753        test_clock.match_handlers(events)
3754    }
3755
3756    fn register_gtd_timer(
3757        trader: &mut Trader,
3758        cache: &Rc<RefCell<Cache>>,
3759        trader_id: TraderId,
3760    ) -> (StrategyId, ClientOrderId, UnixNanos) {
3761        let deadline =
3762            trader.clock_factory.clock().borrow().timestamp_ns() + DurationNanos::new(1_000_000);
3763        let strategy_id = StrategyId::from("TimerRouting-001");
3764        let strategy = TimerRoutingStrategy::new(StrategyConfig {
3765            strategy_id: Some(strategy_id),
3766            manage_gtd_expiry: true,
3767            ..Default::default()
3768        });
3769        let client_order_id = ClientOrderId::from("O-GTD-001");
3770        let order = OrderTestBuilder::new(OrderType::Limit)
3771            .trader_id(trader_id)
3772            .strategy_id(strategy_id)
3773            .instrument_id(InstrumentId::test_default())
3774            .client_order_id(client_order_id)
3775            .quantity(Quantity::from(1))
3776            .price(Price::from("1.00"))
3777            .time_in_force(TimeInForce::Gtd)
3778            .expire_time(deadline)
3779            .build();
3780
3781        trader.add_strategy(strategy).unwrap();
3782        trader.start_components().unwrap();
3783        cache_accepted_order(cache, &order);
3784        get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner())
3785            .set_gtd_expiry(&order)
3786            .unwrap();
3787
3788        (strategy_id, client_order_id, deadline)
3789    }
3790
3791    fn cache_accepted_order(cache: &Rc<RefCell<Cache>>, order: &OrderAny) {
3792        let account_id = AccountId::test_default();
3793        let submitted = OrderEventAny::Submitted(
3794            OrderSubmittedSpec::builder()
3795                .trader_id(order.trader_id())
3796                .strategy_id(order.strategy_id())
3797                .instrument_id(order.instrument_id())
3798                .client_order_id(order.client_order_id())
3799                .account_id(account_id)
3800                .build(),
3801        );
3802        let accepted = OrderEventAny::Accepted(
3803            OrderAcceptedSpec::builder()
3804                .trader_id(order.trader_id())
3805                .strategy_id(order.strategy_id())
3806                .instrument_id(order.instrument_id())
3807                .client_order_id(order.client_order_id())
3808                .venue_order_id(VenueOrderId::from("V-GTD-001"))
3809                .account_id(account_id)
3810                .build(),
3811        );
3812        let mut cache = cache.borrow_mut();
3813        cache.add_order(order.clone(), None, None, false).unwrap();
3814        cache.update_order(&submitted).unwrap();
3815        cache.update_order(&accepted).unwrap();
3816    }
3817
3818    #[rstest]
3819    fn test_trader_component_lifecycle() {
3820        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3821            create_trader_components();
3822        let trader_id = TraderId::test_default();
3823        let instance_id = UUID4::new();
3824
3825        let mut trader = Trader::new(
3826            trader_id,
3827            instance_id,
3828            Environment::Backtest,
3829            clock_factory,
3830            cache,
3831            portfolio,
3832        );
3833
3834        // Initially pre-initialized
3835        assert_eq!(trader.state(), ComponentState::PreInitialized);
3836        assert!(!trader.is_running());
3837        assert!(!trader.is_stopped());
3838        assert!(!trader.is_disposed());
3839
3840        // Cannot start from pre-initialized state
3841        assert!(trader.start().is_err());
3842
3843        // Simulate initialization (normally done by kernel)
3844        trader.initialize().unwrap();
3845
3846        // Test start
3847        assert!(trader.start().is_ok());
3848        assert_eq!(trader.state(), ComponentState::Running);
3849        assert!(trader.is_running());
3850        assert!(trader.ts_started().is_some());
3851
3852        // Test stop
3853        assert!(trader.stop().is_ok());
3854        assert_eq!(trader.state(), ComponentState::Stopped);
3855        assert!(trader.is_stopped());
3856        assert!(trader.ts_stopped().is_some());
3857
3858        // Test reset
3859        assert!(trader.reset().is_ok());
3860        assert_eq!(trader.state(), ComponentState::Ready);
3861        assert!(trader.ts_started().is_none());
3862        assert!(trader.ts_stopped().is_none());
3863
3864        // Test dispose
3865        assert!(trader.dispose().is_ok());
3866        assert_eq!(trader.state(), ComponentState::Disposed);
3867        assert!(trader.is_disposed());
3868    }
3869
3870    #[rstest]
3871    #[case("actor", "actor StopActor-0: test actor stop failure")]
3872    #[case(
3873        "algorithm",
3874        "execution algorithm StopAlgorithm-0: test execution algorithm stop failure"
3875    )]
3876    #[case("strategy", "strategy StopStrategy-000: test strategy stop failure")]
3877    fn test_stop_failure_stops_remaining_components(
3878        #[case] failing_kind: &str,
3879        #[case] expected_error: &str,
3880        #[values(false, true)] after_start_failure: bool,
3881    ) {
3882        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3883            create_trader_components();
3884        let clock = clock_factory.clock();
3885
3886        let mut trader = Trader::new(
3887            TraderId::test_default(),
3888            UUID4::new(),
3889            Environment::Backtest,
3890            clock_factory,
3891            cache,
3892            portfolio,
3893        );
3894
3895        let mut components = Vec::new();
3896
3897        for index in 0..2 {
3898            let actor_id = ActorId::from(format!("StopActor-{index}"));
3899
3900            let mut actor = TestDataActor::new(DataActorConfig {
3901                actor_id: Some(actor_id),
3902                ..Default::default()
3903            });
3904
3905            actor.fail_stop = failing_kind == "actor" && index == 0;
3906            components.push((actor_id.inner(), actor.fail_stop));
3907            trader.add_actor(actor).unwrap();
3908
3909            let algorithm_id = ExecAlgorithmId::from(format!("StopAlgorithm-{index}"));
3910
3911            let mut algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3912                exec_algorithm_id: Some(algorithm_id),
3913                ..Default::default()
3914            });
3915
3916            algorithm.fail_stop = failing_kind == "algorithm" && index == 0;
3917            components.push((algorithm_id.inner(), algorithm.fail_stop));
3918            trader.add_exec_algorithm(algorithm).unwrap();
3919
3920            let strategy_id = StrategyId::from(format!("StopStrategy-{index:03}"));
3921
3922            let mut strategy = TestStrategy::new(StrategyConfig {
3923                strategy_id: Some(strategy_id),
3924                ..Default::default()
3925            });
3926
3927            strategy.fail_stop = failing_kind == "strategy" && index == 0;
3928            components.push((strategy_id.inner(), strategy.fail_stop));
3929            trader.add_strategy(strategy).unwrap();
3930        }
3931
3932        trader.initialize().unwrap();
3933        trader.start().unwrap();
3934        clock
3935            .borrow_mut()
3936            .as_any_mut()
3937            .downcast_mut::<VirtualClock>()
3938            .unwrap()
3939            .set_time(3_000_000_000u64.into());
3940
3941        let result = if after_start_failure {
3942            trader.stop_after_start_failure()
3943        } else {
3944            trader.stop()
3945        };
3946
3947        let error = result.unwrap_err();
3948
3949        let prefix = if after_start_failure {
3950            "Failed to stop one or more trader components after startup failure"
3951        } else {
3952            "Failed to stop trader components"
3953        };
3954
3955        assert_eq!(error.to_string(), format!("{prefix}: {expected_error}"));
3956        assert_eq!(trader.state(), ComponentState::Stopped);
3957        assert_eq!(trader.ts_stopped(), Some(3_000_000_000u64.into()));
3958
3959        for (component_id, fail_stop) in components {
3960            let expected = if fail_stop {
3961                ComponentState::Stopping
3962            } else {
3963                ComponentState::Stopped
3964            };
3965
3966            assert_eq!(component_state(&component_id).unwrap(), expected);
3967        }
3968    }
3969
3970    #[rstest]
3971    fn test_stop_collects_all_callback_errors(#[values(false, true)] after_start_failure: bool) {
3972        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3973            create_trader_components();
3974
3975        let mut trader = Trader::new(
3976            TraderId::test_default(),
3977            UUID4::new(),
3978            Environment::Backtest,
3979            clock_factory,
3980            cache,
3981            portfolio,
3982        );
3983
3984        let actor_ids = [ActorId::from("Stop-A"), ActorId::from("Stop-B")];
3985        for actor_id in actor_ids {
3986            let mut actor = TestDataActor::new(DataActorConfig {
3987                actor_id: Some(actor_id),
3988                ..Default::default()
3989            });
3990
3991            actor.fail_stop = true;
3992            trader.add_actor(actor).unwrap();
3993        }
3994
3995        trader.initialize().unwrap();
3996        trader.start().unwrap();
3997        let result = if after_start_failure {
3998            trader.stop_after_start_failure()
3999        } else {
4000            trader.stop()
4001        };
4002
4003        let prefix = if after_start_failure {
4004            "Failed to stop one or more trader components after startup failure"
4005        } else {
4006            "Failed to stop trader components"
4007        };
4008
4009        assert_eq!(
4010            result.unwrap_err().to_string(),
4011            format!(
4012                "{prefix}: actor Stop-A: test actor stop failure; actor Stop-B: test actor stop failure"
4013            )
4014        );
4015        assert_eq!(trader.state(), ComponentState::Stopped);
4016
4017        for actor_id in actor_ids {
4018            assert_eq!(
4019                component_state(&actor_id.inner()).unwrap(),
4020                ComponentState::Stopping
4021            );
4022        }
4023    }
4024
4025    #[rstest]
4026    fn test_stop_error_preserves_managed_strategy_deferral() {
4027        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4028            create_trader_components();
4029
4030        let mut trader = Trader::new(
4031            TraderId::test_default(),
4032            UUID4::new(),
4033            Environment::Backtest,
4034            clock_factory,
4035            cache,
4036            portfolio,
4037        );
4038
4039        let mut actor = TestDataActor::new(DataActorConfig::default());
4040        actor.fail_stop = true;
4041        trader.add_actor(actor).unwrap();
4042        let strategy_id = StrategyId::from("ManagedStop-001");
4043        trader
4044            .add_strategy(TimerRoutingStrategy::new(StrategyConfig {
4045                strategy_id: Some(strategy_id),
4046                manage_stop: true,
4047                market_exit_interval_ms: 1,
4048                ..Default::default()
4049            }))
4050            .unwrap();
4051
4052        trader.initialize().unwrap();
4053        trader.start().unwrap();
4054
4055        let error = trader.stop().unwrap_err();
4056
4057        assert_eq!(
4058            error.to_string(),
4059            "Failed to stop trader components: actor DataActor: test actor stop failure"
4060        );
4061        assert_eq!(trader.state(), ComponentState::Stopped);
4062        {
4063            let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
4064            assert_eq!(strategy.state(), ComponentState::Running);
4065            assert!(strategy.is_exiting());
4066        }
4067
4068        let clock = trader.clocks[&ComponentId::from(strategy_id)].clone();
4069        let deadline = clock.borrow().timestamp_ns() + DurationNanos::new(1_000_000);
4070        let dispatched = dispatch_component_time_events(&clock, deadline);
4071
4072        let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
4073        assert_eq!(dispatched, 1);
4074        assert_eq!(strategy.state(), ComponentState::Stopped);
4075        assert!(!strategy.is_exiting());
4076        assert_eq!(strategy.post_market_exits, 1);
4077    }
4078
4079    #[rstest]
4080    fn test_stop_includes_degraded_components(#[values(false, true)] after_start_failure: bool) {
4081        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4082            create_trader_components();
4083
4084        let mut trader = Trader::new(
4085            TraderId::test_default(),
4086            UUID4::new(),
4087            Environment::Backtest,
4088            clock_factory,
4089            cache,
4090            portfolio,
4091        );
4092
4093        let actor_id = ActorId::from("DegradedActor");
4094        trader
4095            .add_actor(TestDataActor::new(DataActorConfig {
4096                actor_id: Some(actor_id),
4097                ..Default::default()
4098            }))
4099            .unwrap();
4100
4101        let algorithm_id = ExecAlgorithmId::from("DegradedAlgorithm");
4102        trader
4103            .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
4104                exec_algorithm_id: Some(algorithm_id),
4105                ..Default::default()
4106            }))
4107            .unwrap();
4108
4109        let strategy_id = StrategyId::from("DegradedStrategy-001");
4110        trader
4111            .add_strategy(TestStrategy::new(StrategyConfig {
4112                strategy_id: Some(strategy_id),
4113                ..Default::default()
4114            }))
4115            .unwrap();
4116
4117        trader.initialize().unwrap();
4118        trader.start().unwrap();
4119        get_actor_unchecked::<TestDataActor>(&actor_id.inner())
4120            .degrade()
4121            .unwrap();
4122        get_actor_unchecked::<TestExecutionAlgorithm>(&algorithm_id.inner())
4123            .degrade()
4124            .unwrap();
4125        get_actor_unchecked::<TestStrategy>(&strategy_id.inner())
4126            .degrade()
4127            .unwrap();
4128
4129        if after_start_failure {
4130            trader.stop_after_start_failure().unwrap();
4131        } else {
4132            trader.stop().unwrap();
4133        }
4134
4135        assert_eq!(trader.state(), ComponentState::Stopped);
4136
4137        for component_id in [actor_id.inner(), algorithm_id.inner(), strategy_id.inner()] {
4138            assert_eq!(
4139                component_state(&component_id).unwrap(),
4140                ComponentState::Stopped
4141            );
4142        }
4143    }
4144
4145    #[rstest]
4146    fn test_market_exit_strategy_fails_when_control_endpoint_missing() {
4147        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4148            create_trader_components();
4149        let trader_id = TraderId::test_default();
4150        let instance_id = UUID4::new();
4151
4152        let mut trader = Trader::new(
4153            trader_id,
4154            instance_id,
4155            Environment::Backtest,
4156            clock_factory,
4157            cache,
4158            portfolio,
4159        );
4160
4161        let config = StrategyConfig {
4162            strategy_id: Some(StrategyId::from("Test-Strategy")),
4163            ..Default::default()
4164        };
4165        let strategy = TestStrategy::new(config);
4166        trader.add_strategy(strategy).unwrap();
4167
4168        let strategy_id = StrategyId::from("Test-Strategy");
4169        let endpoint = strategy_control_endpoint(strategy_id);
4170        assert!(
4171            get_message_bus()
4172                .borrow_mut()
4173                .endpoint_map::<StrategyCommand>()
4174                .is_registered(endpoint)
4175        );
4176        get_message_bus()
4177            .borrow_mut()
4178            .endpoint_map::<StrategyCommand>()
4179            .deregister(endpoint);
4180
4181        let trader = Rc::new(RefCell::new(trader));
4182        let result = Trader::market_exit_strategy(&trader, &strategy_id);
4183        assert!(result.is_err());
4184        assert_eq!(
4185            result.unwrap_err().to_string(),
4186            format!(
4187                "Cannot exit market for strategy {strategy_id}: control endpoint '{}' not registered",
4188                endpoint.as_str()
4189            )
4190        );
4191    }
4192
4193    #[rstest]
4194    fn test_remove_strategy_deregisters_strategy_endpoint() {
4195        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4196            create_trader_components();
4197        let trader_id = TraderId::test_default();
4198        let instance_id = UUID4::new();
4199
4200        let mut trader = Trader::new(
4201            trader_id,
4202            instance_id,
4203            Environment::Backtest,
4204            clock_factory,
4205            cache,
4206            portfolio,
4207        );
4208
4209        let config = StrategyConfig {
4210            strategy_id: Some(StrategyId::from("Test-Strategy")),
4211            ..Default::default()
4212        };
4213        let strategy = TestStrategy::new(config);
4214        trader.add_strategy(strategy).unwrap();
4215
4216        let strategy_id = StrategyId::from("Test-Strategy");
4217        let endpoint = strategy_control_endpoint(strategy_id);
4218        assert!(
4219            get_message_bus()
4220                .borrow_mut()
4221                .endpoint_map::<StrategyCommand>()
4222                .is_registered(endpoint)
4223        );
4224
4225        trader.remove_strategy(&strategy_id).unwrap();
4226
4227        assert!(
4228            !get_message_bus()
4229                .borrow_mut()
4230                .endpoint_map::<StrategyCommand>()
4231                .is_registered(endpoint)
4232        );
4233    }
4234
4235    #[rstest]
4236    fn test_remove_strategy_clears_external_order_claims() {
4237        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4238            create_trader_components();
4239        let trader_id = TraderId::test_default();
4240        let instance_id = UUID4::new();
4241        let strategy_id = StrategyId::from("Test-Strategy");
4242        let instrument_id = InstrumentId::from("AUDUSD.SIM");
4243
4244        let mut trader = Trader::new(
4245            trader_id,
4246            instance_id,
4247            Environment::Backtest,
4248            clock_factory,
4249            cache.clone(),
4250            portfolio,
4251        );
4252        trader
4253            .add_strategy(TestStrategy::new(StrategyConfig {
4254                strategy_id: Some(strategy_id),
4255                ..Default::default()
4256            }))
4257            .unwrap();
4258        cache
4259            .borrow_mut()
4260            .set_external_order_claims(strategy_id, &[instrument_id])
4261            .unwrap();
4262
4263        trader.remove_strategy(&strategy_id).unwrap();
4264
4265        assert_eq!(cache.borrow().external_order_claim(&instrument_id), None);
4266    }
4267
4268    #[rstest]
4269    fn test_remove_strategy_cache_borrow_failure_preserves_strategy_and_claims() {
4270        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4271            create_trader_components();
4272        let strategy_id = StrategyId::from("Test-Strategy");
4273        let instrument_id = InstrumentId::from("AUDUSD.SIM");
4274        let mut trader = Trader::new(
4275            TraderId::test_default(),
4276            UUID4::new(),
4277            Environment::Backtest,
4278            clock_factory,
4279            cache.clone(),
4280            portfolio,
4281        );
4282        trader
4283            .add_strategy(TestStrategy::new(StrategyConfig {
4284                strategy_id: Some(strategy_id),
4285                ..Default::default()
4286            }))
4287            .unwrap();
4288        cache
4289            .borrow_mut()
4290            .set_external_order_claims(strategy_id, &[instrument_id])
4291            .unwrap();
4292
4293        let cache_borrow = cache.borrow();
4294        let error = trader.remove_strategy(&strategy_id).unwrap_err();
4295
4296        assert_eq!(
4297            error.to_string(),
4298            "Cannot clear external order claims: RefCell already borrowed"
4299        );
4300        assert_eq!(
4301            cache_borrow.external_order_claim(&instrument_id),
4302            Some(strategy_id)
4303        );
4304        assert_eq!(trader.strategy_ids(), vec![strategy_id]);
4305        assert_eq!(
4306            component_state(&strategy_id.inner()).unwrap(),
4307            ComponentState::Ready
4308        );
4309
4310        drop(cache_borrow);
4311        trader.remove_strategy(&strategy_id).unwrap();
4312
4313        assert!(trader.strategy_ids().is_empty());
4314        assert_eq!(cache.borrow().external_order_claim(&instrument_id), None);
4315    }
4316
4317    #[rstest]
4318    fn test_can_add_components_while_running() {
4319        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4320            create_trader_components();
4321        let trader_id = TraderId::test_default();
4322        let instance_id = UUID4::new();
4323
4324        let mut trader = Trader::new(
4325            trader_id,
4326            instance_id,
4327            Environment::Backtest,
4328            clock_factory,
4329            cache,
4330            portfolio,
4331        );
4332
4333        // Simulate running state
4334        trader.state = ComponentState::Running;
4335
4336        let actor = TestDataActor::new(DataActorConfig::default());
4337        let result = trader.add_actor(actor);
4338        assert!(result.is_ok());
4339        assert_eq!(trader.actor_count(), 1);
4340    }
4341
4342    #[rstest]
4343    fn test_cannot_add_components_while_disposed() {
4344        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4345            create_trader_components();
4346        let trader_id = TraderId::test_default();
4347        let instance_id = UUID4::new();
4348
4349        let mut trader = Trader::new(
4350            trader_id,
4351            instance_id,
4352            Environment::Backtest,
4353            clock_factory,
4354            cache,
4355            portfolio,
4356        );
4357
4358        // Simulate disposed state
4359        trader.state = ComponentState::Disposed;
4360
4361        let actor = TestDataActor::new(DataActorConfig::default());
4362        let result = trader.add_actor(actor);
4363        assert!(result.is_err());
4364        assert!(result.unwrap_err().to_string().contains("disposed trader"));
4365    }
4366
4367    #[rstest]
4368    fn test_create_component_clock_backtest_creates_individual_clocks() {
4369        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4370            create_trader_components();
4371        let trader_id = TraderId::test_default();
4372        let instance_id = UUID4::new();
4373
4374        let mut trader = Trader::new(
4375            trader_id,
4376            instance_id,
4377            Environment::Backtest,
4378            clock_factory.clone(),
4379            cache,
4380            portfolio,
4381        );
4382
4383        let component_a = ComponentId::new("ACTOR-A");
4384        let component_b = ComponentId::new("ACTOR-B");
4385        let clock_a = trader.create_component_clock(component_a);
4386        let clock_b = trader.create_component_clock(component_b);
4387        let primary_clock = clock_factory.clock();
4388
4389        // Each component gets its own clock instance
4390        assert_ne!(
4391            clock_a.as_ptr() as *const _,
4392            primary_clock.as_ptr() as *const _
4393        );
4394        assert_ne!(clock_a.as_ptr() as *const _, clock_b.as_ptr() as *const _);
4395    }
4396
4397    #[rstest]
4398    fn test_get_component_clocks_returns_registration_order() {
4399        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4400            create_trader_components();
4401        let mut trader = Trader::new(
4402            TraderId::test_default(),
4403            UUID4::new(),
4404            Environment::Backtest,
4405            clock_factory,
4406            cache,
4407            portfolio,
4408        );
4409        let mut registered = Vec::new();
4410
4411        for index in 0..32 {
4412            let component_id = ComponentId::new(format!("ACTOR-{index:02}").as_str());
4413            registered.push(trader.create_component_clock(component_id));
4414        }
4415
4416        let returned = trader.get_component_clocks();
4417        assert_eq!(returned.len(), registered.len());
4418        for (actual, expected) in returned.iter().zip(&registered) {
4419            assert!(Rc::ptr_eq(actual, expected));
4420        }
4421    }
4422
4423    #[rstest]
4424    fn test_component_clock_snapshot_tracks_membership() {
4425        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4426            create_trader_components();
4427
4428        let mut trader = Trader::new(
4429            TraderId::test_default(),
4430            UUID4::new(),
4431            Environment::Backtest,
4432            clock_factory,
4433            cache,
4434            portfolio,
4435        );
4436
4437        let component_a = ComponentId::new("ACTOR-A");
4438        let component_b = ComponentId::new("ACTOR-B");
4439        let empty = trader.get_component_clocks_snapshot();
4440
4441        assert!(empty.is_empty());
4442        assert!(Rc::ptr_eq(&empty, &trader.get_component_clocks_snapshot()));
4443
4444        let clock_a = trader.create_component_clock(component_a);
4445        let first = trader.get_component_clocks_snapshot();
4446
4447        assert!(empty.is_empty());
4448        assert_eq!(first.len(), 1);
4449        assert!(Rc::ptr_eq(&first[0], &clock_a));
4450        assert!(Rc::ptr_eq(&first, &trader.get_component_clocks_snapshot()));
4451
4452        let clock_b = trader.create_component_clock(component_b);
4453        let both = trader.get_component_clocks_snapshot();
4454
4455        assert_eq!(first.len(), 1);
4456        assert_eq!(both.len(), 2);
4457        assert!(Rc::ptr_eq(&both[0], &clock_a));
4458        assert!(Rc::ptr_eq(&both[1], &clock_b));
4459
4460        let replacement = trader.create_component_clock(component_a);
4461        let replaced = trader.get_component_clocks_snapshot();
4462
4463        assert_eq!(replaced.len(), 2);
4464        assert!(!Rc::ptr_eq(&both, &replaced));
4465        assert!(Rc::ptr_eq(&both[0], &clock_a));
4466        assert!(Rc::ptr_eq(&replaced[0], &replacement));
4467        assert!(Rc::ptr_eq(&replaced[1], &clock_b));
4468
4469        trader.release_component_clock(component_a);
4470        let remaining = trader.get_component_clocks_snapshot();
4471
4472        assert_eq!(replaced.len(), 2);
4473        assert_eq!(remaining.len(), 1);
4474        assert!(Rc::ptr_eq(&remaining[0], &clock_b));
4475
4476        trader.release_component_clock(component_a);
4477
4478        assert!(Rc::ptr_eq(
4479            &remaining,
4480            &trader.get_component_clocks_snapshot()
4481        ));
4482
4483        trader.dispose_components().unwrap();
4484        let disposed = trader.get_component_clocks_snapshot();
4485
4486        assert_eq!(remaining.len(), 1);
4487        assert!(disposed.is_empty());
4488        assert!(Rc::ptr_eq(
4489            &disposed,
4490            &trader.get_component_clocks_snapshot()
4491        ));
4492    }
4493
4494    #[rstest]
4495    fn test_create_component_clock_live_uses_factory_with_distinct_instances() {
4496        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, _clock_factory) =
4497            create_trader_components();
4498        let calls = Rc::new(Cell::new(0usize));
4499        let calls_in_closure = calls.clone();
4500        let clock_factory = ClockFactory::new(move || {
4501            calls_in_closure.set(calls_in_closure.get() + 1);
4502            Rc::new(RefCell::new(VirtualClock::new())) as Rc<RefCell<dyn Clock>>
4503        });
4504
4505        let mut trader = Trader::new(
4506            TraderId::test_default(),
4507            UUID4::new(),
4508            Environment::Sandbox,
4509            clock_factory,
4510            cache,
4511            portfolio,
4512        );
4513
4514        let a = trader.create_component_clock(ComponentId::new("ACTOR-A"));
4515        let b = trader.create_component_clock(ComponentId::new("ACTOR-B"));
4516
4517        assert_eq!(
4518            calls.get(),
4519            3,
4520            "factory invoked for primary clock and each component",
4521        );
4522        assert!(
4523            !Rc::ptr_eq(&a, &b),
4524            "each component must get its own clock instance"
4525        );
4526    }
4527
4528    #[rstest]
4529    fn test_clear_strategies_preserves_other_handlers() {
4530        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4531            create_trader_components();
4532        let trader_id = TraderId::test_default();
4533        let instance_id = UUID4::new();
4534
4535        let mut trader = Trader::new(
4536            trader_id,
4537            instance_id,
4538            Environment::Backtest,
4539            clock_factory,
4540            cache,
4541            portfolio,
4542        );
4543
4544        let config = StrategyConfig {
4545            strategy_id: Some(StrategyId::from("Test-Strategy")),
4546            ..Default::default()
4547        };
4548        let strategy = TestStrategy::new(config);
4549        trader.add_strategy(strategy).unwrap();
4550
4551        let strategy_id = StrategyId::from("Test-Strategy");
4552        let endpoint = strategy_control_endpoint(strategy_id);
4553        assert!(
4554            get_message_bus()
4555                .borrow_mut()
4556                .endpoint_map::<StrategyCommand>()
4557                .is_registered(endpoint)
4558        );
4559
4560        // Simulate an exec algorithm subscribing to the same strategy topic
4561        let ext_received = Rc::new(RefCell::new(0));
4562        let ext_clone = ext_received.clone();
4563        let ext_handler =
4564            TypedHandler::from_with_id("exec-algo-handler", move |_: &OrderEventAny| {
4565                *ext_clone.borrow_mut() += 1;
4566            });
4567        let order_topic = get_event_order_topic(strategy_id);
4568        msgbus::subscribe_order_events(order_topic.into(), ext_handler, None);
4569
4570        trader.clear_strategies().unwrap();
4571        assert_eq!(trader.strategy_count(), 0);
4572        assert!(
4573            !get_message_bus()
4574                .borrow_mut()
4575                .endpoint_map::<StrategyCommand>()
4576                .is_registered(endpoint)
4577        );
4578
4579        let event = OrderEventAny::Accepted(OrderAccepted::test_default());
4580        msgbus::publish_order_event(order_topic, &event);
4581        assert_eq!(*ext_received.borrow(), 1);
4582    }
4583
4584    #[cfg(feature = "python")]
4585    #[rstest]
4586    fn test_component_message_bus_across_registered_python_components() {
4587        use nautilus_trading::python::algorithm::PyExecutionAlgorithm;
4588
4589        Python::initialize();
4590        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4591            create_trader_components();
4592        let bus = msgbus::get_message_bus();
4593        let mut trader = Trader::new(
4594            TraderId::test_default(),
4595            UUID4::new(),
4596            Environment::Backtest,
4597            clock_factory,
4598            cache,
4599            portfolio,
4600        );
4601        Python::attach(|py| {
4602            let locals = PyDict::new(py);
4603            locals
4604                .set_item("DataActor", py.get_type::<PyDataActor>())
4605                .unwrap();
4606            locals
4607                .set_item("Strategy", py.get_type::<PyStrategy>())
4608                .unwrap();
4609            locals
4610                .set_item("ExecutionAlgorithm", py.get_type::<PyExecutionAlgorithm>())
4611                .unwrap();
4612            py.run(
4613                c_str!(
4614                    r#"
4615import weakref
4616import threading
4617class Hooks:
4618    def on_start(self): self.subscribe_topic("app.shared", self.receive)
4619    def on_stop(self): pass
4620    def on_resume(self): pass
4621    def on_dispose(self): pass
4622    def receive(self, value): self.received.append(value)
4623class Actor(Hooks, DataActor): pass
4624class TradingStrategy(Hooks, Strategy): pass
4625class Algorithm(Hooks, ExecutionAlgorithm): pass
4626actor = Actor()
4627strategy = TradingStrategy()
4628algorithm = Algorithm()
4629components = [actor, strategy, algorithm]
4630for component in components: component.received = []
4631references = [weakref.ref(component) for component in components]
4632"#
4633                ),
4634                Some(&locals),
4635                None,
4636            )
4637            .unwrap();
4638            let actor = locals.get_item("actor").unwrap().unwrap().unbind();
4639            let strategy = locals.get_item("strategy").unwrap().unwrap().unbind();
4640            let algorithm = locals.get_item("algorithm").unwrap().unwrap().unbind();
4641            let actor_id = ActorId::from("Actor");
4642            trader.add_python_actor_instance(&actor, actor_id).unwrap();
4643            trader.add_python_strategy_instance(&strategy).unwrap();
4644            let native_algorithm = algorithm
4645                .bind(py)
4646                .extract::<PyRef<PyExecutionAlgorithm>>()
4647                .unwrap()
4648                .clone();
4649            trader
4650                .add_py_execution_algorithm_instance(native_algorithm, &algorithm)
4651                .unwrap();
4652            drop((actor, strategy, algorithm));
4653            py.run(
4654                c_str!(
4655                    r#"
4656
4657for component in components: component.start()
4658message = {"symbol": "example", "weights": [13, 29]}
4659for component in components: component.publish_message("app.shared", message)
4660for component in components:
4661    assert len(component.received) == 3
4662    assert all(value is message for value in component.received)
4663errors = []
4664def foreign():
4665
4666    for component in components:
4667        for name, args in [("publish_message", ("app.shared", message)),
4668                           ("subscribe_topic", ("app.shared", component.receive)),
4669                           ("unsubscribe_topic", ("app.shared", component.receive))]:
4670            try: getattr(component, name)(*args)
4671            except RuntimeError: pass
4672            except BaseException as error: errors.append(type(error).__name__)
4673            else: errors.append(name)
4674thread = threading.Thread(target=foreign)
4675thread.start()
4676thread.join()
4677assert errors == []
4678
4679for component in components:
4680    component.unsubscribe_topic("app.shared", component.receive)
4681    component.subscribe_topic("app.shared", component.receive)
4682    component.stop()
4683"#
4684                ),
4685                Some(&locals),
4686                None,
4687            )
4688            .unwrap();
4689            assert!(Rc::ptr_eq(&bus, &msgbus::get_message_bus()));
4690            trader.dispose_components().unwrap();
4691            py.run(
4692                c_str!(
4693                    r#"
4694
4695for component in components:
4696    try: component.subscribe_topic("app.shared", component.receive)
4697    except RuntimeError: pass
4698    else: raise AssertionError("disposed component accepted a subscription")
4699del component, components, actor, strategy, algorithm
4700assert [reference() for reference in references] == [None, None, None]
4701"#
4702                ),
4703                Some(&locals),
4704                None,
4705            )
4706            .unwrap();
4707            locals.clear();
4708        });
4709    }
4710
4711    #[cfg(feature = "python")]
4712    #[rstest]
4713    fn test_python_actor_and_strategy_state_callbacks_use_registered_types() {
4714        pyo3::Python::initialize();
4715
4716        Python::attach(|py| {
4717            py.run(
4718                c_str!(
4719                    r#"
4720class StateComponent:
4721    def __init__(self, state):
4722        self.state = state
4723        self.loaded = None
4724        self.calls = []
4725
4726    def on_load(self, state):
4727        self.calls.append("on_load")
4728        self.loaded = dict(state)
4729
4730    def on_save(self):
4731        self.calls.append("on_save")
4732        return self.state
4733"#
4734                ),
4735                None,
4736                None,
4737            )
4738            .unwrap();
4739
4740            let component_class = py.eval(c_str!("StateComponent"), None, None).unwrap();
4741            let actor_save =
4742                IndexMap::from([("actor-save".to_string(), b"python-actor-saved".to_vec())]);
4743            let strategy_save = IndexMap::from([(
4744                "strategy-save".to_string(),
4745                b"python-strategy-saved".to_vec(),
4746            )]);
4747            let py_actor_state = PyDict::new(py);
4748            py_actor_state
4749                .set_item("actor-save", b"python-actor-saved")
4750                .unwrap();
4751            let py_strategy_state = PyDict::new(py);
4752            py_strategy_state
4753                .set_item("strategy-save", b"python-strategy-saved")
4754                .unwrap();
4755            let py_actor = component_class.call1((py_actor_state,)).unwrap().unbind();
4756            let py_strategy = component_class
4757                .call1((py_strategy_state,))
4758                .unwrap()
4759                .unbind();
4760
4761            let actor_id = ActorId::from("PYTHON-STATE-ACTOR");
4762            let strategy_id = StrategyId::from("PYTHON-STATE-STRATEGY-001");
4763            let actor_load =
4764                IndexMap::from([("actor-load".to_string(), b"python-actor-loaded".to_vec())]);
4765            let strategy_load = IndexMap::from([(
4766                "strategy-load".to_string(),
4767                b"python-strategy-loaded".to_vec(),
4768            )]);
4769            let (database, control) = TestCacheDatabaseControl::create();
4770            control.set_actor_state(actor_id, &actor_load);
4771            control.set_strategy_state(strategy_id, &strategy_load);
4772
4773            let (
4774                _msgbus,
4775                cache,
4776                portfolio,
4777                _data_engine,
4778                _risk_engine,
4779                _exec_engine,
4780                clock_factory,
4781            ) = create_trader_components();
4782            cache.borrow_mut().set_database(Box::new(database));
4783            let trader_id = TraderId::test_default();
4784            let mut trader = Trader::new(
4785                trader_id,
4786                UUID4::new(),
4787                Environment::Backtest,
4788                clock_factory,
4789                cache.clone(),
4790                portfolio.clone(),
4791            );
4792
4793            let mut actor = PyDataActor::new(Some(DataActorConfig {
4794                actor_id: Some(actor_id),
4795                ..Default::default()
4796            }));
4797            actor.set_python_instance(py_actor.bind(py)).unwrap();
4798            let actor_clock = trader.create_component_clock(ComponentId::from(actor_id));
4799            actor
4800                .register(trader_id, actor_clock, cache.clone())
4801                .unwrap();
4802            actor.register_in_global_registries().unwrap();
4803            trader
4804                .add_actor_id_for_lifecycle::<PyDataActorInner>(actor_id)
4805                .unwrap();
4806
4807            let mut strategy = PyStrategy::new(Some(StrategyConfig {
4808                strategy_id: Some(strategy_id),
4809                ..Default::default()
4810            }));
4811            strategy.set_python_instance(py_strategy.bind(py)).unwrap();
4812            let strategy_clock = trader.create_component_clock(ComponentId::from(strategy_id));
4813            strategy
4814                .register(trader_id, strategy_clock, cache, portfolio)
4815                .unwrap();
4816            strategy.register_in_global_registries().unwrap();
4817            trader
4818                .add_strategy_id_with_subscriptions::<PyStrategyInner>(strategy_id)
4819                .unwrap();
4820
4821            let trader = Rc::new(RefCell::new(trader));
4822            Trader::load_state(&trader).unwrap();
4823            Trader::save_state(&trader).unwrap();
4824
4825            let actor_loaded = py_actor
4826                .getattr(py, "loaded")
4827                .unwrap()
4828                .extract::<std::collections::HashMap<String, Vec<u8>>>(py)
4829                .unwrap();
4830            let strategy_loaded = py_strategy
4831                .getattr(py, "loaded")
4832                .unwrap()
4833                .extract::<std::collections::HashMap<String, Vec<u8>>>(py)
4834                .unwrap();
4835            let actor_calls = py_actor
4836                .getattr(py, "calls")
4837                .unwrap()
4838                .extract::<Vec<String>>(py)
4839                .unwrap();
4840            let strategy_calls = py_strategy
4841                .getattr(py, "calls")
4842                .unwrap()
4843                .extract::<Vec<String>>(py)
4844                .unwrap();
4845
4846            assert_eq!(
4847                actor_loaded,
4848                std::collections::HashMap::from([(
4849                    "actor-load".to_string(),
4850                    b"python-actor-loaded".to_vec(),
4851                )])
4852            );
4853            assert_eq!(
4854                strategy_loaded,
4855                std::collections::HashMap::from([(
4856                    "strategy-load".to_string(),
4857                    b"python-strategy-loaded".to_vec(),
4858                )])
4859            );
4860            assert_eq!(actor_calls, vec!["on_load", "on_save"]);
4861            assert_eq!(strategy_calls, vec!["on_load", "on_save"]);
4862            assert_eq!(control.actor_state(&actor_id), Some(actor_save));
4863            assert_eq!(control.strategy_state(&strategy_id), Some(strategy_save));
4864        });
4865    }
4866
4867    #[rstest]
4868    fn test_clear_actors_disposes_and_clears_state() {
4869        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4870            create_trader_components();
4871        let trader_id = TraderId::test_default();
4872        let instance_id = UUID4::new();
4873
4874        let mut trader = Trader::new(
4875            trader_id,
4876            instance_id,
4877            Environment::Backtest,
4878            clock_factory,
4879            cache,
4880            portfolio,
4881        );
4882
4883        let actor_a = TestDataActor::new(DataActorConfig {
4884            actor_id: Some(ActorId::from("Actor-A")),
4885            ..Default::default()
4886        });
4887        let actor_b = TestDataActor::new(DataActorConfig {
4888            actor_id: Some(ActorId::from("Actor-B")),
4889            ..Default::default()
4890        });
4891        trader.add_actor(actor_a).unwrap();
4892        trader.add_actor(actor_b).unwrap();
4893        assert_eq!(trader.actor_count(), 2);
4894        assert_eq!(
4895            trader.get_component_clocks().len(),
4896            2,
4897            "each registered actor must have a component clock",
4898        );
4899
4900        trader.clear_actors().unwrap();
4901
4902        assert_eq!(trader.actor_count(), 0);
4903        assert!(trader.actor_ids().is_empty());
4904        assert_eq!(
4905            trader.get_component_clocks().len(),
4906            0,
4907            "actor clocks must be dropped after clear_actors",
4908        );
4909    }
4910
4911    #[rstest]
4912    #[case::removed(false, true)]
4913    #[case::reused(true, true)]
4914    #[case::invalid_registration(false, false)]
4915    fn test_queued_actor_time_event_is_revoked_on_retirement(
4916        #[case] reuse_id: bool,
4917        #[case] retire: bool,
4918    ) {
4919        let _guard = init_logging(
4920            TraderId::test_default(),
4921            UUID4::new(),
4922            LoggerConfig::default(),
4923            FileWriterConfig::default(),
4924        )
4925        .unwrap();
4926        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4927            create_trader_components();
4928
4929        let mut trader = Trader::new(
4930            TraderId::test_default(),
4931            UUID4::new(),
4932            Environment::Backtest,
4933            clock_factory,
4934            cache,
4935            portfolio,
4936        );
4937        let retired_id = ActorId::from("Queued-Retirement");
4938        let active_id = ActorId::from("Queued-Active");
4939        for actor_id in [retired_id, active_id] {
4940            trader
4941                .add_actor(TestDataActor::new(DataActorConfig {
4942                    actor_id: Some(actor_id),
4943                    ..Default::default()
4944                }))
4945                .unwrap();
4946
4947            trader.start_actor(&actor_id).unwrap();
4948        }
4949
4950        let mut handlers = Vec::new();
4951        let interval = DurationNanos::new(1_000_000_000);
4952
4953        for clock in trader.get_component_clocks() {
4954            clock
4955                .borrow_mut()
4956                .set_timer_ns("stats", interval, None, None, None, None, None)
4957                .unwrap();
4958            let deadline = clock.borrow().timestamp_ns() + interval;
4959            handlers.extend(queue_component_time_events(&clock, deadline));
4960        }
4961
4962        assert_eq!(handlers.len(), 2);
4963
4964        if retire {
4965            trader.remove_actor(&retired_id).unwrap();
4966        } else {
4967            deregister_actor(&retired_id.inner());
4968        }
4969
4970        if reuse_id {
4971            trader
4972                .add_actor(TestDataActor::new(DataActorConfig {
4973                    actor_id: Some(retired_id),
4974                    ..Default::default()
4975                }))
4976                .unwrap();
4977
4978            trader.start_actor(&retired_id).unwrap();
4979        }
4980
4981        arm_shutdown_on_error(true);
4982
4983        for handler in handlers {
4984            handler.run();
4985        }
4986
4987        let trigger = take_shutdown_on_error_trigger();
4988        disarm_shutdown_on_error();
4989
4990        if retire {
4991            assert!(
4992                trigger.is_none(),
4993                "retired callback logged an error: {trigger:?}"
4994            );
4995        } else {
4996            assert_eq!(
4997                trigger.unwrap().message,
4998                format!("Actor {retired_id} not found for time event handling")
4999            );
5000        }
5001
5002        assert_eq!(
5003            get_actor_unchecked::<TestDataActor>(&active_id.inner()).time_events,
5004            1
5005        );
5006
5007        if reuse_id {
5008            assert_eq!(
5009                get_actor_unchecked::<TestDataActor>(&retired_id.inner()).time_events,
5010                0
5011            );
5012        } else {
5013            assert!(!actor_exists(&retired_id.inner()));
5014        }
5015    }
5016
5017    #[rstest]
5018    fn test_failed_dispose_preserves_queued_callbacks_until_retry(
5019        #[values(false, true)] named: bool,
5020    ) {
5021        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5022            create_trader_components();
5023
5024        let mut trader = Trader::new(
5025            TraderId::test_default(),
5026            UUID4::new(),
5027            Environment::Backtest,
5028            clock_factory,
5029            cache,
5030            portfolio,
5031        );
5032        let actor_id = ActorId::from("Queued-Failed-Dispose");
5033
5034        let mut actor = TestDataActor::new(DataActorConfig {
5035            actor_id: Some(actor_id),
5036            ..Default::default()
5037        });
5038
5039        actor.fail_dispose = true;
5040        trader.add_actor(actor).unwrap();
5041        let clock = trader.get_component_clocks().pop().unwrap();
5042        let calls = Arc::new(AtomicUsize::new(0));
5043        let callback_calls = calls.clone();
5044        let callback = TimeEventCallback::from(move |_| {
5045            callback_calls.fetch_add(1, Ordering::Relaxed);
5046        });
5047
5048        if !named {
5049            clock
5050                .borrow_mut()
5051                .register_default_handler(callback.clone());
5052        }
5053
5054        let interval = DurationNanos::new(1_000_000_000);
5055        clock
5056            .borrow_mut()
5057            .set_timer_ns(
5058                "queued",
5059                interval,
5060                None,
5061                None,
5062                named.then_some(callback),
5063                None,
5064                None,
5065            )
5066            .unwrap();
5067
5068        let first_tick = clock.borrow().timestamp_ns() + interval;
5069        let handlers = queue_component_time_events(&clock, first_tick);
5070        assert_eq!(handlers.len(), 1);
5071
5072        let error = trader.remove_actor(&actor_id).unwrap_err();
5073        assert_eq!(error.to_string(), "test actor dispose failure");
5074
5075        for handler in handlers {
5076            handler.run();
5077        }
5078
5079        assert_eq!(calls.load(Ordering::Relaxed), 1);
5080        assert!(actor_exists(&actor_id.inner()));
5081        assert!(get_component(&actor_id.inner()).is_some());
5082        assert_eq!(trader.actor_ids(), vec![actor_id]);
5083        assert_eq!(clock.borrow().timer_count(), 1);
5084
5085        let handlers = queue_component_time_events(&clock, first_tick + interval);
5086        assert_eq!(handlers.len(), 1);
5087        trader.remove_actor(&actor_id).unwrap();
5088
5089        for handler in handlers {
5090            handler.run();
5091        }
5092
5093        assert_eq!(calls.load(Ordering::Relaxed), 1);
5094        assert!(!actor_exists(&actor_id.inner()));
5095        assert!(get_component(&actor_id.inner()).is_none());
5096        assert!(trader.get_component_clocks().is_empty());
5097        assert!(trader.actor_ids().is_empty());
5098        assert_eq!(clock.borrow().timer_count(), 0);
5099    }
5100
5101    #[rstest]
5102    fn test_remove_actor_deregisters_component() {
5103        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5104            create_trader_components();
5105        let mut trader = Trader::new(
5106            TraderId::test_default(),
5107            UUID4::new(),
5108            Environment::Backtest,
5109            clock_factory,
5110            cache,
5111            portfolio,
5112        );
5113
5114        let retired_id = ActorId::from("Retired-Actor");
5115        let retained_id = ActorId::from("Retained-Actor");
5116        trader
5117            .add_actor(TestDataActor::new(DataActorConfig {
5118                actor_id: Some(retired_id),
5119                ..Default::default()
5120            }))
5121            .unwrap();
5122        trader
5123            .add_actor(TestDataActor::new(DataActorConfig {
5124                actor_id: Some(retained_id),
5125                ..Default::default()
5126            }))
5127            .unwrap();
5128
5129        trader.remove_actor(&retired_id).unwrap();
5130
5131        assert!(get_component(&retired_id.inner()).is_none());
5132        assert!(!actor_exists(&retired_id.inner()));
5133        assert_eq!(trader.actor_ids(), vec![retained_id]);
5134        assert_eq!(trader.get_component_clocks().len(), 1);
5135
5136        // Deregistration is exact: an unrelated component sharing the registry survives
5137        assert!(get_component(&retained_id.inner()).is_some());
5138        assert!(actor_exists(&retained_id.inner()));
5139    }
5140
5141    #[rstest]
5142    fn test_remove_strategy_deregisters_component() {
5143        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5144            create_trader_components();
5145        let mut trader = Trader::new(
5146            TraderId::test_default(),
5147            UUID4::new(),
5148            Environment::Backtest,
5149            clock_factory,
5150            cache,
5151            portfolio,
5152        );
5153
5154        trader
5155            .add_strategy(TestStrategy::new(StrategyConfig {
5156                strategy_id: Some(StrategyId::from("Retired-001")),
5157                ..Default::default()
5158            }))
5159            .unwrap();
5160        trader
5161            .add_strategy(TestStrategy::new(StrategyConfig {
5162                strategy_id: Some(StrategyId::from("Retained-002")),
5163                ..Default::default()
5164            }))
5165            .unwrap();
5166
5167        let retired_id = StrategyId::from("Retired-001");
5168        let retained_id = StrategyId::from("Retained-002");
5169
5170        // The control endpoint lives in the typed endpoint map, not the `register_any` endpoints
5171        let control_endpoint_registered = |strategy_id| {
5172            get_message_bus()
5173                .borrow_mut()
5174                .endpoint_map::<StrategyCommand>()
5175                .get(strategy_control_endpoint(strategy_id))
5176                .is_some()
5177        };
5178        assert!(control_endpoint_registered(retired_id));
5179        assert!(control_endpoint_registered(retained_id));
5180
5181        trader.remove_strategy(&retired_id).unwrap();
5182
5183        assert!(get_component(&retired_id.inner()).is_none());
5184        assert!(!actor_exists(&retired_id.inner()));
5185        assert!(!trader.strategy_handler_ids.contains_key(&retired_id));
5186        assert!(
5187            !control_endpoint_registered(retired_id),
5188            "the retired strategy control endpoint must be deregistered",
5189        );
5190        assert_eq!(trader.strategy_ids(), vec![retained_id]);
5191
5192        assert!(get_component(&retained_id.inner()).is_some());
5193        assert!(actor_exists(&retained_id.inner()));
5194        assert!(trader.strategy_handler_ids.contains_key(&retained_id));
5195        assert!(
5196            control_endpoint_registered(retained_id),
5197            "deregistration must not remove an unrelated strategy's control endpoint",
5198        );
5199    }
5200
5201    #[rstest]
5202    #[case("clear_actors")]
5203    #[case("remove_actor")]
5204    #[case("remove_strategy")]
5205    fn test_retirement_reports_stop_hook_errors(
5206        #[case] method: &str,
5207        #[values(
5208            ComponentState::Ready,
5209            ComponentState::Starting,
5210            ComponentState::Running,
5211            ComponentState::Resuming,
5212            ComponentState::Degraded,
5213            ComponentState::Stopping,
5214            ComponentState::Stopped,
5215            ComponentState::Faulted,
5216            ComponentState::Disposed
5217        )]
5218        state: ComponentState,
5219    ) {
5220        let _guard = init_logging(
5221            TraderId::test_default(),
5222            UUID4::new(),
5223            LoggerConfig::default(),
5224            FileWriterConfig::default(),
5225        )
5226        .unwrap();
5227        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5228            create_trader_components();
5229
5230        let mut trader = Trader::new(
5231            TraderId::test_default(),
5232            UUID4::new(),
5233            Environment::Backtest,
5234            clock_factory,
5235            cache,
5236            portfolio,
5237        );
5238        let actor_id = ActorId::from("Failing-Stop-Actor");
5239        let strategy_id = StrategyId::from("Failing-Stop-Strategy");
5240
5241        let transitions: &[ComponentTrigger] = match state {
5242            ComponentState::Ready => &[],
5243            ComponentState::Starting => &[ComponentTrigger::Start],
5244            ComponentState::Running => &[ComponentTrigger::Start, ComponentTrigger::StartCompleted],
5245            ComponentState::Resuming => &[
5246                ComponentTrigger::Start,
5247                ComponentTrigger::StartCompleted,
5248                ComponentTrigger::Stop,
5249                ComponentTrigger::StopCompleted,
5250                ComponentTrigger::Resume,
5251            ],
5252            ComponentState::Degraded => &[
5253                ComponentTrigger::Start,
5254                ComponentTrigger::StartCompleted,
5255                ComponentTrigger::Degrade,
5256                ComponentTrigger::DegradeCompleted,
5257            ],
5258            ComponentState::Stopping => &[
5259                ComponentTrigger::Start,
5260                ComponentTrigger::StartCompleted,
5261                ComponentTrigger::Stop,
5262            ],
5263            ComponentState::Stopped => &[
5264                ComponentTrigger::Start,
5265                ComponentTrigger::StartCompleted,
5266                ComponentTrigger::Stop,
5267                ComponentTrigger::StopCompleted,
5268            ],
5269            ComponentState::Faulted => &[
5270                ComponentTrigger::Start,
5271                ComponentTrigger::StartCompleted,
5272                ComponentTrigger::Fault,
5273                ComponentTrigger::FaultCompleted,
5274            ],
5275            ComponentState::Disposed => &[
5276                ComponentTrigger::Dispose,
5277                ComponentTrigger::DisposeCompleted,
5278            ],
5279            _ => unreachable!(),
5280        };
5281
5282        let prepare = |component: &mut dyn Component| {
5283            for trigger in transitions {
5284                component.transition_state(*trigger).unwrap();
5285            }
5286        };
5287
5288        let (id, error) = if method == "remove_strategy" {
5289            let mut strategy = TestStrategy::new(StrategyConfig {
5290                strategy_id: Some(strategy_id),
5291                ..Default::default()
5292            });
5293
5294            strategy.fail_stop = true;
5295            trader.add_strategy(strategy).unwrap();
5296            prepare(&mut *get_actor_unchecked::<TestStrategy>(
5297                &strategy_id.inner(),
5298            ));
5299            (strategy_id.inner(), "test strategy stop failure")
5300        } else {
5301            let mut actor = TestDataActor::new(DataActorConfig {
5302                actor_id: Some(actor_id),
5303                ..Default::default()
5304            });
5305
5306            actor.fail_stop = true;
5307            trader.add_actor(actor).unwrap();
5308            prepare(&mut *get_actor_unchecked::<TestDataActor>(
5309                &actor_id.inner(),
5310            ));
5311            (actor_id.inner(), "test actor stop failure")
5312        };
5313
5314        let other_id = ActorId::from("Other-Actor");
5315        trader
5316            .add_actor(TestDataActor::new(DataActorConfig {
5317                actor_id: Some(other_id),
5318                ..Default::default()
5319            }))
5320            .unwrap();
5321
5322        arm_shutdown_on_error(true);
5323
5324        let result = match method {
5325            "clear_actors" => trader.clear_actors(),
5326            "remove_actor" => trader.remove_actor(&actor_id),
5327            "remove_strategy" => trader.remove_strategy(&strategy_id),
5328            _ => unreachable!(),
5329        };
5330
5331        let trigger = take_shutdown_on_error_trigger();
5332        disarm_shutdown_on_error();
5333
5334        result.unwrap();
5335        assert!(get_component(&id).is_none());
5336        assert!(!actor_exists(&id));
5337        assert_eq!(trader.strategy_count(), 0);
5338        assert_eq!(trader.actor_count(), usize::from(method != "clear_actors"));
5339        assert_eq!(actor_exists(&other_id.inner()), method != "clear_actors");
5340
5341        if matches!(
5342            state,
5343            ComponentState::Starting
5344                | ComponentState::Running
5345                | ComponentState::Resuming
5346                | ComponentState::Degraded
5347        ) {
5348            let trigger = trigger.unwrap();
5349            assert_eq!(trigger.component, id);
5350            assert_eq!(trigger.message, error);
5351        } else {
5352            assert_eq!(trigger, None);
5353        }
5354    }
5355
5356    #[rstest]
5357    fn test_remove_actor_disposes_after_stop_hook_failure() {
5358        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5359            create_trader_components();
5360        let mut trader = Trader::new(
5361            TraderId::test_default(),
5362            UUID4::new(),
5363            Environment::Backtest,
5364            clock_factory,
5365            cache,
5366            portfolio,
5367        );
5368        let actor_id = ActorId::from("Failing-Stop-Actor");
5369        let mut actor = TestDataActor::new(DataActorConfig {
5370            actor_id: Some(actor_id),
5371            ..Default::default()
5372        });
5373        actor.fail_stop = true;
5374        trader.add_actor(actor).unwrap();
5375        trader.start_actor(&actor_id).unwrap();
5376
5377        let error = stop_component(&actor_id.inner()).unwrap_err();
5378        assert_eq!(error.to_string(), "test actor stop failure");
5379        assert_eq!(
5380            component_state(&actor_id.inner()).unwrap(),
5381            ComponentState::Stopping,
5382        );
5383
5384        trader.remove_actor(&actor_id).unwrap();
5385
5386        assert!(get_component(&actor_id.inner()).is_none());
5387        assert!(!actor_exists(&actor_id.inner()));
5388        assert!(!trader.actor_ids().contains(&actor_id));
5389    }
5390
5391    #[rstest]
5392    fn test_remove_strategy_disposes_after_stop_hook_failure() {
5393        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5394            create_trader_components();
5395        let mut trader = Trader::new(
5396            TraderId::test_default(),
5397            UUID4::new(),
5398            Environment::Backtest,
5399            clock_factory,
5400            cache,
5401            portfolio,
5402        );
5403        let strategy_id = StrategyId::from("Failing-Stop-Strategy");
5404        let mut strategy = TestStrategy::new(StrategyConfig {
5405            strategy_id: Some(strategy_id),
5406            ..Default::default()
5407        });
5408        strategy.fail_stop = true;
5409        trader.add_strategy(strategy).unwrap();
5410        trader.start_strategy(&strategy_id).unwrap();
5411
5412        let error = stop_component(&strategy_id.inner()).unwrap_err();
5413        assert_eq!(error.to_string(), "test strategy stop failure");
5414        assert_eq!(
5415            component_state(&strategy_id.inner()).unwrap(),
5416            ComponentState::Stopping,
5417        );
5418
5419        trader.remove_strategy(&strategy_id).unwrap();
5420
5421        assert!(get_component(&strategy_id.inner()).is_none());
5422        assert!(!actor_exists(&strategy_id.inner()));
5423        assert!(!trader.strategy_ids().contains(&strategy_id));
5424    }
5425
5426    #[rstest]
5427    fn test_clear_exec_algorithms_deregisters_components() {
5428        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5429            create_trader_components();
5430        let mut trader = Trader::new(
5431            TraderId::test_default(),
5432            UUID4::new(),
5433            Environment::Backtest,
5434            clock_factory,
5435            cache,
5436            portfolio,
5437        );
5438
5439        let first_id = ExecAlgorithmId::from("EXEC-ALGO-1");
5440        let second_id = ExecAlgorithmId::from("EXEC-ALGO-2");
5441        for exec_algorithm_id in [first_id, second_id] {
5442            trader
5443                .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
5444                    exec_algorithm_id: Some(exec_algorithm_id),
5445                    ..Default::default()
5446                }))
5447                .unwrap();
5448        }
5449
5450        for exec_algorithm_id in [first_id, second_id] {
5451            assert!(
5452                msgbus::has_endpoint(&format!("{exec_algorithm_id}.execute")),
5453                "the execute endpoint must be registered before clearing",
5454            );
5455        }
5456
5457        trader.clear_exec_algorithms().unwrap();
5458
5459        for exec_algorithm_id in [first_id, second_id] {
5460            assert!(get_component(&exec_algorithm_id.inner()).is_none());
5461            assert!(!actor_exists(&exec_algorithm_id.inner()));
5462            assert!(!msgbus::has_endpoint(&format!(
5463                "{exec_algorithm_id}.execute"
5464            )));
5465        }
5466        assert!(trader.exec_algorithm_ids().is_empty());
5467        assert!(trader.get_component_clocks().is_empty());
5468    }
5469
5470    #[rstest]
5471    fn test_failed_dispose_preserves_registration() {
5472        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5473            create_trader_components();
5474        let mut trader = Trader::new(
5475            TraderId::test_default(),
5476            UUID4::new(),
5477            Environment::Backtest,
5478            clock_factory,
5479            cache,
5480            portfolio,
5481        );
5482
5483        let actor_id = ActorId::from("Failing-Dispose-Actor");
5484        let mut actor = TestDataActor::new(DataActorConfig {
5485            actor_id: Some(actor_id),
5486            ..Default::default()
5487        });
5488        actor.fail_dispose = true;
5489        trader.add_actor(actor).unwrap();
5490
5491        let error = trader.remove_actor(&actor_id).unwrap_err();
5492
5493        assert_eq!(error.to_string(), "test actor dispose failure");
5494        assert_eq!(trader.actor_ids(), vec![actor_id]);
5495        assert_eq!(trader.get_component_clocks().len(), 1);
5496        assert!(get_component(&actor_id.inner()).is_some());
5497        assert!(actor_exists(&actor_id.inner()));
5498        assert_eq!(
5499            component_state(&actor_id.inner()).unwrap(),
5500            ComponentState::Faulted,
5501            "a failed disposal faults the component rather than reaching Disposed",
5502        );
5503    }
5504
5505    #[rstest]
5506    fn test_failed_dispose_component_can_be_retired() {
5507        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5508            create_trader_components();
5509        let mut trader = Trader::new(
5510            TraderId::test_default(),
5511            UUID4::new(),
5512            Environment::Backtest,
5513            clock_factory,
5514            cache,
5515            portfolio,
5516        );
5517
5518        let actor_id = ActorId::from("Retired-After-Failed-Dispose-Actor");
5519        let mut actor = TestDataActor::new(DataActorConfig {
5520            actor_id: Some(actor_id),
5521            ..Default::default()
5522        });
5523        actor.fail_dispose = true;
5524        trader.add_actor(actor).unwrap();
5525        trader.start_actor(&actor_id).unwrap();
5526
5527        let instrument_id = InstrumentId::from("AUD/USD.SIM");
5528        let deltas_topic = get_book_deltas_topic(instrument_id);
5529        get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5530            instrument_id,
5531            BookType::L3_MBO,
5532            None,
5533            None,
5534            false,
5535            None,
5536        );
5537
5538        trader.remove_actor(&actor_id).unwrap_err();
5539        assert_eq!(
5540            component_state(&actor_id.inner()).unwrap(),
5541            ComponentState::Faulted
5542        );
5543        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5544
5545        // The dead end this closes: retirement previously failed for the life of the process
5546        trader.remove_actor(&actor_id).unwrap();
5547
5548        assert!(get_component(&actor_id.inner()).is_none());
5549        assert!(!actor_exists(&actor_id.inner()));
5550        assert!(trader.actor_ids().is_empty());
5551        assert!(trader.get_component_clocks().is_empty());
5552        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5553    }
5554
5555    #[rstest]
5556    fn test_failed_dispose_preserves_subscriptions() {
5557        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5558            create_trader_components();
5559        let mut trader = Trader::new(
5560            TraderId::test_default(),
5561            UUID4::new(),
5562            Environment::Backtest,
5563            clock_factory,
5564            cache,
5565            portfolio,
5566        );
5567
5568        let actor_id = ActorId::from("Subscribed-Failing-Dispose-Actor");
5569        let mut actor = TestDataActor::new(DataActorConfig {
5570            actor_id: Some(actor_id),
5571            ..Default::default()
5572        });
5573        actor.fail_dispose = true;
5574        trader.add_actor(actor).unwrap();
5575        trader.start_actor(&actor_id).unwrap();
5576
5577        let instrument_id = InstrumentId::from("AUD/USD.SIM");
5578        let deltas_topic = get_book_deltas_topic(instrument_id);
5579        get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5580            instrument_id,
5581            BookType::L3_MBO,
5582            None,
5583            None,
5584            false,
5585            None,
5586        );
5587
5588        // Positive control: without this the check after the failed disposal would be vacuous
5589        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5590
5591        trader.remove_actor(&actor_id).unwrap_err();
5592
5593        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5594    }
5595
5596    #[rstest]
5597    fn test_runtime_faulted_component_retires_without_leaking_subscriptions() {
5598        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5599            create_trader_components();
5600        let mut trader = Trader::new(
5601            TraderId::test_default(),
5602            UUID4::new(),
5603            Environment::Backtest,
5604            clock_factory,
5605            cache,
5606            portfolio,
5607        );
5608
5609        let actor_id = ActorId::from("Runtime-Faulted-Actor");
5610        trader
5611            .add_actor(TestDataActor::new(DataActorConfig {
5612                actor_id: Some(actor_id),
5613                ..Default::default()
5614            }))
5615            .unwrap();
5616        trader.start_actor(&actor_id).unwrap();
5617
5618        let instrument_id = InstrumentId::from("AUD/USD.SIM");
5619        let deltas_topic = get_book_deltas_topic(instrument_id);
5620        get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5621            instrument_id,
5622            BookType::L3_MBO,
5623            None,
5624            None,
5625            false,
5626            None,
5627        );
5628
5629        // Positive control: without this the check after retirement would be vacuous
5630        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5631
5632        // Faulting at runtime is a separate route to Faulted from a failed disposal, and
5633        // retirement skips disposal for a faulted component
5634        get_actor_unchecked::<TestDataActor>(&actor_id.inner())
5635            .fault()
5636            .unwrap();
5637        assert_eq!(
5638            component_state(&actor_id.inner()).unwrap(),
5639            ComponentState::Faulted
5640        );
5641
5642        trader.remove_actor(&actor_id).unwrap();
5643
5644        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5645        assert!(get_component(&actor_id.inner()).is_none());
5646        assert!(!actor_exists(&actor_id.inner()));
5647    }
5648
5649    #[rstest]
5650    fn test_actor_retires_after_fault_hook_failure() {
5651        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5652            create_trader_components();
5653        let mut trader = Trader::new(
5654            TraderId::test_default(),
5655            UUID4::new(),
5656            Environment::Backtest,
5657            clock_factory,
5658            cache,
5659            portfolio,
5660        );
5661        let actor_id = ActorId::from("Failing-Fault-Actor");
5662        let mut actor = TestDataActor::new(DataActorConfig {
5663            actor_id: Some(actor_id),
5664            ..Default::default()
5665        });
5666        actor.fail_fault = true;
5667        trader.add_actor(actor).unwrap();
5668        trader.start_actor(&actor_id).unwrap();
5669
5670        let instrument_id = InstrumentId::from("AUD/USD.SIM");
5671        let deltas_topic = get_book_deltas_topic(instrument_id);
5672        get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5673            instrument_id,
5674            BookType::L3_MBO,
5675            None,
5676            None,
5677            false,
5678            None,
5679        );
5680        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5681
5682        let error = get_actor_unchecked::<TestDataActor>(&actor_id.inner())
5683            .fault()
5684            .unwrap_err();
5685        assert_eq!(error.to_string(), "test actor fault failure");
5686        assert_eq!(
5687            component_state(&actor_id.inner()).unwrap(),
5688            ComponentState::Faulting,
5689        );
5690        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5691
5692        trader.remove_actor(&actor_id).unwrap();
5693
5694        assert!(get_component(&actor_id.inner()).is_none());
5695        assert!(!actor_exists(&actor_id.inner()));
5696        assert!(trader.actor_ids().is_empty());
5697        assert!(trader.get_component_clocks().is_empty());
5698    }
5699
5700    #[rstest]
5701    fn test_already_disposed_component_can_be_removed() {
5702        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5703            create_trader_components();
5704        let mut trader = Trader::new(
5705            TraderId::test_default(),
5706            UUID4::new(),
5707            Environment::Backtest,
5708            clock_factory,
5709            cache,
5710            portfolio,
5711        );
5712
5713        let actor_id = ActorId::from("Directly-Disposed-Actor");
5714        trader
5715            .add_actor(TestDataActor::new(DataActorConfig {
5716                actor_id: Some(actor_id),
5717                ..Default::default()
5718            }))
5719            .unwrap();
5720
5721        // Mirrors a Python caller invoking `dispose()` on its own component
5722        dispose_component(&actor_id.inner()).unwrap();
5723        assert_eq!(
5724            component_state(&actor_id.inner()).unwrap(),
5725            ComponentState::Disposed
5726        );
5727
5728        trader.remove_actor(&actor_id).unwrap();
5729
5730        assert!(get_component(&actor_id.inner()).is_none());
5731        assert!(!actor_exists(&actor_id.inner()));
5732        assert!(trader.actor_ids().is_empty());
5733        assert!(trader.get_component_clocks().is_empty());
5734    }
5735
5736    #[cfg(feature = "python")]
5737    fn install_owned_actor_module(py: Python<'_>, module_name: &str) {
5738        let module = PyModule::new(py, module_name).expect("test module should create");
5739        module
5740            .setattr("DataActor", py.get_type::<PyDataActor>())
5741            .expect("DataActor type should bind");
5742        module
5743            .setattr("INSTANCES", PyDict::new(py))
5744            .expect("INSTANCES should bind");
5745
5746        let code = std::ffi::CString::new(
5747            r#"
5748import weakref
5749
5750
5751class OwnedActor(DataActor):
5752    def __init__(self):
5753        super().__init__()
5754        INSTANCES["actor"] = weakref.ref(self)
5755"#,
5756        )
5757        .expect("python test code should be valid CString");
5758
5759        py.run(code.as_c_str(), Some(&module.dict()), None)
5760            .expect("test actor code should execute");
5761
5762        py.import("sys")
5763            .expect("sys should import")
5764            .getattr("modules")
5765            .expect("sys.modules should exist")
5766            .set_item(module_name, module)
5767            .expect("test actor module should register");
5768    }
5769
5770    #[cfg(feature = "python")]
5771    fn owned_actor_is_alive(py: Python<'_>, module_name: &str) -> bool {
5772        !py.import(module_name)
5773            .expect("test actor module should import")
5774            .getattr("INSTANCES")
5775            .expect("INSTANCES should exist")
5776            .get_item("actor")
5777            .expect("the actor weak reference should be recorded")
5778            .call0()
5779            .expect("a weak reference should be callable")
5780            .is_none()
5781    }
5782
5783    #[cfg(feature = "python")]
5784    #[rstest]
5785    fn test_trader_owns_python_actor_wrapper_until_removal() {
5786        Python::initialize();
5787
5788        let module_name = "test_trader_owned_actor";
5789        Python::attach(|py| install_owned_actor_module(py, module_name));
5790
5791        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5792            create_trader_components();
5793        let mut trader = Trader::new(
5794            TraderId::test_default(),
5795            UUID4::new(),
5796            Environment::Backtest,
5797            clock_factory,
5798            cache,
5799            portfolio,
5800        );
5801
5802        let actor_id = trader
5803            .add_actor_from_importable_config(&ImportableActorConfig {
5804                actor_path: format!("{module_name}:OwnedActor"),
5805                config_path: String::new(),
5806                config: std::collections::HashMap::new(),
5807            })
5808            .unwrap();
5809
5810        assert_eq!(actor_id, ActorId::from("OwnedActor"));
5811        assert!(
5812            Python::attach(|py| owned_actor_is_alive(py, module_name)),
5813            "the trader must own the registered wrapper after the caller drops its reference",
5814        );
5815
5816        trader.remove_actor(&actor_id).unwrap();
5817
5818        assert!(
5819            !Python::attach(|py| owned_actor_is_alive(py, module_name)),
5820            "removal must release the trader's strong owner and let the wrapper be collected",
5821        );
5822        assert!(get_component(&actor_id.inner()).is_none());
5823        assert!(!actor_exists(&actor_id.inner()));
5824    }
5825
5826    #[cfg(feature = "python")]
5827    fn install_python_component_module(py: Python<'_>, module_name: &str) {
5828        let module = PyModule::new(py, module_name).expect("test module should create");
5829        module
5830            .setattr("DataActor", py.get_type::<PyDataActor>())
5831            .expect("DataActor type should bind");
5832        module
5833            .setattr("Strategy", py.get_type::<PyStrategy>())
5834            .expect("Strategy type should bind");
5835
5836        let code = c_str!(
5837            r#"
5838class ModuleActor(DataActor):
5839    pass
5840
5841
5842class ModuleStrategy(Strategy):
5843    pass
5844"#
5845        );
5846
5847        py.run(code, Some(&module.dict()), None)
5848            .expect("test component code should execute");
5849
5850        py.import("sys")
5851            .expect("sys should import")
5852            .getattr("modules")
5853            .expect("sys.modules should exist")
5854            .set_item(module_name, module)
5855            .expect("test component module should register");
5856    }
5857
5858    #[cfg(feature = "python")]
5859    fn create_python_component(py: Python<'_>, module_name: &str, class_name: &str) -> Py<PyAny> {
5860        py.import(module_name)
5861            .expect("test component module should import")
5862            .getattr(class_name)
5863            .expect("test component class should exist")
5864            .call0()
5865            .expect("test component should construct")
5866            .unbind()
5867    }
5868
5869    #[cfg(feature = "python")]
5870    #[rstest]
5871    fn test_automatic_python_strategy_tag_skips_existing_tags(
5872        #[values(false, true)] remove_first: bool,
5873    ) {
5874        Python::initialize();
5875        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5876            create_trader_components();
5877
5878        let mut trader = Trader::new(
5879            TraderId::test_default(),
5880            UUID4::new(),
5881            Environment::Backtest,
5882            clock_factory,
5883            cache,
5884            portfolio,
5885        );
5886
5887        Python::attach(|py| {
5888            let module_name = "test_automatic_python_strategy_tag";
5889            install_python_component_module(py, module_name);
5890            if remove_first {
5891                let strategy = create_python_component(py, module_name, "ModuleStrategy");
5892                trader.add_python_strategy_instance(&strategy).unwrap();
5893            }
5894
5895            let strategy = create_python_component(py, module_name, "ModuleStrategy");
5896            strategy
5897                .bind(py)
5898                .extract::<PyRefMut<PyStrategy>>()
5899                .unwrap()
5900                .set_strategy_id(StrategyId::from("ModuleStrategy-001"))
5901                .unwrap();
5902            trader.add_python_strategy_instance(&strategy).unwrap();
5903            if remove_first {
5904                trader
5905                    .remove_strategy(&StrategyId::from("ModuleStrategy-000"))
5906                    .unwrap();
5907            }
5908
5909            let strategy = create_python_component(py, module_name, "ModuleStrategy");
5910            let strategy_id = trader.add_python_strategy_instance(&strategy).unwrap();
5911
5912            assert_eq!(strategy_id, StrategyId::from("ModuleStrategy-002"));
5913            assert_eq!(
5914                trader.strategy_ids(),
5915                vec![StrategyId::from("ModuleStrategy-001"), strategy_id]
5916            );
5917        });
5918    }
5919
5920    #[cfg(feature = "python")]
5921    #[rstest]
5922    fn test_colliding_python_registration_leaves_the_live_component_registered() {
5923        Python::initialize();
5924
5925        let module_name = "test_trader_colliding_components";
5926        let strategy_id = StrategyId::from("Colliding-001");
5927        let actor_id = ActorId::from("Colliding-001");
5928        let component_id = ComponentId::from(strategy_id);
5929
5930        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5931            create_trader_components();
5932        let mut trader = Trader::new(
5933            TraderId::test_default(),
5934            UUID4::new(),
5935            Environment::Backtest,
5936            clock_factory,
5937            cache,
5938            portfolio,
5939        );
5940
5941        Python::attach(|py| {
5942            install_python_component_module(py, module_name);
5943
5944            let py_strategy = create_python_component(py, module_name, "ModuleStrategy");
5945            py_strategy
5946                .bind(py)
5947                .extract::<PyRefMut<PyStrategy>>()
5948                .unwrap()
5949                .set_strategy_id(strategy_id)
5950                .unwrap();
5951
5952            trader
5953                .commit_python_strategy_instance(&py_strategy)
5954                .unwrap();
5955
5956            // Positive control: without these the checks after the failed attempt would be vacuous
5957            assert!(get_component(&component_id.inner()).is_some());
5958            assert!(actor_exists(&component_id.inner()));
5959            assert!(
5960                get_python_wrapper(component_id)
5961                    .unwrap()
5962                    .bind(py)
5963                    .is(py_strategy.bind(py))
5964            );
5965
5966            let py_actor = create_python_component(py, module_name, "ModuleActor");
5967            py_actor
5968                .bind(py)
5969                .extract::<PyRefMut<PyDataActor>>()
5970                .unwrap()
5971                .set_actor_id(actor_id);
5972
5973            let error = trader
5974                .add_python_actor_instance(&py_actor, actor_id)
5975                .expect_err("an actor colliding with a live strategy must not register");
5976            assert!(error.to_string().contains("already registered"));
5977
5978            // The strategy keeps every registration its own attempt created
5979            assert!(try_get_actor_unchecked::<PyStrategyInner>(&component_id.inner()).is_some());
5980            assert!(get_component(&component_id.inner()).is_some());
5981            assert!(actor_exists(&component_id.inner()));
5982            assert!(
5983                get_python_wrapper(component_id)
5984                    .expect("the strategy must still hold its wrapper")
5985                    .bind(py)
5986                    .is(py_strategy.bind(py))
5987            );
5988            assert_eq!(trader.strategy_ids(), vec![strategy_id]);
5989            assert!(trader.actor_ids().is_empty());
5990            assert_eq!(trader.get_component_clocks().len(), 1);
5991        });
5992    }
5993
5994    #[cfg(feature = "python")]
5995    #[rstest]
5996    fn test_failed_python_actor_registration_rolls_back_only_its_own_state() {
5997        Python::initialize();
5998
5999        let module_name = "test_trader_rollback_components";
6000        let registered_id = ActorId::from("Rollback-Registered");
6001        let attempted_id = ActorId::from("Rollback-Attempted");
6002        let registered_component_id = ComponentId::from(registered_id);
6003        let attempted_component_id = ComponentId::from(attempted_id);
6004
6005        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6006            create_trader_components();
6007        let mut trader = Trader::new(
6008            TraderId::test_default(),
6009            UUID4::new(),
6010            Environment::Backtest,
6011            clock_factory,
6012            cache,
6013            portfolio,
6014        );
6015
6016        Python::attach(|py| {
6017            install_python_component_module(py, module_name);
6018
6019            let py_actor = create_python_component(py, module_name, "ModuleActor");
6020            py_actor
6021                .bind(py)
6022                .extract::<PyRefMut<PyDataActor>>()
6023                .unwrap()
6024                .set_actor_id(registered_id);
6025
6026            trader
6027                .add_python_actor_instance(&py_actor, registered_id)
6028                .unwrap();
6029
6030            // The same instance cannot register twice, so this attempt fails after it has already
6031            // created a component clock
6032            let error = trader
6033                .add_python_actor_instance(&py_actor, attempted_id)
6034                .expect_err("registering an already registered actor must fail");
6035            assert!(error.to_string().contains("already registered"));
6036
6037            assert!(get_component(&attempted_component_id.inner()).is_none());
6038            assert!(!actor_exists(&attempted_component_id.inner()));
6039            assert!(get_python_wrapper(attempted_component_id).is_none());
6040            assert_eq!(trader.get_component_clocks().len(), 1);
6041
6042            assert!(get_component(&registered_component_id.inner()).is_some());
6043            assert!(actor_exists(&registered_component_id.inner()));
6044            assert!(
6045                get_python_wrapper(registered_component_id)
6046                    .expect("the registered actor must still hold its wrapper")
6047                    .bind(py)
6048                    .is(py_actor.bind(py))
6049            );
6050            assert_eq!(trader.actor_ids(), vec![registered_id]);
6051        });
6052    }
6053
6054    #[cfg(feature = "python")]
6055    #[rstest]
6056    fn test_failed_exec_algorithm_registration_leaves_the_id_reusable() {
6057        use nautilus_trading::{ExecutionAlgorithmNative, python::algorithm::PyExecutionAlgorithm};
6058
6059        Python::initialize();
6060
6061        let exec_algorithm_id = ExecAlgorithmId::from("Rollback-Algo");
6062        let component_id = ComponentId::from(exec_algorithm_id);
6063
6064        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6065            create_trader_components();
6066        let trader_id = TraderId::test_default();
6067        let mut trader = Trader::new(
6068            trader_id,
6069            UUID4::new(),
6070            Environment::Backtest,
6071            clock_factory,
6072            cache.clone(),
6073            portfolio,
6074        );
6075
6076        Python::attach(|py| {
6077            let config = py
6078                .eval(
6079                    c_str!("type('_Cfg', (), {'exec_algorithm_id': 'Rollback-Algo'})()"),
6080                    None,
6081                    None,
6082                )
6083                .unwrap();
6084            let wrapper = py
6085                .get_type::<PyExecutionAlgorithm>()
6086                .as_any()
6087                .call1((config.clone(),))
6088                .unwrap();
6089            let mut algorithm = wrapper
6090                .extract::<PyRefMut<PyExecutionAlgorithm>>()
6091                .unwrap()
6092                .clone();
6093
6094            // An already registered algorithm fails `register`, which the trader only reaches after
6095            // it has created the component clock
6096            let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
6097            algorithm
6098                .exec_algorithm_core_mut()
6099                .register(trader_id, clock, cache)
6100                .unwrap();
6101
6102            let error = trader
6103                .add_py_execution_algorithm_instance(algorithm, &wrapper.unbind())
6104                .expect_err("registering an already registered algorithm must fail");
6105            assert!(error.to_string().contains("already registered"));
6106
6107            // A stranded clock would make the guard reject every later retry of this ID
6108            assert!(trader.get_component_clocks().is_empty());
6109            assert!(trader.exec_algorithm_ids().is_empty());
6110            assert!(get_python_wrapper(component_id).is_none());
6111
6112            let fresh_wrapper = py
6113                .get_type::<PyExecutionAlgorithm>()
6114                .as_any()
6115                .call1((config,))
6116                .unwrap();
6117            let fresh = fresh_wrapper
6118                .extract::<PyRefMut<PyExecutionAlgorithm>>()
6119                .unwrap()
6120                .clone();
6121
6122            trader
6123                .add_py_execution_algorithm_instance(fresh, &fresh_wrapper.unbind())
6124                .expect("a failed attempt must not dead-end the component ID");
6125            assert_eq!(trader.exec_algorithm_ids(), vec![exec_algorithm_id]);
6126            assert!(get_python_wrapper(component_id).is_some());
6127
6128            // Retire everything so the thread-local registries stay isolated between tests
6129            let _ = trader.dispose_components();
6130            assert!(get_python_wrapper(component_id).is_none());
6131            assert!(trader.get_component_clocks().is_empty());
6132        });
6133    }
6134
6135    #[rstest]
6136    fn test_retirement_removes_component_subscriptions() {
6137        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6138            create_trader_components();
6139        let mut trader = Trader::new(
6140            TraderId::test_default(),
6141            UUID4::new(),
6142            Environment::Backtest,
6143            clock_factory,
6144            cache,
6145            portfolio,
6146        );
6147
6148        let actor_id = ActorId::from("Subscribing-Actor");
6149        trader
6150            .add_actor(TestDataActor::new(DataActorConfig {
6151                actor_id: Some(actor_id),
6152                ..Default::default()
6153            }))
6154            .unwrap();
6155        trader.start_actor(&actor_id).unwrap();
6156
6157        let instrument_id = InstrumentId::from("AUD/USD.SIM");
6158        let data_type = DataType::new(stringify!(TestRetirementData), None, None);
6159        let deltas_topic = get_book_deltas_topic(instrument_id);
6160        let depth_topic = get_book_depth_topic(instrument_id);
6161        let data_topic = get_custom_topic(&data_type);
6162
6163        {
6164            let mut actor = get_actor_unchecked::<TestDataActor>(&actor_id.inner());
6165            actor.subscribe_data(data_type, None, None);
6166            actor.subscribe_book_deltas(instrument_id, BookType::L3_MBO, None, None, false, None);
6167            actor.subscribe_book_depth(instrument_id, BookType::L2_MBP, None, None, false, None);
6168        }
6169
6170        // Positive control: without these the checks after retirement would be vacuous
6171        assert_eq!(msgbus::subscriptions_count_any(data_topic).unwrap(), 1);
6172        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
6173        assert_eq!(msgbus::subscriber_count_depth(depth_topic), 1);
6174
6175        trader.remove_actor(&actor_id).unwrap();
6176
6177        // Retirement must leave no handler behind for any of the component's subscription kinds
6178        assert_eq!(msgbus::subscriptions_count_any(data_topic).unwrap(), 0);
6179        assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
6180        assert_eq!(msgbus::subscriber_count_depth(depth_topic), 0);
6181    }
6182
6183    #[rstest]
6184    fn test_retirement_releases_bar_aggregator_after_final_subscriber() {
6185        let (msgbus, cache, portfolio, data_engine, _risk_engine, _exec_engine, clock_factory) =
6186            create_trader_components();
6187        set_message_bus(msgbus);
6188        replace_data_cmd_sender(Arc::new(SyncDataCommandSender));
6189        DataEngine::register_msgbus_handlers(&data_engine);
6190
6191        let instrument = audusd_sim();
6192        cache
6193            .borrow_mut()
6194            .add_instrument(InstrumentAny::CurrencyPair(instrument))
6195            .unwrap();
6196        let mut trader = Trader::new(
6197            TraderId::test_default(),
6198            UUID4::new(),
6199            Environment::Backtest,
6200            clock_factory,
6201            cache,
6202            portfolio,
6203        );
6204        let first_id = ActorId::from("Bar-Subscriber-001");
6205        let second_id = ActorId::from("Bar-Subscriber-002");
6206        for actor_id in [first_id, second_id] {
6207            trader
6208                .add_actor(TestDataActor::new(DataActorConfig {
6209                    actor_id: Some(actor_id),
6210                    ..Default::default()
6211                }))
6212                .unwrap();
6213            trader.start_actor(&actor_id).unwrap();
6214        }
6215
6216        let bar_type = BarType::from("AUD/USD.SIM-1-MINUTE-LAST-INTERNAL");
6217        get_actor_unchecked::<TestDataActor>(&first_id.inner())
6218            .subscribe_bars(bar_type, None, None);
6219        get_actor_unchecked::<TestDataActor>(&second_id.inner())
6220            .subscribe_bars(bar_type, None, None);
6221        drain_data_cmd_queue();
6222        assert!(data_engine.borrow().subscribed_bars().contains(&bar_type));
6223
6224        let topic = get_bars_topic(bar_type);
6225        assert_eq!(msgbus::exact_subscriber_count_bars(topic), 2);
6226
6227        let bar = Bar {
6228            bar_type,
6229            ..stub_bar()
6230        };
6231
6232        trader.remove_actor(&first_id).unwrap();
6233        drain_data_cmd_queue();
6234        assert!(data_engine.borrow().subscribed_bars().contains(&bar_type));
6235
6236        assert_eq!(msgbus::exact_subscriber_count_bars(topic), 1);
6237        msgbus::publish_bar(topic, &bar);
6238        assert_eq!(
6239            get_actor_unchecked::<TestDataActor>(&second_id.inner()).bars_received,
6240            1
6241        );
6242        assert!(!actor_exists(&first_id.inner()));
6243        assert!(get_component(&first_id.inner()).is_none());
6244
6245        trader.remove_actor(&second_id).unwrap();
6246        drain_data_cmd_queue();
6247        assert!(!data_engine.borrow().subscribed_bars().contains(&bar_type));
6248        assert_eq!(msgbus::exact_subscriber_count_bars(topic), 0);
6249        assert!(!actor_exists(&second_id.inner()));
6250        assert!(get_component(&second_id.inner()).is_none());
6251        assert!(trader.get_component_clocks().is_empty());
6252    }
6253
6254    #[rstest]
6255    fn test_failed_bulk_disposal_keeps_bookkeeping_consistent() {
6256        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6257            create_trader_components();
6258        let mut trader = Trader::new(
6259            TraderId::test_default(),
6260            UUID4::new(),
6261            Environment::Backtest,
6262            clock_factory,
6263            cache,
6264            portfolio,
6265        );
6266
6267        let retired_id = ActorId::from("Bulk-Retired-Actor");
6268        let failing_id = ActorId::from("Bulk-Failing-Actor");
6269        trader
6270            .add_actor(TestDataActor::new(DataActorConfig {
6271                actor_id: Some(retired_id),
6272                ..Default::default()
6273            }))
6274            .unwrap();
6275        let mut failing = TestDataActor::new(DataActorConfig {
6276            actor_id: Some(failing_id),
6277            ..Default::default()
6278        });
6279        failing.fail_dispose = true;
6280        trader.add_actor(failing).unwrap();
6281
6282        let error = trader.clear_actors().unwrap_err();
6283
6284        assert_eq!(error.to_string(), "test actor dispose failure");
6285        assert_eq!(trader.actor_ids(), vec![failing_id]);
6286        assert_eq!(trader.get_component_clocks().len(), 1);
6287        assert!(get_component(&retired_id.inner()).is_none());
6288        assert!(!actor_exists(&retired_id.inner()));
6289        assert!(get_component(&failing_id.inner()).is_some());
6290        assert!(actor_exists(&failing_id.inner()));
6291    }
6292
6293    #[rstest]
6294    fn test_subscription_handler_tolerates_deregistered_actor() {
6295        let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6296            create_trader_components();
6297        let mut trader = Trader::new(
6298            TraderId::test_default(),
6299            UUID4::new(),
6300            Environment::Backtest,
6301            clock_factory,
6302            cache,
6303            portfolio,
6304        );
6305
6306        let actor_id = ActorId::from("Snapshotted-Actor");
6307        trader
6308            .add_actor(TestDataActor::new(DataActorConfig {
6309                actor_id: Some(actor_id),
6310                ..Default::default()
6311            }))
6312            .unwrap();
6313        trader.start_actor(&actor_id).unwrap();
6314
6315        let bar = stub_bar();
6316        let topic = get_bars_topic(bar.bar_type.standard());
6317        get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_bars(
6318            bar.bar_type,
6319            None,
6320            None,
6321        );
6322
6323        msgbus::publish_bar(topic, &bar);
6324        assert_eq!(
6325            get_actor_unchecked::<TestDataActor>(&actor_id.inner()).bars_received,
6326            1,
6327        );
6328
6329        // Mirrors the dispatch window where a handler snapshotted for publication outlives
6330        // deregistration, which no unsubscribe can close
6331        deregister_actor(&actor_id.inner());
6332
6333        // The delivery asserted above proves the handler is installed, and deregistering the
6334        // actor does not touch the message bus, so it is still installed here. The assertion is
6335        // that this does not panic resolving the actor which is now gone.
6336        msgbus::publish_bar(topic, &bar);
6337    }
6338
6339    /// One trader operation applied by the retirement property test.
6340    #[derive(Debug, Clone, Copy)]
6341    enum TraderOp {
6342        AddActor(u8),
6343        RemoveActor(u8),
6344        ClearActors,
6345        AddStrategy(u8),
6346        RemoveStrategy(u8),
6347        ClearStrategies,
6348        AddExecutionAlgorithm(u8),
6349        ClearExecutionAlgorithms,
6350        DisposeComponents,
6351    }
6352
6353    fn prop_actor_id(slot: u8) -> ActorId {
6354        ActorId::from(format!("PropActor-{slot}").as_str())
6355    }
6356
6357    fn prop_strategy_id(slot: u8) -> StrategyId {
6358        StrategyId::from(format!("PropStrategy-{slot:03}").as_str())
6359    }
6360
6361    fn prop_exec_algorithm_id(slot: u8) -> ExecAlgorithmId {
6362        ExecAlgorithmId::from(format!("PropExecAlgo-{slot}").as_str())
6363    }
6364
6365    fn apply_trader_op(trader: &mut Trader, op: TraderOp) {
6366        // Every operation may legitimately fail (duplicate add, removing an absent component),
6367        // so the property is about the resulting state rather than the return value.
6368        match op {
6369            TraderOp::AddActor(slot) => {
6370                let _ = trader.add_actor(TestDataActor::new(DataActorConfig {
6371                    actor_id: Some(prop_actor_id(slot)),
6372                    ..Default::default()
6373                }));
6374            }
6375            TraderOp::RemoveActor(slot) => {
6376                let _ = trader.remove_actor(&prop_actor_id(slot));
6377            }
6378            TraderOp::ClearActors => {
6379                let _ = trader.clear_actors();
6380            }
6381            TraderOp::AddStrategy(slot) => {
6382                let _ = trader.add_strategy(TestStrategy::new(StrategyConfig {
6383                    strategy_id: Some(prop_strategy_id(slot)),
6384                    ..Default::default()
6385                }));
6386            }
6387            TraderOp::RemoveStrategy(slot) => {
6388                let _ = trader.remove_strategy(&prop_strategy_id(slot));
6389            }
6390            TraderOp::ClearStrategies => {
6391                let _ = trader.clear_strategies();
6392            }
6393            TraderOp::AddExecutionAlgorithm(slot) => {
6394                let _ = trader.add_exec_algorithm(TestExecutionAlgorithm::new(
6395                    ExecutionAlgorithmConfig {
6396                        exec_algorithm_id: Some(prop_exec_algorithm_id(slot)),
6397                        ..Default::default()
6398                    },
6399                ));
6400            }
6401            TraderOp::ClearExecutionAlgorithms => {
6402                let _ = trader.clear_exec_algorithms();
6403            }
6404            TraderOp::DisposeComponents => {
6405                let _ = trader.dispose_components();
6406            }
6407        }
6408    }
6409
6410    /// Asserts the trader's bookkeeping agrees with the global registries.
6411    ///
6412    /// Tracked components must resolve in both registries, untracked slots must be absent from
6413    /// both, and every tracked component must still own exactly one clock.
6414    fn assert_registry_consistency(trader: &Trader, slots: &[u8]) {
6415        for &slot in slots {
6416            let actor_id = prop_actor_id(slot);
6417            let tracked = trader.actor_ids().contains(&actor_id);
6418            assert_eq!(
6419                get_component(&actor_id.inner()).is_some(),
6420                tracked,
6421                "actor {actor_id} component registry entry must match trader tracking",
6422            );
6423            assert_eq!(
6424                actor_exists(&actor_id.inner()),
6425                tracked,
6426                "actor {actor_id} actor registry entry must match trader tracking",
6427            );
6428
6429            let strategy_id = prop_strategy_id(slot);
6430            let tracked = trader.strategy_ids().contains(&strategy_id);
6431            assert_eq!(
6432                get_component(&strategy_id.inner()).is_some(),
6433                tracked,
6434                "strategy {strategy_id} component registry entry must match trader tracking",
6435            );
6436            assert_eq!(
6437                actor_exists(&strategy_id.inner()),
6438                tracked,
6439                "strategy {strategy_id} actor registry entry must match trader tracking",
6440            );
6441
6442            let exec_algorithm_id = prop_exec_algorithm_id(slot);
6443            let tracked = trader.exec_algorithm_ids().contains(&exec_algorithm_id);
6444            assert_eq!(
6445                get_component(&exec_algorithm_id.inner()).is_some(),
6446                tracked,
6447                "exec algorithm {exec_algorithm_id} component entry must match trader tracking",
6448            );
6449            assert_eq!(
6450                actor_exists(&exec_algorithm_id.inner()),
6451                tracked,
6452                "exec algorithm {exec_algorithm_id} actor entry must match trader tracking",
6453            );
6454        }
6455
6456        assert_eq!(
6457            trader.get_component_clocks().len(),
6458            trader.component_count(),
6459            "every tracked component owns exactly one clock",
6460        );
6461    }
6462
6463    // Anonymous so proptest's `Strategy` does not collide with the trading `Strategy` trait
6464    use proptest::strategy::Strategy as _;
6465
6466    proptest::proptest! {
6467        #![proptest_config(proptest::prelude::ProptestConfig::with_cases(64))]
6468
6469        /// Whatever order add, remove, clear, and dispose arrive in, the trader's bookkeeping
6470        /// never disagrees with the global registries, and nothing it stopped tracking is left
6471        /// behind in them.
6472        #[rstest]
6473        fn prop_trader_bookkeeping_matches_registries(
6474            ops in proptest::collection::vec(
6475                proptest::prop_oneof![
6476                    (0u8..3).prop_map(TraderOp::AddActor),
6477                    (0u8..3).prop_map(TraderOp::RemoveActor),
6478                    proptest::prelude::Just(TraderOp::ClearActors),
6479                    (0u8..3).prop_map(TraderOp::AddStrategy),
6480                    (0u8..3).prop_map(TraderOp::RemoveStrategy),
6481                    proptest::prelude::Just(TraderOp::ClearStrategies),
6482                    (0u8..3).prop_map(TraderOp::AddExecutionAlgorithm),
6483                    proptest::prelude::Just(TraderOp::ClearExecutionAlgorithms),
6484                    proptest::prelude::Just(TraderOp::DisposeComponents),
6485                ],
6486                1..12usize,
6487            ),
6488        ) {
6489            let slots: Vec<u8> = (0u8..3).collect();
6490
6491            // Reset up front: a case which fails mid-way never reaches its teardown, and stale
6492            // registry entries would otherwise corrupt every later shrink iteration
6493            for &slot in &slots {
6494                deregister_component(&prop_actor_id(slot).inner());
6495                deregister_actor(&prop_actor_id(slot).inner());
6496                deregister_component(&prop_strategy_id(slot).inner());
6497                deregister_actor(&prop_strategy_id(slot).inner());
6498                deregister_component(&prop_exec_algorithm_id(slot).inner());
6499                deregister_actor(&prop_exec_algorithm_id(slot).inner());
6500            }
6501
6502            let (
6503                _msgbus,
6504                cache,
6505                portfolio,
6506                _data_engine,
6507                _risk_engine,
6508                _exec_engine,
6509                clock_factory,
6510            ) = create_trader_components();
6511            let mut trader = Trader::new(
6512                TraderId::test_default(),
6513                UUID4::new(),
6514                Environment::Backtest,
6515                clock_factory,
6516                cache,
6517                portfolio,
6518            );
6519
6520            for op in ops {
6521                apply_trader_op(&mut trader, op);
6522                assert_registry_consistency(&trader, &slots);
6523            }
6524
6525            // Retire everything so the thread-local registries stay isolated between cases,
6526            // then prove retirement left nothing behind
6527            let _ = trader.dispose_components();
6528            assert_registry_consistency(&trader, &slots);
6529            assert_eq!(trader.component_count(), 0);
6530            assert!(trader.get_component_clocks().is_empty());
6531        }
6532    }
6533}