Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.6 KB
Raw Blame
#![cfg(target_arch = "wasm32")]

use cache_core::engine::{Engine, ReadResult};
use cache_core::normalize::RecordUpdates;
use cache_core::queue::{
    MutationRequest, NewQueuedMutation, PersistedOptimisticLayer, StoredMutation,
};
use cache_core::store::Storage;
use cache_core::value::{CacheValue, EntityKey, Record};
use cache_turso::{HealthyTursoStorageClosed, TursoStorage, TursoStorageCloseOutcome};
use turso_opfs::{OpenResult, OpfsOwner};
use wasm_bindgen_test::*;

wasm_bindgen_test_configure!(run_in_dedicated_worker);

fn key(value: &str) -> EntityKey<'static> {
    EntityKey(value.to_owned().into())
}

fn record(value: &str) -> Record {
    let mut record = Record::default();
    record
        .fields
        .insert("value".into(), CacheValue::String(value.into()));
    record
}

fn healthy_close(outcome: TursoStorageCloseOutcome) -> HealthyTursoStorageClosed {
    let TursoStorageCloseOutcome::Healthy(closed) = outcome else {
        panic!("healthy browser storage unexpectedly required reset")
    };
    closed
}

fn queued() -> NewQueuedMutation {
    NewQueuedMutation {
        uuid: uuid::Uuid::new_v4(),
        mutation: StoredMutation::new(
            MutationRequest {
                query: "mutation Browser { update { id } }".into(),
                operation_name: Some("Browser".into()),
                variables_json: "{}".into(),
                identity: None,
            },
            1,
        ),
        optimistic: PersistedOptimisticLayer {
            optimistic_data_json: "{}".into(),
            normalized_updates: RecordUpdates::default(),
        },
    }
}

const ENGINE_QUERY: &str = r#"
query BrowserEngine {
  user {
    id
  }
}
"#;

fn engine_data() -> serde_json::Value {
    serde_json::json!({"user": {"id": "browser-user"}})
}

#[wasm_bindgen_test(async)]
async fn real_engine_over_opfs_consumes_storage_for_preserve_and_reset() {
    let owner = OpfsOwner::acquire("cache-turso-wp06-engine.db")
        .await
        .unwrap()
        .recovery_wipe()
        .await
        .unwrap();
    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("recovery wipe must produce a complete fresh pair")
    };
    let storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "engine-scope").unwrap();
    let mut engine = Engine::new(storage);
    engine
        .write_query(
            None,
            ENGINE_QUERY,
            Some("BrowserEngine"),
            &serde_json::Map::new(),
            &engine_data(),
            None,
        )
        .await
        .unwrap();
    let owner = healthy_close(engine.into_storage().try_close().unwrap())
        .preserve()
        .unwrap();

    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("preserved engine database must reopen")
    };
    let storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "engine-scope").unwrap();
    let mut engine = Engine::new(storage);
    let ReadResult::Hit { data } = engine
        .read_query(
            None,
            ENGINE_QUERY,
            Some("BrowserEngine"),
            &serde_json::Map::new(),
        )
        .await
        .unwrap()
    else {
        panic!("reopened OPFS engine must read its durable record")
    };
    assert_eq!(data, engine_data());
    let owner = healthy_close(engine.into_storage().try_close().unwrap())
        .reset()
        .await
        .unwrap();

    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("reset engine database must reopen fresh")
    };
    let storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "engine-scope").unwrap();
    let mut replacement = Engine::new(storage);
    assert!(matches!(
        replacement
            .read_query(
                None,
                ENGINE_QUERY,
                Some("BrowserEngine"),
                &serde_json::Map::new(),
            )
            .await
            .unwrap(),
        ReadResult::Miss
    ));
    healthy_close(replacement.into_storage().try_close().unwrap())
        .preserve()
        .unwrap()
        .release()
        .await
        .unwrap();
}

#[wasm_bindgen_test(async)]
async fn incompatible_opfs_initialization_exposes_reset_only_and_cannot_preserve() {
    let owner = OpfsOwner::acquire("cache-turso-wp06-browser.db")
        .await
        .unwrap()
        .recovery_wipe()
        .await
        .unwrap();
    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("recovery wipe must produce a complete fresh pair")
    };
    let mut storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "browser-scope").unwrap();
    storage
        .put_batch(vec![
            (key("ROOT_QUERY"), record("root")),
            (key("Type0:1"), record("prefix")),
            (key("Type:9"), record("ordinary")),
        ])
        .await
        .unwrap();
    let mutation_id = storage.enqueue_mutation(queued()).await.unwrap();
    let owner = healthy_close(storage.try_close().unwrap())
        .preserve()
        .unwrap();

    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("preserved complete pair must reopen")
    };
    let storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "browser-scope").unwrap();
    assert_eq!(
        storage
            .get_batch(&[key("Type0:1"), key("Type:9")])
            .await
            .unwrap(),
        [Some(record("prefix")), Some(record("ordinary"))]
    );
    assert_eq!(
        storage.load_mutation_queue().await.unwrap()[0].id,
        mutation_id
    );

    let owner = healthy_close(storage.try_close().unwrap())
        .preserve()
        .unwrap();
    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("preserved complete pair must reopen for compatibility validation")
    };
    let failure =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "wrong-browser-scope")
            .unwrap_err();
    assert!(failure.error().requires_physical_reset());
    let owner = failure.reset().await.unwrap();
    let OpenResult::Ready(session) = owner.open().await.unwrap() else {
        panic!("physical reset must recreate a complete fresh pair")
    };
    let storage =
        TursoStorage::from_opfs_session(session.connect().unwrap(), "browser-scope").unwrap();
    assert!(storage.load_mutation_queue().await.unwrap().is_empty());
    assert_eq!(
        storage.get_batch(&[key("Type:9")]).await.unwrap(),
        vec![None]
    );
    healthy_close(storage.try_close().unwrap())
        .preserve()
        .unwrap()
        .release()
        .await
        .unwrap();
}