#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_proxy_high_quality_code() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: Some(
r#"/// A simple greeting function
/// Greet.
pub fn greet(name: &str) -> String {
format!("Hello, {}!", name)
}"#
.to_string(),
),
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let response = service.proxy_operation(request).await.unwrap();
assert!(matches!(response.status, ProxyStatus::Accepted));
assert!(response.quality_report.passed);
}
#[tokio::test]
async fn test_proxy_reject_satd() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: Some(
r#"fn process() {
// TODO: This needs to be implemented properly
// FIXME: Critical bug here
unimplemented!()
}"#
.to_string(),
),
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let response = service.proxy_operation(request).await.unwrap();
assert!(matches!(response.status, ProxyStatus::Rejected));
assert!(!response.quality_report.passed);
assert!(response.quality_report.metrics.satd_count > 0);
}
#[tokio::test]
async fn test_proxy_advisory_mode() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: Some(
r#"pub fn undocumented() {
println!("No docs");
}"#
.to_string(),
),
old_content: None,
new_content: None,
mode: ProxyMode::Advisory,
quality_config: QualityConfig::default(),
};
let response = service.proxy_operation(request).await.unwrap();
assert!(matches!(response.status, ProxyStatus::Accepted));
assert!(!response.quality_report.violations.is_empty());
}
#[test]
fn test_get_operation_content() {
let service = QualityProxyService::new();
let write_request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: Some("write content".to_string()),
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let content = service.get_operation_content(&write_request).unwrap();
assert_eq!(content, "write content");
let edit_request = ProxyRequest {
operation: ProxyOperation::Edit,
file_path: "test.rs".to_string(),
content: Some("original content here".to_string()),
old_content: Some("original".to_string()),
new_content: Some("modified".to_string()),
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let content = service.get_operation_content(&edit_request).unwrap();
assert_eq!(content, "modified content here");
}
#[test]
fn test_quality_proxy_service_new() {
let _service = QualityProxyService::new();
}
#[test]
fn test_quality_proxy_service_default() {
let _service = QualityProxyService::default();
}
#[test]
fn test_get_operation_content_missing_content() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: None,
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let result = service.get_operation_content(&request);
assert!(result.is_err());
}
#[test]
fn test_get_operation_content_append() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Append,
file_path: "test.rs".to_string(),
content: Some("appended".to_string()),
old_content: Some("existing".to_string()),
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let content = service.get_operation_content(&request).unwrap();
assert!(content.contains("existing"));
assert!(content.contains("appended"));
}
#[test]
fn test_get_operation_content_append_no_existing() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Append,
file_path: "test.rs".to_string(),
content: Some("appended content".to_string()),
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let content = service.get_operation_content(&request).unwrap();
assert_eq!(content, "appended content");
}
#[test]
fn test_get_operation_content_edit_missing_parts() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Edit,
file_path: "test.rs".to_string(),
content: Some("content".to_string()),
old_content: Some("old".to_string()),
new_content: None, mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let result = service.get_operation_content(&request);
assert!(result.is_err());
}
#[tokio::test]
async fn test_proxy_non_rust_file() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.py".to_string(),
content: Some("def hello(): print('world')".to_string()),
old_content: None,
new_content: None,
mode: ProxyMode::Strict,
quality_config: QualityConfig::default(),
};
let response = service.proxy_operation(request).await.unwrap();
assert!(matches!(response.status, ProxyStatus::Accepted));
assert!(response.quality_report.passed);
}
#[tokio::test]
async fn test_proxy_autofix_mode_simple() {
let service = QualityProxyService::new();
let request = ProxyRequest {
operation: ProxyOperation::Write,
file_path: "test.rs".to_string(),
content: Some("fn simple() {}".to_string()),
old_content: None,
new_content: None,
mode: ProxyMode::AutoFix,
quality_config: QualityConfig::default(),
};
let response = service.proxy_operation(request).await.unwrap();
assert!(matches!(response.status, ProxyStatus::Accepted));
}
#[test]
fn test_quality_config_default() {
let config = QualityConfig::default();
assert!(config.max_complexity > 0);
let _ = config.allow_satd;
}
#[test]
fn test_proxy_operation_enum_debug() {
let write = ProxyOperation::Write;
let edit = ProxyOperation::Edit;
let append = ProxyOperation::Append;
assert!(format!("{:?}", write).contains("Write"));
assert!(format!("{:?}", edit).contains("Edit"));
assert!(format!("{:?}", append).contains("Append"));
}
#[test]
fn test_proxy_mode_debug() {
let strict = ProxyMode::Strict;
let advisory = ProxyMode::Advisory;
let autofix = ProxyMode::AutoFix;
assert!(format!("{:?}", strict).contains("Strict"));
assert!(format!("{:?}", advisory).contains("Advisory"));
assert!(format!("{:?}", autofix).contains("AutoFix"));
}
#[test]
fn test_proxy_status_variants() {
let accepted = ProxyStatus::Accepted;
let rejected = ProxyStatus::Rejected;
let modified = ProxyStatus::Modified;
assert!(format!("{:?}", accepted).contains("Accepted"));
assert!(format!("{:?}", rejected).contains("Rejected"));
assert!(format!("{:?}", modified).contains("Modified"));
}
#[test]
fn test_violation_severity_ordering() {
let error = ViolationSeverity::Error;
let warning = ViolationSeverity::Warning;
assert!(format!("{:?}", error).contains("Error"));
assert!(format!("{:?}", warning).contains("Warning"));
}
#[test]
fn test_quality_violation_creation() {
let violation = QualityViolation {
violation_type: ViolationType::Complexity,
severity: ViolationSeverity::Error,
location: "test.rs:10".to_string(),
message: "Complexity too high".to_string(),
suggestion: Some("Refactor function".to_string()),
};
assert_eq!(violation.location, "test.rs:10");
assert!(matches!(
violation.violation_type,
ViolationType::Complexity
));
}
#[test]
fn test_quality_metrics_default() {
let metrics = QualityMetrics {
max_complexity: 0,
satd_count: 0,
lint_violations: 0,
coverage_percentage: None,
};
assert_eq!(metrics.max_complexity, 0);
assert_eq!(metrics.satd_count, 0);
}
}
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
use proptest::prelude::*;
proptest! {
#[test]
fn basic_property_stability(_input in ".*") {
prop_assert!(true);
}
#[test]
fn module_consistency_check(_x in 0u32..1000) {
prop_assert!(_x < 1001);
}
}
}