do-memory-mcp 0.1.46

//! Embedding tools tests.

#![allow(unused_imports)]

use std::sync::Arc;

use do_memory_core::SelfLearningMemory;

use crate::mcp::tools::embeddings::tool::{
    EmbeddingTools, configure_embeddings_tool, embedding_provider_status_tool,
    generate_embedding_tool, query_semantic_memory_tool, search_by_embedding_tool,
    test_embeddings_tool,
};
use crate::mcp::tools::embeddings::types::{
    ConfigureEmbeddingsInput, EmbeddingProviderStatusInput, GenerateEmbeddingInput,
    QuerySemanticMemoryInput, SearchByEmbeddingInput,
};

#[test]
fn test_configure_embeddings_tool_definition() {
    let tool = configure_embeddings_tool();
    assert_eq!(tool.name, "configure_embeddings");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Verify required fields
    let schema = tool.input_schema.as_object().unwrap();
    let properties = schema.get("properties").unwrap().as_object().unwrap();
    assert!(properties.contains_key("provider"));

    // Verify provider enum
    let provider = properties.get("provider").unwrap().as_object().unwrap();
    let enum_values = provider.get("enum").unwrap().as_array().unwrap();
    assert_eq!(enum_values.len(), 5);
    assert!(enum_values.contains(&serde_json::json!("openai")));
    assert!(enum_values.contains(&serde_json::json!("local")));
    assert!(enum_values.contains(&serde_json::json!("mistral")));
    assert!(enum_values.contains(&serde_json::json!("azure")));
    assert!(enum_values.contains(&serde_json::json!("cohere")));
}

#[test]
fn test_query_semantic_memory_tool_definition() {
    let tool = query_semantic_memory_tool();
    assert_eq!(tool.name, "query_semantic_memory");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Verify required fields
    let schema = tool.input_schema.as_object().unwrap();
    let required = schema.get("required").unwrap().as_array().unwrap();
    assert_eq!(required.len(), 1);
    assert!(required.contains(&serde_json::json!("query")));
}

#[test]
fn test_test_embeddings_tool_definition() {
    let tool = test_embeddings_tool();
    assert_eq!(tool.name, "test_embeddings");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Should have no required properties
    let schema = tool.input_schema.as_object().unwrap();
    let properties = schema.get("properties").unwrap().as_object().unwrap();
    assert!(properties.is_empty());
}

/// REA-2026-07-26 A5: local provider activation.  In CI the sentence-transformers
/// model is not downloaded, so `build_exact` rejects the degraded-mock provider.
/// When a real model IS available the output must reflect a live activation.
#[tokio::test]
async fn test_configure_embeddings_local() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "local".to_string(),
        model: Some("sentence-transformers/all-MiniLM-L6-v2".to_string()),
        api_key_env: None,
        similarity_threshold: Some(0.75),
        batch_size: Some(16),
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    match result {
        Ok(output) => {
            assert!(output.success);
            assert_eq!(output.provider, "local");
            assert_eq!(output.dimension, 384);
            assert_eq!(output.provider_health, "active");
            assert!(output.activation_revision.is_some());
        }
        Err(e) => {
            let msg = e.to_string();
            assert!(
                msg.contains("activation failed")
                    || msg.contains("not production-ready")
                    || msg.contains("Local embedding model unavailable"),
                "Unexpected error: {msg}"
            );
        }
    }
}

#[tokio::test]
async fn test_configure_embeddings_openai() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "openai".to_string(),
        model: Some("text-embedding-3-small".to_string()),
        api_key_env: Some("OPENAI_API_KEY".to_string()),
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    // May succeed or fail depending on whether OPENAI_API_KEY is set
    // We're testing that it doesn't panic
    assert!(result.is_ok() || result.is_err());
}

#[tokio::test]
async fn test_configure_embeddings_invalid_provider() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "invalid-provider".to_string(),
        model: None,
        api_key_env: None,
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    assert!(result.is_err());
    assert!(
        result
            .unwrap_err()
            .to_string()
            .contains("Unsupported provider")
    );
}

#[tokio::test]
async fn test_query_semantic_memory() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = QuerySemanticMemoryInput {
        query: "implement REST API".to_string(),
        limit: Some(5),
        similarity_threshold: Some(0.8),
        domain: Some("web-api".to_string()),
        task_type: Some("code_generation".to_string()),
    };

    let result = tools.execute_query_semantic_memory(input).await;
    assert!(result.is_ok());

    let output = result.unwrap();
    assert!(output.query_time_ms >= 0.0);
    assert_eq!(output.embedding_dimension, 384);
}

