Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

53.0 KB
Raw Blame
use std::{
    cmp::Ordering as CmpOrdering,
    fs,
    path::PathBuf,
    sync::atomic::{AtomicU64, Ordering},
    time::{SystemTime, UNIX_EPOCH},
};

use crate::{
    persistence::{origin_file_stem, origin_path},
    transaction::{MAX_AUTO_INCREMENT_KEY, transaction_store_mut},
    *,
};

mod schema_validation;

struct TestDir {
    path: PathBuf,
}

#[test]
fn cursor_direction_labels_and_flags_follow_spec_tokens() {
    let cases = [
        ("next", CursorDirection::Next, false, false),
        ("nextunique", CursorDirection::NextUnique, false, true),
        ("prev", CursorDirection::Prev, true, false),
        ("prevunique", CursorDirection::PrevUnique, true, true),
    ];

    for (label, direction, reverse, unique) in cases {
        assert_eq!(CursorDirection::parse(label), Some(direction));
        assert_eq!(direction.as_str(), label);
        assert_eq!(direction.is_reverse(), reverse);
        assert_eq!(direction.is_unique(), unique);
    }
    assert_eq!(CursorDirection::parse("forward"), None);
    assert_eq!(CursorDirection::default_next(), CursorDirection::Next);
}

#[test]
fn cursor_direction_helpers_reverse_and_deduplicate_by_key() {
    let entries = vec![
        (Key::from("a"), 1),
        (Key::from("a"), 2),
        (Key::from("b"), 3),
    ];

    assert_eq!(
        apply_collection_direction(entries.clone(), CursorDirection::Prev),
        vec![
            (Key::from("b"), 3),
            (Key::from("a"), 2),
            (Key::from("a"), 1),
        ]
    );

    assert_eq!(
        apply_cursor_direction_by_key(entries.clone(), CursorDirection::NextUnique, |entry| {
            &entry.0
        }),
        vec![(Key::from("a"), 1), (Key::from("b"), 3)]
    );
    assert_eq!(
        apply_cursor_direction_by_key(entries, CursorDirection::PrevUnique, |entry| &entry.0),
        vec![(Key::from("b"), 3), (Key::from("a"), 1)]
    );
}

#[test]
fn cursor_direction_comparisons_respect_reverse_order() {
    assert_eq!(
        compare_cursor_direction(CursorDirection::Next, &Key::from(2), &Key::from(1)),
        CmpOrdering::Greater
    );
    assert_eq!(
        compare_cursor_direction(CursorDirection::Prev, &Key::from(2), &Key::from(1)),
        CmpOrdering::Less
    );
    assert_eq!(
        compare_cursor_tuple_direction(
            CursorDirection::Next,
            &Key::from(2),
            &Key::from(1),
            &Key::from(2),
            &Key::from(0),
        ),
        CmpOrdering::Greater
    );
    assert_eq!(
        compare_cursor_tuple_direction(
            CursorDirection::Prev,
            &Key::from(2),
            &Key::from(1),
            &Key::from(2),
            &Key::from(0),
        ),
        CmpOrdering::Less
    );
}

impl TestDir {
    fn new() -> Self {
        static NEXT_ID: AtomicU64 = AtomicU64::new(1);
        let unique = NEXT_ID.fetch_add(1, Ordering::Relaxed);
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("system time should be after epoch")
            .as_nanos();
        let path = std::env::temp_dir().join(format!(
            "moli-indexeddb-test-{}-{}-{nanos}",
            std::process::id(),
            unique
        ));
        fs::create_dir(&path).expect("test dir should be created");
        Self { path }
    }
}

impl Drop for TestDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.path);
    }
}

