#[cfg(all(test, feature = "java-ast", feature = "scala-ast"))]
mod tests {
use crate::agents::registry::AgentRegistry;
use crate::mcp_integration::McpTool;
use crate::mcp_integration::{java_tools::*, scala_tools::*};
use serde_json::json;
use std::path::PathBuf;
use std::sync::Arc;
use tempfile::tempdir;
use tokio::fs::File;
use tokio::io::AsyncWriteExt;
async fn create_test_file(dir: &tempfile::TempDir, filename: &str, content: &str) -> PathBuf {
let path = dir.path().join(filename);
let mut file = File::create(&path).await.unwrap();
file.write_all(content.as_bytes()).await.unwrap();
path
}
#[tokio::test]
async fn test_java_analysis_tool() {
let dir = tempdir().unwrap();
let java_content = r#"
package com.example;
public class TestClass {
private int value;
public TestClass(int value) {
this.value = value;
}
public int getValue() {
return this.value;
}
public void setValue(int value) {
this.value = value;
}
public int calculateComplex(int a, int b) {
int result = 0;
if (a > b) {
result = a * 2;
if (result > 100) {
result = 100;
}
} else {
result = b * 3;
for (int i = 0; i < a; i++) {
result += i;
}
}
return result;
}
}
interface TestInterface {
void doSomething();
}
"#;
let java_path = create_test_file(&dir, "TestClass.java", java_content).await;
let agent_registry = Arc::new(AgentRegistry::new());
let java_tool = JavaAnalysisTool::new(agent_registry.clone());
let params = json!({
"path": java_path.to_string_lossy().to_string(),
"include_metrics": false,
"include_ast": false
});
let result = java_tool.execute(params).await.unwrap();
assert_eq!(result["status"], "completed");
assert_eq!(result["language"], "java");
assert_eq!(result["summary"]["class_count"], 1);
assert_eq!(result["summary"]["interface_count"], 1);
assert!(result["summary"]["method_count"].as_u64().unwrap() >= 4);
let params_with_metrics = json!({
"path": java_path.to_string_lossy().to_string(),
"include_metrics": true,
"include_ast": true
});
let result_with_metrics = java_tool.execute(params_with_metrics).await.unwrap();
assert!(result_with_metrics["metrics"].is_object());
assert!(
result_with_metrics["metrics"]["total_complexity"]
.as_u64()
.unwrap()
> 0
);
assert!(
result_with_metrics["metrics"]["avg_complexity"]
.as_f64()
.unwrap()
> 0.0
);
assert!(result_with_metrics["items"].is_array());
assert!(!result_with_metrics["items"].as_array().unwrap().is_empty());
}
#[tokio::test]
async fn test_scala_analysis_tool() {
let dir = tempdir().unwrap();
let scala_content = r#"
package com.example
// A case class (functional pattern)
case class Person(name: String, age: Int)
// A trait (similar to interface)
trait Greeter {
def greet(name: String): String
}
// A singleton object
object HelloWorld extends Greeter {
def main(args: Array[String]): Unit = {
val person = Person("Alice", 30)
println(greet(person.name))
}
def greet(name: String): String = s"Hello, $name!"
// Higher-order function (functional pattern)
def process(data: List[Int], transformer: Int => Int): List[Int] = {
data.map(transformer)
}
// Pattern matching (functional pattern)
def describe(x: Any): String = x match {
case i: Int if i > 0 => "positive integer"
case i: Int => "other integer"
case s: String => s"string: $s"
case p: Person => s"person: ${p.name}"
case _ => "something else"
}
// For-comprehension (functional pattern)
def complexComputation(values: List[Int]): List[Int] = {
for {
v <- values
if v > 0
squared = v * v
} yield squared + 1
}
}
// Regular class (object-oriented pattern)
class Calculator {
var result: Int = 0 // Mutable state (imperative pattern)
def add(x: Int): Unit = {
result += x // Side effect (imperative pattern)
}
def getResult(): Int = result
def clear(): Unit = {
result = 0
}
}
"#;
let scala_path = create_test_file(&dir, "HelloWorld.scala", scala_content).await;
let agent_registry = Arc::new(AgentRegistry::new());
let scala_tool = ScalaAnalysisTool::new(agent_registry.clone());
let params = json!({
"path": scala_path.to_string_lossy().to_string(),
"include_metrics": false,
"include_ast": false
});
let result = scala_tool.execute(params).await.unwrap();
assert_eq!(result["status"], "completed");
assert_eq!(result["language"], "scala");
assert_eq!(result["summary"]["case_class_count"], 1);
assert_eq!(result["summary"]["trait_count"], 1);
assert_eq!(result["summary"]["object_count"], 1);
assert_eq!(result["summary"]["class_count"], 1);
let params_with_metrics = json!({
"path": scala_path.to_string_lossy().to_string(),
"include_metrics": true,
"include_ast": true
});
let result_with_metrics = scala_tool.execute(params_with_metrics).await.unwrap();
assert!(result_with_metrics["metrics"].is_object());
assert!(
result_with_metrics["metrics"]["total_complexity"]
.as_u64()
.unwrap()
> 0
);
assert!(
result_with_metrics["metrics"]["avg_complexity"]
.as_f64()
.unwrap()
> 0.0
);
assert!(
result_with_metrics["metrics"]["functional_percentage"]
.as_f64()
.unwrap()
> 0.0
);
assert!(result_with_metrics["items"].is_array());
assert!(!result_with_metrics["items"].as_array().unwrap().is_empty());
}
#[tokio::test]
async fn test_java_mutation_tool() {
let agent_registry = Arc::new(AgentRegistry::new());
let java_mutation_tool = JavaMutationTool::new(agent_registry.clone());
let params = json!({
"project_path": "/tmp/test-project",
"source_path": "/tmp/test-project/src/main/java/com/example",
"test_command": "mvn test",
"mutation_operators": ["arithmetic", "conditional"],
"timeout": 15
});
let result = java_mutation_tool.execute(params).await.unwrap();
assert_eq!(result["status"], "completed");
assert_eq!(result["message"], "Java mutation testing completed");
assert!(result["results"].is_object());
}
#[tokio::test]
async fn test_scala_mutation_tool() {
let agent_registry = Arc::new(AgentRegistry::new());
let scala_mutation_tool = ScalaMutationTool::new(agent_registry.clone());
let params = json!({
"project_path": "/tmp/test-project",
"source_path": "/tmp/test-project/src/main/scala/com/example",
"test_command": "sbt test",
"mutation_operators": ["arithmetic", "conditional", "functional"],
"timeout": 20
});
let result = scala_mutation_tool.execute(params).await.unwrap();
assert_eq!(result["status"], "completed");
assert_eq!(result["message"], "Scala mutation testing completed");
assert!(result["results"].is_object());
}
}