#[tokio::test]
async fn test_test_embeddings() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let result = tools.execute_test_embeddings().await;
    assert!(result.is_ok());

    let output = result.unwrap();
    assert!(!output.available); // Not configured by default
    // When no semantic service is configured, sample_embedding is empty
    assert_eq!(output.sample_embedding.len(), 0);
    assert_ne!(output.message.len(), 0);
    assert!(output.message.contains("not yet configured"));
}

/// REA-2026-07-26 A1: Azure is no longer selectable — it is rejected at the
/// provider-parsing stage before field validation.
#[tokio::test]
async fn test_configure_embeddings_azure_rejected() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "azure".to_string(),
        model: None,
        api_key_env: None,
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    assert!(result.is_err());
    let error_msg = result.unwrap_err().to_string();
    assert!(
        error_msg.contains("Azure provider is not supported"),
        "Expected 'Azure provider is not supported', got: {error_msg}"
    );
}

#[test]
fn test_generate_embedding_tool_definition() {
    let tool = generate_embedding_tool();
    assert_eq!(tool.name, "generate_embedding");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Verify required fields
    let schema = tool.input_schema.as_object().unwrap();
    let required = schema.get("required").unwrap().as_array().unwrap();
    assert_eq!(required.len(), 1);
    assert!(required.contains(&serde_json::json!("text")));

    // Verify properties
    let properties = schema.get("properties").unwrap().as_object().unwrap();
    assert!(properties.contains_key("text"));
    assert!(properties.contains_key("normalize"));
}

#[test]
fn test_search_by_embedding_tool_definition() {
    let tool = search_by_embedding_tool();
    assert_eq!(tool.name, "search_by_embedding");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Verify required fields
    let schema = tool.input_schema.as_object().unwrap();
    let required = schema.get("required").unwrap().as_array().unwrap();
    assert_eq!(required.len(), 1);
    assert!(required.contains(&serde_json::json!("embedding")));

    // Verify properties
    let properties = schema.get("properties").unwrap().as_object().unwrap();
    assert!(properties.contains_key("embedding"));
    assert!(properties.contains_key("limit"));
    assert!(properties.contains_key("similarity_threshold"));
}

#[test]
fn test_embedding_provider_status_tool_definition() {
    let tool = embedding_provider_status_tool();
    assert_eq!(tool.name, "embedding_provider_status");
    assert_ne!(tool.description.len(), 0);
    assert!(tool.input_schema.is_object());

    // Should have no required properties
    let schema = tool.input_schema.as_object().unwrap();
    let required = schema.get("required");
    assert!(required.is_none() || required.unwrap().as_array().unwrap().is_empty());

    // Verify properties
    let properties = schema.get("properties").unwrap().as_object().unwrap();
    assert!(properties.contains_key("test_connectivity"));
}

#[tokio::test]
async fn test_generate_embedding_not_configured() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = GenerateEmbeddingInput {
        text: "test text".to_string(),
        normalize: true,
    };

    let result = tools.execute_generate_embedding(input).await;
    assert!(result.is_err());
    let error_msg = result.unwrap_err().to_string();
    assert!(
        error_msg.contains("not configured"),
        "Expected error about not configured, got: {}",
        error_msg
    );
}

#[tokio::test]
async fn test_search_by_embedding_not_configured() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = SearchByEmbeddingInput {
        embedding: vec![0.1; 384], // Default dimension
        limit: 10,
        similarity_threshold: 0.7,
        domain: None,
        task_type: None,
    };

    let result = tools.execute_search_by_embedding(input).await;
    assert!(result.is_err());
    let error_msg = result.unwrap_err().to_string();
    assert!(
        error_msg.contains("not configured"),
        "Expected error about not configured, got: {}",
        error_msg
    );
}

#[tokio::test]
async fn test_embedding_provider_status_not_configured() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = EmbeddingProviderStatusInput {
        test_connectivity: false,
    };

    let result = tools.execute_embedding_provider_status(input).await;
    assert!(result.is_ok());

    let output = result.unwrap();
    assert!(!output.configured);
    assert!(!output.available);
    assert_eq!(output.provider, "not-configured");
    assert_ne!(output.warnings.len(), 0);
}

