sqlitegraph 2.0.7

//! MVCC Isolation Tests for Sequential Cluster Reads (Phase 34-35)
//!
//! **Purpose:** Validate that TraversalContext cluster-related fields preserve MVCC isolation
//! **Scope:** Sequential cluster buffer isolation for v1.6 Chain Locality optimization
//! **Focus:** cluster_buffer, cluster_buffer_offsets, node_cluster_index field isolation
//!
//! **Key Design Principle:**
//! TraversalContext is stack-allocated per traversal and evaporates when the traversal
//! function returns. This ensures:
//! - No cross-traversal cluster_buffer pollution
//! - Sequential cluster reads don't leak data between calls
//! - MVCC isolation is preserved by design
//!
//! These tests verify that Phase 34-35 sequential cluster reader features don't introduce
//! isolation violations through cluster_buffer, cluster_buffer_offsets, or node_cluster_index.

use sqlitegraph::backend::native::{
    NativeNodeId,
    adjacency::{Direction, LinearDetector, TraversalPattern},
    edge_store::EdgeStore,
    graph_file::GraphFile,
    graph_ops::TraversalContext,
    node_store::NodeStore,
};

use tempfile::TempDir;

//
// TEST HELPERS
//

/// Helper: Create a simple chain graph for testing
///
/// Creates a linear chain graph: 0 -> 1 -> 2 -> ... -> (size-1)
/// This is the simplest graph that demonstrates sequential cluster read behavior.
///
/// Parameters:
/// - size: Number of nodes in the chain
///
/// Returns:
/// - GraphFile: The native graph file
/// - Vec<NativeNodeId>: Node IDs [0, 1, 2, ..., size-1]
/// - TempDir: Temporary directory (kept for cleanup)
fn create_test_chain(size: usize) -> (GraphFile, Vec<NativeNodeId>, TempDir) {
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let db_path = temp_dir.path().join("test_chain.db");
    let mut graph_file = GraphFile::create(&db_path).expect("Failed to create graph file");

    let mut node_ids = Vec::with_capacity(size);
    for i in 0..size {
        let mut node_store = NodeStore::new(&mut graph_file);
        let node_id = node_store
            .allocate_node_id()
            .expect("Failed to allocate node ID");
        let record = sqlitegraph::backend::native::NodeRecord::new(
            node_id,
            "TestNode".to_string(),
            format!("node_{}", i),
            serde_json::json!({"id": i}),
        );
        node_store
            .write_node(&record)
            .expect("Failed to write node");
        node_ids.push(node_id);
    }

    let mut edge_store = EdgeStore::new(&mut graph_file);
    for i in 0..size.saturating_sub(1) {
        let edge = sqlitegraph::backend::native::EdgeRecord::new(
            i as i64 + 1,
            node_ids[i],
            node_ids[i + 1],
            "chain".to_string(),
            serde_json::json!({"order": i}),
        );
        edge_store.write_edge(&edge).expect("Failed to write edge");
    }

    (graph_file, node_ids, temp_dir)
}

//
// GROUP 1: TRAVERSAL CONTEXT EVAPORATION TESTS
//
// These tests verify that TraversalContext evaporates completely when
// the traversal function returns, ensuring no cross-traversal pollution
// of cluster-related fields.
//

#[test]
fn test_traversal_context_cluster_buffer_evaporates_after_return() {
    // Scenario: Run two traversals with explicit TraversalContext
    // Expected: Second traversal has fresh context (no cluster_buffer pollution)

    let (_graph_file, node_ids, _temp_dir) = create_test_chain(100);

    // First traversal with explicit context
    {
        let mut ctx = TraversalContext::new();

        // Simulate cluster buffer being populated
        // (In real scenario, SequentialClusterReader::read_chain_clusters would populate this)
        ctx.cluster_buffer = Some(vec![1, 2, 3, 4]);
        ctx.cluster_buffer_offsets = vec![(100, 4), (104, 4)];
        ctx.node_cluster_index.insert(node_ids[0], 0);

        // Context has data
        assert!(ctx.cluster_buffer.is_some());
        assert_eq!(ctx.cluster_buffer_offsets.len(), 2);
        assert_eq!(ctx.node_cluster_index.len(), 1);
    } // Context evaporates here

    // Second traversal - fresh context
    {
        let ctx = TraversalContext::new();

        // Fresh context should have empty cluster fields
        assert!(
            ctx.cluster_buffer.is_none(),
            "cluster_buffer should be None on new context"
        );
        assert!(
            ctx.cluster_buffer_offsets.is_empty(),
            "cluster_buffer_offsets should be empty"
        );
        assert!(
            ctx.node_cluster_index.is_empty(),
            "node_cluster_index should be empty"
        );
    }
}

