1pub mod implementations;
4pub mod types;
5
6pub use implementations::*;
8pub use types::*;
9#[cfg(test)]
10mod tests {
11 use super::*;
12 use chrono::{DateTime, Duration as ChronoDuration, Utc};
13 use std::collections::HashMap;
14 use std::sync::{Arc, RwLock};
15 use std::time::Duration;
16 use uuid::Uuid;
17
18 #[tokio::test]
19 async fn test_distributed_orchestrator_creation() {
20 let config = DistributedComputationConfig::default();
21 let orchestrator = DistributedQuantumOrchestrator::new(config);
22
23 let status = orchestrator.get_system_status().await;
24 assert_eq!(status.total_nodes, 0);
25 assert_eq!(status.active_nodes, 0);
26 }
27
28 #[tokio::test]
29 async fn test_node_registration() {
30 let config = DistributedComputationConfig::default();
31 let orchestrator = DistributedQuantumOrchestrator::new(config);
32
33 let node_info = NodeInfo {
34 node_id: NodeId("test_node".to_string()),
35 capabilities: NodeCapabilities {
36 max_qubits: 10,
37 supported_gates: vec!["H".to_string(), "CNOT".to_string()],
38 connectivity_graph: vec![(0, 1), (1, 2)],
39 gate_fidelities: HashMap::new(),
40 readout_fidelity: 0.95,
41 coherence_times: HashMap::new(),
42 classical_compute_power: 1000.0,
43 memory_capacity_gb: 8,
44 network_bandwidth_mbps: 1000.0,
45 },
46 current_load: NodeLoad {
47 qubits_in_use: 0,
48 active_circuits: 0,
49 cpu_utilization: 0.1,
50 memory_utilization: 0.2,
51 network_utilization: 0.05,
52 queue_length: 0,
53 estimated_completion_time: Duration::from_secs(0),
54 },
55 network_info: NetworkInfo {
56 ip_address: "192.168.1.100".to_string(),
57 port: 8080,
58 latency_to_nodes: HashMap::new(),
59 bandwidth_to_nodes: HashMap::new(),
60 connection_quality: HashMap::new(),
61 },
62 status: NodeStatus::Active,
63 last_heartbeat: Utc::now(),
64 };
65
66 orchestrator
67 .register_node(node_info)
68 .await
69 .expect("Node registration should succeed");
70
71 let status = orchestrator.get_system_status().await;
72 assert_eq!(status.total_nodes, 1);
73 assert_eq!(status.active_nodes, 1);
74 assert_eq!(status.total_qubits, 10);
75 }
76
77 #[tokio::test]
78 async fn test_circuit_partitioning() {
79 let circuit = QuantumCircuit {
80 circuit_id: Uuid::new_v4(),
81 gates: vec![QuantumGate {
82 gate_type: "H".to_string(),
83 target_qubits: vec![QubitId {
84 node_id: NodeId("node1".to_string()),
85 local_id: 0,
86 global_id: Uuid::new_v4(),
87 }],
88 parameters: vec![],
89 control_qubits: vec![],
90 classical_controls: vec![],
91 }],
92 qubit_count: 2,
93 classical_bit_count: 2,
94 measurements: vec![],
95 metadata: HashMap::new(),
96 };
97
98 let mut nodes = HashMap::new();
99 nodes.insert(
100 NodeId("node1".to_string()),
101 NodeInfo {
102 node_id: NodeId("node1".to_string()),
103 capabilities: NodeCapabilities {
104 max_qubits: 10,
105 supported_gates: vec!["H".to_string()],
106 connectivity_graph: vec![(0, 1)],
107 gate_fidelities: HashMap::new(),
108 readout_fidelity: 0.95,
109 coherence_times: HashMap::new(),
110 classical_compute_power: 1000.0,
111 memory_capacity_gb: 8,
112 network_bandwidth_mbps: 1000.0,
113 },
114 current_load: NodeLoad {
115 qubits_in_use: 0,
116 active_circuits: 0,
117 cpu_utilization: 0.1,
118 memory_utilization: 0.2,
119 network_utilization: 0.05,
120 queue_length: 0,
121 estimated_completion_time: Duration::from_secs(0),
122 },
123 network_info: NetworkInfo {
124 ip_address: "192.168.1.100".to_string(),
125 port: 8080,
126 latency_to_nodes: HashMap::new(),
127 bandwidth_to_nodes: HashMap::new(),
128 connection_quality: HashMap::new(),
129 },
130 status: NodeStatus::Active,
131 last_heartbeat: Utc::now(),
132 },
133 );
134
135 let config = DistributedComputationConfig::default();
136 let partitioner = CircuitPartitioner::new();
137
138 let partitions = partitioner
139 .partition_circuit(&circuit, &nodes, &config)
140 .expect("Circuit partitioning should succeed");
141 assert!(!partitions.is_empty());
142 assert_eq!(partitions[0].gates.len(), 1);
143 }
144
145 #[test]
146 fn test_load_balancer() {
147 let balancer = CapabilityBasedBalancer::new();
148
149 let partition = CircuitPartition {
150 partition_id: Uuid::new_v4(),
151 node_id: NodeId("test".to_string()),
152 gates: vec![
153 QuantumGate {
154 gate_type: "H".to_string(),
155 target_qubits: vec![QubitId {
156 node_id: NodeId("test".to_string()),
157 local_id: 0,
158 global_id: Uuid::new_v4(),
159 }],
160 control_qubits: vec![],
161 parameters: vec![],
162 classical_controls: vec![],
163 },
164 QuantumGate {
165 gate_type: "CNOT".to_string(),
166 target_qubits: vec![QubitId {
167 node_id: NodeId("test".to_string()),
168 local_id: 1,
169 global_id: Uuid::new_v4(),
170 }],
171 control_qubits: vec![QubitId {
172 node_id: NodeId("test".to_string()),
173 local_id: 0,
174 global_id: Uuid::new_v4(),
175 }],
176 parameters: vec![],
177 classical_controls: vec![],
178 },
179 ],
180 dependencies: vec![],
181 input_qubits: vec![],
182 output_qubits: vec![],
183 classical_inputs: vec![],
184 estimated_execution_time: Duration::from_millis(100),
185 resource_requirements: ResourceRequirements {
186 qubits_needed: 5,
187 gates_count: 10,
188 memory_mb: 50,
189 execution_time_estimate: Duration::from_millis(100),
190 entanglement_pairs_needed: 0,
191 classical_communication_bits: 0,
192 },
193 };
194
195 let node_info = NodeInfo {
196 node_id: NodeId("node1".to_string()),
197 capabilities: NodeCapabilities {
198 max_qubits: 10,
199 supported_gates: vec![],
200 connectivity_graph: vec![],
201 gate_fidelities: HashMap::new(),
202 readout_fidelity: 0.95,
203 coherence_times: HashMap::new(),
204 classical_compute_power: 1000.0,
205 memory_capacity_gb: 8,
206 network_bandwidth_mbps: 1000.0,
207 },
208 current_load: NodeLoad {
209 qubits_in_use: 2,
210 active_circuits: 1,
211 cpu_utilization: 0.3,
212 memory_utilization: 0.4,
213 network_utilization: 0.1,
214 queue_length: 2,
215 estimated_completion_time: Duration::from_secs(30),
216 },
217 network_info: NetworkInfo {
218 ip_address: "192.168.1.100".to_string(),
219 port: 8080,
220 latency_to_nodes: HashMap::new(),
221 bandwidth_to_nodes: HashMap::new(),
222 connection_quality: HashMap::new(),
223 },
224 status: NodeStatus::Active,
225 last_heartbeat: Utc::now(),
226 };
227
228 let execution_time = balancer.predict_execution_time(&partition, &node_info);
229 assert!(execution_time > Duration::from_nanos(0));
230 }
231
232 #[tokio::test]
233 async fn test_state_synchronization() {
234 let protocol = BasicSynchronizationProtocol::new();
235
236 let nodes = vec![NodeId("node1".to_string()), NodeId("node2".to_string())];
237 let result = protocol
238 .synchronize_states(&nodes, 0.95)
239 .await
240 .expect("State synchronization should succeed");
241
242 assert!(result.success);
243 assert_eq!(result.consistency_level, 0.95);
244 assert_eq!(result.synchronized_nodes.len(), 2);
245 }
246
247 #[tokio::test]
248 async fn test_checkpoint_storage() {
249 let storage = InMemoryCheckpointStorage::new();
250
251 let checkpoint_data = CheckpointData {
252 timestamp: Utc::now(),
253 system_state: SystemState {
254 nodes: HashMap::new(),
255 active_computations: HashMap::new(),
256 distributed_states: HashMap::new(),
257 network_topology: NetworkTopology {
258 nodes: vec![],
259 edges: vec![],
260 edge_weights: HashMap::new(),
261 clustering_coefficient: 0.0,
262 diameter: 0,
263 },
264 resource_allocation: HashMap::new(),
265 },
266 computation_progress: HashMap::new(),
267 quantum_states: HashMap::new(),
268 metadata: HashMap::new(),
269 };
270
271 let checkpoint_id = Uuid::new_v4();
272 storage
273 .store_checkpoint(checkpoint_id, &checkpoint_data)
274 .await
275 .expect("Checkpoint storage should succeed");
276
277 let loaded_data = storage
278 .load_checkpoint(checkpoint_id)
279 .await
280 .expect("Checkpoint loading should succeed");
281 assert_eq!(loaded_data.timestamp, checkpoint_data.timestamp);
282
283 let checkpoints = storage
284 .list_checkpoints()
285 .await
286 .expect("Listing checkpoints should succeed");
287 assert_eq!(checkpoints.len(), 1);
288 assert_eq!(checkpoints[0], checkpoint_id);
289 }
290
291 #[tokio::test]
292 async fn test_metrics_storage() {
293 let storage = InMemoryMetricsStorage::new();
294
295 let metric = Metric {
296 metric_name: "cpu_utilization".to_string(),
297 value: 0.75,
298 timestamp: Utc::now(),
299 tags: HashMap::new(),
300 node_id: Some(NodeId("node1".to_string())),
301 };
302
303 storage
304 .store_metric(&metric)
305 .await
306 .expect("Metric storage should succeed");
307
308 let query = MetricsQuery {
309 metric_names: vec!["cpu_utilization".to_string()],
310 time_range: (Utc::now() - ChronoDuration::seconds(60), Utc::now()),
311 filters: HashMap::new(),
312 limit: None,
313 };
314
315 let results = storage
316 .query_metrics(&query)
317 .await
318 .expect("Metrics query should succeed");
319 assert_eq!(results.len(), 1);
320 assert_eq!(results[0].metric_name, "cpu_utilization");
321 assert_eq!(results[0].value, 0.75);
322 }
323
324 #[tokio::test]
325 async fn test_consensus_engine() {
326 let consensus = RaftConsensus::new();
327
328 let proposal = "test_proposal".to_string();
329 let participants = vec![NodeId("node1".to_string()), NodeId("node2".to_string())];
330
331 let result = consensus
332 .reach_consensus(proposal.clone(), &participants, Duration::from_secs(30))
333 .await
334 .expect("Consensus should be reached");
335
336 assert!(result.consensus_achieved);
337 assert_eq!(result.decision, proposal);
338 assert_eq!(result.participating_nodes.len(), 2);
339 assert!(result.confidence > 0.9);
340 }
341}