quantrs2_device/provider_capability_discovery/
mod.rs

1//! Advanced Provider Capability Discovery System
2//!
3//! This module provides comprehensive discovery, analysis, and management of quantum
4//! computing provider capabilities. Features include real-time capability discovery,
5//! comparative analysis, performance benchmarking, and intelligent provider selection
6//! with SciRS2-powered analytics.
7
8mod capabilities;
9mod config;
10mod engines;
11mod events;
12mod system;
13mod types;
14
15// Re-export all public types
16pub use capabilities::*;
17pub use config::*;
18pub use engines::*;
19pub use events::*;
20pub use system::*;
21pub use types::*;
22
23#[cfg(test)]
24mod tests {
25    use super::*;
26    use std::time::Duration;
27
28    #[test]
29    fn test_discovery_config_default() {
30        let config = DiscoveryConfig::default();
31        assert!(config.enable_auto_discovery);
32        assert_eq!(config.discovery_interval, 3600);
33        assert!(config.enable_caching);
34        assert!(config.enable_monitoring);
35        assert!(config.enable_analytics);
36    }
37
38    #[test]
39    fn test_provider_info_creation() {
40        let provider = ProviderInfo {
41            provider_id: "test_provider".to_string(),
42            name: "Test Provider".to_string(),
43            description: "A test quantum provider".to_string(),
44            provider_type: ProviderType::CloudProvider,
45            contact_info: ContactInfo {
46                support_email: Some("support@test.com".to_string()),
47                support_phone: None,
48                support_website: None,
49                technical_contact: None,
50                business_contact: None,
51                emergency_contact: None,
52            },
53            endpoints: Vec::new(),
54            supported_regions: vec!["us-east-1".to_string()],
55            pricing_model: PricingModel {
56                pricing_type: PricingType::PayPerUse,
57                cost_per_shot: Some(0.01),
58                cost_per_circuit: None,
59                cost_per_hour: None,
60                monthly_subscription: None,
61                free_tier: None,
62                currency: "USD".to_string(),
63                billing_model: BillingModel::Postpaid,
64            },
65            terms_of_service: None,
66            privacy_policy: None,
67            compliance_certifications: Vec::new(),
68            last_updated: std::time::SystemTime::now(),
69        };
70
71        assert_eq!(provider.provider_id, "test_provider");
72        assert_eq!(provider.provider_type, ProviderType::CloudProvider);
73    }
74
75    #[test]
76    fn test_capability_requirements() {
77        let requirements = CapabilityRequirements {
78            min_qubits: Some(5),
79            max_error_rate: Some(0.01),
80            required_gates: ["H", "CNOT"].iter().map(|s| s.to_string()).collect(),
81            required_connectivity: Some(ConnectivityRequirement::FullyConnected),
82            required_features: [ProviderFeature::QuantumComputing]
83                .iter()
84                .cloned()
85                .collect(),
86            performance_requirements: PerformanceRequirements {
87                max_execution_time: Some(Duration::from_secs(300)),
88                min_throughput: Some(100.0),
89                max_queue_time: Some(Duration::from_secs(60)),
90                min_availability: Some(0.99),
91                max_cost_per_shot: Some(0.005),
92            },
93        };
94
95        assert_eq!(requirements.min_qubits, Some(5));
96        assert_eq!(requirements.max_error_rate, Some(0.01));
97        assert!(requirements
98            .required_features
99            .contains(&ProviderFeature::QuantumComputing));
100    }
101
102    #[test]
103    fn test_discovery_system_creation() {
104        let config = DiscoveryConfig::default();
105        let _system = ProviderCapabilityDiscoverySystem::new(config);
106        // System should be created successfully
107    }
108
109    #[test]
110    fn test_high_performance_config() {
111        let config = create_high_performance_discovery_config();
112        assert_eq!(config.discovery_interval, 1800);
113        assert_eq!(
114            config.analytics_config.analysis_depth,
115            AnalysisDepth::Comprehensive
116        );
117        assert_eq!(config.verification_config.min_verification_confidence, 0.9);
118    }
119
120    #[tokio::test]
121    async fn test_discovery_system_start() {
122        let config = DiscoveryConfig::default();
123        let system = ProviderCapabilityDiscoverySystem::new(config);
124
125        let start_result = system.start().await;
126        assert!(start_result.is_ok());
127    }
128
129    #[test]
130    fn test_verification_config() {
131        let config = VerificationConfig {
132            enable_verification: true,
133            verification_timeout: Duration::from_secs(300),
134            verification_strategies: vec![
135                VerificationStrategy::EndpointTesting,
136                VerificationStrategy::CapabilityProbing,
137            ],
138            min_verification_confidence: 0.8,
139            enable_continuous_verification: true,
140            verification_frequency: Duration::from_secs(86400),
141        };
142
143        assert!(config.enable_verification);
144        assert_eq!(config.verification_strategies.len(), 2);
145    }
146
147    #[test]
148    fn test_quality_thresholds() {
149        let thresholds = QualityThresholds {
150            min_fidelity: 0.9,
151            max_error_rate: 0.05,
152            min_uptime: 0.98,
153            min_reliability: 0.95,
154            min_performance: 0.8,
155        };
156
157        assert!(thresholds.min_fidelity > 0.8);
158        assert!(thresholds.max_error_rate < 0.1);
159    }
160
161    #[test]
162    fn test_comparison_config() {
163        let config = ComparisonConfig {
164            enable_auto_comparison: true,
165            comparison_criteria: vec![
166                ComparisonCriterion::Performance,
167                ComparisonCriterion::Cost,
168                ComparisonCriterion::Reliability,
169            ],
170            ranking_algorithms: vec![RankingAlgorithm::WeightedSum, RankingAlgorithm::TOPSIS],
171            criterion_weights: std::collections::HashMap::new(),
172            enable_multidimensional_analysis: true,
173        };
174
175        assert!(config.enable_auto_comparison);
176        assert_eq!(config.comparison_criteria.len(), 3);
177        assert_eq!(config.ranking_algorithms.len(), 2);
178    }
179
180    #[test]
181    fn test_provider_feature_equality() {
182        let feature1 = ProviderFeature::QuantumComputing;
183        let feature2 = ProviderFeature::QuantumComputing;
184        let feature3 = ProviderFeature::NoiseModeling;
185
186        assert_eq!(feature1, feature2);
187        assert_ne!(feature1, feature3);
188    }
189
190    #[test]
191    fn test_discovery_strategy_variants() {
192        let strategies = [
193            DiscoveryStrategy::APIDiscovery,
194            DiscoveryStrategy::RegistryDiscovery,
195            DiscoveryStrategy::NetworkDiscovery,
196            DiscoveryStrategy::ConfigurationDiscovery,
197            DiscoveryStrategy::MLEnhancedDiscovery,
198            DiscoveryStrategy::HybridDiscovery,
199        ];
200
201        assert_eq!(strategies.len(), 6);
202    }
203
204    #[test]
205    fn test_health_level_ordering() {
206        // Test that health levels can be compared
207        let excellent = HealthLevel::Excellent;
208        let good = HealthLevel::Good;
209
210        assert_ne!(excellent, good);
211    }
212
213    #[test]
214    fn test_issue_severity() {
215        let severities = [
216            IssueSeverity::Low,
217            IssueSeverity::Medium,
218            IssueSeverity::High,
219            IssueSeverity::Critical,
220        ];
221
222        assert_eq!(severities.len(), 4);
223    }
224
225    #[test]
226    fn test_monitoring_target_type() {
227        let types = [
228            MonitoringTargetType::Provider,
229            MonitoringTargetType::Endpoint,
230            MonitoringTargetType::Service,
231            MonitoringTargetType::Capability,
232            MonitoringTargetType::Performance,
233            MonitoringTargetType::Cost,
234            MonitoringTargetType::Security,
235        ];
236
237        assert_eq!(types.len(), 7);
238    }
239
240    #[test]
241    fn test_trend_model_type() {
242        let model_types = [
243            TrendModelType::Linear,
244            TrendModelType::Exponential,
245            TrendModelType::Polynomial,
246            TrendModelType::Seasonal,
247            TrendModelType::ARIMA,
248            TrendModelType::MachineLearning,
249        ];
250
251        assert_eq!(model_types.len(), 6);
252    }
253
254    #[test]
255    fn test_predictive_model_type() {
256        let model_types = [
257            PredictiveModelType::LinearRegression,
258            PredictiveModelType::RandomForest,
259            PredictiveModelType::NeuralNetwork,
260            PredictiveModelType::SVM,
261            PredictiveModelType::DecisionTree,
262            PredictiveModelType::Ensemble,
263        ];
264
265        assert_eq!(model_types.len(), 6);
266    }
267}
quantrs2_device/provider_capability_discovery/mod.rs

quantrs2_device/provider_capability_discovery/
mod.rs