#[test]
fn test_sequential_cluster_buffer_per_traversal_isolation() {
    // Scenario: Run traverse_with_detection on different chain segments
    // Expected: Each traversal maintains independent cluster_buffer

    let (mut graph_file, node_ids, _temp_dir) = create_test_chain(100);

    // First traversal on chain segment starting from node 0
    {
        let mut ctx = TraversalContext::new();

        // Simulate traversal populating cluster buffer
        // (In real scenario, SequentialClusterReader::read_chain_clusters would populate this)
        ctx.cluster_buffer = Some(vec![1, 2, 3, 4]);
        ctx.cluster_buffer_offsets = vec![(1000, 4), (1004, 4)];

        // Buffer is populated
        assert!(ctx.cluster_buffer.is_some());
    } // Context evaporates

    // Second traversal - independent context
    {
        let mut ctx = TraversalContext::new();

        // Should start with empty buffer
        assert!(ctx.cluster_buffer.is_none());

        // Run actual traversal (if we had cluster metadata)
        // traverse_with_detection(&mut graph_file, node_ids[10], Direction::Outgoing, 0, 0, &mut ctx);

        // Buffer should be independent of first traversal
        assert!(
            !ctx.cluster_buffer.is_some()
                || ctx.cluster_buffer.as_ref().map(|b| b.len()).unwrap_or(0) == 0
        );
    }
}

//
// GROUP 2: NODE_CLUSTER_INDEX MAPPING ISOLATION TESTS
//
// These tests verify that node_cluster_index mapping doesn't leak between traversals.
//

#[test]
fn test_node_cluster_index_mapping_per_traversal_isolation() {
    // Scenario: Populate node_cluster_index in first traversal
    // Expected: Second traversal has empty mapping

    let (_graph_file, node_ids, _temp_dir) = create_test_chain(50);

    // First traversal - populate mapping
    {
        let mut ctx = TraversalContext::new();
        ctx.node_cluster_index.insert(node_ids[0], 0);
        ctx.node_cluster_index.insert(node_ids[1], 1);
        ctx.node_cluster_index.insert(node_ids[2], 2);

        assert_eq!(ctx.node_cluster_index.len(), 3);
    } // Context evaporates

    // Second traversal - fresh mapping
    {
        let ctx = TraversalContext::new();
        assert!(
            ctx.node_cluster_index.is_empty(),
            "node_cluster_index should be empty on new context"
        );
    }
}

#[test]
fn test_node_cluster_index_multiple_traversals_independent() {
    // Scenario: Run multiple traversals, each populating node_cluster_index
    // Expected: Each traversal maintains independent mapping

    let (_graph_file, node_ids, _temp_dir) = create_test_chain(30);

    // First traversal - populate with 3 entries
    {
        let mut ctx = TraversalContext::new();
        ctx.node_cluster_index.insert(node_ids[0], 0);
        ctx.node_cluster_index.insert(node_ids[1], 1);
        ctx.node_cluster_index.insert(node_ids[2], 2);
        assert_eq!(ctx.node_cluster_index.len(), 3);
    }

    // Second traversal - populate with 2 entries
    {
        let mut ctx = TraversalContext::new();
        ctx.node_cluster_index.insert(node_ids[10], 0);
        ctx.node_cluster_index.insert(node_ids[11], 1);
        assert_eq!(ctx.node_cluster_index.len(), 2);
    }

    // Third traversal - empty mapping
    {
        let ctx = TraversalContext::new();
        assert!(ctx.node_cluster_index.is_empty());
    }
}

//
// GROUP 3: CLEAR_CLUSTER_BUFFER METHOD TESTS
//
// These tests verify that clear_cluster_buffer() cleans all cluster-related fields.
//

#[test]
fn test_clear_cluster_buffer_clears_all_fields() {
    // Scenario: Populate all cluster fields, then call clear_cluster_buffer()
    // Expected: All cluster-related fields are empty

    let mut ctx = TraversalContext::new();

    // Populate all cluster fields
    ctx.cluster_buffer = Some(vec![1, 2, 3, 4, 5]);
    ctx.cluster_buffer_offsets = vec![(100, 4), (104, 4), (108, 4)];
    ctx.node_cluster_index.insert(1, 0);
    ctx.node_cluster_index.insert(2, 1);
    ctx.node_cluster_index.insert(3, 2);

    assert!(ctx.cluster_buffer.is_some());
    assert_eq!(ctx.cluster_buffer_offsets.len(), 3);
    assert_eq!(ctx.node_cluster_index.len(), 3);

    // Clear buffer
    ctx.clear_cluster_buffer();

    // Verify all fields cleared
    assert!(
        ctx.cluster_buffer.is_none(),
        "cluster_buffer should be None after clear"
    );
    assert!(
        ctx.cluster_buffer_offsets.is_empty(),
        "cluster_buffer_offsets should be empty after clear"
    );
    assert!(
        ctx.node_cluster_index.is_empty(),
        "node_cluster_index should be empty after clear"
    );
}

