#[test]
fn test_complexity_command_construction() {
let cmd = AnalyzeCommands::Complexity {
path: PathBuf::from("."),
project_path: None,
file: None,
files: vec![],
toolchain: None,
format: ComplexityOutputFormat::Summary,
output: None,
max_cyclomatic: None,
max_cognitive: None,
include: vec![],
watch: false,
top_files: 10,
fail_on_violation: false,
timeout: 60,
ml: false,
};
if let AnalyzeCommands::Complexity {
path, top_files, ..
} = cmd
{
assert_eq!(path, PathBuf::from("."));
assert_eq!(top_files, 10);
} else {
panic!("Expected Complexity command");
}
}
#[test]
fn test_churn_command_construction() {
let cmd = AnalyzeCommands::Churn {
project_path: PathBuf::from("."),
days: 30,
format: ChurnOutputFormat::Summary,
output: None,
top_files: 10,
include: vec![],
exclude: vec![],
};
if let AnalyzeCommands::Churn { days, .. } = cmd {
assert_eq!(days, 30);
} else {
panic!("Expected Churn command");
}
}
#[test]
fn test_dead_code_command_construction() {
let cmd = AnalyzeCommands::DeadCode {
path: PathBuf::from("."),
format: DeadCodeOutputFormat::Summary,
top_files: Some(10),
include_unreachable: false,
min_dead_lines: 10,
include_tests: false,
output: None,
fail_on_violation: false,
max_percentage: 15.0,
timeout: 60,
include: vec![],
exclude: vec![],
max_depth: 8,
};
if let AnalyzeCommands::DeadCode {
min_dead_lines,
max_percentage,
..
} = cmd
{
assert_eq!(min_dead_lines, 10);
assert!((max_percentage - 15.0).abs() < f64::EPSILON);
} else {
panic!("Expected DeadCode command");
}
}
#[test]
fn test_dag_command_construction() {
let cmd = AnalyzeCommands::Dag {
dag_type: DagType::CallGraph,
project_path: PathBuf::from("."),
output: None,
max_depth: Some(5),
target_nodes: None,
filter_external: false,
show_complexity: false,
include_duplicates: false,
include_dead_code: false,
enhanced: false,
};
if let AnalyzeCommands::Dag {
dag_type,
max_depth,
..
} = cmd
{
assert!(matches!(dag_type, DagType::CallGraph));
assert_eq!(max_depth, Some(5));
} else {
panic!("Expected Dag command");
}
}
#[test]
fn test_satd_command_construction() {
let cmd = AnalyzeCommands::Satd {
path: PathBuf::from("."),
format: SatdOutputFormat::Summary,
severity: Some(SatdSeverity::High),
critical_only: false,
include_tests: false,
strict: false,
evolution: false,
days: 30,
metrics: false,
output: None,
top_files: 10,
fail_on_violation: false,
timeout: 60,
include: vec![],
exclude: vec![],
};
if let AnalyzeCommands::Satd { days, strict, .. } = cmd {
assert_eq!(days, 30);
assert!(!strict);
} else {
panic!("Expected Satd command");
}
}
#[test]
fn test_deep_context_command_construction() {
let cmd = AnalyzeCommands::DeepContext {
project_path: PathBuf::from("."),
output: None,
format: DeepContextOutputFormat::Markdown,
full: false,
include: vec![],
exclude: vec![],
period_days: 30,
dag_type: DeepContextDagType::CallGraph,
max_depth: None,
include_patterns: vec![],
exclude_patterns: vec![],
cache_strategy: DeepContextCacheStrategy::Normal,
parallel: None,
verbose: false,
top_files: 10,
};
if let AnalyzeCommands::DeepContext {
period_days,
verbose,
..
} = cmd
{
assert_eq!(period_days, 30);
assert!(!verbose);
} else {
panic!("Expected DeepContext command");
}
}
#[test]
fn test_tdg_command_construction() {
let cmd = AnalyzeCommands::Tdg {
path: PathBuf::from("."),
threshold: 1.5,
top_files: 10,
format: TdgOutputFormat::Table,
include_components: false,
output: None,
critical_only: false,
verbose: false,
ml: false,
};
if let AnalyzeCommands::Tdg {
threshold,
critical_only,
..
} = cmd
{
assert!((threshold - 1.5).abs() < f64::EPSILON);
assert!(!critical_only);
} else {
panic!("Expected Tdg command");
}
}
#[test]
fn test_build_tdg_command_construction() {
let cmd = AnalyzeCommands::BuildTdg {
path: PathBuf::from("."),
release: true,
threshold: 2.0,
fail_on_regression: false,
tdg_only: true,
top_files: 10,
format: TdgOutputFormat::Table,
output: None,
};
if let AnalyzeCommands::BuildTdg {
release,
tdg_only,
threshold,
..
} = cmd
{
assert!(release);
assert!(tdg_only);
assert!((threshold - 2.0).abs() < f64::EPSILON);
} else {
panic!("Expected BuildTdg command");
}
}
#[test]
fn test_lint_hotspot_command_construction() {
let cmd = AnalyzeCommands::LintHotspot {
project_path: PathBuf::from("."),
file: None,
format: LintHotspotOutputFormat::Summary,
max_density: 5.0,
min_confidence: 0.8,
enforce: false,
dry_run: true,
enforcement_metadata: false,
output: None,
perf: false,
clippy_flags: "-W warnings".to_string(),
top_files: 10,
include: vec![],
exclude: vec![],
};
if let AnalyzeCommands::LintHotspot {
max_density,
dry_run,
..
} = cmd
{
assert!((max_density - 5.0).abs() < f64::EPSILON);
assert!(dry_run);
} else {
panic!("Expected LintHotspot command");
}
}
#[test]
fn test_duplicates_command_construction() {
let cmd = AnalyzeCommands::Duplicates {
project_path: PathBuf::from("."),
detection_type: DuplicateType::All,
threshold: 0.85,
min_lines: 5,
max_tokens: 128,
format: DuplicateOutputFormat::Summary,
perf: false,
include: None,
exclude: None,
output: None,
top_files: 10,
};
if let AnalyzeCommands::Duplicates {
threshold,
min_lines,
..
} = cmd
{
assert!((threshold - 0.85).abs() < f32::EPSILON);
assert_eq!(min_lines, 5);
} else {
panic!("Expected Duplicates command");
}
}