use super::*;
mod active_unit_tests {
use super::*;
#[test]
fn test_is_template_tool_generate_template() {
assert!(is_template_tool("generate_template"));
}
#[test]
fn test_is_template_tool_list_templates() {
assert!(is_template_tool("list_templates"));
}
#[test]
fn test_is_template_tool_validate_template() {
assert!(is_template_tool("validate_template"));
}
#[test]
fn test_is_template_tool_scaffold_project() {
assert!(is_template_tool("scaffold_project"));
}
#[test]
fn test_is_template_tool_search_templates() {
assert!(is_template_tool("search_templates"));
}
#[test]
fn test_is_template_tool_negative_analyze() {
assert!(!is_template_tool("analyze_complexity"));
}
#[test]
fn test_is_template_tool_negative_unknown() {
assert!(!is_template_tool("unknown_tool"));
}
#[test]
fn test_is_template_tool_negative_empty() {
assert!(!is_template_tool(""));
}
#[test]
fn test_is_analysis_tool_code_churn() {
assert!(is_analysis_tool("analyze_code_churn"));
}
#[test]
fn test_is_analysis_tool_complexity() {
assert!(is_analysis_tool("analyze_complexity"));
}
#[test]
fn test_is_analysis_tool_dag() {
assert!(is_analysis_tool("analyze_dag"));
}
#[test]
fn test_is_analysis_tool_context() {
assert!(is_analysis_tool("generate_context"));
}
#[test]
fn test_is_analysis_tool_architecture() {
assert!(is_analysis_tool("analyze_system_architecture"));
}
#[test]
fn test_is_analysis_tool_defect_probability() {
assert!(is_analysis_tool("analyze_defect_probability"));
}
#[test]
fn test_is_analysis_tool_dead_code() {
assert!(is_analysis_tool("analyze_dead_code"));
}
#[test]
fn test_is_analysis_tool_deep_context() {
assert!(is_analysis_tool("analyze_deep_context"));
}
#[test]
fn test_is_analysis_tool_tdg() {
assert!(is_analysis_tool("analyze_tdg"));
}
#[test]
fn test_is_analysis_tool_makefile_lint() {
assert!(is_analysis_tool("analyze_makefile_lint"));
}
#[test]
fn test_is_analysis_tool_provability() {
assert!(is_analysis_tool("analyze_provability"));
}
#[test]
fn test_is_analysis_tool_satd() {
assert!(is_analysis_tool("analyze_satd"));
}
#[test]
fn test_is_analysis_tool_qdd() {
assert!(is_analysis_tool("quality_driven_development"));
}
#[test]
fn test_is_analysis_tool_lint_hotspot() {
assert!(is_analysis_tool("analyze_lint_hotspot"));
}
#[test]
fn test_is_analysis_tool_negative_template() {
assert!(!is_analysis_tool("generate_template"));
}
#[test]
fn test_is_analysis_tool_negative_unknown() {
assert!(!is_analysis_tool("unknown_tool"));
}
#[test]
fn test_is_analysis_tool_negative_empty() {
assert!(!is_analysis_tool(""));
}
#[test]
fn test_template_and_analysis_tools_mutually_exclusive() {
let template_tools = [
"generate_template",
"list_templates",
"validate_template",
"scaffold_project",
"search_templates",
];
let analysis_tools = [
"analyze_code_churn",
"analyze_complexity",
"analyze_dag",
"generate_context",
"analyze_system_architecture",
"analyze_defect_probability",
"analyze_dead_code",
"analyze_deep_context",
"analyze_tdg",
"analyze_makefile_lint",
"analyze_provability",
"analyze_satd",
"quality_driven_development",
"analyze_lint_hotspot",
];
for tool in template_tools {
assert!(is_template_tool(tool), "{} should be template tool", tool);
assert!(
!is_analysis_tool(tool),
"{} should NOT be analysis tool",
tool
);
}
for tool in analysis_tools {
assert!(is_analysis_tool(tool), "{} should be analysis tool", tool);
assert!(
!is_template_tool(tool),
"{} should NOT be template tool",
tool
);
}
}
#[test]
fn test_get_template_variant_makefile_rust() {
assert_eq!(get_template_variant("makefile", "rust"), Some("cli"));
}
#[test]
fn test_get_template_variant_makefile_deno() {
assert_eq!(get_template_variant("makefile", "deno"), Some("cli"));
}
#[test]
fn test_get_template_variant_makefile_python_uv() {
assert_eq!(get_template_variant("makefile", "python-uv"), Some("cli"));
}
#[test]
fn test_get_template_variant_readme_rust() {
assert_eq!(get_template_variant("readme", "rust"), Some("cli"));
}
#[test]
fn test_get_template_variant_readme_deno() {
assert_eq!(get_template_variant("readme", "deno"), Some("cli"));
}
#[test]
fn test_get_template_variant_readme_python_uv() {
assert_eq!(get_template_variant("readme", "python-uv"), Some("cli"));
}
#[test]
fn test_get_template_variant_gitignore_rust() {
assert_eq!(get_template_variant("gitignore", "rust"), Some("cli"));
}
#[test]
fn test_get_template_variant_gitignore_deno() {
assert_eq!(get_template_variant("gitignore", "deno"), Some("cli"));
}
#[test]
fn test_get_template_variant_gitignore_python_uv() {
assert_eq!(get_template_variant("gitignore", "python-uv"), Some("cli"));
}
#[test]
fn test_get_template_variant_unknown_template() {
assert_eq!(get_template_variant("unknown", "rust"), None);
}
#[test]
fn test_get_template_variant_unknown_toolchain() {
assert_eq!(get_template_variant("makefile", "java"), None);
}
#[test]
fn test_get_template_variant_empty_template() {
assert_eq!(get_template_variant("", "rust"), None);
}
#[test]
fn test_get_template_variant_empty_toolchain() {
assert_eq!(get_template_variant("makefile", ""), None);
}
#[test]
fn test_parse_tool_call_params_none() {
let request_id = serde_json::json!(1);
let result = parse_tool_call_params(None, &request_id);
assert!(result.is_err());
let error = result.unwrap_err();
assert!(error.error.is_some());
}
#[test]
fn test_parse_tool_call_params_invalid_json() {
let request_id = serde_json::json!(1);
let invalid_params = serde_json::json!("not an object");
let result = parse_tool_call_params(Some(invalid_params), &request_id);
assert!(result.is_err());
}
#[test]
fn test_parse_tool_call_params_valid() {
let request_id = serde_json::json!(1);
let valid_params = serde_json::json!({
"name": "test_tool",
"arguments": {}
});
let result = parse_tool_call_params(Some(valid_params), &request_id);
assert!(result.is_ok());
let params = result.unwrap();
assert_eq!(params.name, "test_tool");
}
#[test]
fn test_parse_validate_template_args_valid() {
let args = serde_json::json!({
"resource_uri": "template://test",
"parameters": {}
});
let result = parse_validate_template_args(args);
assert!(result.is_ok());
}
#[test]
fn test_parse_validate_template_args_missing_uri() {
let args = serde_json::json!({
"parameters": {}
});
let result = parse_validate_template_args(args);
assert!(result.is_err());
}
#[test]
fn test_parse_validate_template_args_missing_parameters() {
let args = serde_json::json!({
"resource_uri": "template://test"
});
let result = parse_validate_template_args(args);
assert!(result.is_err());
}
#[test]
fn test_extract_churn_parameters_defaults() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: None,
format: None,
};
let (path, days, format) = extract_churn_parameters(&args);
assert!(!path.as_os_str().is_empty());
assert_eq!(days, 30);
assert!(matches!(format, ChurnOutputFormat::Summary));
}
#[test]
fn test_extract_churn_parameters_custom_path() {
let args = AnalyzeCodeChurnArgs {
project_path: Some("/custom/path".to_string()),
period_days: None,
format: None,
};
let (path, _, _) = extract_churn_parameters(&args);
assert_eq!(path, PathBuf::from("/custom/path"));
}
#[test]
fn test_extract_churn_parameters_custom_days() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: Some(7),
format: None,
};
let (_, days, _) = extract_churn_parameters(&args);
assert_eq!(days, 7);
}
#[test]
fn test_extract_churn_parameters_json_format() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: None,
format: Some("json".to_string()),
};
let (_, _, format) = extract_churn_parameters(&args);
assert!(matches!(format, ChurnOutputFormat::Json));
}
#[test]
fn test_extract_churn_parameters_markdown_format() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: None,
format: Some("markdown".to_string()),
};
let (_, _, format) = extract_churn_parameters(&args);
assert!(matches!(format, ChurnOutputFormat::Markdown));
}
#[test]
fn test_extract_churn_parameters_csv_format() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: None,
format: Some("csv".to_string()),
};
let (_, _, format) = extract_churn_parameters(&args);
assert!(matches!(format, ChurnOutputFormat::Csv));
}
#[test]
fn test_extract_churn_parameters_invalid_format_defaults_to_summary() {
let args = AnalyzeCodeChurnArgs {
project_path: None,
period_days: None,
format: Some("invalid".to_string()),
};
let (_, _, format) = extract_churn_parameters(&args);
assert!(matches!(format, ChurnOutputFormat::Summary));
}
#[test]
fn test_parse_code_churn_args_valid() {
let args = serde_json::json!({
"project_path": "/test",
"period_days": 14,
"format": "json"
});
let result = parse_code_churn_args(args);
assert!(result.is_ok());
let parsed = result.unwrap();
assert_eq!(parsed.project_path, Some("/test".to_string()));
assert_eq!(parsed.period_days, Some(14));
assert_eq!(parsed.format, Some("json".to_string()));
}
#[test]
fn test_parse_code_churn_args_empty() {
let args = serde_json::json!({});
let result = parse_code_churn_args(args);
assert!(result.is_ok());
let parsed = result.unwrap();
assert!(parsed.project_path.is_none());
assert!(parsed.period_days.is_none());
assert!(parsed.format.is_none());
}
#[test]
fn test_parse_code_churn_args_partial() {
let args = serde_json::json!({
"period_days": 7
});
let result = parse_code_churn_args(args);
assert!(result.is_ok());
let parsed = result.unwrap();
assert!(parsed.project_path.is_none());
assert_eq!(parsed.period_days, Some(7));
}
#[test]
fn test_validation_result_empty() {
let result = ValidationResult {
missing_required: vec![],
validation_errors: vec![],
};
assert!(result.missing_required.is_empty());
assert!(result.validation_errors.is_empty());
}
#[test]
fn test_validation_result_with_missing_required() {
let result = ValidationResult {
missing_required: vec!["field1".to_string(), "field2".to_string()],
validation_errors: vec![],
};
assert_eq!(result.missing_required.len(), 2);
assert!(result.validation_errors.is_empty());
}
#[test]
fn test_validation_result_with_errors() {
let result = ValidationResult {
missing_required: vec![],
validation_errors: vec!["error1".to_string()],
};
assert!(result.missing_required.is_empty());
assert_eq!(result.validation_errors.len(), 1);
}
#[test]
fn test_find_missing_required_no_params() {
let params = serde_json::Map::new();
let specs = vec![];
let missing = find_missing_required_parameters(¶ms, &specs);
assert!(missing.is_empty());
}
#[test]
fn test_find_missing_required_all_present() {
let mut params = serde_json::Map::new();
params.insert("name".to_string(), serde_json::json!("test"));
let specs = vec![ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: None,
}];
let missing = find_missing_required_parameters(¶ms, &specs);
assert!(missing.is_empty());
}
#[test]
fn test_find_missing_required_one_missing() {
let params = serde_json::Map::new();
let specs = vec![ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: None,
}];
let missing = find_missing_required_parameters(¶ms, &specs);
assert_eq!(missing.len(), 1);
assert_eq!(missing[0], "name");
}
#[test]
fn test_find_missing_required_optional_not_reported() {
let params = serde_json::Map::new();
let specs = vec![ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "optional".to_string(),
description: "Optional".to_string(),
required: false,
default_value: None,
validation_pattern: None,
}];
let missing = find_missing_required_parameters(¶ms, &specs);
assert!(missing.is_empty());
}
#[test]
fn test_validate_single_parameter_no_pattern() {
let spec = ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: None,
};
let result = validate_single_parameter("name", &serde_json::json!("anything"), &spec);
assert!(result.is_none());
}
#[test]
fn test_validate_single_parameter_pattern_matches() {
let spec = ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: Some("^[a-z]+$".to_string()),
};
let result = validate_single_parameter("name", &serde_json::json!("abc"), &spec);
assert!(result.is_none());
}
#[test]
fn test_validate_single_parameter_pattern_does_not_match() {
let spec = ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: Some("^[a-z]+$".to_string()),
};
let result = validate_single_parameter("name", &serde_json::json!("ABC123"), &spec);
assert!(result.is_some());
assert!(result.unwrap().contains("does not match pattern"));
}
#[test]
fn test_validate_single_parameter_non_string_value() {
let spec = ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "count".to_string(),
description: "Count".to_string(),
required: true,
default_value: None,
validation_pattern: Some("^[0-9]+$".to_string()),
};
let result = validate_single_parameter("count", &serde_json::json!(42), &spec);
assert!(result.is_none());
}
#[test]
fn test_validate_parameter_values_empty() {
let params = serde_json::Map::new();
let specs = vec![];
let errors = validate_parameter_values(¶ms, &specs);
assert!(errors.is_empty());
}
#[test]
fn test_validate_parameter_values_unknown_param() {
let mut params = serde_json::Map::new();
params.insert("unknown".to_string(), serde_json::json!("value"));
let specs = vec![];
let errors = validate_parameter_values(¶ms, &specs);
assert_eq!(errors.len(), 1);
assert!(errors[0].contains("Unknown parameter"));
}
#[test]
fn test_validate_parameter_values_valid() {
let mut params = serde_json::Map::new();
params.insert("name".to_string(), serde_json::json!("test"));
let specs = vec![ParameterSpec {
param_type: crate::models::template::ParameterType::String,
name: "name".to_string(),
description: "Name".to_string(),
required: true,
default_value: None,
validation_pattern: None,
}];
let errors = validate_parameter_values(¶ms, &specs);
assert!(errors.is_empty());
}
}
mod property_tests {
use proptest::prelude::*;
proptest! {
#[test]
fn basic_property_stability(_input in ".*") {
prop_assert!(true);
}
#[test]
fn module_consistency_check(_x in 0u32..1000) {
prop_assert!(_x < 1001);
}
}
}
#[cfg(all(test, feature = "broken-tests"))]
#[path = "tools_coverage_tests.rs"]
mod coverage_tests;