#[test]
fn test_clear_cluster_buffer_idempotent() {
    // Scenario: Call clear_cluster_buffer() multiple times
    // Expected: No errors, all fields remain empty

    let mut ctx = TraversalContext::new();

    // Populate all fields
    ctx.cluster_buffer = Some(vec![1, 2, 3]);
    ctx.cluster_buffer_offsets = vec![(100, 3)];
    ctx.node_cluster_index.insert(1, 0);

    // First clear
    ctx.clear_cluster_buffer();
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());

    // Second clear (idempotent)
    ctx.clear_cluster_buffer();
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());

    // Third clear (still idempotent)
    ctx.clear_cluster_buffer();
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());
}

#[test]
fn test_clear_cluster_buffer_on_branching_pattern() {
    // Scenario: Simulate branching pattern detection triggering clear_cluster_buffer()
    // Expected: All cluster fields cleared immediately

    use sqlitegraph::backend::native::adjacency::TraversalPattern;

    let mut ctx = TraversalContext::new();

    // Simulate chain detection with populated fields
    ctx.cluster_buffer = Some(vec![1, 2, 3, 4]);
    ctx.cluster_buffer_offsets = vec![(100, 4)];
    ctx.node_cluster_index.insert(1, 0);
    ctx.node_cluster_index.insert(2, 1);

    // Simulate branching pattern detected
    let _pattern = ctx.detector.observe_with_cluster(3, 2, 200, 4);
    let branching_detected =
        ctx.detector.observe_with_cluster(4, 2, 204, 4) == TraversalPattern::Branching;

    if branching_detected {
        ctx.clear_cluster_buffer();
    }

    // Verify all fields cleared
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());
}

//
// GROUP 4: MULTIPLE TRAVERSAL TESTS
//
// These tests verify isolation across multiple sequential traversals.
//

#[test]
fn test_multiple_traversals_with_traverse_with_detection() {
    // Scenario: Run traverse_with_detection multiple times from same start
    // Expected: Each traversal produces correct results independently

    let (mut graph_file, node_ids, _temp_dir) = create_test_chain(20);

    let mut results = Vec::new();

    // Run 5 traversals
    for _i in 0..5 {
        let mut ctx = TraversalContext::new();
        let start_node = node_ids[0];

        // For this test, we verify context starts fresh each time
        assert!(
            ctx.cluster_buffer.is_none(),
            "Context should start with empty cluster_buffer"
        );
        assert!(
            ctx.node_cluster_index.is_empty(),
            "Context should start with empty node_cluster_index"
        );

        // Run traversal (note: need cluster metadata for full traverse_with_detection)
        // For this test, we just verify fresh context
        results.push(start_node);
    }

    // All traversals completed without cross-traversal pollution
    assert_eq!(results.len(), 5);
}

#[test]
fn test_rapid_sequential_traversals_cluster_isolation() {
    // Scenario: Run 50 traversals rapidly, populating cluster fields each time
    // Expected: Each traversal starts with empty cluster fields

    let (_graph_file, node_ids, _temp_dir) = create_test_chain(10);

    for i in 0..50 {
        let ctx = TraversalContext::new();

        // Verify fresh context every time
        assert!(
            ctx.cluster_buffer.is_none(),
            "Iteration {}: cluster_buffer should be None",
            i
        );
        assert!(
            ctx.cluster_buffer_offsets.is_empty(),
            "Iteration {}: cluster_buffer_offsets should be empty",
            i
        );
        assert!(
            ctx.node_cluster_index.is_empty(),
            "Iteration {}: node_cluster_index should be empty",
            i
        );

        // Simulate populating cluster fields
        drop(ctx);

        // Next iteration should have fresh context (proven by next iteration's assertions)
    }
}

//
// GROUP 5: FIELD INTERACTION TESTS
//
// These tests verify that cluster fields interact correctly with other TraversalContext fields.
//