fn seed_database_record(manager: &mut IndexedDbManager, origin: &str, name: &str) {
    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: name.to_owned(),
            version: None,
        })
        .expect("open should succeed");
    if let Some(upgrade) = opened.upgrade_transaction {
        manager
            .create_object_store(upgrade, "items", ObjectStoreOptions::default())
            .expect("store should be created");
        manager
            .commit_transaction(upgrade)
            .expect("upgrade commit should succeed");
    }
    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"record".to_vec())
        .expect("put should succeed");
    manager
        .commit_transaction(tx)
        .expect("record transaction should commit");
    manager
        .close_database(opened.database)
        .expect("database should close");
}

#[test]
fn open_new_database_creates_upgrade_transaction() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");

    assert_eq!(
        opened.disposition,
        OpenDisposition::UpgradeNeeded {
            old_version: 0,
            new_version: 1
        }
    );
    assert!(opened.upgrade_transaction.is_some());
}

#[test]
fn in_memory_manager_does_not_persist_across_reopen() {
    let mut manager = IndexedDbManager::new_in_memory();

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(1),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(
            upgrade,
            "items",
            ObjectStoreOptions {
                key_path: None,
                auto_increment: false,
            },
        )
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let reopened = IndexedDbManager::new_in_memory()
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("reopen should succeed");

    assert_eq!(
        reopened.disposition,
        OpenDisposition::UpgradeNeeded {
            old_version: 0,
            new_version: 1
        }
    );
    assert!(reopened.upgrade_transaction.is_some());
}

#[test]
fn transaction_mode_uses_indexeddb_labels() {
    use std::str::FromStr;

    assert_eq!(
        TransactionMode::from_str("readonly"),
        Ok(TransactionMode::ReadOnly)
    );
    assert_eq!(
        TransactionMode::from_str("readwrite"),
        Ok(TransactionMode::ReadWrite)
    );
    assert_eq!(
        TransactionMode::from_str("versionchange"),
        Ok(TransactionMode::VersionChange)
    );
    let readonly: &'static str = TransactionMode::ReadOnly.into();
    let readwrite: &'static str = TransactionMode::ReadWrite.into();
    let versionchange: &'static str = TransactionMode::VersionChange.into();
    assert_eq!(readonly, "readonly");
    assert_eq!(readwrite, "readwrite");
    assert_eq!(versionchange, "versionchange");
    assert!(TransactionMode::from_str("read-write").is_err());
}

#[test]
fn upgrade_transaction_can_create_store_and_persist() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(3),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");

    manager
        .create_object_store(
            upgrade,
            "items",
            ObjectStoreOptions {
                key_path: None,
                auto_increment: true,
            },
        )
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let reopened = IndexedDbManager::new(&dir.path)
        .expect("manager should be recreated")
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("reopen should succeed");

    assert_eq!(reopened.disposition, OpenDisposition::Existing);
    assert!(reopened.upgrade_transaction.is_none());
}

#[test]
fn upgrade_transaction_can_persist_index_metadata() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(1),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    let index = manager
        .create_index(
            upgrade,
            "items",
            "by-id",
            IndexOptions {
                key_path: KeyPath::from("id"),
                unique: true,
                multi_entry: false,
            },
        )
        .expect("index should be created");

    assert_eq!(
        index,
        IndexInfo {
            name: "by-id".to_owned(),
            key_path: KeyPath::from("id"),
            unique: true,
            multi_entry: false,
        }
    );

    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let store_info = manager
        .object_store_info(opened.database, "items")
        .expect("store info should exist");
    assert_eq!(store_info.index_names, vec!["by-id".to_owned()]);

    let index_info = manager
        .index_info(opened.database, "items", "by-id")
        .expect("index info should exist");
    assert_eq!(index_info, index);

    manager
        .close_database(opened.database)
        .expect("database should close");

    let mut reopened_manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let reopened = reopened_manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("reopen should succeed");

    let store_info = reopened_manager
        .object_store_info(reopened.database, "items")
        .expect("store info should still exist");
    assert_eq!(store_info.index_names, vec!["by-id".to_owned()]);
}

