vipune 0.19.1

//! Tests for search operations.

use crate::memory::lifecycle::{MemoryStatus, MemoryType};
use crate::memory::{MemoryStore, UpdateParams};
use crate::sqlite::Database;

#[test]
fn test_search_basic() {
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    let embedding_match = vec![1.0f32; 384];
    let embedding_other = vec![0.0f32; 384];

    let id_match = db
        .insert(
            "test-project",
            "matching content",
            &embedding_match,
            None,
            "fact",
            "active",
        )
        .unwrap();
    db.insert(
        "test-project",
        "other content",
        &embedding_other,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let results = db
        .search("test-project", &embedding_match, 5, None, None)
        .unwrap();
    assert!(!results.is_empty());
    assert_eq!(results[0].id, id_match);
    assert!(results[0].similarity.unwrap() > 0.9);
}

#[test]
fn test_search_sorting() {
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    let embedding_high = vec![1.0f32; 384];
    let embedding_medium = vec![0.5f32; 384];
    let embedding_low = vec![0.0f32; 384];

    db.insert(
        "test-project",
        "low",
        &embedding_low,
        None,
        "fact",
        "active",
    )
    .unwrap();
    db.insert(
        "test-project",
        "high",
        &embedding_high,
        None,
        "fact",
        "active",
    )
    .unwrap();
    db.insert(
        "test-project",
        "medium",
        &embedding_medium,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let results = db
        .search("test-project", &embedding_high, 10, None, None)
        .unwrap();
    assert!(results[0].similarity.unwrap() >= results[1].similarity.unwrap());
    assert!(results[1].similarity.unwrap() >= results[2].similarity.unwrap());
}

#[test]
fn test_negative_similarity() {
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    let embedding_pos = vec![1.0f32; 384];
    let embedding_neg = vec![-1.0f32; 384];

    db.insert(
        "test-project",
        "positive",
        &embedding_pos,
        None,
        "fact",
        "active",
    )
    .unwrap();

    let results = db
        .search("test-project", &embedding_neg, 10, None, None)
        .unwrap();
    assert!(!results.is_empty());
    assert!(results[0].similarity.unwrap() < 0.0);
}

#[test]
fn test_hybrid_search_basic() {
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    db.initialize_fts().unwrap();

    // Add memories with different embeddings for semantic search
    let embedding_rust: Vec<f32> = vec![1.0, 0.0, 0.0f32]
        .into_iter()
        .cycle()
        .take(384)
        .collect();
    let embedding_python: Vec<f32> = vec![0.0, 1.0, 0.0f32]
        .into_iter()
        .cycle()
        .take(384)
        .collect();
    let embedding_general: Vec<f32> = vec![0.5, 0.5, 0.5f32]
        .into_iter()
        .cycle()
        .take(384)
        .collect();

    let id_rust = db
        .insert(
            "test-project",
            "rust programming language",
            &embedding_rust,
            None,
            "fact",
            "active",
        )
        .unwrap();
    let _id_python = db
        .insert(
            "test-project",
            "python code examples",
            &embedding_python,
            None,
            "fact",
            "active",
        )
        .unwrap();
    let _id_general = db
        .insert(
            "test-project",
            "general software development",
            &embedding_general,
            None,
            "fact",
            "active",
        )
        .unwrap();

    // Test hybrid search combines semantic and BM25
    let semantic_results = db
        .search("test-project", &embedding_rust, 50, None, None)
        .unwrap();
    let bm25_results = db
        .search_bm25("rust", "test-project", 50, None, None)
        .unwrap();

    // Verify semantic search finds rust-related content
    assert!(!semantic_results.is_empty());
    assert!(semantic_results.iter().any(|m| m.id == id_rust));
    assert!(semantic_results.iter().any(|m| m.content.contains("rust")));

    // BM25 should find matches for "rust" query
    assert!(!bm25_results.is_empty());

    // Rust memory should appear in both semantic and BM25 results
    assert!(semantic_results.iter().any(|m| m.id == id_rust));
    assert!(
        bm25_results
            .iter()
            .any(|m| m.content.to_lowercase().contains("rust"))
    );
}

#[test]
fn test_hybrid_search_empty_results() {
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    db.initialize_fts().unwrap();

    // Add one memory
    let embedding = vec![0.5f32; 384];
    db.insert(
        "test-project",
        "some content",
        &embedding,
        None,
        "fact",
        "active",
    )
    .unwrap();

    // Query with non-matching text
    let semantic_results = db
        .search("test-project", &vec![0.1f32; 384], 50, None, None)
        .unwrap();
    let bm25_results = db
        .search_bm25("nonexistent term xyz", "test-project", 50, None, None)
        .unwrap();

    // One may be empty, but fusion should handle it
    assert!(!semantic_results.is_empty() || !bm25_results.is_empty());
}

#[test]
fn test_hybrid_search_with_recency() {
    use chrono::{Duration, Utc};
    let (_dir, path) = MemoryStore::test_db_path();

    let db = Database::open(&path).unwrap();
    db.initialize_fts().unwrap();

    // Add memories with known embedding
    let embedding_good = vec![1.0f32; 384];
    let embedding_bad = vec![0.0f32; 384];

    let now = Utc::now();
    let old_time = (now - Duration::days(100)).to_rfc3339();
    let new_time = now.to_rfc3339();

    // Old high-similarity memory
    let id_old = db
        .insert_with_time(
            "test-project",
            "old but relevant",
            &embedding_good,
            None,
            &old_time,
            &old_time,
            "fact",
            "active",
        )
        .unwrap();

    // New low-similarity memory (same content for BM25 relevance)
    let _id_new = db
        .insert_with_time(
            "test-project",
            "new but less relevant",
            &embedding_bad,
            None,
            &new_time,
            &new_time,
            "fact",
            "active",
        )
        .unwrap();

    // Search without recency weighting - should find high-similarity first
    let semantic_results = db
        .search("test-project", &embedding_good, 10, None, None)
        .unwrap();
    if !semantic_results.is_empty() {
        let top_id = &semantic_results[0].id;
        // With zero recency weight, similarity dominates
        // Either the high-similarity old memory is first, or we have a single result
        assert!(top_id == &id_old || semantic_results.len() == 1);
    }
}

#[ignore]
#[test]
fn test_integration_add_search_roundtrip() {
    // Full integration test with real model
    // Requires: cargo test -- --ignored
    use crate::config::Config;
    use tempfile::TempDir;
    let dir = TempDir::new().unwrap();
    let path = dir.path().join("test.db");
    let config = Config::default();

    let mut store = MemoryStore::new(&path, "BAAI/bge-small-en-v1.5", config).unwrap();

    let id = match store
        .add_with_conflict(
            "test-project",
            "semantic search is useful",
            None,
            false,
            MemoryType::Fact,
            MemoryStatus::Active,
        )
        .unwrap()
    {
        crate::memory_types::AddResult::Added { id } => id,
        _ => panic!("Expected AddResult::Added"),
    };

    let results = store
        .search(
            "test-project",
            "finding information",
            5,
            0.0,
            crate::memory::SearchOptions::default(),
        )
        .unwrap();
    assert!(!results.is_empty());

    let memory = store.get(&id, "test-project").unwrap().unwrap();
    assert_eq!(memory.content, "semantic search is useful");
}

#[ignore]
#[test]
fn test_integration_update_changes_embedding() {
    // Full integration test with real model
    // Requires: cargo test -- --ignored
    use crate::config::Config;
    use tempfile::TempDir;
    let dir = TempDir::new().unwrap();
    let path = dir.path().join("test.db");
    let config = Config::default();

    let mut store = MemoryStore::new(&path, "BAAI/bge-small-en-v1.5", config).unwrap();

    let id = match store
        .add_with_conflict(
            "test-project",
            "original content",
            None,
            false,
            MemoryType::Fact,
            MemoryStatus::Active,
        )
        .unwrap()
    {
        crate::memory_types::AddResult::Added { id } => id,
        _ => panic!("Expected AddResult::Added"),
    };

    store
        .update(
            &id,
            "test-project",
            UpdateParams {
                text: Some("completely different content"),
                metadata: None,
                memory_type: None,
                status: None,
                importance: None,
            },
        )
        .unwrap();

    let memory = store.get(&id, "test-project").unwrap().unwrap();
    assert_eq!(memory.content, "completely different content");
}

#[test]
fn a_corrupt_blob_reaches_the_public_error_with_its_id() {
    // The Domain arm of `sqlite::classify_db_error` is what promotes a row's
    // decoding failure into the public `CorruptEmbedding`, and `errors.rs`
    // says only the structured decoding variants may be trusted as a
    // row-conversion payload. `sqlite::search`'s own test builds that error
    // from the decoder; this drives the whole chain the CLI takes — a real
    // store, a real corrupt BLOB, the store-level `search` that owns the
    // identity gate and the recency pass — so a public lock- or
    // classifier-shaped regression anywhere between the decoder and the caller
    // shows up here rather than only at the storage boundary.
    use crate::memory::SearchOptions;

    let (_dir, path) = MemoryStore::test_db_path();

    let id = {
        let db = Database::open(&path).unwrap();
        db.insert(
            "test-project",
            "corrupt embedding",
            &vec![0.1f32; 384],
            None,
            "fact",
            "active",
        )
        .unwrap()
    };

    // Corrupt the stored BLOB: a real row whose embedding is not a valid f32
    // buffer (3 bytes), written through the same connection the store owns.
    {
        let db = Database::open(&path).unwrap();
        db.conn()
            .execute(
                "UPDATE memories SET embedding = X'000102' WHERE id = ?1",
                rusqlite::params![id.clone()],
            )
            .unwrap();
    }

    // `from_db_with_test_embedder` keeps the model identity the insert wrote,
    // so the identity gate passes and the failure under test is the decode.
    let mut store = MemoryStore::from_db_with_test_embedder(Database::open(&path).unwrap());
    let err = store
        .search(
            "test-project",
            "corrupt embedding",
            10,
            0.0,
            SearchOptions::default(),
        )
        .expect_err("a row whose BLOB cannot be decoded must fail the search");

    assert!(
        matches!(&err, crate::errors::Error::CorruptEmbedding { id: corrupt_id, .. }
            if corrupt_id == &id),
        "the public error must stay CorruptEmbedding and name the row, got {err:?}"
    );
    // And it was not the classifier's Locked arm that produced it: the same
    // row read through the non-search path (the shared `map_row_to_memory`
    // decoder) fails the same way, so the verdict is the decode and nothing
    // upstream of it.
    assert!(
        !err.is_locked(),
        "a corrupt BLOB must not classify as a lock, got {err:?}"
    );
    let listed = store
        .list("test-project", 10, None, None)
        .expect_err("the same corrupt BLOB breaks the plain read path");
    assert!(
        matches!(&listed, crate::errors::Error::CorruptEmbedding { id: corrupt_id, .. }
            if corrupt_id == &id),
        "the read path must name the same row, got {listed:?}"
    );
}