#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod simple_tests {
use super::*;
#[test]
fn test_resource_limits_default() {
let limits = ResourceLimits::default();
assert_eq!(limits.max_memory_mb, 1024.0);
assert_eq!(limits.max_cpu_utilization, 0.8);
assert_eq!(limits.max_concurrent_ops, 20);
assert_eq!(limits.memory_warning_threshold, 0.7);
assert_eq!(limits.cpu_warning_threshold, 0.6);
assert_eq!(limits.check_interval_secs, 5);
}
#[test]
fn test_resource_limits_clone() {
let limits = ResourceLimits {
max_memory_mb: 512.0,
max_cpu_utilization: 0.5,
max_concurrent_ops: 10,
memory_warning_threshold: 0.6,
cpu_warning_threshold: 0.5,
check_interval_secs: 3,
};
let cloned = limits.clone();
assert_eq!(cloned.max_memory_mb, 512.0);
assert_eq!(cloned.max_concurrent_ops, 10);
}
#[test]
fn test_operation_type_variants() {
let analysis = OperationType::Analysis;
let commit = OperationType::Commit;
let background = OperationType::Background;
let storage = OperationType::Storage;
let cleanup = OperationType::Cleanup;
assert!(matches!(analysis, OperationType::Analysis));
assert!(matches!(commit, OperationType::Commit));
assert!(matches!(background, OperationType::Background));
assert!(matches!(storage, OperationType::Storage));
assert!(matches!(cleanup, OperationType::Cleanup));
}
#[test]
fn test_operation_type_equality() {
assert_eq!(OperationType::Analysis, OperationType::Analysis);
assert_ne!(OperationType::Analysis, OperationType::Commit);
}
#[test]
fn test_operation_type_clone() {
let op = OperationType::Analysis;
let cloned = op.clone();
assert_eq!(cloned, OperationType::Analysis);
}
#[test]
fn test_resource_pressure_variants() {
let low = ResourcePressure::Low;
let medium = ResourcePressure::Medium;
let high = ResourcePressure::High;
let critical = ResourcePressure::Critical;
assert!(matches!(low, ResourcePressure::Low));
assert!(matches!(medium, ResourcePressure::Medium));
assert!(matches!(high, ResourcePressure::High));
assert!(matches!(critical, ResourcePressure::Critical));
}
#[test]
fn test_resource_pressure_equality() {
assert_eq!(ResourcePressure::Low, ResourcePressure::Low);
assert_ne!(ResourcePressure::Low, ResourcePressure::High);
}
#[test]
fn test_operation_priority_variants() {
let critical = OperationPriority::Critical;
let high = OperationPriority::High;
let medium = OperationPriority::Medium;
let low = OperationPriority::Low;
assert!(matches!(critical, OperationPriority::Critical));
assert!(matches!(high, OperationPriority::High));
assert!(matches!(medium, OperationPriority::Medium));
assert!(matches!(low, OperationPriority::Low));
}
#[test]
fn test_operation_priority_ordering() {
assert!(OperationPriority::Critical < OperationPriority::High);
assert!(OperationPriority::High < OperationPriority::Medium);
assert!(OperationPriority::Medium < OperationPriority::Low);
}
#[test]
fn test_operation_priority_equality() {
assert_eq!(OperationPriority::High, OperationPriority::High);
assert_ne!(OperationPriority::High, OperationPriority::Low);
}
#[test]
fn test_resource_action_allow() {
let action = ResourceAction::Allow;
assert!(matches!(action, ResourceAction::Allow));
}
#[test]
fn test_resource_action_throttle() {
let action = ResourceAction::Throttle { delay_ms: 1000 };
if let ResourceAction::Throttle { delay_ms } = action {
assert_eq!(delay_ms, 1000);
} else {
panic!("Expected Throttle action");
}
}
#[test]
fn test_resource_action_queue() {
let action = ResourceAction::Queue {
estimated_wait_ms: 5000,
};
if let ResourceAction::Queue { estimated_wait_ms } = action {
assert_eq!(estimated_wait_ms, 5000);
} else {
panic!("Expected Queue action");
}
}
#[test]
fn test_resource_action_reject() {
let action = ResourceAction::Reject {
reason: "Too busy".to_string(),
};
if let ResourceAction::Reject { reason } = action {
assert_eq!(reason, "Too busy");
} else {
panic!("Expected Reject action");
}
}
#[test]
fn test_resource_action_emergency_stop() {
let action = ResourceAction::EmergencyStop;
assert!(matches!(action, ResourceAction::EmergencyStop));
}
#[test]
fn test_operation_context_creation() {
let context = OperationContext {
id: "test-op".to_string(),
operation_type: OperationType::Analysis,
started_at: Instant::now(),
estimated_memory_mb: 100.0,
priority: OperationPriority::High,
};
assert_eq!(context.id, "test-op");
assert_eq!(context.estimated_memory_mb, 100.0);
assert_eq!(context.priority, OperationPriority::High);
}
#[test]
fn test_operation_context_clone() {
let context = OperationContext {
id: "clone-test".to_string(),
operation_type: OperationType::Commit,
started_at: Instant::now(),
estimated_memory_mb: 50.0,
priority: OperationPriority::Critical,
};
let cloned = context.clone();
assert_eq!(cloned.id, "clone-test");
assert_eq!(cloned.priority, OperationPriority::Critical);
}
#[test]
fn test_resource_enforcement_stats_format_diagnostic() {
let stats = ResourceEnforcementStats {
total_requests: 100,
allowed_requests: 85,
throttled_requests: 5,
queued_requests: 7,
rejected_requests: 3,
current_active_operations: 10,
};
let output = stats.format_diagnostic();
assert!(output.contains("Total requests: 100"));
assert!(output.contains("85.0%")); assert!(output.contains("Allowed: 85"));
assert!(output.contains("Throttled: 5"));
assert!(output.contains("Queued: 7"));
assert!(output.contains("Rejected: 3"));
assert!(output.contains("Active operations: 10"));
}
#[test]
fn test_resource_enforcement_stats_empty() {
let stats = ResourceEnforcementStats {
total_requests: 0,
allowed_requests: 0,
throttled_requests: 0,
queued_requests: 0,
rejected_requests: 0,
current_active_operations: 0,
};
let output = stats.format_diagnostic();
assert!(output.contains("Total requests: 0"));
assert!(output.contains("100.0%")); }
#[test]
fn test_resource_enforcement_stats_clone() {
let stats = ResourceEnforcementStats {
total_requests: 50,
allowed_requests: 40,
throttled_requests: 5,
queued_requests: 3,
rejected_requests: 2,
current_active_operations: 5,
};
let cloned = stats.clone();
assert_eq!(cloned.total_requests, 50);
assert_eq!(cloned.allowed_requests, 40);
}
#[test]
fn test_enforcement_event_creation() {
let usage = ResourceUsage {
timestamp: Instant::now(),
memory_mb: 500.0,
cpu_utilization: 0.5,
active_operations: 5,
memory_pressure: ResourcePressure::Low,
cpu_pressure: ResourcePressure::Low,
};
let event = EnforcementEvent {
timestamp: Instant::now(),
operation_id: "event-test".to_string(),
action: ResourceAction::Allow,
resource_usage: usage,
reason: "Test event".to_string(),
};
assert_eq!(event.operation_id, "event-test");
assert_eq!(event.reason, "Test event");
}
#[test]
fn test_resource_usage_clone() {
let usage = ResourceUsage {
timestamp: Instant::now(),
memory_mb: 750.0,
cpu_utilization: 0.65,
active_operations: 8,
memory_pressure: ResourcePressure::Medium,
cpu_pressure: ResourcePressure::Low,
};
let cloned = usage.clone();
assert_eq!(cloned.memory_mb, 750.0);
assert_eq!(cloned.cpu_utilization, 0.65);
assert_eq!(cloned.active_operations, 8);
}
#[test]
fn test_factory_create_default() {
let controller = ResourceControllerFactory::create_default();
let _ = controller;
}
#[test]
fn test_factory_create_dev_optimized() {
let controller = ResourceControllerFactory::create_dev_optimized();
let _ = controller;
}
#[test]
fn test_factory_create_prod_optimized() {
let controller = ResourceControllerFactory::create_prod_optimized();
let _ = controller;
}
#[test]
fn test_factory_create_ci_optimized() {
let controller = ResourceControllerFactory::create_ci_optimized();
let _ = controller;
}
#[test]
fn test_controller_creation() {
let limits = ResourceLimits::default();
let controller = PlatformResourceController::new(limits);
let _ = controller;
}
}