appcore-sync-sqlite 1.0.1-rc.4

Bounded SQLite persistence provider for AppCore synchronization state.
Documentation
// =============================================================================
//        #######
//     ###       ###     F: opaque_objects.rs
//    ##   ## ##   ##    P: AppCore-Runtime
//         ## ##
//                       C: 2026/10/12 00:00:00 by dnettoRaw
//    ##   ## ##   ##    U: 2026/10/12 00:00:00 by dnettoRaw
//      ###########      S: 1.0.2-rc
// =============================================================================

//! Canonical opaque storage, transactional coupling and bounded incremental recovery.
use appcore_core::NodeId;
use appcore_sync::{ReplicationLog, SyncOutbox};
use appcore_sync_sqlite::*;
fn object(key: &str, value: &[u8]) -> OpaqueObjectV1 {
    OpaqueObjectV1 {
        installation_id: "qa".into(),
        object_key: key.into(),
        envelope: value.into(),
        metadata: b"opaque-routing-metadata".into(),
        tombstone: value.is_empty(),
    }
}
fn store(path: &std::path::Path) -> SqliteSyncStore {
    SqliteSyncStore::open(SqliteSyncConfig::new(path)).unwrap()
}
#[test]
fn object_sync_and_intent_share_one_commit_and_callback_failure_rolls_everything_back() {
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("sync.db");
    let provider = store(&path);
    let object = object("object-a", b"encrypted opaque QA");
    let message = appcore_sync::SyncMessage::new_simple(
        NodeId::new("source").unwrap(),
        1,
        vec![b"opaque event".to_vec()],
    );
    let intent = ObjectWriteIntentV1 {
        intent_id: "intent-a".into(),
        installation_id: "qa".into(),
        object_key: "object-a".into(),
        envelope: object.envelope.clone(),
    };
    let apply = |work: &mut SqliteSyncWork<'_>| {
        let result = work.put_object_v1(&object, "mutation-a", ObjectRevisionV1::Absent)?;
        work.append(b"opaque log", 1)?;
        work.enqueue(&message)?;
        work.checkpoint("source", 1, &"a".repeat(64), 1)?;
        work.stage_object_write(&intent)?;
        Ok(result)
    };
    let aborted = provider.transaction(|work| {
        apply(work)?;
        Err::<(), _>(SqliteSyncError::CapacityExceeded("QA abort"))
    });
    assert!(aborted.is_err());
    assert!(provider
        .opaque_objects_v1()
        .get("qa", "object-a")
        .unwrap()
        .is_none());
    assert_eq!(provider.opaque_objects_v1().head().unwrap().revision, 0);
    assert_eq!(provider.replication_log().len().unwrap(), 0);
    assert_eq!(provider.outbox().len().unwrap(), 0);
    assert!(provider
        .pending_object_writes("qa", 10, 1024)
        .unwrap()
        .is_empty());
    let committed = provider.transaction(apply).unwrap();
    assert_eq!(committed.revision, 1);
    drop(provider);
    let provider = store(&path);
    assert_eq!(
        provider
            .opaque_objects_v1()
            .get("qa", "object-a")
            .unwrap()
            .unwrap()
            .object,
        object
    );
    assert_eq!(provider.replication_log().len().unwrap(), 1);
    assert_eq!(provider.outbox().len().unwrap(), 1);
    assert_eq!(
        provider.pending_object_writes("qa", 10, 1024).unwrap(),
        vec![intent]
    );
    provider.health().unwrap();
}
#[test]
fn exact_replay_never_overwrites_a_later_value_and_conflicting_reuse_or_revision_fails() {
    let root = tempfile::tempdir().unwrap();
    let provider = store(&root.path().join("sync.db"));
    let first = object("a", b"one");
    let second = object("a", b"two");
    provider
        .transaction(|work| work.put_object_v1(&first, "one", ObjectRevisionV1::Absent))
        .unwrap();
    provider
        .transaction(|work| work.put_object_v1(&second, "two", ObjectRevisionV1::Exact(1)))
        .unwrap();
    let replay = provider
        .transaction(|work| work.put_object_v1(&first, "one", ObjectRevisionV1::Absent))
        .unwrap();
    assert_eq!(
        replay,
        ObjectWriteResultV1 {
            revision: 1,
            changed: false
        }
    );
    assert!(provider
        .transaction(|work| work.put_object_v1(&second, "one", ObjectRevisionV1::Exact(2)))
        .is_err());
    assert_eq!(
        provider.transaction(|work| work.put_object_v1(
            &first,
            "stale",
            ObjectRevisionV1::Exact(1)
        )),
        Err(SqliteSyncError::CorruptRecord("opaque object precondition"))
    );
    assert_eq!(
        provider
            .opaque_objects_v1()
            .get("qa", "a")
            .unwrap()
            .unwrap()
            .object,
        second
    );
    assert!(provider
        .opaque_objects_v1()
        .get("other-installation", "a")
        .unwrap()
        .is_none());
    assert_eq!(provider.opaque_objects_v1().head().unwrap().revision, 2);
}
#[test]
fn bounded_pages_resume_without_skips_deduplicate_changes_and_admit_bytes_before_reading() {
    let root = tempfile::tempdir().unwrap();
    let provider = store(&root.path().join("sync.db"));
    for index in 0..25 {
        provider
            .transaction(|work| {
                work.put_object_v1(
                    &object(&format!("key-{index:03}"), &[1; 300]),
                    &format!("put-{index}"),
                    ObjectRevisionV1::Absent,
                )
            })
            .unwrap();
    }
    let objects = provider.opaque_objects_v1();
    let head = objects.head().unwrap();
    let mut cursor = 0;
    let mut total = 0;
    loop {
        let page = objects
            .changes("qa", &head.generation, cursor, head.revision, 7, 4096)
            .unwrap();
        assert!(page.cursor > cursor);
        cursor = page.cursor;
        total += page.records.len();
        if page.complete {
            break;
        }
    }
    assert_eq!(total, 25);
    assert_eq!(cursor, head.revision);
    let mut key = None;
    let mut scanned = 0;
    loop {
        let page = objects.scan("qa", key.as_deref(), 7, 4096).unwrap();
        scanned += page.records.len();
        key = page.next_key;
        if key.is_none() {
            break;
        }
    }
    assert_eq!(scanned, 25);
    assert!(objects
        .changes("qa", &head.generation, 0, head.revision, 7, 1)
        .is_err());
    assert!(objects.scan("qa", None, 0, 4096).is_err());
    assert!(objects
        .changes("qa", "different-generation", 0, head.revision, 7, 4096)
        .is_err());
    // Cursor invalidations cover the frozen range, while each value is current at page read time.
    provider
        .transaction(|work| {
            work.put_object_v1(
                &object("key-000", b"new"),
                "new-value",
                ObjectRevisionV1::Exact(1),
            )
        })
        .unwrap();
    let page = objects
        .changes("qa", &head.generation, 0, head.revision, 100, 100_000)
        .unwrap();
    assert_eq!(page.records.len(), 25);
    assert!(page
        .records
        .iter()
        .any(|record| record.revision > head.revision));
    let deleted = object("key-000", b"");
    provider
        .transaction(|work| work.put_object_v1(&deleted, "delete", ObjectRevisionV1::Exact(26)))
        .unwrap();
    let page = objects
        .changes("qa", &head.generation, head.revision, 27, 100, 100_000)
        .unwrap();
    assert_eq!(page.records.len(), 1);
    assert!(page.records[0].object.tombstone);
}
#[test]
fn backup_preserves_generation_objects_replay_and_bytes_and_tampering_fails_closed() {
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("sync.db");
    let provider = store(&path);
    let value = object("a", b"opaque QA");
    provider
        .transaction(|work| work.put_object_v1(&value, "original", ObjectRevisionV1::Absent))
        .unwrap();
    let head = provider.opaque_objects_v1().head().unwrap();
    let backup = root.path().join("backup.db");
    provider.online_backup(&backup).unwrap();
    let restored = store(&backup);
    assert_eq!(restored.opaque_objects_v1().head().unwrap(), head);
    assert_eq!(
        restored
            .opaque_objects_v1()
            .get("qa", "a")
            .unwrap()
            .unwrap()
            .object,
        value
    );
    drop(restored);
    drop(provider);
    let connection = rusqlite::Connection::open(&path).unwrap();
    connection
        .execute(
            "UPDATE appcore_opaque_object SET envelope=?1",
            [b"corrupt".as_slice()],
        )
        .unwrap();
    drop(connection);
    assert!(SqliteSyncStore::open(SqliteSyncConfig::new(&path)).is_err());
    assert!(path.is_file());
    assert!(format!("{value:?}").find("opaque QA").is_none());
}

