fn create_test_dir() -> TempDir {
tempfile::tempdir().expect("Failed to create temp directory")
}
fn create_test_file(dir: &TempDir, name: &str, content: &str) -> PathBuf {
let path = dir.path().join(name);
std::fs::write(&path, content).expect("Failed to write test file");
path
}
#[test]
fn test_contract_cli_handler_new_succeeds() {
let result = ContractCliHandler::new();
assert!(result.is_ok(), "ContractCliHandler::new() should succeed");
}
#[test]
fn test_contract_cli_handler_new_creates_valid_handler() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let _ = &handler.service;
}
#[tokio::test]
async fn test_handle_command_generate_returns_ok() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let cmd = Commands::Generate {
category: "rust".to_string(),
template: "cli".to_string(),
params: vec![],
output: None,
create_dirs: false,
};
let result = handler.handle_command(cmd).await;
assert!(result.is_ok(), "Generate command should return Ok");
}
#[tokio::test]
async fn test_handle_command_list_returns_ok() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let cmd = Commands::List {
toolchain: None,
category: None,
format: crate::cli::OutputFormat::Table,
};
let result = handler.handle_command(cmd).await;
assert!(result.is_ok(), "List command should return Ok");
}
#[tokio::test]
async fn test_handle_command_search_returns_ok() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let cmd = Commands::Search {
query: "test".to_string(),
toolchain: None,
limit: 10,
};
let result = handler.handle_command(cmd).await;
assert!(result.is_ok(), "Search command should return Ok");
}
#[tokio::test]
async fn test_handle_command_validate_returns_ok() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let cmd = Commands::Validate {
uri: "rust/cli".to_string(),
params: vec![],
};
let result = handler.handle_command(cmd).await;
assert!(result.is_ok(), "Validate command should return Ok");
}
#[test]
fn test_output_result_with_string_value() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::Value::String("Test output".to_string());
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Complexity {
path: temp_dir.path().to_path_buf(),
project_path: None,
file: None,
files: vec![],
toolchain: None,
format: crate::cli::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,
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with string value"
);
}
#[test]
fn test_output_result_with_json_object() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({
"key": "value",
"count": 42
});
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Satd {
path: temp_dir.path().to_path_buf(),
format: crate::cli::SatdOutputFormat::Summary,
severity: None,
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![],
extended: false,
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with JSON object"
);
}
#[test]
fn test_output_result_with_output_file() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({"status": "ok"});
let temp_dir = create_test_dir();
let output_path = temp_dir.path().join("output.json");
let cmd = AnalyzeCommands::DeadCode {
path: temp_dir.path().to_path_buf(),
format: crate::cli::DeadCodeOutputFormat::Json,
top_files: Some(10),
include_unreachable: false,
min_dead_lines: 10,
include_tests: false,
output: Some(output_path.clone()),
fail_on_violation: false,
max_percentage: 15.0,
timeout: 60,
include: vec![],
exclude: vec![],
max_depth: 8,
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with output file"
);
assert!(output_path.exists(), "Output file should be created");
let content = std::fs::read_to_string(&output_path).expect("Should read file");
assert!(content.contains("status"), "File should contain result");
}
#[test]
fn test_output_result_null_value() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::Value::Null;
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Tdg {
path: temp_dir.path().to_path_buf(),
threshold: 1.5,
top_files: 10,
format: crate::cli::TdgOutputFormat::Table,
include_components: false,
output: None,
critical_only: false,
verbose: false,
ml: false,
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with null value"
);
}
#[test]
fn test_output_result_array_value() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!([1, 2, 3, "test"]);
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::LintHotspot {
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
file: None,
format: crate::cli::LintHotspotOutputFormat::Summary,
max_density: 5.0,
min_confidence: 0.8,
enforce: false,
dry_run: false,
enforcement_metadata: false,
output: None,
perf: false,
clippy_flags: "-W warnings".to_string(),
top_files: 10,
include: vec![],
exclude: vec![],
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with array value"
);
}
#[test]
fn test_output_result_with_other_command_type() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::Value::String("result".to_string());
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Churn {
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
days: 30,
format: crate::models::churn::ChurnOutputFormat::Summary,
output: None,
top_files: 10,
include: vec![],
exclude: vec![],
};
let output = handler.output_result(result, &cmd);
assert!(
output.is_ok(),
"output_result should succeed with Churn command"
);
}
#[test]
fn test_output_result_complexity_output_path() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({"test": true});
let temp_dir = create_test_dir();
let output_path = temp_dir.path().join("complexity.json");
let cmd = AnalyzeCommands::Complexity {
path: temp_dir.path().to_path_buf(),
project_path: None,
file: None,
files: vec![],
toolchain: None,
format: crate::cli::ComplexityOutputFormat::Json,
output: Some(output_path.clone()),
max_cyclomatic: None,
max_cognitive: None,
include: vec![],
watch: false,
top_files: 10,
fail_on_violation: false,
timeout: 60,
ml: false,
};
let output = handler.output_result(result, &cmd);
assert!(output.is_ok());
assert!(output_path.exists());
}
#[test]
fn test_output_result_satd_output_path() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({"satd": []});
let temp_dir = create_test_dir();
let output_path = temp_dir.path().join("satd.json");
let cmd = AnalyzeCommands::Satd {
path: temp_dir.path().to_path_buf(),
format: crate::cli::SatdOutputFormat::Json,
severity: None,
critical_only: false,
include_tests: false,
strict: false,
evolution: false,
days: 30,
metrics: false,
output: Some(output_path.clone()),
top_files: 10,
fail_on_violation: false,
timeout: 60,
include: vec![],
exclude: vec![],
extended: false,
};
let output = handler.output_result(result, &cmd);
assert!(output.is_ok());
assert!(output_path.exists());
}
#[test]
fn test_output_result_tdg_output_path() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({"tdg_scores": []});
let temp_dir = create_test_dir();
let output_path = temp_dir.path().join("tdg.json");
let cmd = AnalyzeCommands::Tdg {
path: temp_dir.path().to_path_buf(),
threshold: 1.5,
top_files: 10,
format: crate::cli::TdgOutputFormat::Json,
include_components: false,
output: Some(output_path.clone()),
critical_only: false,
verbose: false,
ml: false,
};
let output = handler.output_result(result, &cmd);
assert!(output.is_ok());
assert!(output_path.exists());
}
#[test]
fn test_output_result_lint_hotspot_output_path() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let result = serde_json::json!({"hotspots": []});
let temp_dir = create_test_dir();
let output_path = temp_dir.path().join("lint.json");
let cmd = AnalyzeCommands::LintHotspot {
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
file: None,
format: crate::cli::LintHotspotOutputFormat::Json,
max_density: 5.0,
min_confidence: 0.8,
enforce: false,
dry_run: false,
enforcement_metadata: false,
output: Some(output_path.clone()),
perf: false,
clippy_flags: "-W warnings".to_string(),
top_files: 10,
include: vec![],
exclude: vec![],
};
let output = handler.output_result(result, &cmd);
assert!(output.is_ok());
assert!(output_path.exists());
}
#[test]
fn test_as_any_trait_returns_self() {
let temp_dir = create_test_dir();
let complexity_contract = AnalyzeComplexityContract {
base: super::super::BaseAnalysisContract {
path: temp_dir.path().to_path_buf(),
format: super::super::OutputFormat::Table,
output: None,
top_files: Some(10),
include_tests: false,
timeout: 60,
},
max_cyclomatic: None,
max_cognitive: None,
max_halstead: None,
};
let validation_result = complexity_contract.validate();
assert!(validation_result.is_ok());
}
#[tokio::test]
#[ignore = "requires full service integration"]
async fn test_handle_analyze_command_prints_deprecation_warnings() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Complexity {
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
file: None,
files: vec![],
toolchain: None,
format: crate::cli::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,
};
let result = handler.handle_analyze_command(cmd).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_handle_analyze_command_churn_standard_mode() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Churn {
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
days: 30,
format: crate::models::churn::ChurnOutputFormat::Summary,
output: None,
top_files: 10,
include: vec![],
exclude: vec![],
};
let result = handler.handle_analyze_command(cmd).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_handle_analyze_command_dag_standard_mode() {
let handler = ContractCliHandler::new().expect("Handler creation should succeed");
let temp_dir = create_test_dir();
let cmd = AnalyzeCommands::Dag {
dag_type: crate::cli::DagType::FullDependency,
path: PathBuf::from("."),
project_path: Some(temp_dir.path().to_path_buf()),
output: None,
max_depth: None,
target_nodes: None,
filter_external: false,
show_complexity: false,
include_duplicates: false,
include_dead_code: false,
enhanced: false,
};
let result = handler.handle_analyze_command(cmd).await;
assert!(result.is_ok());
}