Skip to main content

moonpool_sim/providers/
sim_providers.rs

1//! Simulation providers bundle implementation.
2
3use moonpool_core::{Providers, TokioTaskProvider};
4
5use crate::network::SimNetworkProvider;
6use crate::sim::WeakSimWorld;
7use crate::storage::SimStorageProvider;
8
9use super::{SimRandomProvider, SimTimeProvider};
10
11/// Simulation providers bundle for deterministic testing.
12///
13/// This struct bundles all four simulation-based providers into a single
14/// instance that implements [`Providers`].
15///
16/// ## Usage
17///
18/// `SimProviders` is typically created by the simulation framework during
19/// workload setup, but can also be manually constructed:
20///
21/// ```rust,ignore
22/// use moonpool_sim::{SimWorld, SimProviders, Providers};
23///
24/// let sim = SimWorld::new();
25/// let providers = SimProviders::new(sim.downgrade(), 42);
26///
27/// // Access individual providers
28/// let network = providers.network();
29/// let time = providers.time();
30/// ```
31///
32/// ## Implementation Notes
33///
34/// - Uses `SimNetworkProvider` for simulated TCP connections
35/// - Uses `SimTimeProvider` for logical/simulated time
36/// - Uses `TokioTaskProvider` for task spawning (same as production)
37/// - Uses `SimRandomProvider` for seeded deterministic randomness
38/// - Uses `SimStorageProvider` for simulated file I/O with fault injection
39#[derive(Clone)]
40pub struct SimProviders {
41    network: SimNetworkProvider,
42    time: SimTimeProvider,
43    task: TokioTaskProvider,
44    random: SimRandomProvider,
45    storage: SimStorageProvider,
46}
47
48impl SimProviders {
49    /// Create a new simulation providers bundle.
50    ///
51    /// # Arguments
52    ///
53    /// * `sim` - Weak reference to the simulation world
54    /// * `seed` - Seed for deterministic random number generation
55    pub fn new(sim: WeakSimWorld, seed: u64) -> Self {
56        Self {
57            network: SimNetworkProvider::new(sim.clone()),
58            time: SimTimeProvider::new(sim.clone()),
59            task: TokioTaskProvider,
60            random: SimRandomProvider::new(seed),
61            storage: SimStorageProvider::new(sim),
62        }
63    }
64}
65
66impl Providers for SimProviders {
67    type Network = SimNetworkProvider;
68    type Time = SimTimeProvider;
69    type Task = TokioTaskProvider;
70    type Random = SimRandomProvider;
71
72    fn network(&self) -> &Self::Network {
73        &self.network
74    }
75
76    fn time(&self) -> &Self::Time {
77        &self.time
78    }
79
80    fn task(&self) -> &Self::Task {
81        &self.task
82    }
83
84    fn random(&self) -> &Self::Random {
85        &self.random
86    }
87
88    type Storage = SimStorageProvider;
89
90    fn storage(&self) -> &Self::Storage {
91        &self.storage
92    }
93}