use std::time::Duration;
use happenstance_core::{
Event, EventId, EventStore, EventType, Query, ReadOptions, RecordedAt, SequencePosition,
SequencedEvent, StoreId, StoreLimit, Tag, Tags, collect,
};
use happenstance_sync::{
Classify, FailureClass, IngestError, IngestGroup, IngestStore, Ingested, ReplicatedEvent,
Watermark,
};
use sqlx::postgres::PgPoolOptions;
use super::{CONFLICT_CLAUSE, OwnedGroup, foreign_statement};
use crate::error::PostgresEventStoreError;
use crate::event_store::tests::server as sqlstate;
use crate::event_store::{NewRow, Origin, PostgresEventStore, insert_statement};
mod claims;
mod family;
mod groups;
mod live;
mod peer_family;
mod restore_family;
mod server;
fn peer(byte: u8) -> StoreId {
StoreId::from_bytes([byte; 16])
}
fn id(store: StoreId, position: u64) -> EventId {
EventId::new(
store,
SequencePosition::new(position).expect("test origin positions are non-zero"),
)
}
fn event(kind: &str, tag: &str) -> Event {
Event::new(kind, b"payload".to_vec())
.expect("test event types are valid")
.with_tags(Tags::from_pairs([("k", tag)]).expect("test tags are valid"))
}
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 watermark<S: IngestStore>(store: &S) -> Watermark
where
S::Error: core::fmt::Debug,
{
store
.watermark()
.await
.expect("the watermark of a reachable store reads")
}
async fn log<S: EventStore>(store: &S) -> Vec<SequencedEvent>
where
S::Error: core::fmt::Debug,
{
collect(store.read(&Query::all(), ReadOptions::default()))
.await
.expect("the log of a reachable store reads")
}
fn carrying(log: &[SequencedEvent], id: EventId) -> &SequencedEvent {
let mut matching = log.iter().filter(|event| event.id == id);
let found = matching
.next()
.unwrap_or_else(|| panic!("no event carries {id}"));
assert!(matching.next().is_none(), "two events carry {id}");
found
}
async fn holds(store: &PostgresEventStore, id: EventId) -> bool {
EventStore::contains_event_id(store, id)
.await
.expect("a membership probe of a reachable store answers")
}
async fn append(store: &PostgresEventStore, events: &[Event]) -> SequencePosition {
EventStore::append(store, events, None)
.await
.expect("an unconditional append to a reachable store lands")
}
async fn rows(store: &PostgresEventStore) -> i64 {
sqlx::query_scalar("SELECT count(*) FROM event")
.fetch_one(store.pool())
.await
.expect("a count of a reachable schema answers")
}
async fn own(store: &PostgresEventStore) -> StoreId {
IngestStore::store_id(store)
.await
.expect("a reachable, migrated store has an identity")
}
async fn live_store() -> PostgresEventStore {
PostgresEventStore::new(server::fresh_pool().await)
}
fn unreachable_store() -> PostgresEventStore {
let pool = PgPoolOptions::new()
.acquire_timeout(Duration::from_secs(1))
.connect_lazy("postgres://happenstance@127.0.0.1:1/unreachable")
.expect("a well-formed URL builds a lazy pool");
PostgresEventStore::new(pool)
}
#[test]
fn ingest_store_satisfies_the_bare_bounds() {
fn assert_bounds<S: EventStore + IngestStore + Send + Sync>() {}
assert_bounds::<PostgresEventStore>();
}
#[tokio::test]
async fn store_id_through_the_port_reads_the_row_on_every_call() {
let store = unreachable_store();
for _ in 0..2 {
let refused = IngestStore::store_id(&store)
.await
.expect_err("an identity on a server that is not there cannot be read");
assert!(
matches!(refused, PostgresEventStoreError::Driver(_)),
"{refused:?}"
);
}
}
#[tokio::test]
async fn ingest_reports_an_unreadable_identity_as_a_store_error() {
let store = unreachable_store();
let from = peer(0x61);
let one = [shipped(id(from, 1), 1, event("Shipped", "a"))];
let refused = ingest(&store, &[IngestGroup::new(&one, &[])])
.await
.expect_err("an identity on a server that is not there cannot be read");
assert!(
matches!(
refused,
IngestError::Store(PostgresEventStoreError::Driver(_))
),
"{refused:?}"
);
assert_eq!(refused.class(), FailureClass::Transient);
let foreign: Vec<ReplicatedEvent> = (1..=257)
.map(|position| shipped(id(from, position), 1, event("Shipped", "a")))
.collect();
let refused = ingest(&store, &[IngestGroup::new(&foreign, &[])])
.await
.expect_err("257 events exceed a ceiling of 256");
assert!(
matches!(
refused,
IngestError::ExceedsStoreLimit {
limit: StoreLimit::EventsPerBatch,
len: 257,
..
}
),
"{refused:?}"
);
let past_a_bigint = SequencePosition::new(u64::MAX).expect("u64::MAX is not zero");
let unstorable = [shipped(
EventId::new(from, past_a_bigint),
1,
event("Shipped", "a"),
)];
let refused = ingest(&store, &[IngestGroup::new(&unstorable, &[])])
.await
.expect_err("an origin position past a bigint cannot be stored");
assert!(
matches!(
refused,
IngestError::Store(PostgresEventStoreError::OriginPositionOutOfRange { .. })
),
"the origin check must answer before the identity read reaches the wire: {refused:?}"
);
}
#[tokio::test]
async fn an_empty_ingest_writes_nothing_and_never_reaches_the_server() {
let store = unreachable_store();
let compensation = [event("Compensated", "a")];
let empty: [IngestGroup<'_>; 0] = [];
let no_foreign = [IngestGroup::new(&[], &compensation)];
for groups in [&empty[..], &no_foreign[..]] {
let ingested = ingest(&store, groups)
.await
.expect("an ingest of nothing foreign reaches no server, so cannot fail");
assert_eq!(ingested, Ingested::default());
}
}
#[tokio::test]
async fn ceilings_are_checked_before_the_wire_against_the_worst_case() {
let store = unreachable_store();
let from = peer(0x31);
let foreign: Vec<ReplicatedEvent> = (1..=200)
.map(|position| shipped(id(from, position), 1, event("Shipped", "a")))
.collect();
let compensation: Vec<Event> = (0..57).map(|_| event("Compensated", "a")).collect();
let refused = ingest(&store, &[IngestGroup::new(&foreign, &compensation)])
.await
.expect_err("257 events exceed a ceiling of 256");
assert!(
matches!(
refused,
IngestError::ExceedsStoreLimit {
limit: StoreLimit::EventsPerBatch,
len: 257,
..
}
),
"{refused:?}"
);
assert_eq!(refused.class(), FailureClass::Split);
let oversized = [Event::new(
"Compensated",
vec![0_u8; PostgresEventStore::MAX_EVENT_DATA_LEN + 1],
)
.expect("a valid event type")];
let losing = [shipped(id(from, 1), 1, event("Reserved", "seat"))];
let refused = ingest(&store, &[IngestGroup::new(&losing, &oversized)])
.await
.expect_err("a compensation over the data ceiling never fits");
match refused {
IngestError::ExceedsStoreLimit {
limit: StoreLimit::EventDataLen,
len,
..
} => assert_eq!(len, PostgresEventStore::MAX_EVENT_DATA_LEN + 1),
ref other => panic!("expected the data ceiling, got {other:?}"),
}
assert_eq!(refused.class(), FailureClass::Park);
}
#[tokio::test]
async fn an_origin_position_past_i64_is_refused_not_saturated() {
let store = unreachable_store();
let from = peer(0x41);
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
.expect_err("an origin position past a bigint cannot be stored");
match refused {
IngestError::Store(PostgresEventStoreError::OriginPositionOutOfRange { position }) => {
assert_eq!(position.get(), u64::MAX - 1, "not the first offender");
}
ref other => panic!("expected OriginPositionOutOfRange, got {other:?}"),
}
assert_eq!(refused.class(), FailureClass::Park);
}
#[test]
fn ingest_sends_appends_insert_plus_the_conflict_clause() {
let own = peer(0x51);
let sent = [
shipped(id(peer(0x52), 4), 4, event("Shipped", "a")),
shipped(id(peer(0x52), 9), 9, event("Shipped", "b")),
];
let owned = OwnedGroup::try_from_group(&IngestGroup::new(&sent, &[]))
.expect("both origin positions fit a bigint");
let positions = [41, 42];
let recorded_at = RecordedAt::from_millis(1);
let local = insert_statement(
own,
sent.iter().map(|replicated| NewRow {
event: &replicated.event,
origin: Origin::Local,
recorded_at,
}),
&positions,
positions.iter().copied().min(),
);
let foreign = foreign_statement(own, &owned.events, &positions);
let suffix = foreign.sql().strip_prefix(local.sql()).unwrap_or_else(|| {
panic!(
"{:?} does not start with append's {:?}",
foreign.sql(),
local.sql()
)
});
assert_eq!(suffix, CONFLICT_CLAUSE);
}
#[tokio::test]
async fn postgres_errors_state_their_class() {
use FailureClass::{Park, Stop, Transient};
use PostgresEventStoreError as E;
let panicked = tokio::spawn(async { panic!("a scripted panic, for its JoinError") })
.await
.expect_err("the task panicked");
let aborted = {
let handle = tokio::spawn(core::future::pending::<()>());
handle.abort();
handle.await.expect_err("the task was aborted")
};
let cases = [
(sqlstate("08006"), Transient),
(sqlstate("53300"), Transient),
(sqlstate("40001"), Transient),
(sqlstate("40P01"), Transient),
(sqlstate("57P01"), Transient),
(sqlstate("57P02"), Transient),
(sqlstate("57P03"), Transient),
(sqlstate("23505"), Stop),
(sqlstate("P0001"), Stop),
(sqlstate("42P01"), Stop),
(
E::Driver(sqlx::Error::Io(std::io::Error::other("reset"))),
Transient,
),
(E::Driver(sqlx::Error::PoolTimedOut), Transient),
(E::Driver(sqlx::Error::PoolClosed), Stop),
(E::Driver(sqlx::Error::Protocol("scripted".into())), Stop),
(E::Worker(aborted), Transient),
(E::Worker(panicked), Stop),
(
E::OriginPositionOutOfRange {
position: SequencePosition::FIRST,
},
Park,
),
(E::PositionOutOfRange { value: 0 }, Stop),
(
E::EventType(EventType::new("").expect_err("an empty event type is invalid")),
Stop,
),
(
E::Tag(Tag::new("").expect_err("an empty tag is invalid")),
Stop,
),
(E::MissingIdentity, Stop),
(E::MalformedIdentity { len: 3 }, Stop),
(
E::UnstampedEvent {
position: SequencePosition::FIRST,
},
Stop,
),
(E::NoRuntime, Stop),
(E::UnreadableTransactionId, Stop),
(
E::StoredGuard {
first: SequencePosition::FIRST,
source: happenstance_sync::write_group::decode_guard(&[])
.expect_err("no bytes are no guard"),
},
Stop,
),
(E::GroupOrder(misordered()), Stop),
];
for (error, class) in cases {
assert_eq!(error.class(), class, "{error:?}");
}
}
fn misordered() -> happenstance_sync::write_group::GroupOrderError {
let at = |raw: u64| SequencePosition::new(raw).expect("non-zero");
let row = |raw: u64| shipped(id(peer(0x60), raw), 0, event("Shipped", "row"));
let mut builder = happenstance_sync::write_group::GroupPageBuilder::new(
core::num::NonZeroUsize::new(8).expect("non-zero"),
);
for (group, position) in [(2, 2), (1, 3)] {
if builder.offer(at(group), None, row(position)).is_break() {
break;
}
}
builder
.finish(happenstance_sync::Waiting::Nothing)
.expect_err("group 1 was offered after group 2")
}