#[test]
fn index_key_path_may_be_empty_string() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(1),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    let index = manager
        .create_index(
            upgrade,
            "items",
            "by-value",
            IndexOptions {
                key_path: KeyPath::from(""),
                unique: false,
                multi_entry: false,
            },
        )
        .expect("empty string index keyPath should be allowed");

    assert_eq!(index.key_path, KeyPath::from(""));
}

#[test]
fn readwrite_transaction_can_store_and_reload_records() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect("put should succeed");
    manager
        .commit_transaction(tx)
        .expect("transaction should commit");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let reopened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("reopen should succeed");
    let tx = manager
        .begin_transaction(
            reopened.database,
            &[String::from("items")],
            TransactionMode::ReadOnly,
        )
        .expect("readonly transaction should start");
    let value = manager
        .get(tx, "items", &Key::from("alpha"))
        .expect("get should succeed");
    assert_eq!(value, RequestOutcome::Value(Some(b"one".to_vec().into())));
}

#[test]
fn external_blob_file_and_file_system_handle_objects_persist_with_their_record() {
    let dir = TestDir::new();
    let origin = "https://external-objects.example";
    let stored_value = IndexedDbValue::new(
        vec![0xFF, 0x0F],
        vec![
            IndexedDbExternalObject::Blob {
                bytes: b"blob bytes".to_vec(),
                mime_type: "text/plain".to_owned(),
            },
            IndexedDbExternalObject::File {
                bytes: b"file bytes".to_vec(),
                mime_type: "text/custom".to_owned(),
                name: "note.txt".to_owned(),
                last_modified: 123.0,
            },
            IndexedDbExternalObject::FileSystemHandle {
                kind: crate::IndexedDbFileSystemHandleKind::File,
                bucket: crate::IndexedDbFileSystemHandleBucket::Named { bucket_id: 42 },
                path: vec!["directory".to_owned(), "note.txt".to_owned()],
            },
        ],
    );
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");
    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade should commit");
    let write = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("write transaction should start");
    manager
        .put(
            write,
            "items",
            Some(Key::from("external")),
            stored_value.clone(),
        )
        .expect("external value should be stored");
    manager
        .commit_transaction(write)
        .expect("write transaction should commit");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let reopened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("database should reopen");
    let read = manager
        .begin_transaction(
            reopened.database,
            &[String::from("items")],
            TransactionMode::ReadOnly,
        )
        .expect("read transaction should start");
    assert_eq!(
        manager
            .get(read, "items", &Key::from("external"))
            .expect("stored external value should be readable"),
        RequestOutcome::Value(Some(stored_value))
    );
}

#[test]
fn write_quota_rejection_rolls_back_working_copy() {
    let mut manager = IndexedDbManager::new_in_memory();
    let origin = "https://quota.example";
    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect("initial put should succeed");
    manager
        .commit_transaction(tx)
        .expect("initial transaction should commit");
    let before = manager
        .origin_usage_bytes(origin)
        .expect("usage should be readable");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    let error = manager
        .put_with_quota(
            tx,
            "items",
            Some(Key::from("alpha")),
            vec![b'x'; 4096],
            IndexedDbQuotaCheck {
                quota: before + 10,
                non_indexed_db_usage: 0,
            },
        )
        .expect_err("oversized replacement should exceed quota");
    assert!(matches!(error, IndexedDbError::QuotaExceeded { .. }));
    let value = manager
        .get(tx, "items", &Key::from("alpha"))
        .expect("get should succeed after quota rejection");
    assert_eq!(value, RequestOutcome::Value(Some(b"one".to_vec().into())));
    manager
        .commit_transaction(tx)
        .expect("rollback-preserved transaction should commit");
    assert_eq!(
        manager
            .origin_usage_bytes(origin)
            .expect("usage should be readable"),
        before
    );
}

