use rostra_core::event::content_kind::{EventContentKind as _, SocialPost};
use rostra_core::event::{
Event, EventContentRaw, EventExt as _, EventKind, VerifiedEvent, VerifiedEventContent,
};
use rostra_core::id::{RostraIdSecretKey, ToShort as _};
use rostra_core::{EventId, ShortEventId, Timestamp};
use crate::social::EventPaginationCursor;
use crate::{
Database, SocialPostScanRequest, SocialPostScanStop, content_store, social_posts_by_time,
social_posts_replaced_by, social_posts_replaces,
};
fn request() -> SocialPostScanRequest {
SocialPostScanRequest {
cursor: None,
authored_from: None,
authored_through: None,
author: None,
max_rows: 100,
max_content_bytes: 1_000_000,
max_records: 100,
}
}
fn post(
secret: RostraIdSecretKey,
timestamp: i64,
parent: Option<EventId>,
replaces: Option<EventId>,
body: &str,
) -> VerifiedEventContent {
let content = SocialPost::new(body.to_owned(), None, Default::default())
.serialize_cbor()
.unwrap();
let signed = Event::builder_raw_content()
.author(secret.id())
.kind(EventKind::SOCIAL_POST)
.timestamp(time::OffsetDateTime::from_unix_timestamp(timestamp).unwrap())
.content(&content)
.maybe_parent_prev(parent.map(Into::into))
.maybe_delete(replaces.map(Into::into))
.build()
.signed_by(secret);
VerifiedEventContent::assume_verified(
VerifiedEvent::verify_signed(secret.id(), signed).unwrap(),
content,
)
}
fn cursor(post: &VerifiedEventContent) -> EventPaginationCursor {
EventPaginationCursor {
ts: post.event.timestamp(),
event_id: post.event_id().to_short(),
}
}
#[tokio::test(flavor = "multi_thread")]
async fn zero_hit_pages_charge_each_filtered_row_and_make_progress() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let other = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
for ts in 1..=9 {
db.try_process_event_with_content(&post(owner, ts, None, None, "hidden by author"))
.await?;
}
let mut req = request();
req.author = Some(other.id());
req.max_rows = 1;
req.max_content_bytes = 0;
let mut examined = 0;
loop {
let page = db.scan_social_posts_rev(req).await?;
assert!(page.rows.is_empty());
assert_eq!(page.content_bytes_decoded, 0);
assert_eq!(page.contents_decoded, 0);
assert!(page.rows_scanned <= 1);
examined += page.rows_scanned;
if page.stop == SocialPostScanStop::Exhausted {
assert_eq!(page.next_cursor, None);
break;
}
assert_eq!(page.stop, SocialPostScanStop::RowBudget);
assert!(page.next_cursor < req.cursor.or(Some(EventPaginationCursor::MAX)));
req.cursor = page.next_cursor;
}
assert_eq!(examined, 9);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn single_record_pages_preserve_ties_ranges_and_unreturned_candidates() -> anyhow::Result<()>
{
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let mut expected = Vec::new();
for ts in [1, 2, 2, 2, 3, 4] {
let candidate = post(owner, ts, None, None, &format!("post {}", expected.len()));
db.try_process_event_with_content(&candidate).await?;
expected.push(cursor(&candidate));
}
expected.retain(|key| (2..=3).contains(&key.ts.as_u64()));
expected.sort_by(|a, b| b.cmp(a));
let mut req = request();
req.authored_from = Some(2.into());
req.authored_through = Some(3.into());
req.max_records = 1;
let mut seen = Vec::new();
loop {
let page = db.scan_social_posts_rev(req).await?;
assert!(page.rows.len() <= 1);
assert_eq!(page.rows_scanned, page.rows.len());
assert_eq!(page.contents_decoded, page.rows.len());
seen.extend(page.rows.iter().map(|row| EventPaginationCursor {
ts: row.ts,
event_id: row.event_id,
}));
if page.stop == SocialPostScanStop::Exhausted {
break;
}
assert_eq!(page.stop, SocialPostScanStop::RecordBudget);
req.cursor = page.next_cursor;
}
assert_eq!(seen, expected);
req.cursor = Some(expected[1]);
let repeated = db.scan_social_posts_rev(req).await?;
assert_eq!(repeated.rows[0].event_id, expected[1].event_id);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn byte_limits_leave_blocked_candidates_and_charge_actual_decode_attempts()
-> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let older = post(owner, 1, None, None, "older");
let newer = post(owner, 2, None, None, "newer");
for candidate in [&older, &newer] {
db.try_process_event_with_content(candidate).await?;
}
let len = newer.event.content_len() as usize;
assert_eq!(len, older.event.content_len() as usize);
let mut req = request();
req.max_content_bytes = len;
let first = db.scan_social_posts_rev(req).await?;
assert_eq!(first.stop, SocialPostScanStop::ContentByteBudget);
assert_eq!(first.rows.len(), 1);
assert_eq!(first.rows[0].event_id, newer.event_id().to_short());
assert_eq!(first.rows_scanned, 2);
assert_eq!(first.contents_decoded, 1);
assert_eq!(first.content_bytes_decoded, len);
assert_eq!(first.next_cursor, Some(cursor(&older)));
req.cursor = first.next_cursor;
let second = db.scan_social_posts_rev(req).await?;
assert_eq!(second.stop, SocialPostScanStop::Exhausted);
assert_eq!(second.rows_scanned, 1);
assert_eq!(second.content_bytes_decoded, len);
assert_eq!(second.rows[0].event_id, older.event_id().to_short());
req.cursor = None;
req.max_content_bytes = len - 1;
let oversized = db.scan_social_posts_rev(req).await?;
assert_eq!(oversized.stop, SocialPostScanStop::ContentTooLarge);
assert_eq!(oversized.rows_scanned, 1);
assert_eq!(oversized.contents_decoded, 0);
assert_eq!(oversized.content_bytes_decoded, 0);
assert_eq!(oversized.next_cursor, Some(cursor(&newer)));
assert!(oversized.rows.is_empty());
req.max_content_bytes = 0;
assert_eq!(
db.scan_social_posts_rev(req).await?.stop,
SocialPostScanStop::ContentTooLarge
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn effective_edits_deletion_and_unavailable_content_match_reverse_timeline()
-> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let original = post(owner, 1, None, None, "old text");
let edit = post(
owner,
2,
Some(original.event_id()),
Some(original.event_id()),
"effective text",
);
let removed = post(owner, 3, None, None, "deleted text");
let deletion = post(
owner,
4,
Some(removed.event_id()),
Some(removed.event_id()),
"",
);
let unavailable = post(owner, 5, None, None, "unavailable");
for candidate in [&original, &edit, &removed, &deletion, &unavailable] {
db.try_process_event_with_content(candidate).await?;
}
db.write_with(|tx| {
tx.open_table(&content_store::TABLE)?
.remove(&unavailable.event.content_hash())?;
Ok(())
})
.await?;
let page = db.scan_social_posts_rev(request()).await?;
assert_eq!(page.stop, SocialPostScanStop::Exhausted);
assert_eq!(page.rows.len(), 1);
assert_eq!(page.rows[0].event_id, edit.event_id().to_short());
assert_eq!(
page.rows[0].content.djot_content.as_deref(),
Some("effective text")
);
assert_eq!(page.contents_decoded, 1);
let (legacy, _) = db.paginate_social_posts_rev(None, 100, |_| true).await;
assert_eq!(
page.rows.iter().map(|row| row.event_id).collect::<Vec<_>>(),
legacy.iter().map(|row| row.event_id).collect::<Vec<_>>()
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn hidden_rows_and_cyclic_reply_ancestry_do_not_escape_row_budget() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let visible = post(owner, 1, None, None, "visible");
let hidden = post(owner, 2, None, None, "replaced");
for candidate in [&visible, &hidden] {
db.try_process_event_with_content(candidate).await?;
}
db.write_with(|tx| {
let id = visible.event_id().to_short();
tx.open_table(&social_posts_replaces::TABLE)?
.insert(&(owner.id(), id, id), &())?;
tx.open_table(&social_posts_replaced_by::TABLE)?
.insert(&(owner.id(), hidden.event_id().to_short(), id), &())?;
Ok(())
})
.await?;
let mut req = request();
req.max_rows = 1;
let first = db.scan_social_posts_rev(req).await?;
assert_eq!(first.stop, SocialPostScanStop::RowBudget);
assert!(first.rows.is_empty());
assert_eq!(first.rows_scanned, 1);
assert_eq!(first.contents_decoded, 0);
req.cursor = first.next_cursor;
let next = db.scan_social_posts_rev(req).await?;
assert_eq!(next.rows.len(), 1);
assert_eq!(next.rows_scanned, 1);
assert_eq!(next.rows[0].event_id, visible.event_id().to_short());
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn invalid_payloads_are_charged_and_storage_decode_errors_propagate() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let candidate = post(owner, 1, None, None, "content");
db.try_process_event_with_content(&candidate).await?;
let len = candidate.event.content_len() as usize;
db.write_with(|tx| {
tx.open_table(&content_store::TABLE)?.insert(
&candidate.event.content_hash(),
&crate::event::ContentStoreRecord(std::borrow::Cow::Owned(EventContentRaw::new(
vec![0xff; len],
))),
)?;
Ok(())
})
.await?;
let page = db.scan_social_posts_rev(request()).await?;
assert_eq!(page.stop, SocialPostScanStop::Exhausted);
assert!(page.rows.is_empty());
assert_eq!(page.contents_decoded, 1);
assert_eq!(page.content_bytes_decoded, len);
db.write_with(|tx| {
let key =
crate::social_post_scan_ops::encode_content_hash_key(candidate.event.content_hash());
let mut table = tx.as_raw().open_table(content_store::TABLE.as_raw())?;
table.insert(key.as_slice(), [0xff].as_slice())?;
Ok(())
})
.await?;
assert!(db.scan_social_posts_rev(request()).await.is_err());
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn stored_wrapper_length_and_trailing_bytes_are_rejected() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let candidate = post(owner, 1, None, None, "valid payload");
db.try_process_event_with_content(&candidate).await?;
let key = crate::social_post_scan_ops::encode_content_hash_key(candidate.event.content_hash());
let original = db
.read_with(|tx| {
let table = tx.as_raw().open_table(content_store::TABLE.as_raw())?;
Ok(table.get(key.as_slice())?.unwrap().value().to_vec())
})
.await?;
let mut trailing = original.clone();
trailing.push(0);
let wrong_length = bincode::encode_to_vec(
crate::event::ContentStoreRecord(std::borrow::Cow::Owned(EventContentRaw::new(vec![
0; candidate.event.content_len() as usize + 1
]))),
redb_bincode::BINCODE_CONFIG,
)?;
for malformed in [trailing, wrong_length] {
db.write_with(|tx| {
tx.as_raw()
.open_table(content_store::TABLE.as_raw())?
.insert(key.as_slice(), malformed.as_slice())?;
Ok(())
})
.await?;
assert!(db.scan_social_posts_rev(request()).await.is_err());
}
db.write_with(|tx| {
tx.as_raw()
.open_table(content_store::TABLE.as_raw())?
.insert(key.as_slice(), original.as_slice())?;
Ok(())
})
.await?;
assert_eq!(db.scan_social_posts_rev(request()).await?.rows.len(), 1);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn unavailable_states_are_counted_without_touching_retained_payloads() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let states = [
crate::EventContentState::Missing {
last_fetch_attempt: None,
fetch_attempt_count: 0,
next_fetch_attempt: Timestamp::ZERO,
},
crate::EventContentState::Deleted {
deleted_by: ShortEventId::MAX,
},
crate::EventContentState::Pruned,
crate::EventContentState::Invalid,
];
for (index, state) in states.into_iter().enumerate() {
let candidate = post(owner, index as i64 + 1, None, None, &"large".repeat(10_000));
db.try_process_event_with_content(&candidate).await?;
db.write_with(|tx| {
tx.open_table(&crate::events_content_state::TABLE)?
.insert(&candidate.event_id().to_short(), &state)?;
Ok(())
})
.await?;
}
let mut req = request();
req.max_content_bytes = 0;
let page = db.scan_social_posts_rev(req).await?;
assert_eq!(page.stop, SocialPostScanStop::Exhausted);
assert_eq!(page.rows_scanned, states.len());
assert_eq!(page.contents_decoded, 0);
assert_eq!(page.content_bytes_decoded, 0);
assert!(page.rows.is_empty());
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn zero_limits_empty_ranges_and_terminal_keys_are_conservative() -> anyhow::Result<()> {
let owner = RostraIdSecretKey::generate();
let db = Database::new_in_memory(owner.id()).await?;
let mut req = request();
req.max_rows = 0;
let page = db.scan_social_posts_rev(req).await?;
assert_eq!(page.stop, SocialPostScanStop::RowBudget);
assert_eq!(page.rows_scanned, 0);
assert_eq!(page.next_cursor, Some(EventPaginationCursor::MAX));
req.max_rows = 100;
req.max_records = 0;
assert_eq!(
db.scan_social_posts_rev(req).await?.stop,
SocialPostScanStop::RecordBudget
);
req.authored_from = Some(2.into());
req.authored_through = Some(1.into());
let empty = db.scan_social_posts_rev(req).await?;
assert_eq!(empty.stop, SocialPostScanStop::Exhausted);
assert_eq!(empty.next_cursor, None);
db.write_with(|tx| {
let mut table = tx.open_table(&social_posts_by_time::TABLE)?;
table.insert(&(Timestamp::ZERO, ShortEventId::ZERO), &())?;
table.insert(&(Timestamp::from(1), ShortEventId::ZERO), &())?;
table.insert(&(Timestamp::ZERO, ShortEventId::MAX), &())?;
table.insert(&(Timestamp::MAX, ShortEventId::MAX), &())?;
Ok(())
})
.await?;
req = request();
req.max_rows = 1;
let max = db.scan_social_posts_rev(req).await?;
assert_eq!(max.rows_scanned, 1);
assert_eq!(max.next_cursor.unwrap().ts, Timestamp::MAX);
req.cursor = Some(EventPaginationCursor {
ts: 1.into(),
event_id: ShortEventId::ZERO,
});
let rollover = db.scan_social_posts_rev(req).await?;
assert_eq!(
rollover.next_cursor,
Some(EventPaginationCursor {
ts: Timestamp::ZERO,
event_id: ShortEventId::MAX
})
);
req.cursor = rollover.next_cursor;
let last_range = db.scan_social_posts_rev(req).await?;
assert_eq!(last_range.rows_scanned, 1);
req.cursor = last_range.next_cursor;
let terminal = db.scan_social_posts_rev(req).await?;
assert_eq!(terminal.rows_scanned, 1);
assert_eq!(terminal.stop, SocialPostScanStop::Exhausted);
assert_eq!(terminal.next_cursor, None);
Ok(())
}