#[test]
fn test_entropy_command_construction() {
let cmd = AnalyzeCommands::Entropy {
project_path: PathBuf::from("."),
format: EntropyOutputFormat::Summary,
output: None,
min_severity: EntropySeverity::Medium,
top_violations: 10,
file: None,
include_tests: false,
};
if let AnalyzeCommands::Entropy {
min_severity,
top_violations,
include_tests,
..
} = cmd
{
assert!(matches!(min_severity, EntropySeverity::Medium));
assert_eq!(top_violations, 10);
assert!(!include_tests);
} else {
panic!("Expected Entropy command");
}
}
#[test]
fn test_wasm_command_construction() {
let cmd = AnalyzeCommands::Wasm {
wasm_file: PathBuf::from("test.wasm"),
format: WasmOutputFormat::Summary,
verify: false,
security: true,
profile: false,
baseline: None,
output: None,
verbose: false,
};
if let AnalyzeCommands::Wasm {
verify, security, ..
} = cmd
{
assert!(!verify);
assert!(security);
} else {
panic!("Expected Wasm command");
}
}
#[test]
fn test_core_analysis_commands_are_routed() {
let commands = vec![
"Complexity",
"Churn",
"DeadCode",
"Defects",
"Dag",
"Satd",
];
for cmd_name in commands {
assert!(
["Complexity", "Churn", "DeadCode", "Defects", "Dag", "Satd"]
.contains(&cmd_name),
"Core analysis should include {}",
cmd_name
);
}
}
#[test]
fn test_advanced_analysis_commands_are_routed() {
let commands = vec![
"DeepContext",
"Tdg",
"BuildTdg",
"LintHotspot",
"Comprehensive",
];
for cmd_name in commands {
assert!(
[
"DeepContext",
"Tdg",
"BuildTdg",
"LintHotspot",
"Comprehensive"
]
.contains(&cmd_name),
"Advanced analysis should include {}",
cmd_name
);
}
}
#[test]
fn test_quality_analysis_commands_are_routed() {
let commands = vec![
"Duplicates",
"DefectPrediction",
"Provability",
"Clippy",
"Entropy",
];
for cmd_name in commands {
assert!(
[
"Duplicates",
"DefectPrediction",
"Provability",
"Clippy",
"Entropy"
]
.contains(&cmd_name),
"Quality analysis should include {}",
cmd_name
);
}
}
#[test]
fn test_specialized_analysis_commands_are_routed() {
let commands = vec![
"GraphMetrics",
"NameSimilarity",
"ProofAnnotations",
"IncrementalCoverage",
"CoverageImprove",
"SymbolTable",
"BigO",
];
for cmd_name in commands {
assert!(
[
"GraphMetrics",
"NameSimilarity",
"ProofAnnotations",
"IncrementalCoverage",
"CoverageImprove",
"SymbolTable",
"BigO"
]
.contains(&cmd_name),
"Specialized analysis should include {}",
cmd_name
);
}
}
#[test]
fn test_language_specific_commands_are_routed() {
let commands = vec!["AssemblyScript", "WebAssembly", "Wasm"];
for cmd_name in commands {
assert!(
["AssemblyScript", "WebAssembly", "Wasm"].contains(&cmd_name),
"Language-specific analysis should include {}",
cmd_name
);
}
}
#[test]
fn test_all_dag_types_convert() {
let variants = [
DeepContextDagType::CallGraph,
DeepContextDagType::ImportGraph,
DeepContextDagType::Inheritance,
DeepContextDagType::FullDependency,
];
for variant in variants {
let result = convert_deep_context_dag_type(variant);
match result {
DagType::CallGraph
| DagType::ImportGraph
| DagType::Inheritance
| DagType::FullDependency => {}
_ => panic!("Unexpected DagType variant"),
}
}
}
#[test]
fn test_all_cache_strategies_convert() {
let variants = [
DeepContextCacheStrategy::Normal,
DeepContextCacheStrategy::ForceRefresh,
DeepContextCacheStrategy::Offline,
];
let expected = ["normal", "force-refresh", "offline"];
for (variant, exp) in variants.iter().zip(expected.iter()) {
let result = convert_cache_strategy(variant.clone());
assert_eq!(result, *exp);
}
}
#[test]
fn test_create_entropy_config_excludes_tests_when_disabled() {
let config = create_entropy_config(EntropySeverity::Low, false);
assert!(
config.exclude_paths.len() >= 2,
"Should have test exclusions when include_tests is false"
);
assert!(config
.exclude_paths
.iter()
.any(|p| p.contains("test") || p.contains("tests")));
}
#[test]
fn test_create_entropy_config_includes_tests_when_enabled() {
let config = create_entropy_config(EntropySeverity::High, true);
assert!(matches!(
config.min_severity,
crate::entropy::violation_detector::Severity::High
));
}
#[test]
fn test_get_top_violations_returns_all_when_limit_exceeds_count() {
let violations: Vec<crate::entropy::violation_detector::ActionableViolation> = vec![];
let result = get_top_violations(&violations, 100);
assert_eq!(result.len(), 0);
}
#[test]
fn test_format_violation_list_with_empty_vector() {
let violations: Vec<crate::entropy::violation_detector::ActionableViolation> = vec![];
let result = format_violation_list(&violations);
assert!(result.is_empty());
}
#[test]
fn test_format_markdown_violations_with_zero_max() {
let violations: Vec<crate::entropy::violation_detector::ActionableViolation> = vec![];
let result = format_markdown_violations(&violations, 0);
assert!(result.is_empty());
}
#[test]
fn test_output_entropy_results_creates_parent_dirs() {
let temp_dir = TempDir::new().unwrap();
let nested_path = temp_dir.path().join("nested").join("dir").join("output.txt");
std::fs::create_dir_all(nested_path.parent().unwrap()).unwrap();
let result = output_entropy_results(Some(nested_path.clone()), "test");
assert!(result.is_ok());
}
#[test]
fn test_defects_severity_parsing_critical() {
let severity_str = "critical";
let result = match severity_str.to_lowercase().as_str() {
"critical" => Some(crate::services::defect_detector::Severity::Critical),
"high" => Some(crate::services::defect_detector::Severity::High),
"medium" => Some(crate::services::defect_detector::Severity::Medium),
"low" => Some(crate::services::defect_detector::Severity::Low),
_ => None,
};
assert!(matches!(
result,
Some(crate::services::defect_detector::Severity::Critical)
));
}
#[test]
fn test_defects_severity_parsing_high() {
let severity_str = "HIGH";
let result = match severity_str.to_lowercase().as_str() {
"critical" => Some(crate::services::defect_detector::Severity::Critical),
"high" => Some(crate::services::defect_detector::Severity::High),
"medium" => Some(crate::services::defect_detector::Severity::Medium),
"low" => Some(crate::services::defect_detector::Severity::Low),
_ => None,
};
assert!(matches!(
result,
Some(crate::services::defect_detector::Severity::High)
));
}
#[test]
fn test_defects_severity_parsing_medium() {
let severity_str = "Medium";
let result = match severity_str.to_lowercase().as_str() {
"critical" => Some(crate::services::defect_detector::Severity::Critical),
"high" => Some(crate::services::defect_detector::Severity::High),
"medium" => Some(crate::services::defect_detector::Severity::Medium),
"low" => Some(crate::services::defect_detector::Severity::Low),
_ => None,
};
assert!(matches!(
result,
Some(crate::services::defect_detector::Severity::Medium)
));
}
#[test]
fn test_defects_severity_parsing_low() {
let severity_str = "low";
let result = match severity_str.to_lowercase().as_str() {
"critical" => Some(crate::services::defect_detector::Severity::Critical),
"high" => Some(crate::services::defect_detector::Severity::High),
"medium" => Some(crate::services::defect_detector::Severity::Medium),
"low" => Some(crate::services::defect_detector::Severity::Low),
_ => None,
};
assert!(matches!(
result,
Some(crate::services::defect_detector::Severity::Low)
));
}
#[test]
fn test_defects_severity_parsing_invalid() {
let severity_str = "unknown";
let result = match severity_str.to_lowercase().as_str() {
"critical" => Some(crate::services::defect_detector::Severity::Critical),
"high" => Some(crate::services::defect_detector::Severity::High),
"medium" => Some(crate::services::defect_detector::Severity::Medium),
"low" => Some(crate::services::defect_detector::Severity::Low),
_ => None,
};
assert!(result.is_none());
}
#[test]
fn test_defects_output_format_text() {
let format = DefectsOutputFormat::Text;
assert!(matches!(format, DefectsOutputFormat::Text));
}
#[test]
fn test_defects_output_format_json() {
let format = DefectsOutputFormat::Json;
assert!(matches!(format, DefectsOutputFormat::Json));
}
#[test]
fn test_defects_output_format_junit() {
let format = DefectsOutputFormat::Junit;
assert!(matches!(format, DefectsOutputFormat::Junit));
}
#[test]
fn test_comprehensive_command_with_all_flags() {
let cmd = AnalyzeCommands::Comprehensive {
project_path: PathBuf::from("."),
file: None,
files: vec![PathBuf::from("src/main.rs"), PathBuf::from("src/lib.rs")],
format: crate::cli::ComprehensiveOutputFormat::Summary,
include_duplicates: true,
include_dead_code: true,
include_defects: true,
include_complexity: true,
include_tdg: true,
confidence_threshold: 0.7,
min_lines: 5,
include: Some("**/*.rs".to_string()),
exclude: Some("**/target/**".to_string()),
output: None,
perf: true,
executive_summary: true,
top_files: 20,
};
if let AnalyzeCommands::Comprehensive {
files,
include_duplicates,
include_dead_code,
include_defects,
include_complexity,
include_tdg,
executive_summary,
..
} = cmd
{
assert_eq!(files.len(), 2);
assert!(include_duplicates);
assert!(include_dead_code);
assert!(include_defects);
assert!(include_complexity);
assert!(include_tdg);
assert!(executive_summary);
} else {
panic!("Expected Comprehensive command");
}
}
#[test]
fn test_incremental_coverage_command_construction() {
let cmd = AnalyzeCommands::IncrementalCoverage {
project_path: PathBuf::from("."),
base_branch: Some("main".to_string()),
target_branch: Some("feature".to_string()),
format: crate::cli::IncrementalCoverageOutputFormat::Summary,
coverage_threshold: 80.0,
changed_files_only: true,
detailed: false,
output: None,
perf: false,
cache_dir: None,
force_refresh: false,
top_files: 10,
};
if let AnalyzeCommands::IncrementalCoverage {
base_branch,
target_branch,
coverage_threshold,
changed_files_only,
..
} = cmd
{
assert_eq!(base_branch, Some("main".to_string()));
assert_eq!(target_branch, Some("feature".to_string()));
assert!((coverage_threshold - 80.0).abs() < f64::EPSILON);
assert!(changed_files_only);
} else {
panic!("Expected IncrementalCoverage command");
}
}
#[test]
fn test_big_o_command_construction() {
let cmd = AnalyzeCommands::BigO {
project_path: PathBuf::from("."),
format: crate::cli::BigOOutputFormat::Summary,
confidence_threshold: 0.7,
analyze_space: true,
include: vec!["src/**/*.rs".to_string()],
exclude: vec!["target/**".to_string()],
high_complexity_only: true,
output: None,
perf: false,
top_files: 10,
};
if let AnalyzeCommands::BigO {
confidence_threshold,
analyze_space,
high_complexity_only,
..
} = cmd
{
assert!((confidence_threshold - 0.7).abs() < f64::EPSILON);
assert!(analyze_space);
assert!(high_complexity_only);
} else {
panic!("Expected BigO command");
}
}
#[test]
fn test_assemblyscript_command_construction() {
let cmd = AnalyzeCommands::AssemblyScript {
project_path: PathBuf::from("."),
format: WasmOutputFormat::Summary,
wasm_complexity: true,
memory_analysis: true,
security: true,
output: None,
timeout: 60,
perf: false,
top_files: 10,
};