#[test]
fn external_blob_bytes_participate_in_quota_and_rollback() {
    let mut manager = IndexedDbManager::new_in_memory();
    let origin = "https://external-quota.example";
    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade should commit");
    let before = manager
        .origin_usage_bytes(origin)
        .expect("usage should be readable");

    let write = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("write transaction should start");
    let value = IndexedDbValue::new(
        vec![1],
        vec![IndexedDbExternalObject::Blob {
            bytes: vec![b'x'; 4096],
            mime_type: "application/octet-stream".to_owned(),
        }],
    );
    let error = manager
        .put_with_quota(
            write,
            "items",
            Some(Key::from("blob")),
            value,
            IndexedDbQuotaCheck {
                quota: before + 100,
                non_indexed_db_usage: 0,
            },
        )
        .expect_err("external Blob bytes should exceed quota");
    assert!(matches!(error, IndexedDbError::QuotaExceeded { .. }));
    assert_eq!(
        manager
            .get(write, "items", &Key::from("blob"))
            .expect("quota rollback should leave the record absent"),
        RequestOutcome::Value(None)
    );
}

#[test]
fn transaction_commit_rechecks_aggregate_quota_without_publishing_working_copy() {
    let mut manager = IndexedDbManager::new_in_memory();
    let origin = "https://commit-quota.example";
    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade should commit");
    let committed_before = manager
        .origin_usage_bytes(origin)
        .expect("usage should be readable");

    let write = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("write transaction should start");
    manager
        .put(write, "items", Some(Key::from("large")), vec![b'x'; 4096])
        .expect("working-copy write should succeed before commit gate");
    let error = manager
        .commit_transaction_with_quota(
            write,
            IndexedDbQuotaCheck {
                quota: committed_before + 64,
                non_indexed_db_usage: 0,
            },
        )
        .expect_err("commit should reject the oversized working copy");
    assert!(matches!(error, IndexedDbError::QuotaExceeded { .. }));
    assert_eq!(
        manager
            .origin_usage_bytes(origin)
            .expect("committed usage should remain readable"),
        committed_before
    );

    let read = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadOnly,
        )
        .expect("read transaction should start");
    assert_eq!(
        manager
            .get(read, "items", &Key::from("large"))
            .expect("read should succeed"),
        RequestOutcome::Value(None)
    );
}

