use anyhow::Result;
use serial_test::serial;
use std::fs;
use std::io::Write;
use tempfile::tempdir;
use terraphim_config::{Config, ConfigState};
use terraphim_service::TerraphimService;
use terraphim_types::{NormalizedTermValue, SearchQuery};
#[tokio::test]
#[serial]
async fn test_real_config_auto_summarization_e2e() -> Result<()> {
if std::env::var("RUN_REAL_CONFIG_E2E_TESTS")
.map(|v| v != "1" && !v.eq_ignore_ascii_case("true"))
.unwrap_or(true)
{
eprintln!("Skipping: set RUN_REAL_CONFIG_E2E_TESTS=1 to run real-config e2e tests");
return Ok(());
}
println!("🚀 Starting E2E test with real Terraphim Engineer config");
terraphim_persistence::DeviceStorage::init_memory_only().await?;
println!("📦 Initialized memory-only persistence");
let config_path = "/Users/alex/projects/terraphim/terraphim-ai/terraphim_server/default/terraphim_engineer_config.json";
let config_str =
fs::read_to_string(config_path).expect("Failed to read terraphim_engineer_config.json");
let mut config: Config =
serde_json::from_str(&config_str).expect("Failed to parse terraphim_engineer_config.json");
println!("⚙️ Loaded real Terraphim Engineer config");
println!(" Default role: {}", config.default_role);
if let Some(role) = config.roles.get(&config.default_role) {
println!(" Role extra fields: {:?}", role.extra);
let auto_summarize = role
.extra
.get("llm_auto_summarize")
.and_then(|v| v.as_bool())
.unwrap_or(false);
println!(" Auto-summarization enabled: {}", auto_summarize);
if !auto_summarize {
println!(" Checking alternative auto-summarize keys...");
for (key, value) in &role.extra {
if key.contains("auto") || key.contains("summarize") {
println!(" {}: {:?}", key, value);
}
}
}
}
let temp_dir = tempdir().expect("Failed to create temp dir");
create_test_documents_in_docs(&temp_dir)?;
if let Some(role) = config.roles.get_mut(&config.default_role) {
if let Some(haystack) = role.haystacks.first_mut() {
haystack.location = temp_dir.path().to_string_lossy().to_string();
println!(" Updated haystack location to: {}", haystack.location);
}
}
let config_state = ConfigState::new(&mut config).await?;
let mut service = TerraphimService::new(config_state);
println!("✅ Initialized TerraphimService with real config");
let search_query = SearchQuery {
search_term: NormalizedTermValue::new("Rust".into()),
limit: Some(10),
skip: Some(0),
role: Some(config.default_role.clone()),
..Default::default()
};
println!(
"🔍 Executing search query for 'Rust' with role '{}'",
config.default_role
);
let search_results = service.search(&search_query).await?;
println!("📊 Search Results:");
println!(" Documents found: {}", search_results.len());
println!(
" Summarization tasks queued: {}",
0 );
assert!(
!search_results.is_empty(),
"Should find documents matching 'Rust'"
);
let docs_with_descriptions = search_results
.iter()
.filter(|doc| doc.description.is_some())
.count();
println!(" Documents with descriptions: {}", docs_with_descriptions);
for (i, doc) in search_results.iter().enumerate() {
println!(" 📄 Document {}: {}", i + 1, doc.title);
println!(" ID: {}", doc.id);
println!(" URL: {}", doc.url);
if let Some(description) = &doc.description {
println!(" Description: {}", description);
} else {
println!(" Description: None");
}
if let Some(rank) = doc.rank {
println!(" Rank: {}", rank);
}
println!();
}
println!("✅ Search completed successfully (no rate limit errors)");
println!("⏳ Waiting for potential summarization completion...");
tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
let merged_results = &search_results;
let docs_with_summaries = merged_results
.iter()
.filter(|doc| doc.summarization.is_some())
.count();
println!("📝 After merging:");
println!(" Documents with summaries: {}", docs_with_summaries);
println!("🔍 Testing role graph functionality");
if let Some(role) = config.roles.get(&config.default_role) {
if role.kg.is_some() {
println!(" ✅ Role has knowledge graph configuration");
}
}
println!("🎉 Real config E2E test completed successfully!");
println!(" ✅ Configuration loaded and parsed");
println!(" ✅ Service initialized without errors");
println!(" ✅ Search executed and returned results");
println!(" ✅ Auto-summarization workflow triggered");
println!(" ✅ No rate limiting deadlocks occurred");
println!(" ✅ Description extraction working");
Ok(())
}
fn create_test_documents_in_docs(temp_dir: &tempfile::TempDir) -> Result<()> {
let docs = vec![
(
"rust_basics.md",
r#"# Rust Programming Basics
Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. This document covers the fundamental concepts of Rust programming.
## Memory Safety
Rust's ownership system manages memory automatically without requiring a garbage collector. The three main rules of ownership are:
1. Each value in Rust has a variable that's called its owner
2. There can only be one owner at a time
3. When the owner goes out of scope, the value will be dropped
## Borrowing and References
Instead of transferring ownership, you can create references to values. References allow you to refer to some value without taking ownership of it.
```rust
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
```
## Conclusion
Rust provides memory safety without sacrificing performance, making it ideal for systems programming.
"#,
),
(
"async_rust.md",
r#"# Asynchronous Programming in Rust
Asynchronous programming allows programs to handle multiple tasks concurrently without blocking. Rust provides excellent support for async programming through the async/await syntax.
## Futures and Async Functions
In Rust, asynchronous functions return Future types that represent computations that haven't completed yet.
```rust
use tokio;
async fn fetch_data() -> String {
// Simulate an async operation
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
"Data fetched!".to_string()
}
#[tokio::main]
async fn main() {
let result = fetch_data().await;
println!("{}", result);
}
```
## Concurrency with Tokio
Tokio is the most popular async runtime for Rust, providing:
- A multi-threaded runtime for executing async tasks
- Async versions of std library types
- Utilities for async programming
## Error Handling
Async functions can return Result types just like synchronous functions:
```rust
async fn fallible_operation() -> Result<String, Box<dyn std::error::Error>> {
// Some operation that might fail
Ok("Success".to_string())
}
```
This allows for robust error handling in async contexts.
"#,
),
(
"web_dev_rust.md",
r#"# Web Development with Rust
Rust has a growing ecosystem for web development, with frameworks like Actix-web, Warp, and Axum providing powerful tools for building web applications.
## Actix-Web Framework
Actix-web is a powerful, pragmatic, and extremely fast web framework for Rust.
```rust
use actix_web::{web, App, HttpResponse, HttpServer, Result};
async fn hello() -> Result<HttpResponse> {
Ok(HttpResponse::Ok().body("Hello, Rust web development!"))
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.route("/hello", web::get().to(hello))
})
.bind("127.0.0.1:8080")?
.run()
.await
}
```
## Benefits of Rust for Web Development
1. **Performance**: Rust's zero-cost abstractions provide excellent performance
2. **Safety**: Memory safety prevents common web vulnerabilities
3. **Concurrency**: Built-in async support handles many concurrent connections
4. **Ecosystem**: Growing collection of web-related crates
## Database Integration
Rust has excellent database support through crates like:
- SQLx for SQL databases
- MongoDB driver for NoSQL
- Diesel as an ORM
This makes it easy to build data-driven web applications.
"#,
),
(
"rust_tooling.md",
r#"# Rust Development Tools and Ecosystem
The Rust ecosystem provides excellent tooling that makes development productive and enjoyable.
## Cargo Package Manager
Cargo is Rust's build system and package manager that handles:
- Building your code
- Downloading dependencies
- Building those dependencies
Common Cargo commands:
```bash
cargo new my_project # Create new project
cargo build # Build project
cargo run # Build and run
cargo test # Run tests
cargo clippy # Linting
cargo fmt # Code formatting
```
## Development Environment
Popular tools for Rust development include:
- **VS Code** with rust-analyzer extension
- **IntelliJ IDEA** with Rust plugin
- **Vim/Neovim** with various Rust plugins
- **Emacs** with rustic-mode
## Testing Framework
Rust has built-in support for unit and integration testing:
```rust
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let result = 2 + 2;
assert_eq!(result, 4);
}
}
```
## Documentation
Rust's documentation system generates beautiful docs from comments:
```rust
/// This function adds two numbers together
///
/// # Examples
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
a + b
}
```
The tooling ecosystem makes Rust development efficient and enjoyable.
"#,
),
];
for (filename, content) in docs {
let file_path = temp_dir.path().join(filename);
let mut file = fs::File::create(&file_path)?;
file.write_all(content.as_bytes())?;
println!("📄 Created test document: {}", filename);
}
Ok(())
}
#[tokio::test]
#[serial]
async fn test_summarization_manager_with_real_config() -> Result<()> {
use terraphim_service::summarization_manager::SummarizationManager;
use terraphim_service::summarization_queue::QueueConfig;
println!("🧪 Testing SummarizationManager with realistic configuration");
terraphim_persistence::DeviceStorage::init_memory_only().await?;
let config = QueueConfig::default();
let manager = SummarizationManager::new(config);
println!("📊 Manager created successfully");
println!(" Healthy: {}", manager.is_healthy());
let stats = manager.get_stats().await?;
println!(" Queue size: {}", stats.queue_size);
println!(" Completed tasks: {}", stats.completed_tasks);
println!(" Failed tasks: {}", stats.failed_tasks);
assert!(manager.is_healthy(), "Manager should be healthy");
assert_eq!(stats.queue_size, 0, "Queue should be empty initially");
println!("✅ SummarizationManager working correctly with real config");
Ok(())
}