use happenstance_core::{Event, EventStore, Query, ReadOptions, SequencedEvent, Tags, collect};
use happenstance_sync::{
EventGroup, IngestGroup, IngestStore, PushBatch, StoreSyncPeer, SyncPeer, Waiting,
WriteGroupStore,
};
use happenstance_sync_testkit::{
IngestFixture, MemoryIngestFixture, RefusalsOf, SyncFixture, oversized_push_refusal,
};
use happenstance_testkit::{Capability, Reopened};
use sqlx::PgPool;
use tokio::sync::Mutex;
use super::server;
use crate::event_store::PostgresEventStore;
use crate::migration;
type PostgresPeer = StoreSyncPeer<PostgresEventStore, PostgresEventStore>;
#[derive(Debug)]
struct PostgresPeerFixture {
schema: String,
pool: Mutex<Option<PgPool>>,
}
impl PostgresPeerFixture {
fn new() -> Self {
Self {
schema: server::fresh_schema_name(),
pool: Mutex::new(None),
}
}
async fn pool(&self) -> PgPool {
let mut current = self.pool.lock().await;
if let Some(pool) = current.as_ref() {
return pool.clone();
}
let opened = server::pool_onto(&self.schema).await;
migration::apply(&opened).await.unwrap_or_else(|error| {
panic!("a broken test environment: the event log's migrations failed ({error})")
});
current.insert(opened).clone()
}
}
impl SyncFixture for PostgresPeerFixture {
type Peer = PostgresPeer;
const REOPEN: Capability = Capability::SUPPORTED;
async fn connect(&self) -> Self::Peer {
let pool = self.pool().await;
StoreSyncPeer::new(
PostgresEventStore::new(pool.clone()),
PostgresEventStore::new(pool),
)
}
async fn refusals(&self, peer: &Self::Peer) -> RefusalsOf<Self::Peer> {
oversized_push_refusal(peer).await
}
async fn reopen(&self) -> Reopened {
let closing = self.pool.lock().await.take();
if let Some(pool) = closing {
pool.close().await;
}
Reopened::Discarded
}
}
macro_rules! emit_ignored_sync_tokio {
($($name:ident),* $(,)?) => {
$(
#[tokio::test]
#[ignore = "needs a live Postgres; run with `-- --ignored` (starts a container, or set HAPPENSTANCE_POSTGRES_URL)"]
async fn $name() -> ::core::result::Result<(), ::happenstance_sync_testkit::Violation> {
::happenstance_sync_testkit::rules::$name(__conformance_fixture)
.await?
.report(::core::stringify!($name));
Ok(())
}
)*
};
}
pub(crate) use emit_ignored_sync_tokio;
happenstance_sync_testkit::sync_peer_conformance!(
mod_name = sync_conformance,
emit = super::emit_ignored_sync_tokio,
fixture = super::PostgresPeerFixture::new()
);
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 awkward_events() -> [Vec<Event>; 2] {
let tagged = Tags::from_pairs([("k", "v")]).expect("a valid tag");
[
vec![
Event::new("EveryByte", (0..=u8::MAX).collect::<Vec<u8>>())
.expect("a valid type")
.with_metadata((0..=u8::MAX).rev().collect::<Vec<u8>>()),
Event::new("Empty", Vec::new()).expect("a valid type"),
Event::new("Nul", vec![0_u8]).expect("a valid type"),
],
vec![
Event::new("NotUtf8", vec![0xC3, 0x28, 0xFF, 0xFE])
.expect("a valid type")
.with_tags(tagged),
Event::new("Padding", b"==".to_vec()).expect("a valid type"),
],
]
}
async fn groups_of<N: WriteGroupStore>(near: &N) -> PushBatch
where
N::Error: core::fmt::Debug,
{
let page = near
.read_groups(None, core::num::NonZeroUsize::new(128).expect("non-zero"))
.await
.expect("the near store's groups read");
assert_eq!(page.waiting, Waiting::Nothing, "the test log fits one page");
PushBatch::new(page.groups.into_iter().map(EventGroup::from).collect())
}
async fn pull_all<P: SyncPeer>(peer: &P) -> PushBatch
where
P::Error: core::fmt::Debug,
{
let mut groups = Vec::new();
let mut from: Option<P::Resume> = None;
for _ in 0..64 {
let pulled = peer.pull(from.as_ref()).await.expect("a pull answers");
groups.extend(pulled.batch.groups);
if pulled.waiting == Waiting::Nothing {
return PushBatch::new(groups);
}
from = Some(pulled.resume);
}
panic!("the peer never said nothing was waiting");
}
#[tokio::test]
#[ignore = "needs a live Postgres; run with `-- --ignored` (starts a container, or set HAPPENSTANCE_POSTGRES_URL)"]
async fn a_round_trip_through_the_postgres_peer_is_byte_identical() {
let near = MemoryIngestFixture::new().connect().await;
let back = MemoryIngestFixture::new().connect().await;
let fixture = PostgresPeerFixture::new();
let peer = fixture.connect().await;
let far = PostgresEventStore::new(fixture.pool().await);
let [first, second] = awkward_events();
for events in [&first, &second] {
EventStore::append(&near, events, None)
.await
.expect("the near store's own append lands");
}
let sent = groups_of(&near).await;
let ack = peer.push(&sent).await.expect("the push lands");
let pulled = pull_all(&peer).await;
let own = [Event::new("PostgresOwn", vec![0x00, 0xFF, 0x80]).expect("a valid type")];
far.append(&own, None)
.await
.expect("the Postgres store's own append lands");
let everything = pull_all(&peer).await;
let groups: Vec<IngestGroup<'_>> = everything
.groups
.iter()
.map(|group| IngestGroup::new(&group.events, &[]).with_guard(group.guard.as_ref()))
.collect();
IngestStore::ingest(&back, &groups)
.await
.expect("a well-formed ingest into the near store lands");
assert_eq!(ack.appended, 5);
assert_eq!(
pulled, sent,
"the near log came back from Postgres unchanged"
);
let back_log = log(&back).await;
let held: Vec<Carried<'_>> = back_log
.iter()
.map(|stored| carried(&stored.event))
.collect();
let expected: Vec<Carried<'_>> = first
.iter()
.chain(&second)
.chain(&own)
.map(carried)
.collect();
assert_eq!(held, expected, "every payload byte for byte, in order");
}
type Carried<'e> = (&'e [u8], Option<&'e [u8]>, &'e Tags);
fn carried(event: &Event) -> Carried<'_> {
(
event.data().as_ref(),
event.metadata().map(AsRef::as_ref),
event.tags(),
)
}
#[tokio::test]
#[ignore = "needs a live Postgres; run with `-- --ignored` (starts a container, or set HAPPENSTANCE_POSTGRES_URL)"]
async fn replaying_a_pushed_batch_changes_nothing() {
let near = MemoryIngestFixture::new().connect().await;
let [first, second] = awkward_events();
for events in [&first, &second] {
EventStore::append(&near, events, None)
.await
.expect("the near store's own append lands");
}
let batch = groups_of(&near).await;
let fixture = PostgresPeerFixture::new();
let peer = fixture.connect().await;
let far = PostgresEventStore::new(fixture.pool().await);
let once = peer.push(&batch).await.expect("the first push lands");
let before = log(&far).await;
let page = peer.pull(None).await.expect("a pull answers");
let again = peer.push(&batch).await.expect("the replay lands");
assert_eq!((once.appended, once.skipped), (5, 0));
assert_eq!((again.appended, again.skipped), (0, 5));
assert_eq!(again.confirmed, once.confirmed);
assert_eq!(log(&far).await, before, "the log is unchanged");
let replayed = peer.pull(None).await.expect("a pull answers");
assert_eq!(replayed.batch, page.batch);
assert_eq!(replayed.resume, page.resume);
}