#[test]
fn origin_usage_tracks_committed_metadata_and_record_bytes() {
    let mut manager = IndexedDbManager::new_in_memory();
    let origin = "https://usage.example";

    assert_eq!(
        manager
            .origin_usage_bytes(origin)
            .expect("initial usage should be readable"),
        0
    );

    let opened = manager
        .open(OpenOptions {
            origin: origin.to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");
    let metadata_usage = manager
        .origin_usage_bytes(origin)
        .expect("metadata usage should be readable");
    assert!(
        metadata_usage > 0,
        "an empty committed object store should contribute metadata usage"
    );

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"first".to_vec())
        .expect("put should succeed");
    assert_eq!(
        manager
            .origin_usage_bytes(origin)
            .expect("uncommitted usage should be readable"),
        metadata_usage,
        "usage should only expose committed data"
    );
    manager
        .commit_transaction(tx)
        .expect("transaction should commit");
    let first_record_usage = manager
        .origin_usage_bytes(origin)
        .expect("committed usage should be readable");
    assert!(first_record_usage > metadata_usage);

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("replace transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"xx".to_vec())
        .expect("replace should succeed");
    manager
        .commit_transaction(tx)
        .expect("replace transaction should commit");
    let replacement_usage = manager
        .origin_usage_bytes(origin)
        .expect("replacement usage should be readable");
    assert!(replacement_usage > metadata_usage);
    assert!(replacement_usage < first_record_usage);
    assert_eq!(
        manager
            .origin_usage_bytes("https://other.example")
            .expect("other origin usage should be readable"),
        0
    );
}

#[test]
fn origin_prefix_usage_sums_matching_storage_key_owners() {
    let dir = TestDir::new();
    let prefix = "storage-key:v1;origin=https://usage.example;top-level-site=";
    let first_party = format!("{prefix}https://usage.example");
    let partitioned = format!("{prefix}https://top.example");
    let sibling =
        "storage-key:v1;origin=https://sibling.example;top-level-site=https://usage.example";

    {
        let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");
        seed_database_record(&mut manager, &first_party, "first-party");
        seed_database_record(&mut manager, &partitioned, "partitioned");
        seed_database_record(&mut manager, sibling, "sibling");
    }

    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let total = manager
        .origins_with_prefix_usage_bytes(prefix)
        .expect("prefix usage should be readable");
    let sibling_usage = manager
        .origin_usage_bytes(sibling)
        .expect("sibling usage should be readable");

    assert!(total > 0);
    assert!(sibling_usage > 0);
    assert_eq!(
        manager
            .origins_with_prefix_usage_bytes(
                "storage-key:v1;origin=https://missing.example;top-level-site="
            )
            .expect("missing prefix usage should be readable"),
        0
    );
}

#[test]
fn clear_origins_with_prefix_removes_only_matching_storage_key_owners() {
    let dir = TestDir::new();
    let prefix = "storage-key:v1;origin=https://clear.example;top-level-site=";
    let first_party = format!("{prefix}https://clear.example");
    let partitioned = format!("{prefix}https://top.example");
    let sibling =
        "storage-key:v1;origin=https://sibling.example;top-level-site=https://clear.example";

    {
        let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");
        seed_database_record(&mut manager, &first_party, "first-party");
        seed_database_record(&mut manager, &partitioned, "partitioned");
        seed_database_record(&mut manager, sibling, "sibling");
    }

    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    manager
        .clear_origins_with_prefix(prefix)
        .expect("prefix clear should succeed");

    assert_eq!(
        manager
            .origin_usage_bytes(&first_party)
            .expect("first-party usage should be readable"),
        0
    );
    assert_eq!(
        manager
            .origin_usage_bytes(&partitioned)
            .expect("partitioned usage should be readable"),
        0
    );
    assert!(
        manager
            .origin_usage_bytes(sibling)
            .expect("sibling usage should be readable")
            > 0
    );
}

#[test]
fn clear_origins_with_prefix_removes_hash_named_storage_key_owners() {
    let dir = TestDir::new();
    let prefix = "storage-key:v1;origin=https://clear-long.example;top-level-site=";
    let first_party = format!("{prefix}https://{}", "a".repeat(120));
    let partitioned = format!("{prefix}https://{}", "b".repeat(120));
    let sibling = format!(
        "storage-key:v1;origin=https://sibling.example;top-level-site=https://{}",
        "c".repeat(120)
    );

    assert!(origin_file_stem(&first_party).starts_with("h-"));
    assert!(origin_file_stem(&partitioned).starts_with("h-"));
    assert!(origin_file_stem(&sibling).starts_with("h-"));

    {
        let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");
        seed_database_record(&mut manager, &first_party, "first-party");
        seed_database_record(&mut manager, &partitioned, "partitioned");
        seed_database_record(&mut manager, &sibling, "sibling");
    }

    assert!(origin_path(&dir.path, &first_party).exists());
    assert!(origin_path(&dir.path, &partitioned).exists());
    assert!(origin_path(&dir.path, &sibling).exists());

    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    manager
        .clear_origins_with_prefix(prefix)
        .expect("prefix clear should succeed");

    assert!(!origin_path(&dir.path, &first_party).exists());
    assert!(!origin_path(&dir.path, &partitioned).exists());
    assert!(origin_path(&dir.path, &sibling).exists());
    assert!(
        manager
            .origin_usage_bytes(&sibling)
            .expect("sibling usage should be readable")
            > 0
    );
}

#[test]
fn migrate_origin_preserves_data_across_restart_and_is_replay_safe() {
    let dir = TestDir::new();
    let source = "bucket:v1:legacy-name-key";
    let destination = "bucket:v2:persistent-id-key:17";
    let expected_usage = {
        let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");
        seed_database_record(&mut manager, source, "app");
        let expected = manager
            .origin_usage_bytes(source)
            .expect("source usage should load");
        manager
            .migrate_origin(source, destination)
            .expect("owner migration should succeed");
        assert_eq!(
            manager
                .origin_usage_bytes(source)
                .expect("migrated source should be empty"),
            0
        );
        assert_eq!(
            manager
                .origin_usage_bytes(destination)
                .expect("destination usage should load"),
            expected
        );
        manager
            .migrate_origin(source, destination)
            .expect("replaying a completed migration should be harmless");
        expected
    };

    let mut reopened = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    assert_eq!(
        reopened
            .origin_usage_bytes(source)
            .expect("source usage should load after restart"),
        0
    );
    assert_eq!(
        reopened
            .origin_usage_bytes(destination)
            .expect("destination usage should load after restart"),
        expected_usage
    );
}

#[test]
fn readwrite_transaction_can_list_keys() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("beta")), b"two".to_vec())
        .expect("put should succeed");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect("put should succeed");

    let keys = manager
        .get_all_keys(tx, "items")
        .expect("get_all_keys should succeed");
    assert_eq!(
        keys,
        RequestOutcome::Keys(vec![Key::from("alpha"), Key::from("beta")])
    );
}

