#![cfg(test)]
use crate::backend::{Backend, MemoryBackend, TransactionReader, WriteOp};
use crate::error::StoreError;
fn blob_key() -> String {
"blob/probe".to_string()
}
fn ref_key(owner: &str) -> String {
format!("probe/ref/{owner}")
}
const REF_PREFIX: &str = "probe/ref/";
async fn collection_refuses_a_claim_that_landed_before_the_transaction<B: Backend + Sync>(backend: B) {
backend.put(&blob_key(), b"bytes").await.unwrap();
backend.put(&ref_key("new-owner"), b"1").await.unwrap();
backend
.transact(Box::new(|reader: &dyn TransactionReader| {
if !reader.list(REF_PREFIX).unwrap().is_empty() {
return vec![]; }
vec![WriteOp::Delete { key: blob_key() }]
}))
.await
.unwrap();
assert!(
backend.get(&blob_key()).await.unwrap().is_some(),
"transact must refuse collection once a reference is live"
);
assert!(backend.get(&ref_key("new-owner")).await.unwrap().is_some());
}
async fn claim_after_commit_sees_the_blob_gone_with_no_dangling_reference<B: Backend + Sync>(backend: B) {
backend.put(&blob_key(), b"bytes").await.unwrap();
backend
.transact(Box::new(|reader: &dyn TransactionReader| {
if !reader.list(REF_PREFIX).unwrap().is_empty() {
return vec![];
}
vec![WriteOp::Delete { key: blob_key() }]
}))
.await
.unwrap();
let blob_present = backend.get(&blob_key()).await.unwrap().is_some();
assert!(!blob_present, "collection committed: the blob is gone");
if blob_present {
backend.put(&ref_key("late-owner"), b"1").await.unwrap();
}
assert!(
backend.get(&ref_key("late-owner")).await.unwrap().is_none(),
"no dangling reference: a late claim must refuse against a gone blob"
);
}
async fn negative_control_apply_alone_does_not_recheck_a_new_owner<B: Backend + Sync>(backend: B) {
backend.put(&blob_key(), b"bytes").await.unwrap();
let proposed = vec![WriteOp::Delete { key: blob_key() }];
backend.put(&ref_key("new-owner"), b"1").await.unwrap();
backend.apply(&proposed).await.unwrap();
assert!(
backend.get(&blob_key()).await.unwrap().is_none(),
"negative control must expose the loss: apply alone deletes the blob"
);
assert!(
backend.get(&ref_key("new-owner")).await.unwrap().is_some(),
"and leaves the new owner's reference dangling"
);
}
mod memory_backend {
use super::*;
#[test]
fn collection_refuses_a_claim_that_landed_before_the_transaction() {
pollster::block_on(super::collection_refuses_a_claim_that_landed_before_the_transaction(
MemoryBackend::new(),
));
}
#[test]
fn claim_after_commit_sees_the_blob_gone_with_no_dangling_reference() {
pollster::block_on(
super::claim_after_commit_sees_the_blob_gone_with_no_dangling_reference(
MemoryBackend::new(),
),
);
}
#[test]
fn negative_control_apply_alone_does_not_recheck_a_new_owner() {
pollster::block_on(super::negative_control_apply_alone_does_not_recheck_a_new_owner(
MemoryBackend::new(),
));
}
}
#[cfg(feature = "redb")]
mod redb_backend {
#[allow(unused_imports)]
use super::*;
use crate::RedbBackend;
fn temp_backend() -> (tempfile::TempDir, RedbBackend) {
let dir = tempfile::tempdir().unwrap();
let backend = RedbBackend::open(dir.path().join("custody.redb")).unwrap();
(dir, backend)
}
#[test]
fn collection_refuses_a_claim_that_landed_before_the_transaction() {
let (_dir, backend) = temp_backend();
pollster::block_on(super::collection_refuses_a_claim_that_landed_before_the_transaction(
backend,
));
}
#[test]
fn claim_after_commit_sees_the_blob_gone_with_no_dangling_reference() {
let (_dir, backend) = temp_backend();
pollster::block_on(
super::claim_after_commit_sees_the_blob_gone_with_no_dangling_reference(backend),
);
}
#[test]
fn negative_control_apply_alone_does_not_recheck_a_new_owner() {
let (_dir, backend) = temp_backend();
pollster::block_on(super::negative_control_apply_alone_does_not_recheck_a_new_owner(
backend,
));
}
}
#[cfg(feature = "directory")]
mod directory_backend {
#[allow(unused_imports)]
use super::*;
use crate::DirectoryBackend;
fn temp_backend() -> (tempfile::TempDir, DirectoryBackend) {
let dir = tempfile::tempdir().unwrap();
let backend = DirectoryBackend::open(dir.path().join("custody")).unwrap();
(dir, backend)
}
#[test]
fn collection_refuses_a_claim_that_landed_before_the_transaction() {
let (_dir, backend) = temp_backend();
pollster::block_on(super::collection_refuses_a_claim_that_landed_before_the_transaction(
backend,
));
}
#[test]
fn claim_after_commit_sees_the_blob_gone_with_no_dangling_reference() {
let (_dir, backend) = temp_backend();
pollster::block_on(
super::claim_after_commit_sees_the_blob_gone_with_no_dangling_reference(backend),
);
}
#[test]
fn negative_control_apply_alone_does_not_recheck_a_new_owner() {
let (_dir, backend) = temp_backend();
pollster::block_on(super::negative_control_apply_alone_does_not_recheck_a_new_owner(
backend,
));
}
}
struct NoTransact(MemoryBackend);
#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
impl Backend for NoTransact {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
self.0.get(key).await
}
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError> {
self.0.put(key, bytes).await
}
async fn delete(&self, key: &str) -> Result<(), StoreError> {
self.0.delete(key).await
}
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
self.0.list(prefix).await
}
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError> {
self.0.scan(start, end).await
}
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError> {
self.0.apply(ops).await
}
}
#[test]
fn default_refusal_is_typed() {
pollster::block_on(async {
let backend = NoTransact(MemoryBackend::new());
let result = backend
.transact(Box::new(|_reader: &dyn TransactionReader| Vec::new()))
.await;
assert_eq!(result, Err(StoreError::NotTransactional));
});
}
#[cfg(feature = "zip")]
#[test]
fn zip_backend_transact_refusal_is_typed() {
pollster::block_on(async {
let dir = tempfile::tempdir().unwrap();
let backend = crate::ZipBackend::open(dir.path().join("store.zip")).unwrap();
let result = backend
.transact(Box::new(|_reader: &dyn TransactionReader| Vec::new()))
.await;
assert_eq!(result, Err(StoreError::NotTransactional));
});
}