use happenstance_core::StoreId;
use happenstance_sync::{Classify, FailureClass, IngestError, IngestGroup, Ingested, Watermark};
use rusqlite::ErrorCode;
use crate::event_store::{SqliteEventStore, SqliteEventStoreError};
#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
impl happenstance_sync::SendIngestStore for SqliteEventStore {
type Error = SqliteEventStoreError;
async fn store_id(&self) -> Result<StoreId, Self::Error> {
Ok(Self::store_id(self))
}
async fn ingest(
&self,
groups: &[IngestGroup<'_>],
) -> Result<Ingested, IngestError<Self::Error>> {
self.ingest_groups(groups)
}
async fn watermark(&self) -> Result<Watermark, Self::Error> {
self.origin_watermark()
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
impl Classify for SqliteEventStoreError {
fn class(&self) -> FailureClass {
match self {
Self::Sqlite(error) if transient_driver_failure(error) => FailureClass::Transient,
Self::Worker(error) if error.is_cancelled() => FailureClass::Transient,
Self::OriginPositionOutOfRange { .. } => FailureClass::Park,
Self::Sqlite(_)
| Self::Worker(_)
| Self::ConnectionPoisoned
| Self::NoRuntime(_)
| Self::InvalidPosition(_)
| Self::StoredEventType(_)
| Self::StoredTag(_)
| Self::UnsupportedSchemaVersion { .. }
| Self::MissingIdentity
| Self::MalformedIdentity { .. }
| Self::IdentityMoved { .. }
| Self::UnstampedEvent { .. }
| Self::CorruptTags => FailureClass::Stop,
}
}
}
fn transient_driver_failure(error: &rusqlite::Error) -> bool {
crate::connection::is_busy(error)
|| matches!(
error.sqlite_error_code(),
Some(ErrorCode::DiskFull | ErrorCode::SystemIoFailure | ErrorCode::OutOfMemory)
)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
use futures_core::Stream;
use happenstance_core::{
AppendCondition, AppendError, Event, EventId, EventStore, Query, QueryItem, ReadOptions,
RecordedAt, SequencePosition, SequencedEvent, StoreId, StoreLimit, Tags,
};
use happenstance_sync::{
Classify, FailureClass, IngestError, IngestGroup, IngestStore, Ingested, ReplicatedEvent,
Watermark,
};
use crate::event_store::{SqliteEventStore, SqliteEventStoreError};
fn peer(byte: u8) -> StoreId {
StoreId::from_bytes([byte; 16])
}
fn id(store: StoreId, position: u64) -> EventId {
EventId::new(store, SequencePosition::new(position).unwrap())
}
fn event(kind: &str, tag: &str) -> Event {
Event::new(kind, b"payload".to_vec())
.unwrap()
.with_tags(Tags::from_pairs([("k", tag)]).unwrap())
}
fn shipped(id: EventId, millis: i64, event: Event) -> ReplicatedEvent {
ReplicatedEvent::new(id, RecordedAt::from_millis(millis), event)
}
async fn ingest<S: IngestStore>(
store: &S,
groups: &[IngestGroup<'_>],
) -> Result<Ingested, IngestError<S::Error>> {
store.ingest(groups).await
}
async fn log<S: EventStore>(store: &S) -> Vec<SequencedEvent>
where
S::Error: core::fmt::Debug,
{
let everything = Query::all();
let mut stream = Box::pin(store.read(&everything, ReadOptions::default()));
let mut out = Vec::new();
while let Some(item) =
core::future::poll_fn(|context| stream.as_mut().poll_next(context)).await
{
out.push(item.unwrap());
}
out
}
fn carrying(log: &[SequencedEvent], id: EventId) -> &SequencedEvent {
let mut matching = log.iter().filter(|event| event.id == id);
let found = matching.next().unwrap();
assert!(matching.next().is_none(), "two events carry {id}");
found
}
struct TempFile(PathBuf);
impl TempFile {
fn new() -> Self {
static NEXT: AtomicU64 = AtomicU64::new(1);
let mut path = std::env::temp_dir();
path.push(format!(
"happenstance-sqlite-ingest-spike-{}-{}.db",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
));
let file = Self(path);
file.remove();
file
}
fn remove(&self) {
for suffix in ["", "-wal", "-shm"] {
let mut path = self.0.clone().into_os_string();
path.push(suffix);
let _ = std::fs::remove_file(PathBuf::from(path));
}
}
fn inspect(&self) -> rusqlite::Connection {
rusqlite::Connection::open(&self.0).unwrap()
}
}
impl Drop for TempFile {
fn drop(&mut self) {
self.remove();
}
}
#[tokio::test]
async fn ingest_preserves_foreign_event_id_and_recorded_at() {
let store = SqliteEventStore::open_in_memory().unwrap();
let from = peer(0xA1);
let batch = [
shipped(id(from, 3), -86_400_000, event("Shipped", "a")),
shipped(id(from, 7), 1_700_000_000_000, event("Shipped", "b")),
];
let ingested = ingest(&store, &[IngestGroup::new(&batch, &[])])
.await
.unwrap();
assert_eq!(ingested.appended, 2);
let log = log(&store).await;
for sent in &batch {
let held = carrying(&log, sent.id);
assert_eq!(held.id, sent.id, "the origin identity was re-minted");
assert_eq!(
held.recorded_at, sent.recorded_at,
"the origin's recorded time was restamped"
);
assert_eq!(held.event, sent.event);
}
}
#[tokio::test]
async fn redelivery_is_a_skip_not_an_error() {
let file = TempFile::new();
let store = SqliteEventStore::open(&file.0).unwrap();
let from = peer(0xB2);
let first = [
shipped(id(from, 1), 10, event("Shipped", "a")),
shipped(id(from, 2), 20, event("Shipped", "b")),
];
ingest(&store, &[IngestGroup::new(&first, &[])])
.await
.unwrap();
let tables = |connection: &rusqlite::Connection| -> (i64, i64) {
(
connection
.query_row("SELECT count(*) FROM event_tag", [], |row| row.get(0))
.unwrap(),
connection
.query_row("SELECT sum(events) FROM tag_cardinality", [], |row| {
row.get(0)
})
.unwrap(),
)
};
let head = store.head().await.unwrap();
let before = tables(&file.inspect());
let again = ingest(&store, &[IngestGroup::new(&first, &[])])
.await
.unwrap();
assert_eq!((again.appended, again.skipped), (0, 2));
assert_eq!(store.head().await.unwrap(), head);
assert_eq!(
tables(&file.inspect()),
before,
"a skipped row wrote tag rows or counted its tags"
);
let mixed = [
first[1].clone(),
shipped(id(from, 3), 30, event("Shipped", "c")),
];
let partial = ingest(&store, &[IngestGroup::new(&mixed, &[])])
.await
.unwrap();
assert_eq!((partial.appended, partial.skipped), (1, 1));
assert_eq!(log(&store).await.len(), 3);
}
#[tokio::test]
async fn ingested_events_land_above_the_local_head() {
let store = SqliteEventStore::open_in_memory().unwrap();
store
.append(
&[
event("Local", "a"),
event("Local", "b"),
event("Local", "c"),
],
None,
)
.await
.unwrap();
let local_head = store.head().await.unwrap().unwrap();
let from = peer(0xC3);
let batch = [shipped(id(from, 1), 1, event("Shipped", "x"))];
ingest(&store, &[IngestGroup::new(&batch, &[])])
.await
.unwrap();
let landed = carrying(&log(&store).await, batch[0].id).position;
assert!(
landed > local_head,
"ingested at {landed}, below {local_head}"
);
assert_eq!(store.head().await.unwrap(), Some(landed));
let next = store.append(&[event("Local", "d")], None).await.unwrap();
assert!(next > landed);
}
#[tokio::test]
async fn compensation_is_atomic_with_the_losing_event_and_skipped_on_redelivery() {
let store = SqliteEventStore::open_in_memory().unwrap();
let from = peer(0xD4);
let losing = [shipped(id(from, 5), 50, event("Reserved", "seat-1"))];
let compensation = [event("ReservationCompensated", "seat-1")];
let first = ingest(&store, &[IngestGroup::new(&losing, &compensation)])
.await
.unwrap();
assert_eq!((first.appended, first.compensated), (1, 1));
let log_after = log(&store).await;
assert_eq!(log_after.len(), 2);
let lost = carrying(&log_after, losing[0].id);
let answer = log_after
.iter()
.find(|held| held.event == compensation[0])
.unwrap();
assert!(answer.position > lost.position);
assert_eq!(
answer.id,
EventId::new(store.store_id(), answer.position),
"compensation is minted here, like any local append"
);
let again = ingest(&store, &[IngestGroup::new(&losing, &compensation)])
.await
.unwrap();
assert_eq!(
(again.appended, again.skipped, again.compensated),
(0, 1, 0)
);
assert_eq!(log(&store).await.len(), 2, "compensation written twice");
let never_fits = [Event::new(
"ReservationCompensated",
vec![0u8; SqliteEventStore::MAX_EVENT_DATA_LEN + 1],
)
.unwrap()];
let doomed = [shipped(id(from, 6), 60, event("Reserved", "seat-2"))];
let refused = ingest(&store, &[IngestGroup::new(&doomed, &never_fits)]).await;
assert!(matches!(
refused,
Err(IngestError::ExceedsStoreLimit {
limit: StoreLimit::EventDataLen,
..
})
));
assert!(!store.contains_event_id(doomed[0].id).await.unwrap());
}
#[tokio::test]
async fn a_compensation_that_fails_in_the_transaction_takes_the_losing_event_with_it() {
let file = TempFile::new();
let store = SqliteEventStore::open(&file.0).unwrap();
file.inspect()
.execute_batch(
"CREATE TRIGGER poison BEFORE INSERT ON event \
WHEN NEW.event_type = 'Poisoned' \
BEGIN SELECT RAISE(ABORT, 'poisoned compensation'); END;",
)
.unwrap();
let losing = [shipped(id(peer(0xE5), 1), 1, event("Reserved", "seat"))];
let poisoned = [event("Poisoned", "seat")];
let failed = ingest(&store, &[IngestGroup::new(&losing, &poisoned)]).await;
assert!(matches!(
failed,
Err(IngestError::Store(SqliteEventStoreError::Sqlite(_)))
));
assert!(
!store.contains_event_id(losing[0].id).await.unwrap(),
"the losing event committed without its compensation"
);
assert_eq!(store.head().await.unwrap(), None);
}
#[tokio::test]
async fn a_local_append_after_ingest_does_not_restamp_foreign_rows() {
let store = SqliteEventStore::open_in_memory().unwrap();
let from = peer(0xF6);
let batch = [
shipped(id(from, 4), 4, event("Shipped", "a")),
shipped(id(from, 8), 8, event("Shipped", "b")),
];
ingest(&store, &[IngestGroup::new(&batch, &[])])
.await
.unwrap();
store
.append(&[event("Local", "a"), event("Local", "b")], None)
.await
.unwrap();
let log = log(&store).await;
for sent in &batch {
assert_eq!(carrying(&log, sent.id).id, sent.id);
}
let local: Vec<&SequencedEvent> = log
.iter()
.filter(|held| held.id.store() == store.store_id())
.collect();
assert_eq!(local.len(), 2);
for held in local {
assert_eq!(held.id.position(), held.position);
}
}
#[tokio::test]
async fn an_origin_position_past_i64_is_refused_not_skipped() {
let store = SqliteEventStore::open_in_memory().unwrap();
let from = peer(0xE7);
let batch = [
shipped(id(from, 1), 1, event("Shipped", "a")),
shipped(id(from, u64::MAX - 1), 2, event("Shipped", "b")),
shipped(id(from, u64::MAX), 3, event("Shipped", "c")),
];
let refused = ingest(&store, &[IngestGroup::new(&batch, &[])]).await;
match refused {
Err(IngestError::Store(SqliteEventStoreError::OriginPositionOutOfRange {
position,
})) => assert_eq!(position.get(), u64::MAX - 1),
other => panic!("expected OriginPositionOutOfRange, got {other:?}"),
}
assert!(
log(&store).await.is_empty(),
"the representable event before it was not rolled back"
);
}
#[tokio::test]
async fn contains_event_id_answers_for_a_foreign_id() {
let store = SqliteEventStore::open_in_memory().unwrap();
let from = peer(0x17);
let sent = id(from, 42);
assert!(!store.contains_event_id(sent).await.unwrap());
let batch = [shipped(sent, 1, event("Shipped", "a"))];
ingest(&store, &[IngestGroup::new(&batch, &[])])
.await
.unwrap();
assert!(store.contains_event_id(sent).await.unwrap());
assert!(!store.contains_event_id(id(peer(0x18), 42)).await.unwrap());
let landed = carrying(&log(&store).await, sent).position;
assert!(
!store
.contains_event_id(EventId::new(store.store_id(), landed))
.await
.unwrap()
);
}
#[tokio::test]
async fn ingest_ignores_append_conditions() {
let store = SqliteEventStore::open_in_memory().unwrap();
let seat = Query::from_item(
QueryItem::tagged(Tags::from_pairs([("k", "seat-9")]).unwrap()).unwrap(),
);
let decided_at = store
.append(&[event("Reserved", "seat-9")], None)
.await
.unwrap();
let taken = AppendCondition::new(seat.clone());
assert!(
store
.append(&[event("Reserved", "seat-9")], Some(&taken))
.await
.unwrap_err()
.is_condition_violated()
);
let rival = [shipped(id(peer(0x29), 3), 3, event("Reserved", "seat-9"))];
let ingested = ingest(&store, &[IngestGroup::new(&rival, &[])])
.await
.unwrap();
assert_eq!(ingested.appended, 1);
let landed = carrying(&log(&store).await, rival[0].id).position;
let since_decision = AppendCondition::new(seat).after_every_guard(decided_at);
match store
.append(&[event("Reserved", "seat-9")], Some(&since_decision))
.await
{
Err(AppendError::ConditionViolated(violated)) => {
assert_eq!(violated.conflicting_position, Some(landed));
}
other => panic!("expected the ingested event as the conflict, got {other:?}"),
}
}
#[tokio::test]
async fn watermark_is_max_origin_position_per_origin() {
let store = SqliteEventStore::open_in_memory().unwrap();
assert!(ingest_watermark(&store).await.is_empty());
let (one, two) = (peer(0x31), peer(0x32));
let batch = [
shipped(id(one, 2), 2, event("Shipped", "a")),
shipped(id(one, 9), 9, event("Shipped", "b")),
shipped(id(one, 5), 5, event("Shipped", "c")),
shipped(id(two, 4), 4, event("Shipped", "d")),
];
ingest(
&store,
&[
IngestGroup::new(&batch[..2], &[]),
IngestGroup::new(&batch[2..], &[]),
],
)
.await
.unwrap();
store
.append(&[event("Local", "a"), event("Local", "b")], None)
.await
.unwrap();
let mut expected = Watermark::new();
for held in log(&store).await {
expected.advance(held.id.store(), held.id.position());
}
let watermark = ingest_watermark(&store).await;
assert_eq!(watermark, expected);
assert_eq!(watermark.len(), 3);
for from in [one, two] {
let sent = batch
.iter()
.filter(|shipped| shipped.id.store() == from)
.map(|shipped| shipped.id.position())
.max();
assert_eq!(watermark.get(from), sent);
}
}
async fn ingest_watermark<S: IngestStore>(store: &S) -> Watermark
where
S::Error: core::fmt::Debug,
{
store.watermark().await.unwrap()
}
#[tokio::test]
async fn an_echo_of_an_own_event_is_a_skip() {
let store = SqliteEventStore::open_in_memory().unwrap();
let held = store.append(&[event("Local", "a")], None).await.unwrap();
let back_home = [shipped(
EventId::new(store.store_id(), held),
1,
event("Local", "a"),
)];
let skipped = ingest(&store, &[IngestGroup::new(&back_home, &[])])
.await
.expect("an echo of a held event is not an error");
assert_eq!((skipped.appended, skipped.skipped), (0, 1));
assert_eq!(store.head().await.unwrap(), Some(held));
}
struct Claimed {
claim: EventId,
first: [ReplicatedEvent; 1],
second: [ReplicatedEvent; 2],
}
impl Claimed {
async fn on(store: &SqliteEventStore) -> Self {
let held = store.append(&[event("Local", "a")], None).await.unwrap();
let claimed = held
.next()
.and_then(SequencePosition::next)
.and_then(SequencePosition::next)
.expect("three positions past a fresh head exist");
let claim = EventId::new(store.store_id(), claimed);
let from = peer(0x4A);
Self {
claim,
first: [shipped(id(from, 1), 1, event("Shipped", "f1"))],
second: [
shipped(id(from, 2), 2, event("Shipped", "f2")),
shipped(claim, 3, event("Local", "forged")),
],
}
}
fn groups(&self) -> [IngestGroup<'_>; 2] {
[
IngestGroup::new(&self.first, &[]),
IngestGroup::new(&self.second, &[]),
]
}
}
#[tokio::test]
async fn an_unheld_own_identity_stops_the_ingest_and_writes_nothing() {
let store = SqliteEventStore::open_in_memory().unwrap();
let claimed = Claimed::on(&store).await;
let head = store.head().await.unwrap();
let watermark = ingest_watermark(&store).await;
let refused = ingest(&store, &claimed.groups())
.await
.expect_err("an unheld own identity must refuse the ingest");
assert!(
matches!(refused, IngestError::UnheldOwnIdentity { id, .. } if id == claimed.claim),
"expected UnheldOwnIdentity naming {}, got {refused:?}",
claimed.claim
);
assert_eq!(refused.class(), FailureClass::Stop);
for sent in [&claimed.first[0], &claimed.second[0], &claimed.second[1]] {
assert!(
!store.contains_event_id(sent.id).await.unwrap(),
"{} was written by a refused ingest",
sent.id
);
}
assert_eq!(store.head().await.unwrap(), head);
assert_eq!(ingest_watermark(&store).await, watermark);
}
#[tokio::test]
async fn local_appends_are_not_wedged_after_a_refused_claim() {
let store = SqliteEventStore::open_in_memory().unwrap();
let claimed = Claimed::on(&store).await;
ingest(&store, &claimed.groups())
.await
.expect_err("the claim is refused");
let mut assigned = Vec::new();
for _ in 0..5 {
assigned.push(
store
.append(&[event("Local", "next")], None)
.await
.expect("a local append after a refused claim lands"),
);
}
assert!(
assigned.contains(&claimed.claim.position()),
"no append reached the claimed position, so this proves nothing \
about the wedge: {assigned:?}"
);
assert!(
store.contains_event_id(claimed.claim).await.unwrap(),
"the local event at the claimed position carries this store's identity"
);
}
#[tokio::test]
async fn a_claim_lands_as_foreign_after_the_store_is_reminted() {
let file = TempFile::new();
let store = SqliteEventStore::open(&file.0).unwrap();
let claimed = Claimed::on(&store).await;
ingest(&store, &claimed.groups())
.await
.expect_err("before the re-mint the claim is refused");
drop(store);
let reminted = SqliteEventStore::remint_identity(&file.0).unwrap();
let store = SqliteEventStore::open(&file.0).unwrap();
assert_eq!(store.store_id(), reminted);
assert_ne!(store.store_id(), claimed.claim.store());
let landed = ingest(&store, &claimed.groups())
.await
.expect("after the re-mint the claim is a foreign event");
assert_eq!((landed.appended, landed.skipped), (3, 0));
assert!(store.contains_event_id(claimed.claim).await.unwrap());
let log = log(&store).await;
let held = carrying(&log, claimed.claim);
assert_eq!(held.id.store(), claimed.claim.store());
assert_ne!(held.id.store(), store.store_id());
}
#[tokio::test]
async fn a_compensation_whose_group_carries_an_unheld_own_identity_is_not_written() {
let store = SqliteEventStore::open_in_memory().unwrap();
let claimed = Claimed::on(&store).await;
let before = log(&store).await;
let answers = [[event("Compensated", "one")], [event("Compensated", "two")]];
let refused = ingest(
&store,
&[
IngestGroup::new(&claimed.first, &answers[0]),
IngestGroup::new(&claimed.second, &answers[1]),
],
)
.await;
assert!(
matches!(refused, Err(IngestError::UnheldOwnIdentity { .. })),
"{refused:?}"
);
assert_eq!(
log(&store).await,
before,
"a refused ingest left compensation, or a foreign event, behind"
);
}
#[tokio::test]
async fn a_claim_the_calls_own_compensation_would_hide_is_refused() {
let store = SqliteEventStore::open_in_memory().unwrap();
let held = store.append(&[event("Local", "a")], None).await.unwrap();
let before = log(&store).await;
let compensated_at = held
.next()
.and_then(SequencePosition::next)
.expect("two positions past a fresh head exist");
let claim = EventId::new(store.store_id(), compensated_at);
let from = peer(0x5B);
let first = [shipped(id(from, 1), 1, event("Shipped", "f1"))];
let answer = [event("Compensated", "c1")];
let second = [
shipped(id(from, 2), 2, event("Shipped", "f2")),
shipped(claim, 3, event("Local", "forged")),
];
let refused = ingest(
&store,
&[
IngestGroup::new(&first, &answer),
IngestGroup::new(&second, &[]),
],
)
.await;
assert!(
matches!(refused, Err(IngestError::UnheldOwnIdentity { id, .. }) if id == claim),
"expected UnheldOwnIdentity naming {claim}, got {refused:?}"
);
assert_eq!(
log(&store).await,
before,
"a refused ingest left its compensation or a foreign event behind"
);
}
#[test]
fn sqlite_errors_state_their_class() {
let driver = |code| {
SqliteEventStoreError::Sqlite(rusqlite::Error::SqliteFailure(
rusqlite::ffi::Error::new(code),
None,
))
};
let cases = [
(driver(rusqlite::ffi::SQLITE_BUSY), FailureClass::Transient),
(
driver(rusqlite::ffi::SQLITE_LOCKED),
FailureClass::Transient,
),
(driver(rusqlite::ffi::SQLITE_FULL), FailureClass::Transient),
(driver(rusqlite::ffi::SQLITE_IOERR), FailureClass::Transient),
(driver(rusqlite::ffi::SQLITE_NOMEM), FailureClass::Transient),
(driver(rusqlite::ffi::SQLITE_CONSTRAINT), FailureClass::Stop),
(driver(rusqlite::ffi::SQLITE_CORRUPT), FailureClass::Stop),
(
SqliteEventStoreError::OriginPositionOutOfRange {
position: SequencePosition::FIRST,
},
FailureClass::Park,
),
(
SqliteEventStoreError::IdentityMoved {
handle: peer(1),
persisted: peer(2),
},
FailureClass::Stop,
),
(
SqliteEventStoreError::ConnectionPoisoned,
FailureClass::Stop,
),
];
for (error, class) in cases {
assert_eq!(error.class(), class, "{error}");
}
}
mod ingest_family {
use happenstance_sync_testkit::{IngestFixture, Violation};
use happenstance_testkit::Capability;
use super::TempFile;
use crate::event_store::SqliteEventStore;
struct SqliteIngestFixture {
file: TempFile,
}
impl SqliteIngestFixture {
fn new() -> Self {
Self {
file: TempFile::new(),
}
}
}
impl IngestFixture for SqliteIngestFixture {
type Store = SqliteEventStore;
const MID_GROUP_FAULT: Capability = Capability::SUPPORTED;
const MAX_EVENT_DATA_LEN: Option<usize> = Some(SqliteEventStore::MAX_EVENT_DATA_LEN);
const MAX_TAGS_PER_EVENT: Option<usize> = Some(SqliteEventStore::MAX_TAGS_PER_EVENT);
async fn connect(&self) -> Self::Store {
SqliteEventStore::open(&self.file.0)
.expect("a fresh temporary file opens as a store")
}
async fn arm_mid_group_fault(&self, after: usize) -> Result<(), Violation> {
let unarmable = |error: rusqlite::Error| {
Violation::new(
"SY-30",
format!("the SQLite fixture could not arm its trigger: {error}"),
)
};
let connection = self.file.inspect();
let held: i64 = connection
.query_row("SELECT count(*) FROM event", [], |row| row.get(0))
.map_err(unarmable)?;
let ceiling = i64::try_from(after)
.ok()
.and_then(|after| held.checked_add(after))
.ok_or_else(|| {
Violation::new("SY-30", format!("a cut at row {after} overflows an i64"))
})?;
connection
.execute_batch(&format!(
"CREATE TRIGGER mid_group_fault AFTER INSERT ON event \
WHEN (SELECT count(*) FROM event) > {ceiling} \
BEGIN SELECT RAISE(ABORT, 'the fixture armed a mid-group fault'); END;"
))
.map_err(unarmable)
}
}
happenstance_sync_testkit::ingest_store_conformance!(
mod_name = ingest_conformance,
fixture = super::SqliteIngestFixture::new()
);
}
}