#[test]
fn mixed_keys_sort_in_indexeddb_order() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::Integer(10)), b"ten".to_vec())
        .expect("integer put should succeed");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect("string put should succeed");
    manager
        .put(tx, "items", Some(Key::Integer(2)), b"two".to_vec())
        .expect("integer put should succeed");

    let keys = manager
        .get_all_keys(tx, "items")
        .expect("get_all_keys should succeed");
    assert_eq!(
        keys,
        RequestOutcome::Keys(vec![Key::Integer(2), Key::Integer(10), Key::from("alpha"),])
    );
}

#[test]
fn aborted_transaction_does_not_persist_changes() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect("put should succeed");
    manager.abort_transaction(tx).expect("abort should succeed");

    let check = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadOnly,
        )
        .expect("readonly transaction should start");
    let value = manager
        .get(check, "items", &Key::from("alpha"))
        .expect("get should succeed");
    assert_eq!(value, RequestOutcome::Value(None));
}

#[test]
fn delete_database_removes_persisted_state() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");
    manager
        .close_database(opened.database)
        .expect("database should close");
    manager
        .delete_database("https://example.com", "app")
        .expect("delete should succeed");

    let reopened = IndexedDbManager::new(&dir.path)
        .expect("manager should reopen")
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");

    assert_eq!(
        reopened.disposition,
        OpenDisposition::UpgradeNeeded {
            old_version: 0,
            new_version: 1
        }
    );
}

#[test]
fn databases_lists_committed_name_version_snapshot() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let beta = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "beta".to_owned(),
            version: Some(2),
        })
        .expect("beta open should succeed");
    manager
        .commit_transaction(beta.upgrade_transaction.expect("beta upgrade tx"))
        .expect("beta upgrade commit should succeed");
    let alpha = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "alpha".to_owned(),
            version: None,
        })
        .expect("alpha open should succeed");
    manager
        .commit_transaction(alpha.upgrade_transaction.expect("alpha upgrade tx"))
        .expect("alpha upgrade commit should succeed");

    let infos = manager
        .databases("https://example.com")
        .expect("database list should be readable");
    assert_eq!(
        infos,
        vec![
            DatabaseNameAndVersion {
                name: "alpha".to_owned(),
                version: 1,
            },
            DatabaseNameAndVersion {
                name: "beta".to_owned(),
                version: 2,
            },
        ]
    );

    let mut reopened = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let infos = reopened
        .databases("https://example.com")
        .expect("persisted database list should be readable");
    assert_eq!(
        infos
            .into_iter()
            .map(|info| format!("{}:{}", info.name, info.version))
            .collect::<Vec<_>>(),
        vec!["alpha:1", "beta:2"]
    );
}

