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