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());
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);
}