#[test]
fn clear_origin_removes_persisted_state_and_keeps_other_origins() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let first = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("first open should succeed");
    let first_upgrade = first
        .upgrade_transaction
        .expect("first upgrade transaction should exist");
    manager
        .create_object_store(first_upgrade, "items", ObjectStoreOptions::default())
        .expect("first store should be created");
    manager
        .commit_transaction(first_upgrade)
        .expect("first upgrade commit should succeed");

    let second = manager
        .open(OpenOptions {
            origin: "https://other.example".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("second open should succeed");
    let second_upgrade = second
        .upgrade_transaction
        .expect("second upgrade transaction should exist");
    manager
        .create_object_store(second_upgrade, "items", ObjectStoreOptions::default())
        .expect("second store should be created");
    manager
        .commit_transaction(second_upgrade)
        .expect("second upgrade commit should succeed");

    manager
        .clear_origin("https://example.com")
        .expect("origin clear should succeed");

    let mut reopened = IndexedDbManager::new(&dir.path).expect("manager should reopen from disk");
    let cleared = reopened
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("cleared origin open should succeed");
    assert_eq!(
        cleared.disposition,
        OpenDisposition::UpgradeNeeded {
            old_version: 0,
            new_version: 1
        }
    );

    let kept = reopened
        .open(OpenOptions {
            origin: "https://other.example".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("other origin open should succeed");
    assert_eq!(kept.disposition, OpenDisposition::Existing);
}

#[test]
fn readonly_transaction_rejects_writes() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadOnly,
        )
        .expect("readonly transaction should start");

    let error = manager
        .put(tx, "items", Some(Key::from("alpha")), b"one".to_vec())
        .expect_err("readonly put should fail");
    assert!(matches!(error, IndexedDbError::ReadOnly(_)));
}

#[test]
fn transaction_scope_is_enforced_per_object_store() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("items store should be created");
    manager
        .create_object_store(upgrade, "other", ObjectStoreOptions::default())
        .expect("other store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");

    let error = manager
        .put(tx, "other", Some(Key::from("alpha")), b"one".to_vec())
        .expect_err("out-of-scope store write should fail");
    assert!(matches!(error, IndexedDbError::InvalidState(_)));
}

#[test]
fn delete_database_rejects_open_connections() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let error = manager
        .delete_database("https://example.com", "app")
        .expect_err("delete should fail while handle remains open");
    assert!(matches!(error, IndexedDbError::InvalidState(_)));
}

#[test]
fn aborted_upgrade_transaction_does_not_publish_schema() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(2),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .abort_transaction(upgrade)
        .expect("abort should succeed");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let reopened = IndexedDbManager::new(&dir.path)
        .expect("manager should reopen")
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("reopen should succeed");

    assert_eq!(
        reopened.disposition,
        OpenDisposition::UpgradeNeeded {
            old_version: 0,
            new_version: 1
        }
    );
}

#[test]
fn upgrade_can_delete_object_store_before_commit() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .create_object_store(upgrade, "temp", ObjectStoreOptions::default())
        .expect("temp store should be created");
    manager
        .delete_object_store(upgrade, "temp")
        .expect("temp store should be deleted");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let info = manager
        .database_info(opened.database)
        .expect("database info should be readable");
    assert_eq!(info.object_store_names, vec!["items".to_owned()]);

    let error = manager
        .object_store_info(opened.database, "temp")
        .expect_err("deleted store should be absent");
    assert!(matches!(error, IndexedDbError::NotFound(_)));
}

