use super::*;
#[test]
fn test_violation_type_complexity() {
let vt = ViolationType::Complexity;
let json = serde_json::to_string(&vt).unwrap();
assert_eq!(json, "\"complexity\"");
}
#[test]
fn test_violation_type_satd() {
let vt = ViolationType::Satd;
let json = serde_json::to_string(&vt).unwrap();
assert_eq!(json, "\"satd\"");
}
#[test]
fn test_violation_type_lint() {
let vt = ViolationType::Lint;
let json = serde_json::to_string(&vt).unwrap();
assert_eq!(json, "\"lint\"");
}
#[test]
fn test_violation_type_docs() {
let vt = ViolationType::Docs;
let json = serde_json::to_string(&vt).unwrap();
assert_eq!(json, "\"docs\"");
}
#[test]
fn test_violation_severity_error() {
let sev = ViolationSeverity::Error;
let json = serde_json::to_string(&sev).unwrap();
assert_eq!(json, "\"error\"");
}
#[test]
fn test_violation_severity_warning() {
let sev = ViolationSeverity::Warning;
let json = serde_json::to_string(&sev).unwrap();
assert_eq!(json, "\"warning\"");
}
#[test]
fn test_quality_violation_creation() {
let violation = QualityViolation {
violation_type: ViolationType::Complexity,
severity: ViolationSeverity::Error,
location: "src/main.rs:42".to_string(),
message: "Cyclomatic complexity of 25 exceeds limit of 20".to_string(),
suggestion: Some("Extract helper functions".to_string()),
};
assert!(matches!(
violation.violation_type,
ViolationType::Complexity
));
assert!(matches!(violation.severity, ViolationSeverity::Error));
assert_eq!(violation.location, "src/main.rs:42");
assert!(violation.message.contains("complexity"));
}
#[test]
fn test_quality_violation_without_suggestion() {
let violation = QualityViolation {
violation_type: ViolationType::Satd,
severity: ViolationSeverity::Warning,
location: "src/lib.rs:10".to_string(),
message: "TODO marker found".to_string(),
suggestion: None,
};
assert!(violation.suggestion.is_none());
}
#[test]
fn test_quality_violation_serialization() {
let violation = QualityViolation {
violation_type: ViolationType::Lint,
severity: ViolationSeverity::Warning,
location: "test.rs:5".to_string(),
message: "Unused variable".to_string(),
suggestion: None,
};
let json = serde_json::to_string(&violation).unwrap();
assert!(json.contains("\"type\":\"lint\""));
assert!(json.contains("\"severity\":\"warning\""));
assert!(!json.contains("suggestion"));
}
#[test]
fn test_quality_metrics_creation() {
let metrics = QualityMetrics {
max_complexity: 25,
satd_count: 3,
lint_violations: 5,
coverage_percentage: Some(85.5),
};
assert_eq!(metrics.max_complexity, 25);
assert_eq!(metrics.satd_count, 3);
assert_eq!(metrics.lint_violations, 5);
assert_eq!(metrics.coverage_percentage, Some(85.5));
}
#[test]
fn test_quality_metrics_no_coverage() {
let metrics = QualityMetrics {
max_complexity: 10,
satd_count: 0,
lint_violations: 0,
coverage_percentage: None,
};
assert!(metrics.coverage_percentage.is_none());
}
#[test]
fn test_quality_metrics_serialization() {
let metrics = QualityMetrics {
max_complexity: 15,
satd_count: 2,
lint_violations: 1,
coverage_percentage: None,
};
let json = serde_json::to_string(&metrics).unwrap();
assert!(!json.contains("coverage_percentage"));
}
#[test]
fn test_quality_report_passed() {
let report = QualityReport {
passed: true,
metrics: QualityMetrics {
max_complexity: 10,
satd_count: 0,
lint_violations: 0,
coverage_percentage: Some(95.0),
},
violations: vec![],
};
assert!(report.passed);
assert!(report.violations.is_empty());
}
#[test]
fn test_quality_report_failed() {
let report = QualityReport {
passed: false,
metrics: QualityMetrics {
max_complexity: 30,
satd_count: 5,
lint_violations: 3,
coverage_percentage: Some(60.0),
},
violations: vec![QualityViolation {
violation_type: ViolationType::Complexity,
severity: ViolationSeverity::Error,
location: "test.rs:10".to_string(),
message: "High complexity".to_string(),
suggestion: None,
}],
};
assert!(!report.passed);
assert_eq!(report.violations.len(), 1);
}
#[test]
fn test_proxy_response_accepted() {
let response = ProxyResponse {
status: ProxyStatus::Accepted,
quality_report: QualityReport {
passed: true,
metrics: QualityMetrics {
max_complexity: 10,
satd_count: 0,
lint_violations: 0,
coverage_percentage: None,
},
violations: vec![],
},
final_content: "fn test() {}".to_string(),
refactoring_applied: false,
refactoring_plan: None,
};
assert!(matches!(response.status, ProxyStatus::Accepted));
assert!(!response.refactoring_applied);
assert!(response.refactoring_plan.is_none());
}
#[test]
fn test_proxy_response_modified_with_refactoring() {
let mut plan_step = HashMap::new();
plan_step.insert("action".to_string(), serde_json::json!("extract_function"));
plan_step.insert("lines".to_string(), serde_json::json!([10, 20]));
let response = ProxyResponse {
status: ProxyStatus::Modified,
quality_report: QualityReport {
passed: true,
metrics: QualityMetrics {
max_complexity: 15,
satd_count: 0,
lint_violations: 0,
coverage_percentage: None,
},
violations: vec![],
},
final_content: "fn helper() {}\nfn test() { helper(); }".to_string(),
refactoring_applied: true,
refactoring_plan: Some(vec![plan_step]),
};
assert!(matches!(response.status, ProxyStatus::Modified));
assert!(response.refactoring_applied);
assert!(response.refactoring_plan.is_some());
assert_eq!(response.refactoring_plan.as_ref().unwrap().len(), 1);
}
#[test]
fn test_proxy_response_rejected() {
let response = ProxyResponse {
status: ProxyStatus::Rejected,
quality_report: QualityReport {
passed: false,
metrics: QualityMetrics {
max_complexity: 50,
satd_count: 10,
lint_violations: 5,
coverage_percentage: Some(30.0),
},
violations: vec![QualityViolation {
violation_type: ViolationType::Complexity,
severity: ViolationSeverity::Error,
location: "main.rs:1".to_string(),
message: "Exceeds limits".to_string(),
suggestion: Some("Refactor".to_string()),
}],
},
final_content: String::new(),
refactoring_applied: false,
refactoring_plan: None,
};
assert!(matches!(response.status, ProxyStatus::Rejected));
assert!(!response.quality_report.passed);
assert_eq!(response.quality_report.violations.len(), 1);
}
#[test]
fn test_proxy_response_serialization_roundtrip() {
let response = ProxyResponse {
status: ProxyStatus::Accepted,
quality_report: QualityReport {
passed: true,
metrics: QualityMetrics {
max_complexity: 10,
satd_count: 0,
lint_violations: 0,
coverage_percentage: Some(90.0),
},
violations: vec![],
},
final_content: "fn foo() {}".to_string(),
refactoring_applied: false,
refactoring_plan: None,
};
let json = serde_json::to_string(&response).unwrap();
let deserialized: ProxyResponse = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized.status, ProxyStatus::Accepted));
assert!(deserialized.quality_report.passed);
assert_eq!(deserialized.final_content, "fn foo() {}");
}
#[test]
fn test_proxy_operation_clone() {
let op = ProxyOperation::Write;
let cloned = op.clone();
assert!(matches!(cloned, ProxyOperation::Write));
}
#[test]
fn test_quality_config_clone() {
let config = QualityConfig::default();
let cloned = config.clone();
assert_eq!(cloned.max_complexity, config.max_complexity);
}
#[test]
fn test_quality_violation_clone() {
let violation = QualityViolation {
violation_type: ViolationType::Satd,
severity: ViolationSeverity::Warning,
location: "test.rs:1".to_string(),
message: "TODO".to_string(),
suggestion: None,
};
let cloned = violation.clone();
assert_eq!(cloned.location, violation.location);
}
#[test]
fn test_proxy_operation_debug() {
let op = ProxyOperation::Edit;
let debug = format!("{:?}", op);
assert!(debug.contains("Edit"));
}
#[test]
fn test_proxy_mode_debug() {
let mode = ProxyMode::Advisory;
let debug = format!("{:?}", mode);
assert!(debug.contains("Advisory"));
}
#[test]
fn test_quality_metrics_debug() {
let metrics = QualityMetrics {
max_complexity: 20,
satd_count: 1,
lint_violations: 2,
coverage_percentage: Some(80.0),
};
let debug = format!("{:?}", metrics);
assert!(debug.contains("max_complexity: 20"));
}