gitlore/tests/fts_search.rs

//! Integration tests for FTS5 search.
//!
//! These tests create an in-memory SQLite database, apply migrations through 008 (FTS5),
//! seed documents, and verify search behavior.

use rusqlite::Connection;

fn create_test_db() -> Connection {
    let conn = Connection::open_in_memory().unwrap();
    conn.pragma_update(None, "foreign_keys", "ON").unwrap();

    let migrations_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("migrations");

    for version in 1..=8 {
        let entries: Vec<_> = std::fs::read_dir(&migrations_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .filter(|e| {
                e.file_name()
                    .to_string_lossy()
                    .starts_with(&format!("{:03}", version))
            })
            .collect();

        assert!(!entries.is_empty(), "Migration {} not found", version);
        let sql = std::fs::read_to_string(entries[0].path()).unwrap();
        conn.execute_batch(&sql)
            .unwrap_or_else(|e| panic!("Migration {} failed: {}", version, e));
    }

    // Seed a project
    conn.execute(
        "INSERT INTO projects (id, gitlab_project_id, path_with_namespace) VALUES (1, 100, 'group/project')",
        [],
    )
    .unwrap();

    conn
}

fn insert_document(conn: &Connection, id: i64, source_type: &str, title: &str, content: &str) {
    conn.execute(
        "INSERT INTO documents (id, source_type, source_id, project_id, title, content_text, content_hash, url)
         VALUES (?1, ?2, ?1, 1, ?3, ?4, 'hash_' || ?1, 'https://example.com/' || ?1)",
        rusqlite::params![id, source_type, title, content],
    )
    .unwrap();
}

#[test]
fn fts_basic_search() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Authentication bug",
        "Users cannot login when using OAuth tokens. The JWT refresh fails silently.",
    );
    insert_document(
        &conn,
        2,
        "merge_request",
        "Add user profile page",
        "This MR adds a new user profile page with avatar upload support.",
    );
    insert_document(
        &conn,
        3,
        "issue",
        "Database migration failing",
        "The migration script crashes on PostgreSQL 14 due to deprecated syntax.",
    );

    let results = lore::search::search_fts(
        &conn,
        "authentication login",
        10,
        lore::search::FtsQueryMode::Safe,
    )
    .unwrap();

    assert!(
        !results.is_empty(),
        "Expected at least one result for 'authentication login'"
    );
    assert_eq!(
        results[0].document_id, 1,
        "Authentication issue should be top result"
    );
}

#[test]
fn fts_stemming_matches() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Running tests",
        "The test runner is executing integration tests.",
    );
    insert_document(
        &conn,
        2,
        "issue",
        "Deployment config",
        "Deployment configuration for production servers.",
    );

    // "running" should match "runner" and "executing" via porter stemmer
    let results =
        lore::search::search_fts(&conn, "running", 10, lore::search::FtsQueryMode::Safe).unwrap();
    assert!(
        !results.is_empty(),
        "Stemming should match 'running' to 'runner'"
    );
    assert_eq!(results[0].document_id, 1);
}

#[test]
fn fts_empty_results() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Bug fix",
        "Fixed a null pointer dereference in the parser.",
    );

    let results = lore::search::search_fts(
        &conn,
        "kubernetes deployment helm",
        10,
        lore::search::FtsQueryMode::Safe,
    )
    .unwrap();
    assert!(
        results.is_empty(),
        "No documents should match unrelated query"
    );
}

#[test]
fn fts_special_characters_handled() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "C++ compiler",
        "The C++ compiler segfaults on template metaprogramming.",
    );

    // Special characters should not crash the search
    let results =
        lore::search::search_fts(&conn, "C++ compiler", 10, lore::search::FtsQueryMode::Safe)
            .unwrap();
    // Safe mode sanitizes the query — it should still return results or at least not crash
    assert!(results.len() <= 1);
}

