#![cfg_attr(coverage_nightly, coverage(off))]
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use tracing::info;
include!("enhanced_reporting_types.rs");
include!("enhanced_reporting_generation.rs");
include!("enhanced_reporting_sections.rs");
include!("enhanced_reporting_formatting.rs");
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_risk_level_serde_roundtrip() {
for level in [
RiskLevel::Low,
RiskLevel::Medium,
RiskLevel::High,
RiskLevel::Critical,
] {
let json = serde_json::to_string(&level).unwrap();
let back: RiskLevel = serde_json::from_str(&json).unwrap();
assert_eq!(
std::mem::discriminant(&level),
std::mem::discriminant(&back)
);
}
}
#[test]
fn test_section_type_serde_roundtrip() {
for st in [
SectionType::Complexity,
SectionType::DeadCode,
SectionType::Duplication,
SectionType::TechnicalDebt,
SectionType::BigOAnalysis,
SectionType::Security,
SectionType::Performance,
SectionType::Dependencies,
SectionType::TestCoverage,
SectionType::CodeSmells,
] {
let json = serde_json::to_string(&st).unwrap();
let _back: SectionType = serde_json::from_str(&json).unwrap();
}
}
#[test]
fn test_trend_serde_roundtrip() {
for t in [Trend::Improving, Trend::Stable, Trend::Degrading] {
let json = serde_json::to_string(&t).unwrap();
let back: Trend = serde_json::from_str(&json).unwrap();
assert_eq!(std::mem::discriminant(&t), std::mem::discriminant(&back));
}
}
#[test]
fn test_severity_serde_roundtrip() {
for s in [
Severity::Low,
Severity::Medium,
Severity::High,
Severity::Critical,
] {
let json = serde_json::to_string(&s).unwrap();
let back: Severity = serde_json::from_str(&json).unwrap();
assert_eq!(std::mem::discriminant(&s), std::mem::discriminant(&back));
}
}
#[test]
fn test_effort_level_serde_roundtrip() {
for e in [
EffortLevel::Trivial,
EffortLevel::Easy,
EffortLevel::Medium,
EffortLevel::Hard,
EffortLevel::VeryHard,
] {
let json = serde_json::to_string(&e).unwrap();
let back: EffortLevel = serde_json::from_str(&json).unwrap();
assert_eq!(std::mem::discriminant(&e), std::mem::discriminant(&back));
}
}
#[test]
fn test_priority_serde_roundtrip() {
for p in [
Priority::Low,
Priority::Medium,
Priority::High,
Priority::Critical,
] {
let json = serde_json::to_string(&p).unwrap();
let back: Priority = serde_json::from_str(&json).unwrap();
assert_eq!(std::mem::discriminant(&p), std::mem::discriminant(&back));
}
}
#[test]
fn test_visualization_type_serde_roundtrip() {
for vt in [
VisualizationType::BarChart,
VisualizationType::PieChart,
VisualizationType::LineChart,
VisualizationType::HeatMap,
VisualizationType::TreeMap,
VisualizationType::NetworkGraph,
VisualizationType::Table,
] {
let json = serde_json::to_string(&vt).unwrap();
let _back: VisualizationType = serde_json::from_str(&json).unwrap();
}
}
#[test]
fn test_metric_value_serde() {
let mv = MetricValue {
value: 42.5,
unit: "percent".to_string(),
trend: Trend::Improving,
threshold: Some(50.0),
};
let json = serde_json::to_string(&mv).unwrap();
let back: MetricValue = serde_json::from_str(&json).unwrap();
assert_eq!(back.value, 42.5);
assert!(matches!(back.trend, Trend::Improving));
assert_eq!(back.threshold, Some(50.0));
}
#[test]
fn test_finding_serde() {
let f = Finding {
severity: Severity::High,
category: "complexity".to_string(),
description: "Function too complex".to_string(),
location: Some(Location {
file: "src/main.rs".to_string(),
line: Some(42),
column: Some(1),
}),
impact: "Hard to maintain".to_string(),
effort: EffortLevel::Medium,
};
let json = serde_json::to_string(&f).unwrap();
let back: Finding = serde_json::from_str(&json).unwrap();
assert_eq!(back.category, "complexity");
assert!(back.location.is_some());
}
#[test]
fn test_recommendation_serde() {
let r = Recommendation {
priority: Priority::High,
category: "testing".to_string(),
title: "Increase coverage".to_string(),
description: "Add unit tests".to_string(),
effort: EffortLevel::Medium,
expected_impact: "Better quality".to_string(),
related_findings: vec!["finding-1".to_string()],
};
let json = serde_json::to_string(&r).unwrap();
let back: Recommendation = serde_json::from_str(&json).unwrap();
assert_eq!(back.title, "Increase coverage");
assert_eq!(back.related_findings.len(), 1);
}
#[test]
fn test_report_format_equality() {
assert_eq!(ReportFormat::Json, ReportFormat::Json);
assert_eq!(ReportFormat::Markdown, ReportFormat::Markdown);
assert_eq!(ReportFormat::Html, ReportFormat::Html);
assert_ne!(ReportFormat::Json, ReportFormat::Markdown);
}
#[test]
fn test_report_config_construction() {
let config = ReportConfig {
project_path: PathBuf::from("/test"),
output_format: ReportFormat::Json,
include_visualizations: true,
include_executive_summary: true,
include_recommendations: true,
confidence_threshold: 80,
output_path: None,
};
assert_eq!(config.confidence_threshold, 80);
assert!(config.include_visualizations);
}
#[test]
fn test_enhanced_reporting_service_default() {
let service = EnhancedReportingService::default();
let _ = format!("{:?}", "service created");
drop(service);
}
#[test]
fn test_executive_summary_serde() {
let summary = ExecutiveSummary {
overall_health_score: 85.0,
critical_issues: 0,
high_priority_issues: 2,
key_findings: vec!["Good coverage".to_string()],
risk_assessment: RiskLevel::Low,
};
let json = serde_json::to_string(&summary).unwrap();
let back: ExecutiveSummary = serde_json::from_str(&json).unwrap();
assert_eq!(back.overall_health_score, 85.0);
assert!(matches!(back.risk_assessment, RiskLevel::Low));
}
#[test]
fn test_visualization_serde() {
let viz = Visualization {
title: "Test Chart".to_string(),
viz_type: VisualizationType::BarChart,
data: serde_json::json!({"values": [1, 2, 3]}),
config: HashMap::new(),
};
let json = serde_json::to_string(&viz).unwrap();
let back: Visualization = serde_json::from_str(&json).unwrap();
assert_eq!(back.title, "Test Chart");
}
#[test]
fn test_report_section_serde() {
let section = ReportSection {
title: "Complexity".to_string(),
section_type: SectionType::Complexity,
content: serde_json::json!({}),
metrics: HashMap::new(),
findings: vec![],
};
let json = serde_json::to_string(§ion).unwrap();
let back: ReportSection = serde_json::from_str(&json).unwrap();
assert_eq!(back.title, "Complexity");
assert!(back.findings.is_empty());
}
#[test]
fn test_analysis_results_minimal() {
let results = AnalysisResults {
total_duration: std::time::Duration::from_secs(1),
analyzed_files: 10,
total_lines: 1000,
complexity_analysis: None,
dead_code_analysis: None,
duplication_analysis: None,
tdg_analysis: None,
big_o_analysis: None,
};
assert_eq!(results.analyzed_files, 10);
assert!(results.complexity_analysis.is_none());
}
#[test]
fn test_complexity_analysis_fields() {
let ca = ComplexityAnalysis {
total_cyclomatic: 100,
total_cognitive: 150,
functions: 20,
max_cyclomatic: 15,
high_complexity_functions: 2,
distribution: vec![10, 5, 3, 1, 1],
};
assert_eq!(ca.functions, 20);
assert_eq!(ca.distribution.len(), 5);
}
#[test]
fn test_location_serde() {
let loc = Location {
file: "src/lib.rs".to_string(),
line: Some(42),
column: Some(10),
};
let json = serde_json::to_string(&loc).unwrap();
let back: Location = serde_json::from_str(&json).unwrap();
assert_eq!(back.file, "src/lib.rs");
assert_eq!(back.line, Some(42));
}
#[test]
fn test_location_none_fields() {
let loc = Location {
file: "test.rs".to_string(),
line: None,
column: None,
};
let json = serde_json::to_string(&loc).unwrap();
let back: Location = serde_json::from_str(&json).unwrap();
assert!(back.line.is_none());
assert!(back.column.is_none());
}
}