#[test]
fn distinct_origins_persist_to_distinct_storage_files() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let first = manager
        .open(OpenOptions {
            origin: "https://a:b".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("first open should succeed");
    let first_upgrade = first
        .upgrade_transaction
        .expect("first upgrade transaction should exist");
    manager
        .create_object_store(first_upgrade, "alpha", ObjectStoreOptions::default())
        .expect("alpha store should be created");
    manager
        .commit_transaction(first_upgrade)
        .expect("first commit should succeed");
    manager
        .close_database(first.database)
        .expect("first database should close");

    let second = manager
        .open(OpenOptions {
            origin: "https://a/b".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("second open should succeed");
    let second_upgrade = second
        .upgrade_transaction
        .expect("second upgrade transaction should exist");
    manager
        .create_object_store(second_upgrade, "beta", ObjectStoreOptions::default())
        .expect("beta store should be created");
    manager
        .commit_transaction(second_upgrade)
        .expect("second commit should succeed");
    manager
        .close_database(second.database)
        .expect("second database should close");

    let mut reopened = IndexedDbManager::new(&dir.path).expect("manager should reopen");
    let first = reopened
        .open(OpenOptions {
            origin: "https://a:b".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("first reopen should succeed");
    let second = reopened
        .open(OpenOptions {
            origin: "https://a/b".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("second reopen should succeed");

    assert_eq!(
        reopened
            .database_info(first.database)
            .expect("first info should exist")
            .object_store_names,
        vec!["alpha".to_owned()]
    );
    assert_eq!(
        reopened
            .database_info(second.database)
            .expect("second info should exist")
            .object_store_names,
        vec!["beta".to_owned()]
    );
}

#[test]
fn failed_open_does_not_block_later_delete_database() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(2),
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(upgrade, "items", ObjectStoreOptions::default())
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");
    manager
        .close_database(opened.database)
        .expect("database should close");

    let error = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: Some(1),
        })
        .expect_err("lower version open should fail");
    assert!(matches!(error, IndexedDbError::Version(_)));

    manager
        .delete_database("https://example.com", "app")
        .expect("delete should still succeed after failed open");
}

#[test]
fn auto_increment_rejects_exhausted_safe_integer_range() {
    let dir = TestDir::new();
    let mut manager = IndexedDbManager::new(&dir.path).expect("manager should be created");

    let opened = manager
        .open(OpenOptions {
            origin: "https://example.com".to_owned(),
            name: "app".to_owned(),
            version: None,
        })
        .expect("open should succeed");
    let upgrade = opened
        .upgrade_transaction
        .expect("upgrade transaction should exist");
    manager
        .create_object_store(
            upgrade,
            "items",
            ObjectStoreOptions {
                key_path: None,
                auto_increment: true,
            },
        )
        .expect("store should be created");
    manager
        .commit_transaction(upgrade)
        .expect("upgrade commit should succeed");

    let tx = manager
        .begin_transaction(
            opened.database,
            &[String::from("items")],
            TransactionMode::ReadWrite,
        )
        .expect("readwrite transaction should start");
    let store = transaction_store_mut(
        manager
            .transactions
            .get_mut(&tx)
            .expect("transaction should exist"),
        "items",
    )
    .expect("store should exist");
    store.auto_increment_counter = MAX_AUTO_INCREMENT_KEY;

    let error = manager
        .generate_key(tx, "items")
        .expect_err("generate_key should fail once the safe integer range is exhausted");
    assert!(matches!(error, IndexedDbError::Constraint(_)));
}

#[test]
fn reverse_unique_index_cursor_keeps_first_primary_key_for_each_index_key() {
    let entries = vec![
        (Key::from("a"), 1),
        (Key::from("a"), 2),
        (Key::from("b"), 3),
        (Key::from("b"), 4),
        (Key::from("c"), 5),
        (Key::from("c"), 6),
    ];
    let actual =
        apply_cursor_direction_by_key(entries, CursorDirection::PrevUnique, |entry| &entry.0);
    assert_eq!(
        actual,
        vec![
            (Key::from("c"), 5),
            (Key::from("b"), 3),
            (Key::from("a"), 1)
        ]
    );
}