codex-memory 3.0.15

use crate::common::TestDatabaseManager;
use anyhow::Result;
use codex_memory::mcp_server::MCPHandlers;
use codex_memory::Storage;
use serde_json::json;
use serial_test::serial;
use std::sync::Arc;

#[tokio::test]
#[serial]
async fn test_mcp_store_with_all_fields() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Simulate MCP tool call with all fields
    let params = json!({
        "content": "Test content for MCP integration",
        "context": "Integration test context",
        "summary": "Testing MCP with all fields populated",
        "tags": ["mcp", "integration", "test"]
    });

    let result = handlers.handle_tool_call("store_memory", params).await?;

    // Verify response
    assert!(result["id"].is_string());
    assert_eq!(result["message"], "Memory stored successfully");

    // Retrieve and verify
    let id = result["id"].as_str().unwrap();
    let get_params = json!({"id": id});
    let retrieved = handlers.handle_tool_call("get_memory", get_params).await?;

    assert_eq!(retrieved["content"], "Test content for MCP integration");
    assert_eq!(retrieved["context"], "Integration test context");
    assert_eq!(
        retrieved["summary"],
        "Testing MCP with all fields populated"
    );
    assert_eq!(retrieved["tags"], json!(["mcp", "integration", "test"]));

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_store_content_only() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Simulate MCP tool call with minimal required fields
    let params = json!({
        "content": "Just the content, nothing else",
        "context": "Default context",
        "summary": "Default summary",
        "tags": []
    });

    let result = handlers.handle_tool_call("store_memory", params).await?;

    // Should succeed with minimal required fields
    assert!(result["id"].is_string());
    assert_eq!(result["message"], "Memory stored successfully");

    // Retrieve and verify fields
    let id = result["id"].as_str().unwrap();
    let get_params = json!({"id": id});
    let retrieved = handlers.handle_tool_call("get_memory", get_params).await?;

    assert_eq!(retrieved["content"], "Just the content, nothing else");
    assert_eq!(retrieved["context"], "Default context");
    assert_eq!(retrieved["summary"], "Default summary");
    assert_eq!(retrieved["tags"], json!([]));

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_store_with_partial_fields() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Test with context and summary provided
    let params = json!({
        "content": "Content with summary but minimal context",
        "context": "Partial test context",
        "summary": "A brief summary",
        "tags": ["partial"]
    });

    let result = handlers.handle_tool_call("store_memory", params).await?;
    assert!(result["id"].is_string());

    let id = result["id"].as_str().unwrap();
    let get_params = json!({"id": id});
    let retrieved = handlers.handle_tool_call("get_memory", get_params).await?;

    assert_eq!(retrieved["summary"], "A brief summary");
    assert_eq!(retrieved["context"], "Partial test context");
    assert_eq!(retrieved["tags"], json!(["partial"]));

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_delete_memory() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store a memory
    let store_params = json!({
        "content": "Content to be deleted",
        "context": "Test delete context",
        "summary": "Test delete summary",
        "tags": []
    });
    let store_result = handlers
        .handle_tool_call("store_memory", store_params)
        .await?;
    let id = store_result["id"].as_str().unwrap();

    // Delete it
    let delete_params = json!({"id": id});
    let delete_result = handlers
        .handle_tool_call("delete_memory", delete_params)
        .await?;

    assert_eq!(delete_result["deleted"], true);
    assert_eq!(delete_result["message"], "Memory deleted successfully");

    // Try to get it - should fail
    let get_params = json!({"id": id});
    let get_result = handlers.handle_tool_call("get_memory", get_params).await;
    assert!(get_result.is_err());

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_get_statistics() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Get initial stats
    let stats = handlers
        .handle_tool_call("get_statistics", json!({}))
        .await?;
    assert_eq!(stats["total_memories"], 0);

    // Store some memories
    for i in 0..3 {
        let params = json!({
            "content": format!("Memory {}", i),
            "context": format!("Context for memory {}", i),
            "summary": format!("Summary for memory {}", i),
            "tags": []
        });
        handlers.handle_tool_call("store_memory", params).await?;
    }

    // Get updated stats
    let stats = handlers
        .handle_tool_call("get_statistics", json!({}))
        .await?;
    assert_eq!(stats["total_memories"], 3);
    assert!(stats["last_memory_created"].is_string());

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_error_handling() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Test missing content parameter
    let params = json!({
        "summary": "Summary without content"
    });
    let result = handlers.handle_tool_call("store_memory", params).await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("Missing content"));

    // Test invalid UUID
    let params = json!({"id": "not-a-uuid"});
    let result = handlers.handle_tool_call("get_memory", params).await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("Invalid UUID"));

    // Test non-existent memory
    let params = json!({"id": "00000000-0000-0000-0000-000000000000"});
    let result = handlers.handle_tool_call("get_memory", params).await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("Memory not found"));

    // Test unknown tool
    let result = handlers.handle_tool_call("unknown_tool", json!({})).await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("Unknown tool"));

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_content_not_modified() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Test various content that should be stored exactly as-is
    let test_contents = vec![
        "Plain text",
        "Text with 'single quotes'",
        r#"Text with "double quotes""#,
        "Multi\nline\ntext",
        "Text with special chars: !@#$%^&*()",
        "   Spaces at start and end   ",
        "Text\twith\ttabs",
        "Emoji content 🎉 🚀 💾",
    ];

    for content in test_contents {
        let params = json!({
            "content": content,
            "context": "Content preservation test",
            "summary": "Testing content storage without modification",
            "tags": []
        });

        let result = handlers.handle_tool_call("store_memory", params).await?;
        let id = result["id"].as_str().unwrap();

        let get_params = json!({"id": id});
        let retrieved = handlers.handle_tool_call("get_memory", get_params).await?;

        assert_eq!(
            retrieved["content"].as_str().unwrap(),
            content,
            "Content should be stored without modification"
        );
    }

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_multiple_storage_operations() -> Result<()> {
    // Use TestDatabaseManager for proper isolation
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Test multiple storage operations with different content
    let test_cases = [
        ("First test content", "programming", "testing"),
        ("Second test content", "debugging", "validation"),
        ("Third test content", "documentation", "writing"),
    ];

    for (i, (content, tag1, tag2)) in test_cases.iter().enumerate() {
        let params = json!({
            "content": format!("{} - {}", content, i),
            "context": format!("Test context for operation {}", i),
            "summary": format!("Test summary for operation {}", i),
            "tags": [tag1, tag2, "mcp-test"]
        });

        let result = handlers.handle_tool_call("store_memory", params).await?;
        let id = result["id"].as_str().unwrap();

        let get_params = json!({"id": id});
        let retrieved = handlers.handle_tool_call("get_memory", get_params).await?;

        // Verify content is stored correctly
        assert_eq!(retrieved["content"], format!("{} - {}", content, i));
        assert_eq!(retrieved["tags"], json!([tag1, tag2, "mcp-test"]));
    }

    // Cleanup
    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_basic() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store some test memories
    let memories = [
        (
            "Rust programming tutorial",
            "Programming guide",
            "Learn Rust basics",
            vec!["rust", "programming"],
        ),
        (
            "Python data analysis",
            "Data science context",
            "Analyze data with Python",
            vec!["python", "data-science"],
        ),
        (
            "Web development tips",
            "Frontend development",
            "Modern web development practices",
            vec!["web", "frontend"],
        ),
    ];

    for (content, context, summary, tags) in memories {
        let params = json!({
            "content": content,
            "context": context,
            "summary": summary,
            "tags": tags
        });
        handlers.handle_tool_call("store_memory", params).await?;
    }

    // Test basic search
    let search_params = json!({
        "query": "programming"
    });

    let results = handlers
        .handle_tool_call("search_memory", search_params)
        .await?;

    // Search results are returned as a direct array for Claude Desktop compatibility
    assert!(results.is_array(), "Search should return array of results");

    let results_array = results.as_array().unwrap();
    assert!(
        !results_array.is_empty(),
        "Should find programming-related results"
    );

    // Verify first result has expected structure
    let first_result = &results_array[0];
    assert!(first_result["id"].is_string());
    assert!(first_result["content"].is_string());
    assert!(first_result["combined_score"].is_number());

    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_with_filters() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store memories with different tags
    let memories = [
        (
            "Rust web framework",
            "Web development",
            "Building web apps with Rust",
            vec!["rust", "web"],
        ),
        (
            "Python web framework",
            "Web development",
            "Building web apps with Python",
            vec!["python", "web"],
        ),
        (
            "Database design",
            "Backend development",
            "Database schema design principles",
            vec!["database", "backend"],
        ),
    ];

    for (content, context, summary, tags) in memories {
        let params = json!({
            "content": content,
            "context": context,
            "summary": summary,
            "tags": tags
        });
        handlers.handle_tool_call("store_memory", params).await?;
    }

    // Search with tag filter
    let search_params = json!({
        "query": "web",
        "tag_filter": ["rust"],
        "max_results": 5
    });

    let results = handlers
        .handle_tool_call("search_memory", search_params)
        .await?;
    let results_array = results.as_array().unwrap();

    // Should only return Rust-related results
    for result in results_array {
        let tags = result["tags"].as_array().unwrap();
        let tag_strings: Vec<String> = tags
            .iter()
            .map(|t| t.as_str().unwrap().to_string())
            .collect();
        assert!(
            tag_strings.contains(&"rust".to_string()),
            "Result should contain rust tag"
        );
    }

    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_different_strategies() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store test memory
    let params = json!({
        "content": "Machine learning algorithms and techniques",
        "context": "AI research context",
        "summary": "Overview of ML algorithms",
        "tags": ["machine-learning", "ai", "algorithms"]
    });
    handlers.handle_tool_call("store_memory", params).await?;

    // Test different search strategies
    let strategies = ["TagsFirst", "ContentFirst", "Hybrid"];

    for strategy in strategies {
        let search_params = json!({
            "query": "machine learning",
            "search_strategy": strategy,
            "similarity_threshold": 0.1
        });

        let result = handlers
            .handle_tool_call("search_memory", search_params)
            .await;
        assert!(
            result.is_ok(),
            "Search should succeed for strategy: {}",
            strategy
        );

        let results = result.unwrap();
        assert!(
            results["search_metadata"]["search_strategy"]
                .as_str()
                .unwrap()
                == strategy
        );
    }

    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_parameters() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store multiple memories
    for i in 1..=10 {
        let params = json!({
            "content": format!("Test memory content number {}", i),
            "context": "Test context",
            "summary": "Test summary",
            "tags": ["test"]
        });
        handlers.handle_tool_call("store_memory", params).await?;
    }

    // Test max_results parameter
    let search_params = json!({
        "query": "test memory",
        "max_results": 3
    });

    let results = handlers
        .handle_tool_call("search_memory", search_params)
        .await?;
    let results_array = results.as_array().unwrap();
    assert!(results_array.len() <= 3, "Should respect max_results limit");

    // Test similarity_threshold parameter
    let search_params = json!({
        "query": "test memory",
        "similarity_threshold": 0.9
    });

    let results = handlers
        .handle_tool_call("search_memory", search_params)
        .await?;
    assert!(results["search_metadata"]["similarity_threshold"] == 0.9);

    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_error_handling() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Test missing query parameter
    let params = json!({
        "max_results": 10
    });
    let result = handlers.handle_tool_call("search_memory", params).await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("query"));

    // Test invalid similarity threshold
    let params = json!({
        "query": "test",
        "similarity_threshold": 1.5 // Invalid - should be 0.0-1.0
    });
    let result = handlers.handle_tool_call("search_memory", params).await;
    assert!(result.is_err());

    // Test invalid max_results
    let params = json!({
        "query": "test",
        "max_results": -1
    });
    let result = handlers.handle_tool_call("search_memory", params).await;
    assert!(result.is_err());

    manager.cleanup().await?;
    Ok(())
}

#[tokio::test]
#[serial]
async fn test_mcp_search_memory_empty_results() -> Result<()> {
    let mut manager = TestDatabaseManager::new()?;
    let pool = manager.setup_test_database().await?;
    let storage = Arc::new(Storage::new(pool));
    let handlers = MCPHandlers::new(storage);

    // Store specific content
    let params = json!({
        "content": "Blockchain technology overview",
        "context": "Crypto context",
        "summary": "Understanding blockchain",
        "tags": ["blockchain", "crypto"]
    });
    handlers.handle_tool_call("store_memory", params).await?;

    // Search for completely unrelated content
    let search_params = json!({
        "query": "cooking recipes pasta italian cuisine",
        "similarity_threshold": 0.8
    });

    let results = handlers
        .handle_tool_call("search_memory", search_params)
        .await?;
    let results_array = results.as_array().unwrap();

    // Should return empty or very few results
    assert!(
        results_array.len() < 2,
        "Should return few results for unrelated search"
    );
    assert_eq!(
        results["search_metadata"]["total_results"],
        results_array.len()
    );

    manager.cleanup().await?;
    Ok(())
}