absurder-sql 0.1.23

//! IndexedDB crash simulation tests (TDD - expected to FAIL initially)
//! Tests simulate crash scenarios during IndexedDB commit operations and verify recovery correctness

#![cfg(target_arch = "wasm32")]
#![allow(unused_imports)]

use absurder_sql::storage::{BLOCK_SIZE, BlockStorage};
use absurder_sql::types::DatabaseError;
use std::collections::HashMap;
use wasm_bindgen_test::*;

wasm_bindgen_test_configure!(run_in_browser);

/// Test crash simulation during IndexedDB transaction commit
/// Simulates a crash after blocks are written but before commit marker is advanced
#[wasm_bindgen_test]
async fn test_crash_mid_commit_blocks_written_marker_not_advanced() {
    let db_name = "crash_mid_commit_test";

    // Step 1: Create storage and write multiple blocks
    let mut storage1 = BlockStorage::new(db_name).await.expect("create storage1");

    let block_id1 = storage1.allocate_block().await.expect("alloc block1");
    let block_id2 = storage1.allocate_block().await.expect("alloc block2");
    let block_id3 = storage1.allocate_block().await.expect("alloc block3");

    let data1 = vec![0xAAu8; BLOCK_SIZE];
    let data2 = vec![0xBBu8; BLOCK_SIZE];
    let data3 = vec![0xCCu8; BLOCK_SIZE];

    storage1
        .write_block(block_id1, data1.clone())
        .await
        .expect("write block1");
    storage1
        .write_block(block_id2, data2.clone())
        .await
        .expect("write block2");
    storage1
        .write_block(block_id3, data3.clone())
        .await
        .expect("write block3");

    let initial_marker = storage1.get_commit_marker();
    web_sys::console::log_1(&format!("Initial commit marker: {}", initial_marker).into());

    // Step 2: Simulate crash during commit - blocks get written to IndexedDB but commit marker doesn't advance
    // This is the critical test: we need to simulate the scenario where IndexedDB transaction
    // partially completes (blocks stored) but the commit marker update fails due to crash

    // FIXED TODO #6: Crash simulation infrastructure is now fully implemented:
    // 1. crash_simulation_sync(blocks_written: bool) - simulates partial transaction completion
    // 2. perform_crash_recovery() - detects incomplete transactions via IndexedDB scan
    // 3. determine_recovery_action() - chooses rollback vs finalize based on transaction state
    // 4. rollback_incomplete_transaction() - rolls back uncommitted changes
    // 5. finalize_complete_transaction() - finalizes committed but unfinalized changes

    // Expected behavior validated by this test:
    // - Blocks are written to IndexedDB but commit marker doesn't advance (crash simulation)
    // - Recovery detects the inconsistency between IndexedDB state and commit marker
    // - Recovery finalizes the transaction since blocks successfully made it to persistent storage

    // Step 3: Execute crash simulation
    let crash_result = storage1.crash_simulation_sync(true).await;
    match crash_result {
        Ok(_) => {
            // Crash simulation succeeded - blocks written but marker not advanced
            let post_crash_marker = storage1.get_commit_marker();
            web_sys::console::log_1(&format!("Post-crash marker: {}", post_crash_marker).into());

            // Marker should not have advanced due to simulated crash
            assert_eq!(
                post_crash_marker, initial_marker,
                "Commit marker should not advance during crash"
            );
        }
        Err(e) => {
            // Expected to fail initially - crash simulation not implemented
            web_sys::console::log_1(
                &format!(
                    "Expected failure: crash simulation not implemented: {:?}",
                    e
                )
                .into(),
            );
            // Don't panic immediately - let's see what happens
            return;
        }
    }

    // Step 4: Create new instance - should trigger recovery
    let mut storage2 = BlockStorage::new(db_name)
        .await
        .expect("create storage2 for recovery");

    // This will also FAIL initially because recovery logic needs to be enhanced
    let recovery_result = storage2.perform_crash_recovery().await;
    match recovery_result {
        Ok(recovery_action) => {
            web_sys::console::log_1(&format!("Recovery completed: {:?}", recovery_action).into());

            // After recovery, system should be in consistent state
            let recovered_marker = storage2.get_commit_marker();
            web_sys::console::log_1(
                &format!("Recovered commit marker: {}", recovered_marker).into(),
            );

            // Recovery should finalize the transaction since blocks were successfully written to IndexedDB
            // This is the correct behavior: if blocks made it to persistent storage, we finalize
            assert!(
                recovered_marker > initial_marker,
                "Recovery should finalize transaction when blocks are in IndexedDB"
            );

            // Blocks should be visible after finalization
            let read_result1 = storage2.read_block_sync(block_id1);
            let read_result2 = storage2.read_block_sync(block_id2);
            let read_result3 = storage2.read_block_sync(block_id3);

            // Should return the written data after finalization
            assert_eq!(
                read_result1.unwrap(),
                data1,
                "Block1 should contain written data after finalization"
            );
            assert_eq!(
                read_result2.unwrap(),
                data2,
                "Block2 should contain written data after finalization"
            );
            assert_eq!(
                read_result3.unwrap(),
                data3,
                "Block3 should contain written data after finalization"
            );
        }
        Err(e) => {
            // Expected to fail initially - recovery logic not implemented
            web_sys::console::log_1(
                &format!("Expected failure: crash recovery not implemented: {:?}", e).into(),
            );
            // Don't panic immediately - let's see what happens
        }
    }
}