#[test]
fn fts_result_ordering_by_relevance() {
    let conn = create_test_db();

    // Doc 1: "authentication" in title and content
    insert_document(
        &conn,
        1,
        "issue",
        "Authentication system redesign",
        "The authentication system needs a complete redesign. Authentication flows are broken.",
    );
    // Doc 2: "authentication" only in content, once
    insert_document(
        &conn,
        2,
        "issue",
        "Login page update",
        "Updated the login page with better authentication error messages.",
    );
    // Doc 3: unrelated
    insert_document(
        &conn,
        3,
        "issue",
        "Database optimization",
        "Optimize database queries for faster response times.",
    );

    let results = lore::search::search_fts(
        &conn,
        "authentication",
        10,
        lore::search::FtsQueryMode::Safe,
    )
    .unwrap();

    assert!(results.len() >= 2, "Should match at least 2 documents");
    // Doc 1 should rank higher (more occurrences of the term)
    assert_eq!(
        results[0].document_id, 1,
        "Document with more term occurrences should rank first"
    );
}

#[test]
fn fts_respects_limit() {
    let conn = create_test_db();

    for i in 1..=20 {
        insert_document(
            &conn,
            i,
            "issue",
            &format!("Bug report {}", i),
            &format!("This is bug report number {} about the login system.", i),
        );
    }

    let results =
        lore::search::search_fts(&conn, "bug login", 5, lore::search::FtsQueryMode::Safe).unwrap();
    assert!(results.len() <= 5, "Results should be capped at limit");
}

#[test]
fn fts_snippet_generated() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Performance issue",
        "The application performance degrades significantly when more than 100 users are connected simultaneously. Memory usage spikes to 4GB.",
    );

    let results =
        lore::search::search_fts(&conn, "performance", 10, lore::search::FtsQueryMode::Safe)
            .unwrap();

    assert!(!results.is_empty());
    // Snippet should contain some text (may have FTS5 highlight markers)
    assert!(
        !results[0].snippet.is_empty(),
        "Snippet should be generated"
    );
}

#[test]
fn fts_triggers_sync_on_insert() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Test document",
        "This is test content for FTS trigger verification.",
    );

    // Verify FTS table has an entry via direct query
    let fts_count: i64 = conn
        .query_row(
            "SELECT COUNT(*) FROM documents_fts WHERE documents_fts MATCH 'test'",
            [],
            |r| r.get(0),
        )
        .unwrap();

    assert_eq!(fts_count, 1, "FTS trigger should auto-index on INSERT");
}

#[test]
fn fts_triggers_sync_on_delete() {
    let conn = create_test_db();

    insert_document(
        &conn,
        1,
        "issue",
        "Deletable document",
        "This content will be deleted from the index.",
    );

    // Verify it's indexed
    let before: i64 = conn
        .query_row(
            "SELECT COUNT(*) FROM documents_fts WHERE documents_fts MATCH 'deletable'",
            [],
            |r| r.get(0),
        )
        .unwrap();
    assert_eq!(before, 1);

    // Delete the document
    conn.execute("DELETE FROM documents WHERE id = 1", [])
        .unwrap();

    // Verify it's removed from FTS
    let after: i64 = conn
        .query_row(
            "SELECT COUNT(*) FROM documents_fts WHERE documents_fts MATCH 'deletable'",
            [],
            |r| r.get(0),
        )
        .unwrap();
    assert_eq!(after, 0, "FTS trigger should remove entry on DELETE");
}

#[test]
fn fts_null_title_handled() {
    let conn = create_test_db();

    // Discussion documents have NULL titles
    conn.execute(
        "INSERT INTO documents (id, source_type, source_id, project_id, title, content_text, content_hash, url)
         VALUES (1, 'discussion', 1, 1, NULL, 'Discussion about API rate limiting strategies.', 'hash1', 'https://example.com/1')",
        [],
    )
    .unwrap();

    let results =
        lore::search::search_fts(&conn, "rate limiting", 10, lore::search::FtsQueryMode::Safe)
            .unwrap();
    assert!(!results.is_empty(), "Should find documents with NULL title");
}