mod tests {
    use super::*;
    use rooch_config::state_prune::SnapshotMeta;
    use rooch_store::RoochStore;
    use std::fs;
    use tempfile::TempDir;

    #[test]
    fn test_incremental_replayer_creation() {
        let config = ReplayConfig::default();
        let (moveos_store, _tmpdir) = MoveOSStore::mock_moveos_store().unwrap();
        let (rooch_store, _rooch_tmpdir) = RoochStore::mock_rooch_store().unwrap();
        let replayer = IncrementalReplayer::new(config, rooch_store, moveos_store);
        assert!(replayer.is_ok());
    }

    #[test]
    fn test_invalid_config() {
        let config = rooch_config::state_prune::ReplayConfig {
            default_batch_size: 0,
            ..Default::default()
        };

        let (moveos_store, _tmpdir) = MoveOSStore::mock_moveos_store().unwrap();
        let (rooch_store, _rooch_tmpdir) = RoochStore::mock_rooch_store().unwrap();
        let replayer = IncrementalReplayer::new(config, rooch_store, moveos_store);
        assert!(replayer.is_err());
    }

    #[test]
    fn test_load_snapshot_store_uses_snapshot_path_not_live_db() {
        // This is a regression test for issue #3900
        // It verifies that load_snapshot_store actually loads from the snapshot path,
        // not from the live MoveOSStore

        // Create a temporary directory for the snapshot
        let snapshot_dir = TempDir::new().unwrap();
        let snapshot_path = snapshot_dir.path();

        // Create a snapshot database directory
        let snapshot_db_path = snapshot_path.join("snapshot.db");
        fs::create_dir_all(&snapshot_db_path).unwrap();

        // Create a minimal snapshot metadata file
        let snapshot_meta = SnapshotMeta {
            tx_order: 100,
            state_root: H256::from([1u8; 32]),
            global_size: 1000,
            node_count: 100,
            created_at: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs(),
            version: 1,
            metadata: serde_json::json!({}),
        };
        let meta_path = snapshot_path.join("snapshot_meta.json");
        let meta_content = serde_json::to_string_pretty(&snapshot_meta).unwrap();
        fs::write(&meta_path, meta_content).unwrap();

        // Create a live store (this represents the live database)
        let (live_moveos_store, _live_tmpdir) = MoveOSStore::mock_moveos_store().unwrap();
        let (live_rooch_store, _rooch_tmpdir) = RoochStore::mock_rooch_store().unwrap();

        // Create a replayer with the live store
        let config = ReplayConfig::default();
        let replayer =
            IncrementalReplayer::new(config, live_rooch_store, live_moveos_store).unwrap();

        // Load snapshot store from the snapshot path
        let result = replayer.load_snapshot_store(snapshot_path);

        // Before the fix for issue #3900, this would succeed and return the live store
        // After the fix, it should succeed and return a store loaded from the snapshot path

        // The test passes if load_snapshot_store succeeds and loads from the snapshot path
        assert!(result.is_ok(), "load_snapshot_store should succeed");

        let snapshot_store = result.unwrap();

        // Verify that the snapshot store is different from the live store
        // (They should have different database paths)
        // We can't directly compare the paths, but we can verify the snapshot store was created
        // by checking it's a valid MoveOSStore

        // Try to access the startup info from the snapshot store
        // This will fail if the snapshot database is empty, which is expected for this test
        let startup_info_result = snapshot_store.get_config_store().get_startup_info();

        // The snapshot database is empty (we only created the directory structure),
        // so we expect no startup info, but the store should be valid
        assert!(
            startup_info_result.is_ok(),
            "Should be able to access config store"
        );
        assert!(
            startup_info_result.unwrap().is_none(),
            "New snapshot should have no startup info"
        );

        // Test that loading from a non-existent path fails
        let nonexistent_path = TempDir::new().unwrap();
        let nonexistent_snapshot_path = nonexistent_path.path().join("nonexistent");
        let result = replayer.load_snapshot_store(&nonexistent_snapshot_path);
        assert!(
            result.is_err(),
            "Should fail to load from non-existent path"
        );
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Snapshot database not found"),
            "Error should mention missing snapshot database"
        );
    }

    #[test]
    fn test_load_snapshot_store_validates_path() {
        // Test that load_snapshot_store validates the snapshot path

        let (live_moveos_store, _live_tmpdir) = MoveOSStore::mock_moveos_store().unwrap();
        let (live_rooch_store, _rooch_tmpdir) = RoochStore::mock_rooch_store().unwrap();
        let config = ReplayConfig::default();
        let replayer =
            IncrementalReplayer::new(config, live_rooch_store, live_moveos_store).unwrap();

        // Test with a file instead of a directory
        let file_as_snapshot = TempDir::new().unwrap();
        let file_path = file_as_snapshot.path().join("snapshot.db");
        fs::write(&file_path, b"not a directory").unwrap();

        let result = replayer.load_snapshot_store(file_as_snapshot.path());
        assert!(
            result.is_err(),
            "Should fail when snapshot.db is a file, not a directory"
        );
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("not a valid database"),
            "Error should mention invalid database"
        );
    }