quantrs2_anneal/comprehensive_integration_testing/
scenarios.rs

1//! Test scenarios and test case definitions
2
3use std::collections::HashMap;
4use std::time::{Duration, SystemTime};
5
6/// Test case registry
7pub struct TestRegistry {
8    /// Registered test cases
9    pub test_cases: HashMap<String, IntegrationTestCase>,
10    /// Test suites
11    pub test_suites: HashMap<String, TestSuite>,
12    /// Test dependencies
13    pub dependencies: HashMap<String, Vec<String>>,
14    /// Test categories
15    pub categories: HashMap<TestCategory, Vec<String>>,
16}
17
18impl TestRegistry {
19    #[must_use]
20    pub fn new() -> Self {
21        Self {
22            test_cases: HashMap::new(),
23            test_suites: HashMap::new(),
24            dependencies: HashMap::new(),
25            categories: HashMap::new(),
26        }
27    }
28
29    pub fn register_test_case(&mut self, test_case: IntegrationTestCase) -> Result<(), String> {
30        let id = test_case.id.clone();
31        let category = test_case.category.clone();
32
33        self.test_cases.insert(id.clone(), test_case);
34
35        // Add to category index
36        self.categories
37            .entry(category)
38            .or_insert_with(Vec::new)
39            .push(id);
40
41        Ok(())
42    }
43
44    /// Register a test suite
45    pub fn register_test_suite(&mut self, test_suite: TestSuite) -> Result<(), String> {
46        let id = test_suite.id.clone();
47        self.test_suites.insert(id, test_suite);
48        Ok(())
49    }
50
51    /// Unregister a test case
52    pub fn unregister_test_case(&mut self, test_case_id: &str) -> Result<(), String> {
53        self.test_cases
54            .remove(test_case_id)
55            .ok_or_else(|| format!("Test case {test_case_id} not found"))?;
56
57        // Remove from dependencies
58        self.dependencies.remove(test_case_id);
59
60        Ok(())
61    }
62
63    /// Get a test case by ID
64    #[must_use]
65    pub fn get_test_case(&self, test_case_id: &str) -> Option<&IntegrationTestCase> {
66        self.test_cases.get(test_case_id)
67    }
68
69    /// Get a test suite by ID
70    #[must_use]
71    pub fn get_test_suite(&self, test_suite_id: &str) -> Option<&TestSuite> {
72        self.test_suites.get(test_suite_id)
73    }
74
75    /// Get all test cases in a category
76    #[must_use]
77    pub fn get_test_cases_by_category(&self, category: &TestCategory) -> Vec<&IntegrationTestCase> {
78        if let Some(ids) = self.categories.get(category) {
79            ids.iter()
80                .filter_map(|id| self.test_cases.get(id))
81                .collect()
82        } else {
83            Vec::new()
84        }
85    }
86
87    /// Add a dependency between test cases
88    pub fn add_dependency(&mut self, test_case_id: String, dependency_id: String) {
89        self.dependencies
90            .entry(test_case_id)
91            .or_insert_with(Vec::new)
92            .push(dependency_id);
93    }
94
95    /// Get dependencies for a test case
96    #[must_use]
97    pub fn get_dependencies(&self, test_case_id: &str) -> Vec<&str> {
98        self.dependencies
99            .get(test_case_id)
100            .map(|deps| deps.iter().map(std::string::String::as_str).collect())
101            .unwrap_or_default()
102    }
103
104    /// List all test cases
105    #[must_use]
106    pub fn list_test_cases(&self) -> Vec<&IntegrationTestCase> {
107        self.test_cases.values().collect()
108    }
109
110    /// List all test suites
111    #[must_use]
112    pub fn list_test_suites(&self) -> Vec<&TestSuite> {
113        self.test_suites.values().collect()
114    }
115
116    /// Get test case count
117    #[must_use]
118    pub fn test_case_count(&self) -> usize {
119        self.test_cases.len()
120    }
121
122    /// Get test suite count
123    #[must_use]
124    pub fn test_suite_count(&self) -> usize {
125        self.test_suites.len()
126    }
127
128    /// Clear all test cases and suites
129    pub fn clear_all(&mut self) {
130        self.test_cases.clear();
131        self.test_suites.clear();
132        self.dependencies.clear();
133        self.categories.clear();
134    }
135
136    /// Find test cases by name pattern
137    #[must_use]
138    pub fn find_test_cases(&self, pattern: &str) -> Vec<&IntegrationTestCase> {
139        self.test_cases
140            .values()
141            .filter(|tc| tc.name.contains(pattern) || tc.description.contains(pattern))
142            .collect()
143    }
144}
145
146/// Integration test case definition
147#[derive(Debug, Clone)]
148pub struct IntegrationTestCase {
149    /// Test case identifier
150    pub id: String,
151    /// Test case name
152    pub name: String,
153    /// Test description
154    pub description: String,
155    /// Test category
156    pub category: TestCategory,
157    /// Test priority
158    pub priority: TestPriority,
159    /// Test timeout
160    pub timeout: Duration,
161    /// Test prerequisites
162    pub prerequisites: Vec<String>,
163    /// Test parameters
164    pub parameters: HashMap<String, TestParameter>,
165    /// Expected results
166    pub expected_results: ExpectedResults,
167    /// Test steps
168    pub test_steps: Vec<TestStep>,
169    /// Test metadata
170    pub metadata: TestMetadata,
171}
172
173/// Test suite definition
174#[derive(Debug, Clone)]
175pub struct TestSuite {
176    /// Suite identifier
177    pub id: String,
178    /// Suite name
179    pub name: String,
180    /// Suite description
181    pub description: String,
182    /// Test cases in the suite
183    pub test_cases: Vec<String>,
184    /// Suite configuration
185    pub configuration: TestSuiteConfig,
186    /// Suite metadata
187    pub metadata: TestMetadata,
188}
189
190/// Test categories
191#[derive(Debug, Clone, PartialEq, Eq, Hash)]
192pub enum TestCategory {
193    /// Unit integration tests
194    Unit,
195    /// Component integration tests
196    Component,
197    /// System integration tests
198    System,
199    /// End-to-end tests
200    EndToEnd,
201    /// Performance tests
202    Performance,
203    /// Stress tests
204    Stress,
205    /// Security tests
206    Security,
207    /// Compatibility tests
208    Compatibility,
209    /// Custom category
210    Custom(String),
211}
212
213/// Test priorities
214#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
215pub enum TestPriority {
216    Low = 1,
217    Normal = 2,
218    High = 3,
219    Critical = 4,
220}
221
222/// Test parameter definition
223#[derive(Debug, Clone)]
224pub struct TestParameter {
225    /// Parameter name
226    pub name: String,
227    /// Parameter type
228    pub parameter_type: ParameterType,
229    /// Default value
230    pub default_value: Option<ParameterValue>,
231    /// Parameter description
232    pub description: String,
233    /// Validation rules
234    pub validation: ParameterValidation,
235}
236
237/// Parameter types
238#[derive(Debug, Clone, PartialEq)]
239pub enum ParameterType {
240    /// Boolean parameter
241    Boolean,
242    /// Integer parameter
243    Integer,
244    /// Float parameter
245    Float,
246    /// String parameter
247    String,
248    /// Array parameter
249    Array(Box<Self>),
250    /// Object parameter
251    Object(HashMap<String, Self>),
252}
253
254/// Parameter values
255#[derive(Debug, Clone)]
256pub enum ParameterValue {
257    /// Boolean value
258    Boolean(bool),
259    /// Integer value
260    Integer(i64),
261    /// Float value
262    Float(f64),
263    /// String value
264    String(String),
265    /// Array value
266    Array(Vec<Self>),
267    /// Object value
268    Object(HashMap<String, Self>),
269}
270
271/// Parameter validation rules
272#[derive(Debug, Clone)]
273pub struct ParameterValidation {
274    /// Required parameter
275    pub required: bool,
276    /// Minimum value
277    pub min_value: Option<f64>,
278    /// Maximum value
279    pub max_value: Option<f64>,
280    /// Allowed values
281    pub allowed_values: Option<Vec<ParameterValue>>,
282    /// Custom validation function
283    pub custom_validator: Option<String>,
284}
285
286/// Expected test results
287#[derive(Debug, Clone)]
288pub struct ExpectedResults {
289    /// Expected outcome
290    pub outcome: ExpectedOutcome,
291    /// Result validation
292    pub validation: ResultValidation,
293    /// Expected performance metrics
294    pub performance_metrics: Option<ExpectedPerformanceMetrics>,
295    /// Expected side effects
296    pub side_effects: Vec<ExpectedSideEffect>,
297}
298
299/// Expected test outcomes
300#[derive(Debug, Clone, PartialEq, Eq)]
301pub enum ExpectedOutcome {
302    /// Test should pass
303    Pass,
304    /// Test should fail
305    Fail,
306    /// Test should be skipped
307    Skip,
308    /// Custom outcome
309    Custom(String),
310}
311
312/// Result validation specification
313#[derive(Debug, Clone)]
314pub struct ResultValidation {
315    /// Validation method
316    pub method: ValidationMethod,
317    /// Tolerance for numeric results
318    pub tolerance: Option<f64>,
319    /// Confidence level required
320    pub confidence_level: f64,
321}
322
323/// Validation methods for results
324#[derive(Debug, Clone, PartialEq, Eq)]
325pub enum ValidationMethod {
326    /// Exact match
327    Exact,
328    /// Approximate match
329    Approximate,
330    /// Range check
331    Range,
332    /// Statistical validation
333    Statistical,
334    /// Custom validation
335    Custom(String),
336}
337
338/// Expected performance metrics
339#[derive(Debug, Clone)]
340pub struct ExpectedPerformanceMetrics {
341    /// Expected execution time
342    pub execution_time: Option<Duration>,
343    /// Expected memory usage
344    pub memory_usage: Option<usize>,
345    /// Expected throughput
346    pub throughput: Option<f64>,
347    /// Expected error rate
348    pub error_rate: Option<f64>,
349    /// Custom metrics
350    pub custom_metrics: HashMap<String, f64>,
351}
352
353/// Expected side effects
354#[derive(Debug, Clone)]
355pub struct ExpectedSideEffect {
356    /// Side effect name
357    pub name: String,
358    /// Side effect type
359    pub effect_type: SideEffectType,
360    /// Effect description
361    pub description: String,
362    /// Acceptance criteria
363    pub acceptance_criteria: AcceptanceCriteria,
364}
365
366/// Types of side effects
367#[derive(Debug, Clone, PartialEq, Eq)]
368pub enum SideEffectType {
369    /// State change
370    StateChange,
371    /// Resource consumption
372    ResourceConsumption,
373    /// Performance impact
374    PerformanceImpact,
375    /// Data modification
376    DataModification,
377    /// Custom side effect
378    Custom(String),
379}
380
381/// Acceptance criteria for side effects
382#[derive(Debug, Clone)]
383pub struct AcceptanceCriteria {
384    /// Acceptable impact level
385    pub acceptable_impact: ImpactLevel,
386    /// Maximum duration
387    pub max_duration: Option<Duration>,
388    /// Recovery requirements
389    pub recovery_requirements: Vec<String>,
390}
391
392/// Impact levels for side effects
393#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
394pub enum ImpactLevel {
395    None = 0,
396    Minimal = 1,
397    Low = 2,
398    Medium = 3,
399    High = 4,
400    Critical = 5,
401}
402
403/// Individual test step
404#[derive(Debug, Clone)]
405pub struct TestStep {
406    /// Step identifier
407    pub id: String,
408    /// Step name
409    pub name: String,
410    /// Step description
411    pub description: String,
412    /// Step type
413    pub step_type: StepType,
414    /// Step parameters
415    pub parameters: HashMap<String, ParameterValue>,
416    /// Step timeout
417    pub timeout: Option<Duration>,
418    /// Retry configuration
419    pub retry_config: Option<RetryConfig>,
420}
421
422/// Test step types
423#[derive(Debug, Clone, PartialEq, Eq)]
424pub enum StepType {
425    /// Setup step
426    Setup,
427    /// Execution step
428    Execution,
429    /// Validation step
430    Validation,
431    /// Cleanup step
432    Cleanup,
433    /// Custom step
434    Custom(String),
435}
436
437/// Retry configuration for test steps
438#[derive(Debug, Clone)]
439pub struct RetryConfig {
440    /// Maximum retry attempts
441    pub max_attempts: usize,
442    /// Retry delay
443    pub retry_delay: Duration,
444    /// Exponential backoff
445    pub exponential_backoff: bool,
446    /// Retry conditions
447    pub retry_conditions: Vec<String>,
448}
449
450/// Test suite configuration
451#[derive(Debug, Clone)]
452pub struct TestSuiteConfig {
453    /// Execution order
454    pub execution_order: ExecutionOrder,
455    /// Parallel execution settings
456    pub parallel_execution: ParallelExecutionConfig,
457    /// Suite timeout
458    pub timeout: Duration,
459    /// Failure handling
460    pub failure_handling: FailureHandling,
461}
462
463/// Test execution order
464#[derive(Debug, Clone, PartialEq, Eq)]
465pub enum ExecutionOrder {
466    /// Sequential execution
467    Sequential,
468    /// Parallel execution
469    Parallel,
470    /// Dependency-based order
471    DependencyBased,
472    /// Priority-based order
473    PriorityBased,
474    /// Custom order
475    Custom(Vec<String>),
476}
477
478/// Parallel execution configuration
479#[derive(Debug, Clone)]
480pub struct ParallelExecutionConfig {
481    /// Enable parallel execution
482    pub enable_parallel: bool,
483    /// Maximum parallel threads
484    pub max_threads: usize,
485    /// Thread pool configuration
486    pub thread_pool_config: ThreadPoolConfig,
487}
488
489/// Thread pool configuration
490#[derive(Debug, Clone)]
491pub struct ThreadPoolConfig {
492    /// Core pool size
493    pub core_size: usize,
494    /// Maximum pool size
495    pub max_size: usize,
496    /// Thread keepalive time
497    pub keepalive_time: Duration,
498    /// Queue capacity
499    pub queue_capacity: usize,
500}
501
502/// Failure handling strategies
503#[derive(Debug, Clone, PartialEq, Eq)]
504pub enum FailureHandling {
505    /// Stop on first failure
506    StopOnFirstFailure,
507    /// Continue on failure
508    ContinueOnFailure,
509    /// Retry failed tests
510    RetryFailedTests,
511    /// Custom handling
512    Custom(String),
513}
514
515/// Test metadata
516#[derive(Debug, Clone)]
517pub struct TestMetadata {
518    /// Test author
519    pub author: String,
520    /// Creation timestamp
521    pub created: SystemTime,
522    /// Last modified timestamp
523    pub modified: SystemTime,
524    /// Test version
525    pub version: String,
526    /// Tags
527    pub tags: Vec<String>,
528    /// Custom metadata
529    pub custom: HashMap<String, String>,
530}
quantrs2_anneal/comprehensive_integration_testing/scenarios.rs

quantrs2_anneal/comprehensive_integration_testing/
scenarios.rs