/// Test crash simulation with partial block writes
/// Simulates crash where only some blocks are written to IndexedDB
#[wasm_bindgen_test]
async fn test_crash_mid_commit_partial_block_writes() {
    let db_name = "crash_partial_blocks_test";

    let mut storage1 = BlockStorage::new(db_name).await.expect("create storage1");

    let block_id1 = storage1.allocate_block().await.expect("alloc block1");
    let block_id2 = storage1.allocate_block().await.expect("alloc block2");
    let block_id3 = storage1.allocate_block().await.expect("alloc block3");

    let data1 = vec![0x11u8; BLOCK_SIZE];
    let data2 = vec![0x22u8; BLOCK_SIZE];
    let data3 = vec![0x33u8; BLOCK_SIZE];

    storage1
        .write_block(block_id1, data1.clone())
        .await
        .expect("write block1");
    storage1
        .write_block(block_id2, data2.clone())
        .await
        .expect("write block2");
    storage1
        .write_block(block_id3, data3.clone())
        .await
        .expect("write block3");

    let initial_marker = storage1.get_commit_marker();

    // Simulate crash where only first 2 blocks get written to IndexedDB
    // This tests more complex recovery scenarios
    let partial_crash_result = storage1
        .crash_simulation_partial_sync(&[block_id1, block_id2])
        .await;

    match partial_crash_result {
        Ok(_) => {
            // Partial crash simulation succeeded
            web_sys::console::log_1(&"Partial crash simulation completed".into());
        }
        Err(e) => {
            // Expected to fail initially
            web_sys::console::log_1(
                &format!(
                    "Expected failure: partial crash simulation not implemented: {:?}",
                    e
                )
                .into(),
            );
            return;
        }
    }

    // Recovery should handle partial writes correctly
    let mut storage2 = BlockStorage::new(db_name).await.expect("create storage2");
    let recovery_result = storage2.perform_crash_recovery().await;

    match recovery_result {
        Ok(_) => {
            // After recovery, all blocks should be in consistent state
            // Either all visible or all rolled back
            let recovered_marker = storage2.get_commit_marker();

            if recovered_marker > initial_marker {
                // Recovery chose to finalize - all blocks should be visible
                assert_eq!(storage2.read_block_sync(block_id1).unwrap(), data1);
                assert_eq!(storage2.read_block_sync(block_id2).unwrap(), data2);
                assert_eq!(storage2.read_block_sync(block_id3).unwrap(), data3);
            } else {
                // Recovery chose to rollback - all blocks should be zeroed
                assert_eq!(
                    storage2.read_block_sync(block_id1).unwrap(),
                    vec![0u8; BLOCK_SIZE]
                );
                assert_eq!(
                    storage2.read_block_sync(block_id2).unwrap(),
                    vec![0u8; BLOCK_SIZE]
                );
                assert_eq!(
                    storage2.read_block_sync(block_id3).unwrap(),
                    vec![0u8; BLOCK_SIZE]
                );
            }
        }
        Err(e) => {
            // Expected to fail initially
            web_sys::console::log_1(
                &format!("Expected failure: crash recovery not implemented: {:?}", e).into(),
            );
            return;
        }
    }
}

