#![cfg_attr(coverage_nightly, coverage(off))]
use super::*;
mod tests {
use super::*;
use std::path::PathBuf;
use tokio;
#[test]
fn test_analysis_type_variants() {
let ast_type = AnalysisType::Ast;
let complexity_type = AnalysisType::Complexity;
let churn_type = AnalysisType::Churn;
let dag_type = AnalysisType::Dag;
assert_eq!(ast_type, AnalysisType::Ast);
assert_eq!(complexity_type, AnalysisType::Complexity);
assert_eq!(churn_type, AnalysisType::Churn);
assert_eq!(dag_type, AnalysisType::Dag);
}
#[test]
fn test_dag_type_variants() {
let call_graph = DagType::CallGraph;
let import_graph = DagType::ImportGraph;
let inheritance = DagType::Inheritance;
let full_dependency = DagType::FullDependency;
assert_eq!(call_graph, DagType::CallGraph);
assert_eq!(import_graph, DagType::ImportGraph);
assert_eq!(inheritance, DagType::Inheritance);
assert_eq!(full_dependency, DagType::FullDependency);
}
#[test]
fn test_cache_strategy_variants() {
let normal = CacheStrategy::Normal;
let force_refresh = CacheStrategy::ForceRefresh;
let offline = CacheStrategy::Offline;
assert_eq!(normal, CacheStrategy::Normal);
assert_eq!(force_refresh, CacheStrategy::ForceRefresh);
assert_eq!(offline, CacheStrategy::Offline);
}
#[test]
fn test_complexity_thresholds_creation() {
let thresholds = ComplexityThresholds {
max_cyclomatic: 20,
max_cognitive: 15,
};
assert_eq!(thresholds.max_cyclomatic, 20);
assert_eq!(thresholds.max_cognitive, 15);
}
#[test]
fn test_deep_context_config_default() {
let config = DeepContextConfig::default();
assert_eq!(config.period_days, 30);
assert_eq!(config.dag_type, DagType::CallGraph);
assert_eq!(config.max_depth, Some(10));
assert_eq!(config.cache_strategy, CacheStrategy::Normal);
assert_eq!(config.parallel, num_cpus::get());
assert!(config.include_analyses.contains(&AnalysisType::Ast));
assert!(config.include_analyses.contains(&AnalysisType::Complexity));
assert!(config.include_analyses.contains(&AnalysisType::Churn));
assert!(config.include_analyses.contains(&AnalysisType::Dag));
assert!(config.include_analyses.contains(&AnalysisType::DeadCode));
assert!(config.include_analyses.contains(&AnalysisType::Satd));
assert!(config
.include_analyses
.contains(&AnalysisType::TechnicalDebtGradient));
assert!(config.include_patterns.is_empty()); assert!(config
.exclude_patterns
.contains(&"**/node_modules/**".to_string()));
assert!(config
.exclude_patterns
.contains(&"**/target/**".to_string()));
assert!(config.exclude_patterns.contains(&"**/.git/**".to_string()));
assert!(config
.exclude_patterns
.contains(&"**/vendor/**".to_string()));
}
#[test]
fn test_deep_context_analyzer_creation() {
let config = DeepContextConfig::default();
let analyzer = DeepContextAnalyzer::new(config.clone());
assert_eq!(analyzer.config.period_days, config.period_days);
assert_eq!(analyzer.config.parallel, config.parallel);
}
#[test]
fn test_ast_summary_creation() {
let summary = AstSummary {
path: "test.rs".to_string(),
language: "rust".to_string(),
total_items: 100,
functions: 50,
classes: 20,
imports: 10,
};
assert_eq!(summary.path, "test.rs");
assert_eq!(summary.language, "rust");
assert_eq!(summary.total_items, 100);
assert_eq!(summary.functions, 50);
assert_eq!(summary.classes, 20);
assert_eq!(summary.imports, 10);
}
#[test]
fn test_dead_code_summary_creation() {
let summary = DeadCodeSummary {
total_functions: 100,
dead_functions: 15,
total_lines: 10000,
total_dead_lines: 450,
dead_percentage: 4.5,
};
assert_eq!(summary.total_functions, 100);
assert_eq!(summary.dead_functions, 15);
assert_eq!(summary.total_lines, 10000);
assert_eq!(summary.total_dead_lines, 450);
assert_eq!(summary.dead_percentage, 4.5);
}
#[test]
fn test_dead_code_analysis_creation() {
let summary = DeadCodeSummary {
total_functions: 50,
dead_functions: 8,
total_lines: 5000,
total_dead_lines: 200,
dead_percentage: 4.0,
};
let analysis = DeadCodeAnalysis {
summary,
dead_functions: vec![],
warnings: vec![],
};
assert_eq!(analysis.summary.total_functions, 50);
assert_eq!(analysis.summary.dead_functions, 8);
assert_eq!(analysis.dead_functions.len(), 0);
}
#[test]
fn test_context_metadata_creation() {
let now = chrono::Utc::now();
let cache_stats = CacheStats {
hit_rate: 0.75,
memory_efficiency: 0.8,
time_saved_ms: 2000,
};
let metadata = ContextMetadata {
generated_at: now,
tool_version: "1.0.0".to_string(),
project_root: PathBuf::from("/test"),
cache_stats,
analysis_duration: Duration::from_secs(30),
};
assert_eq!(metadata.generated_at, now);
assert_eq!(metadata.tool_version, "1.0.0");
assert_eq!(metadata.project_root, PathBuf::from("/test"));
assert_eq!(metadata.cache_stats.hit_rate, 0.75);
assert_eq!(metadata.analysis_duration, Duration::from_secs(30));
}
#[test]
fn test_cache_stats_creation() {
let stats = CacheStats {
hit_rate: 0.8,
memory_efficiency: 0.75,
time_saved_ms: 1500,
};
assert_eq!(stats.hit_rate, 0.8);
assert_eq!(stats.memory_efficiency, 0.75);
assert_eq!(stats.time_saved_ms, 1500);
}
#[test]
fn test_node_type_variants() {
let file = NodeType::File;
let directory = NodeType::Directory;
assert_eq!(file, NodeType::File);
assert_eq!(directory, NodeType::Directory);
}
#[test]
fn test_node_annotations_creation() {
let annotations = NodeAnnotations {
defect_score: Some(15.5),
complexity_score: Some(12.3),
cognitive_complexity: Some(8),
churn_score: Some(0.3),
dead_code_items: 2,
satd_items: 0,
centrality: None,
test_coverage: None,
big_o_complexity: None,
memory_complexity: None,
duplication_score: None,
};
assert_eq!(annotations.defect_score, Some(15.5));
assert_eq!(annotations.complexity_score, Some(12.3));
assert_eq!(annotations.cognitive_complexity, Some(8));
assert_eq!(annotations.churn_score, Some(0.3));
assert_eq!(annotations.dead_code_items, 2);
}
#[test]
fn test_annotated_node_creation() {
let path = PathBuf::from("/test/file.rs");
let annotations = NodeAnnotations {
defect_score: Some(10.0),
complexity_score: Some(8.5),
cognitive_complexity: Some(12),
churn_score: Some(0.2),
dead_code_items: 2,
satd_items: 0,
centrality: None,
test_coverage: None,
big_o_complexity: None,
memory_complexity: None,
duplication_score: None,
};
let node = AnnotatedNode {
name: "file.rs".to_string(),
path: path.clone(),
node_type: NodeType::File,
annotations,
children: vec![],
};
assert_eq!(node.path, path);
assert_eq!(node.node_type, NodeType::File);
assert_eq!(node.annotations.complexity_score, Some(8.5));
assert_eq!(node.children.len(), 0);
}
#[test]
fn test_annotated_file_tree_creation() {
let root_path = PathBuf::from("/project");
let root_annotations = NodeAnnotations {
defect_score: Some(50.0),
complexity_score: Some(15.2),
cognitive_complexity: Some(18),
churn_score: Some(0.1),
dead_code_items: 5,
satd_items: 0,
centrality: Some(1.0),
test_coverage: Some(80.0),
big_o_complexity: Some("O(n)".to_string()),
memory_complexity: Some("O(1)".to_string()),
duplication_score: Some(0.05),
};
let root_node = AnnotatedNode {
name: "test".to_string(),
path: root_path.clone(),
node_type: NodeType::Directory,
annotations: root_annotations,
children: vec![],
};
let tree = AnnotatedFileTree {
root: root_node,
total_files: 1,
total_size_bytes: 1024,
};
assert_eq!(tree.root.path, root_path);
assert_eq!(tree.total_files, 1);
assert_eq!(tree.total_size_bytes, 1024);
}
#[test]
fn test_deep_context_result_creation() {
}
#[tokio::test]
async fn test_analyze_single_file_nonexistent() {
let nonexistent_path = std::path::Path::new("/nonexistent/file.rs");
let result = analyze_single_file(nonexistent_path).await;
assert!(result.is_err());
}
}