#[tokio::test]
async fn test_embedding_provider_status_with_test() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = EmbeddingProviderStatusInput {
        test_connectivity: true,
    };

    let result = tools.execute_embedding_provider_status(input).await;
    assert!(result.is_ok());

    let output = result.unwrap();
    assert!(!output.configured);
    assert!(!output.available);
    // test_result should be None since not configured
    assert!(output.test_result.is_none());
}

#[tokio::test]
async fn test_search_by_embedding_wrong_dimension() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = SearchByEmbeddingInput {
        embedding: vec![0.1; 128], // Wrong dimension
        limit: 10,
        similarity_threshold: 0.7,
        domain: None,
        task_type: None,
    };

    let result = tools.execute_search_by_embedding(input).await;
    // Since not configured, will error about not configured first
    assert!(result.is_err());
}

/// `api_key_env = None` for a cloud provider emits a warning and passes
/// `api_key = None` to `build_exact`, which rejects it with a credential error.
/// This covers the `resolve_api_key` warning-then-None path.
#[tokio::test]
async fn test_configure_openai_no_api_key_env_emits_warning_and_fails() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "openai".to_string(),
        model: Some("text-embedding-3-small".to_string()),
        api_key_env: None, // No env var supplied → warning path in resolve_api_key
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    // build_exact must reject because api_key is None for OpenAI.
    assert!(
        result.is_err(),
        "configure must fail when no API key env var is given for OpenAI"
    );
    let msg = result.unwrap_err().to_string();
    assert!(
        msg.contains("OPENAI_API_KEY")
            || msg.contains("activation failed")
            || msg.contains("'openai' not enabled"),
        "Unexpected error: {msg}"
    );
}

/// Unknown OpenAI model name triggers a warning and falls back to
/// `text-embedding-3-small`. The configure call may succeed or fail depending
/// on whether a real key is available; we only verify the call doesn't panic.
#[tokio::test]
async fn test_configure_openai_unknown_model_falls_back() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "openai".to_string(),
        model: Some("text-embedding-unknown-model-xyz".to_string()),
        api_key_env: Some("OPENAI_API_KEY".to_string()),
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    // Must not panic; success depends on whether OPENAI_API_KEY is set.
    let result = tools.execute_configure_embeddings(input).await;
    match result {
        Ok(output) => {
            // Warning was emitted and fallback model was used.
            assert!(
                !output.warnings.is_empty(),
                "warnings should be set for unknown model"
            );
        }
        Err(_) => {
            // No API key in CI — expected.
        }
    }
}

/// `generate_embedding` returns an error when the text exceeds
/// `MAX_EMBEDDING_TEXT_LEN`.
#[tokio::test]
async fn test_generate_embedding_text_too_long() {
    use crate::mcp::tools::embeddings::types::GenerateEmbeddingInput;

    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    // 51_000 bytes exceeds the 50_000-byte limit.
    let long_text = "x".repeat(51_000);
    let input = GenerateEmbeddingInput {
        text: long_text,
        normalize: false,
    };

    let result = tools.execute_generate_embedding(input).await;
    assert!(result.is_err(), "should fail for oversized text");
    let msg = result.unwrap_err().to_string();
    assert!(
        msg.contains("exceeds maximum"),
        "error must mention 'exceeds maximum', got: {msg}"
    );
}

/// `build_exact` for Mistral with `api_key = None` must fail — covers the
/// Mistral arm of the match in `semantic_service.rs`.
#[tokio::test]
async fn test_configure_mistral_no_api_key_env_fails() {
    let memory = Arc::new(SelfLearningMemory::new());
    let tools = EmbeddingTools::new(memory);

    let input = ConfigureEmbeddingsInput {
        provider: "mistral".to_string(),
        model: None,
        api_key_env: Some("__NONEXISTENT_MISTRAL_KEY_RSLM__".to_string()),
        similarity_threshold: None,
        batch_size: None,
        base_url: None,
        api_version: None,
        resource_name: None,
        deployment_name: None,
    };

    let result = tools.execute_configure_embeddings(input).await;
    // Env var does not exist → resolve_api_key returns Err → configure fails.
    assert!(
        result.is_err(),
        "configure must fail when mistral credential env var is not set"
    );
}