#[test]
fn test_cluster_fields_isolated_from_l2_cache() {
    // Scenario: Populate L2 cache and cluster buffer
    // Expected: clear_cluster_buffer() only clears cluster fields, not L2 cache

    let mut ctx = TraversalContext::new();

    // Populate both L2 cache and cluster fields
    // Note: TraversalCache key is (NativeNodeId, Direction)
    let node1: NativeNodeId = 1;
    let node2: NativeNodeId = 2;
    ctx.cache
        .insert((node1, Direction::Outgoing), vec![2, 3, 4]);
    ctx.cache.insert((node2, Direction::Outgoing), vec![5, 6]);
    ctx.cluster_buffer = Some(vec![1, 2, 3, 4]);
    ctx.cluster_buffer_offsets = vec![(100, 4)];
    ctx.node_cluster_index.insert(node1, 0);

    // Verify both are populated
    assert_eq!(ctx.cache.len(), 2);
    assert!(ctx.cluster_buffer.is_some());

    // Clear only cluster buffer
    ctx.clear_cluster_buffer();

    // Verify cluster fields cleared but L2 cache intact
    assert!(
        ctx.cluster_buffer.is_none(),
        "cluster_buffer should be cleared"
    );
    assert!(
        ctx.cluster_buffer_offsets.is_empty(),
        "cluster_buffer_offsets should be cleared"
    );
    assert!(
        ctx.node_cluster_index.is_empty(),
        "node_cluster_index should be cleared"
    );
    assert_eq!(ctx.cache.len(), 2, "L2 cache should remain intact");
    assert!(
        ctx.cache.contains_key(&(node1, Direction::Outgoing)),
        "L2 cache should still contain key 1"
    );
    assert!(
        ctx.cache.contains_key(&(node2, Direction::Outgoing)),
        "L2 cache should still contain key 2"
    );
}

#[test]
fn test_cluster_fields_isolated_from_detector() {
    // Scenario: Populate LinearDetector and cluster buffer
    // Expected: clear_cluster_buffer() doesn't affect detector state

    let mut ctx = TraversalContext::new();

    // Populate detector and cluster fields
    let _pattern = ctx.detector.observe_with_cluster(1, 1, 100, 4);
    let _pattern2 = ctx.detector.observe_with_cluster(2, 1, 104, 4);
    let _pattern3 = ctx.detector.observe_with_cluster(3, 1, 108, 4);

    ctx.cluster_buffer = Some(vec![1, 2, 3]);
    ctx.cluster_buffer_offsets = vec![(100, 4)];
    ctx.node_cluster_index.insert(1, 0);

    // Verify detector has state and cluster is populated
    assert!(!ctx.detector.cluster_offsets().is_empty());
    assert!(ctx.cluster_buffer.is_some());

    // Clear cluster buffer
    ctx.clear_cluster_buffer();

    // Verify cluster fields cleared but detector intact
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());
    assert!(
        !ctx.detector.cluster_offsets().is_empty(),
        "LinearDetector state should remain intact"
    );
}

//
// GROUP 6: EDGE CASE TESTS
//
// These tests verify TraversalContext behavior in edge cases.
//

#[test]
fn test_empty_traversal_context_cluster_fields() {
    // Scenario: Create TraversalContext without populating cluster fields
    // Expected: All cluster fields are empty/None

    let ctx = TraversalContext::new();

    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());
}

#[test]
fn test_default_traversal_context_cluster_fields() {
    // Scenario: Create TraversalContext via Default trait
    // Expected: All cluster fields are empty/None

    let ctx = TraversalContext::default();

    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
    assert!(ctx.node_cluster_index.is_empty());
}

#[test]
fn test_large_cluster_buffer_cleared() {
    // Scenario: Populate cluster_buffer with large data (simulating long chain)
    // Expected: clear_cluster_buffer() handles large buffers correctly

    let mut ctx = TraversalContext::new();

    // Simulate large cluster buffer (512KB max from Phase 34)
    let large_buffer = vec![1u8; 512 * 1024];
    let large_offsets: Vec<(u64, u32)> = (0..128).map(|i| (i as u64 * 4096, 4096)).collect();

    ctx.cluster_buffer = Some(large_buffer);
    ctx.cluster_buffer_offsets = large_offsets;

    // Verify populated
    assert!(ctx.cluster_buffer.is_some());
    assert_eq!(ctx.cluster_buffer_offsets.len(), 128);

    // Clear buffer
    ctx.clear_cluster_buffer();

    // Verify cleared
    assert!(ctx.cluster_buffer.is_none());
    assert!(ctx.cluster_buffer_offsets.is_empty());
}

#[test]
fn test_node_cluster_index_with_many_entries() {
    // Scenario: Populate node_cluster_index with many entries (long chain)
    // Expected: All entries cleared correctly

    let mut ctx = TraversalContext::new();

    // Populate with 1000 entries
    for i in 0..1000 {
        let node_id: NativeNodeId = i;
        ctx.node_cluster_index.insert(node_id, i as usize);
    }

    assert_eq!(ctx.node_cluster_index.len(), 1000);

    // Clear buffer
    ctx.clear_cluster_buffer();

    // Verify all entries cleared
    assert!(ctx.node_cluster_index.is_empty());
    assert_eq!(ctx.node_cluster_index.len(), 0);
}