#[test]
fn crash_object_worker() {
    let Ok(path) = std::env::var("APPCORE_OPAQUE_CRASH_FIXTURE") else {
        return;
    };
    let provider = store(std::path::Path::new(&path));
    provider
        .transaction::<()>(|work| {
            work.put_object_v1(
                &object("interrupted", b"opaque interrupted"),
                "interrupted",
                ObjectRevisionV1::Absent,
            )?;
            work.append(b"opaque interrupted log", 1)?;
            std::process::exit(73);
        })
        .unwrap();
}
#[test]
fn process_exit_during_object_transaction_leaves_no_partial_object_or_log() {
    use std::process::{Command, Stdio};
    let root = tempfile::tempdir().unwrap();
    let path = root.path().join("sync.db");
    let provider = store(&path);
    let before = provider.opaque_objects_v1().head().unwrap();
    drop(provider);
    let mut child = Command::new(std::env::current_exe().unwrap())
        .args(["--exact", "crash_object_worker"])
        .env("APPCORE_OPAQUE_CRASH_FIXTURE", &path)
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    let started = std::time::Instant::now();
    let status = loop {
        if let Some(status) = child.try_wait().unwrap() {
            break status;
        }
        if started.elapsed() > std::time::Duration::from_secs(10) {
            child.kill().unwrap();
            child.wait().unwrap();
            panic!("opaque crash fixture exceeded deadline");
        }
        std::thread::sleep(std::time::Duration::from_millis(10));
    };
    assert_eq!(status.code(), Some(73));
    let provider = store(&path);
    assert_eq!(provider.opaque_objects_v1().head().unwrap(), before);
    assert!(provider
        .opaque_objects_v1()
        .get("qa", "interrupted")
        .unwrap()
        .is_none());
    assert_eq!(provider.replication_log().len().unwrap(), 0);
}