use std::collections::{BTreeMap, BTreeSet};
use proptest::prelude::*;
use rostra_core::event::{Event, EventContentRaw, EventExt as _, EventKind, VerifiedEvent};
use rostra_core::id::{RostraId, RostraIdSecretKey};
use rostra_core::{ContentHash, ShortEventId};
use super::runner::{Plan, plan_strategy, run_pair, run_property, with_content};
use super::usage::Usage;
use crate::{
Database, DbResult, content_rc, content_store, events_content_missing, events_content_state,
ids_data_usage,
};
#[derive(Clone, Debug)]
struct ContentSpec {
author: u8,
payload: u8,
byte: u8,
}
#[derive(Debug, PartialEq, Eq)]
struct ContentSnapshot {
unprocessed: BTreeSet<ShortEventId>,
fetch_queue: BTreeSet<ShortEventId>,
store: BTreeMap<ContentHash, Vec<u8>>,
reference_counts: BTreeMap<ContentHash, u64>,
usage: BTreeMap<RostraId, Usage>,
}
fn strategy() -> impl Strategy<Value = (Vec<ContentSpec>, Plan, Plan)> {
(
prop::collection::vec(
(0u8..3, 0u8..5, any::<u8>()).prop_map(|(author, payload, byte)| ContentSpec {
author,
payload,
byte,
}),
1..=8,
),
plan_strategy(),
plan_strategy(),
)
}
fn payload(spec: &ContentSpec) -> EventContentRaw {
EventContentRaw::new(match spec.payload {
0 => vec![],
1 => vec![0x41],
2 => vec![0x42, 0x42],
3 => vec![spec.byte],
_ => vec![spec.byte; usize::from(spec.byte % 8) + 1],
})
}
fn materialize(specs: &[ContentSpec]) -> Vec<rostra_core::event::VerifiedEventContent> {
let secrets = [
RostraIdSecretKey::from_bytes([21; 32]),
RostraIdSecretKey::from_bytes([22; 32]),
RostraIdSecretKey::from_bytes([23; 32]),
];
specs
.iter()
.enumerate()
.map(|(index, spec)| {
let secret = secrets[usize::from(spec.author) % secrets.len()];
let content = payload(spec);
let event = Event::builder_raw_content()
.author(secret.id())
.kind(EventKind::RAW)
.content(&content)
.timestamp(
time::OffsetDateTime::from_unix_timestamp(20_000 + index as i64)
.expect("property timestamp"),
)
.build();
let event = VerifiedEvent::verify_signed(secret.id(), event.signed_by(secret))
.expect("deterministic event verifies");
with_content(event, content)
})
.collect()
}
fn model(events: &[rostra_core::event::VerifiedEventContent]) -> ContentSnapshot {
let mut store = BTreeMap::new();
let mut reference_counts = BTreeMap::new();
let mut usage: BTreeMap<RostraId, Usage> = BTreeMap::new();
for event in events {
let content = event.content.as_ref().expect("runner content");
let hash = content.compute_content_hash();
store.insert(hash, content.as_ref().to_vec());
*reference_counts.entry(hash).or_default() += 1;
let author_usage = usage.entry(event.author()).or_default();
author_usage.current_metadata_size += 192;
author_usage.total_metadata_size += 192;
author_usage.current_metadata_num += 1;
author_usage.total_metadata_num += 1;
author_usage.current_content_size += content.len() as u64;
author_usage.total_content_size += content.len() as u64;
author_usage.current_payload_num += 1;
author_usage.total_payload_num += 1;
}
ContentSnapshot {
unprocessed: BTreeSet::new(),
fetch_queue: BTreeSet::new(),
store,
reference_counts,
usage,
}
}
async fn snapshot(db: &Database) -> DbResult<ContentSnapshot> {
db.read_with(|tx| {
let unprocessed = tx
.open_table(&events_content_state::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value()))
.collect::<Result<_, _>>()?;
let fetch_queue = tx
.open_table(&events_content_missing::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value().1))
.collect::<Result<_, _>>()?;
let store = tx
.open_table(&content_store::TABLE)?
.range(..)?
.map(|entry| {
entry
.map(|(key, value)| (key.value(), value.value().0.as_ref().as_slice().to_vec()))
})
.collect::<Result<_, _>>()?;
let reference_counts = tx
.open_table(&content_rc::TABLE)?
.range(..)?
.filter_map(|entry| match entry {
Ok((key, value)) if value.value() != 0 => Some(Ok((key.value(), value.value()))),
Ok(_) => None,
Err(error) => Some(Err(error)),
})
.collect::<Result<_, _>>()?;
let usage = tx
.open_table(&ids_data_usage::TABLE)?
.range(..)?
.map(|entry| {
entry.map(|(key, value)| {
let value = value.value();
(key.value(), value.into())
})
})
.collect::<Result<_, _>>()?;
Ok(ContentSnapshot {
unprocessed,
fetch_queue,
store,
reference_counts,
usage,
})
})
.await
}
async fn check(input: (Vec<ContentSpec>, Plan, Plan)) -> Result<(), String> {
let (specs, first_plan, second_plan) = input;
let events = materialize(&specs);
let expected = model(&events);
let self_id = RostraIdSecretKey::from_bytes([29; 32]).id();
let replicas = run_pair(self_id, &events, &first_plan, &second_plan)
.await
.map_err(|error| error.to_string())?;
let first = snapshot(&replicas.first)
.await
.map_err(|error| error.to_string())?;
let second = snapshot(&replicas.second)
.await
.map_err(|error| error.to_string())?;
if first != expected || second != expected || first != second {
return Err(format!(
"content mismatch\nexpected={expected:#?}\nfirst={first:#?}\nsecond={second:#?}"
));
}
Ok(())
}
#[test]
fn prop_live_raw_content_lifecycle_converges() {
run_property(
concat!(
module_path!(),
"::prop_live_raw_content_lifecycle_converges"
),
16,
file!(),
concat!(
env!("CARGO_MANIFEST_DIR"),
"/proptest-regressions/property/content.txt"
),
strategy(),
check,
);
}