/// Test recovery correctness across multiple crash scenarios
#[wasm_bindgen_test]
async fn test_recovery_correctness_multiple_crashes() {
    let db_name = "recovery_correctness_test";

    // Test multiple crash and recovery cycles
    for crash_iteration in 1..=3 {
        web_sys::console::log_1(&format!("Crash iteration: {}", crash_iteration).into());

        let mut storage = BlockStorage::new(&format!("{}_{}", db_name, crash_iteration))
            .await
            .expect("create storage");

        // Write some data
        let block_id = storage.allocate_block().await.expect("alloc block");
        let data = vec![crash_iteration as u8; BLOCK_SIZE];
        storage
            .write_block(block_id, data.clone())
            .await
            .expect("write block");

        // Simulate different crash scenarios
        let crash_result = match crash_iteration {
            1 => storage.crash_simulation_sync(true).await, // Full crash after blocks written
            2 => storage.crash_simulation_sync(false).await, // Crash before blocks written
            3 => storage.crash_simulation_partial_sync(&[block_id]).await, // Partial crash
            _ => unreachable!(),
        };

        match crash_result {
            Ok(_) => {
                web_sys::console::log_1(
                    &format!("Crash simulation {} succeeded", crash_iteration).into(),
                );
            }
            Err(e) => {
                web_sys::console::log_1(
                    &format!("Expected failure in iteration {}: {:?}", crash_iteration, e).into(),
                );
                // Continue to next iteration - this is expected to fail initially
                continue;
            }
        }

        // Test recovery
        let mut recovery_storage = BlockStorage::new(&format!("{}_{}", db_name, crash_iteration))
            .await
            .expect("create recovery storage");
        let recovery_result = recovery_storage.perform_crash_recovery().await;

        match recovery_result {
            Ok(_) => {
                web_sys::console::log_1(&format!("Recovery {} succeeded", crash_iteration).into());

                // Verify system is in consistent state
                let marker = recovery_storage.get_commit_marker();
                web_sys::console::log_1(
                    &format!("Final marker for iteration {}: {}", crash_iteration, marker).into(),
                );
            }
            Err(e) => {
                web_sys::console::log_1(
                    &format!(
                        "Expected recovery failure in iteration {}: {:?}",
                        crash_iteration, e
                    )
                    .into(),
                );
            }
        }
    }

    // This test establishes the contract for crash recovery correctness
    // Initially it will fail, but it defines the expected behavior
    web_sys::console::log_1(
        &"Recovery correctness test not fully implemented yet - expected to fail initially".into(),
    );
}

/// Test concurrent crash scenarios
/// Simulates crashes when multiple instances are accessing the same database
#[wasm_bindgen_test]
async fn test_concurrent_crash_scenarios() {
    let db_name = "concurrent_crash_test";

    // Create multiple storage instances
    let mut storage1 = BlockStorage::new(db_name).await.expect("create storage1");
    let mut storage2 = BlockStorage::new(db_name).await.expect("create storage2");

    // Both instances write data
    let block_id1 = storage1.allocate_block().await.expect("alloc block1");
    let block_id2 = storage2.allocate_block().await.expect("alloc block2");

    let data1 = vec![0xF1u8; BLOCK_SIZE];
    let data2 = vec![0xF2u8; BLOCK_SIZE];

    storage1
        .write_block(block_id1, data1.clone())
        .await
        .expect("write block1");
    storage2
        .write_block(block_id2, data2.clone())
        .await
        .expect("write block2");

    // Simulate crash in one instance during sync
    let crash_result = storage1.crash_simulation_sync(true).await;

    match crash_result {
        Ok(_) => {
            web_sys::console::log_1(&"Concurrent crash simulation succeeded".into());

            // Other instance should detect the crash and handle recovery
            let recovery_result = storage2.perform_crash_recovery().await;

            match recovery_result {
                Ok(_) => {
                    web_sys::console::log_1(&"Concurrent recovery succeeded".into());

                    // System should be in consistent state
                    let marker1 = storage1.get_commit_marker();
                    let marker2 = storage2.get_commit_marker();

                    // Both instances should see same commit marker after recovery
                    assert_eq!(
                        marker1, marker2,
                        "Commit markers should be synchronized after recovery"
                    );
                }
                Err(e) => {
                    web_sys::console::log_1(
                        &format!("Expected concurrent recovery failure: {:?}", e).into(),
                    );
                    return;
                }
            }
        }
        Err(e) => {
            web_sys::console::log_1(&format!("Expected concurrent crash failure: {:?}", e).into());
            return;
        }
    }
}