mod event_order;
mod property;
use rostra_core::event::content_kind::{self, EventContentKind as _};
use rostra_core::event::{
Event, EventContentRaw, EventExt as _, EventKind, PersonaSelector, VerifiedEvent,
VerifiedEventContent,
};
use rostra_core::id::{RostraId, RostraIdSecretKey, ToShort as _};
use rostra_core::{EventId, Timestamp};
use rostra_util_error::BoxedErrorResult;
use snafu::ResultExt as _;
use tempfile::{TempDir, tempdir};
use tracing::info;
use crate::event::EventContentState;
use crate::event_order::EventOrder;
use crate::{
Database, content_rc, content_store, events, events_by_time, events_content_missing,
events_content_state, events_heads, events_missing, ids_full,
};
pub(crate) async fn temp_db_rng() -> BoxedErrorResult<(TempDir, super::Database)> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
temp_db(author).await
}
pub(crate) async fn temp_db(self_id: RostraId) -> BoxedErrorResult<(TempDir, super::Database)> {
let dir = tempdir()?;
let db = super::Database::open(dir.path().join("db.redb"), self_id)
.await
.boxed()?;
Ok((dir, db))
}
fn build_test_event(
id_secret: RostraIdSecretKey,
parent: impl Into<Option<EventId>>,
) -> VerifiedEvent {
let parent = parent.into();
let content = EventContentRaw::new(vec![]);
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.content(&content)
.build();
let signed_event = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed_event).expect("Valid event")
}
fn build_follow_event_content(
secret: RostraIdSecretKey,
followee: RostraId,
timestamp: time::OffsetDateTime,
parent: Option<EventId>,
) -> VerifiedEventContent {
let content = content_kind::Follow {
followee,
persona: None,
selector: Some(PersonaSelector::Except { ids: vec![] }),
persona_tags_selector: None,
}
.serialize_cbor()
.expect("Follow content must serialize");
let event = Event::builder_raw_content()
.author(secret.id())
.kind(EventKind::FOLLOW)
.content(&content)
.timestamp(timestamp)
.maybe_parent_prev(parent.map(Into::into))
.build();
let signed_event = event.signed_by(secret);
let verified_event =
VerifiedEvent::verify_signed(secret.id(), signed_event).expect("Valid event");
VerifiedEventContent::assume_verified(verified_event, content)
}
fn build_post_event_content(
secret: RostraIdSecretKey,
timestamp: time::OffsetDateTime,
parent: Option<EventId>,
text: &str,
) -> VerifiedEventContent {
let content = content_kind::SocialPost::new(text.to_owned(), None, Default::default())
.serialize_cbor()
.expect("Social post content must serialize");
let event = Event::builder_raw_content()
.author(secret.id())
.kind(EventKind::SOCIAL_POST)
.content(&content)
.timestamp(timestamp)
.maybe_parent_prev(parent.map(Into::into))
.build();
let signed_event = event.signed_by(secret);
let verified_event =
VerifiedEvent::verify_signed(secret.id(), signed_event).expect("Valid event");
VerifiedEventContent::assume_verified(verified_event, content)
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_store_event() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event_a = build_test_event(id_secret, None);
let event_a_id = event_a.event_id;
let event_b = build_test_event(id_secret, event_a.event_id);
let event_b_id = event_b.event_id;
let event_c = build_test_event(id_secret, event_b.event_id);
let event_c_id = event_c.event_id;
let event_d = build_test_event(id_secret, event_c.event_id);
let event_d_id = event_d.event_id;
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx).boxed()?;
let mut events_table = tx.open_table(&events::TABLE).boxed()?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE).boxed()?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE).boxed()?;
let mut content_store_table = tx.open_table(&content_store::TABLE).boxed()?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE).boxed()?;
let mut events_content_missing_table =
tx.open_table(&events_content_missing::TABLE).boxed()?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE).boxed()?;
for (event, missing_expect, heads_expect) in [
(event_a, vec![], vec![event_a_id]),
(event_c, vec![event_b_id], vec![event_a_id, event_c_id]),
(event_d, vec![event_b_id], vec![event_a_id, event_d_id]),
(event_b, vec![], vec![event_d_id]),
] {
let mut missing_expect: Vec<rostra_core::ShortEventId> =
missing_expect.into_iter().map(Into::into).collect();
let mut heads_expect: Vec<rostra_core::ShortEventId> =
heads_expect.into_iter().map(Into::into).collect();
missing_expect.sort_unstable();
heads_expect.sort_unstable();
for _ in 0..2 {
info!(event_id = %event.event_id, "Inserting");
Database::insert_event_tx(
event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
info!(event_id = %event.event_id, "Checking missing");
let missing =
Database::get_missing_events_for_id_tx(author, &events_missing_table)?;
missing
.iter()
.for_each(|missing| info!(%missing, "Missing"));
assert_eq!(missing, missing_expect);
info!(event_id = %event.event_id, "Checking heads");
let heads = Database::get_heads_events_tx(author, &events_heads_table)?;
heads.iter().for_each(|head| info!(%head, "Head"));
assert_eq!(heads, heads_expect);
}
}
Ok(())
})
.await?;
Ok(())
}
fn build_test_event_2(
id_secret: RostraIdSecretKey,
parent: impl Into<Option<EventId>>,
delete: impl Into<Option<EventId>>,
) -> VerifiedEvent {
let parent = parent.into();
let delete = delete.into();
let content = EventContentRaw::from(vec![]);
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.maybe_delete(delete.map(Into::into))
.content(&content)
.build();
let signed_event = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed_event).expect("Valid event")
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_store_deleted_event() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let event_a = build_test_event_2(id_secret, None, None);
let event_a_id = event_a.event_id;
let event_b = build_test_event_2(id_secret, event_a.event_id, event_a_id);
let event_b_id = event_b.event_id;
let event_c = build_test_event_2(id_secret, event_b.event_id, event_a_id);
let event_c_id = event_c.event_id;
let event_d = build_test_event_2(id_secret, event_c.event_id, event_b_id);
let event_d_id = event_d.event_id;
let event_a_deleted_by = [
(event_b.timestamp(), event_b_id.to_short()),
(event_c.timestamp(), event_c_id.to_short()),
]
.into_iter()
.max()
.expect("two direct deleters")
.1;
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx).boxed()?;
let mut events_table = tx.open_table(&events::TABLE).boxed()?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE).boxed()?;
let mut content_store_table = tx.open_table(&content_store::TABLE).boxed()?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE).boxed()?;
let mut events_content_missing_table =
tx.open_table(&events_content_missing::TABLE).boxed()?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE).boxed()?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE).boxed()?;
for (event, expected_states) in [
(event_a, [Some(None), None, None, None]),
(
event_c,
[Some(Some(event_c_id.into())), None, Some(None), None],
),
(
event_d,
[Some(Some(event_c_id.into())), None, Some(None), Some(None)],
),
(
event_b,
[
Some(Some(event_a_deleted_by)),
Some(Some(event_d_id.into())),
Some(None),
Some(None),
],
),
] {
info!(event_id = %event.event_id, "# Inserting");
for _ in 0..2 {
Database::insert_event_tx(
event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
for (event_id, expected_state) in [event_a_id, event_b_id, event_c_id, event_d_id]
.into_iter()
.zip(expected_states)
{
info!(event_id = %event_id, "Checking");
let state = Database::get_event_tx(event_id, &events_table)?.map(|_record| {
let content_state = Database::get_event_content_state_tx(
event_id,
&events_content_state_table,
)
.expect("no db errors");
info!(event_id = %event_id, ?content_state, "State");
match content_state {
Some(EventContentState::Deleted { deleted_by }) => Some(deleted_by),
Some(_) => None,
None => None,
}
});
assert_eq!(state, expected_state);
}
}
}
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_cross_author_parent_never_resolves_or_deletes() -> BoxedErrorResult<()> {
let child_secret = RostraIdSecretKey::generate();
let child_author = child_secret.id();
let target_secret = RostraIdSecretKey::generate();
let target_author = target_secret.id();
let target_content = EventContentRaw::new(vec![1, 2, 3]);
let target = Event::builder_raw_content()
.author(target_author)
.kind(EventKind::SOCIAL_POST)
.content(&target_content)
.build()
.signed_by(target_secret);
let target =
VerifiedEvent::verify_signed(target_author, target).expect("target event is valid");
let target_id = target.event_id.to_short();
let target_content_hash = target.content_hash();
let child_content = EventContentRaw::new(vec![]);
let ordinary_child = Event::builder_raw_content()
.author(child_author)
.kind(EventKind::SOCIAL_POST)
.parent_prev(target_id)
.content(&child_content)
.build()
.signed_by(child_secret);
let ordinary_child = VerifiedEvent::verify_signed(child_author, ordinary_child)
.expect("ordinary child is valid");
let deleting_child = Event::builder_raw_content()
.author(child_author)
.kind(EventKind::SOCIAL_POST)
.delete(target_id)
.content(&child_content)
.build()
.signed_by(child_secret);
let deleting_child = VerifiedEvent::verify_signed(child_author, deleting_child)
.expect("deleting child is valid");
for (name, child, target_first) in [
("target then ordinary child", ordinary_child, true),
("ordinary child then target", ordinary_child, false),
("target then deleting child", deleting_child, true),
("deleting child then target", deleting_child, false),
] {
let (_dir, db) = temp_db(child_author).await?;
if target_first {
db.process_event(&target).await;
db.process_event(&child).await;
} else {
db.process_event(&child).await;
db.process_event(&target).await;
}
db.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let events_missing_table = tx.open_table(&events_missing::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let stored_target = Database::get_event_tx(target_id, &events_table)?
.unwrap_or_else(|| panic!("{name}: target must remain stored"));
assert_eq!(
stored_target.author(),
target_author,
"{name}: target author changed"
);
let target_state =
Database::get_event_content_state_tx(target_id, &events_content_state_table)?;
assert!(
matches!(target_state, Some(EventContentState::Missing { .. })),
"{name}: cross-author child changed target state to {target_state:?}"
);
assert_eq!(
Database::get_content_rc_tx(target_content_hash, &content_rc_table)?,
1,
"{name}: cross-author child changed target content reference count"
);
let missing_parent = events_missing_table
.get(&(child_author, target_id))?
.map(|record| record.value())
.unwrap_or_else(|| panic!("{name}: parent must remain missing for child author"));
assert_eq!(
missing_parent.deleted_by,
child
.is_delete_parent_aux_content_set()
.then_some(child.event_id.to_short()),
"{name}: missing-parent deletion intent changed"
);
assert!(
events_missing_table
.get(&(target_author, target_id))?
.is_none(),
"{name}: target must not be missing from its own graph"
);
Ok(())
})
.await?;
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_content_reference_counting() -> BoxedErrorResult<()> {
use rostra_core::event::EventContentRaw;
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let test_content = EventContentRaw::new(vec![1u8; 32]);
let test_content_hash = test_content.compute_content_hash();
db.write_with(|tx| {
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let initial_count = Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(initial_count, 0, "Initial count should be 0");
Database::increment_content_rc_tx(test_content_hash, &mut content_rc_table)?;
let count_after_first = Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(
count_after_first, 1,
"Count should be 1 after first increment"
);
Database::increment_content_rc_tx(test_content_hash, &mut content_rc_table)?;
let count_after_second = Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(
count_after_second, 2,
"Count should be 2 after second increment"
);
Database::increment_content_rc_tx(test_content_hash, &mut content_rc_table)?;
let count_after_third = Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(
count_after_third, 3,
"Count should be 3 after third increment"
);
let remaining =
Database::decrement_content_rc_tx(test_content_hash, &mut content_rc_table)?;
assert_eq!(remaining, 2, "Remaining count should be 2");
let count_after_first_decrement =
Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(
count_after_first_decrement, 2,
"Count should be 2 after first decrement"
);
let remaining =
Database::decrement_content_rc_tx(test_content_hash, &mut content_rc_table)?;
assert_eq!(remaining, 1, "Remaining count should be 1");
let remaining =
Database::decrement_content_rc_tx(test_content_hash, &mut content_rc_table)?;
assert_eq!(remaining, 0, "Remaining count should be 0");
let final_count = Database::get_content_rc_tx(test_content_hash, &content_rc_table)?;
assert_eq!(final_count, 0, "Count should be 0 after all decrements");
let rc_entry_exists = content_rc_table.get(&test_content_hash)?.is_some();
assert!(
!rc_entry_exists,
"RC entry should be removed when count reaches 0"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_event_arrives_before_content() -> BoxedErrorResult<()> {
use std::borrow::Cow;
use rostra_core::Timestamp;
use rostra_core::id::ToShort;
use crate::event::ContentStoreRecord;
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let event = build_test_event(id_secret, None);
let event_id = event.event_id.to_short();
let content_hash = event.content_hash();
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
Database::insert_event_tx(
event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_id))?
.is_none(),
"content_len=0 event should NOT be in events_content_missing"
);
assert!(
Database::get_event_content_state_tx(event_id, &events_content_state_table)?.is_none(),
"content_len=0 event should have no content state entry"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 — incremented for content_len=0");
let test_content = EventContentRaw::new(vec![]);
content_store_table.insert(&content_hash, &ContentStoreRecord(Cow::Owned(test_content)))?;
assert!(
Database::is_content_available_for_event_tx(
event_id,
content_hash,
&events_content_state_table,
&content_store_table
)?,
"Content should be available now"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 for content_len=0");
assert!(
Database::get_event_content_state_tx(event_id, &events_content_state_table)?.is_none(),
"content_len=0 event should still have no content state entry"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_content_exists_when_event_arrives() -> BoxedErrorResult<()> {
use std::borrow::Cow;
use rostra_core::Timestamp;
use rostra_core::id::ToShort;
use crate::event::ContentStoreRecord;
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let event = build_test_event(id_secret, None);
let event_id = event.event_id.to_short();
let content_hash = event.content_hash();
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
let test_content = EventContentRaw::new(vec![]);
content_store_table.insert(&content_hash, &ContentStoreRecord(Cow::Owned(test_content)))?;
Database::insert_event_tx(
event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_id))?
.is_none(),
"Event should NOT be in events_content_missing"
);
let state = Database::get_event_content_state_tx(event_id, &events_content_state_table)?;
assert!(
state.is_none(),
"content_len=0 event should have no content state entry"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 — incremented for content_len=0");
assert!(
Database::is_content_available_for_event_tx(
event_id,
content_hash,
&events_content_state_table,
&content_store_table
)?,
"Content should be available"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_multiple_events_share_content() -> BoxedErrorResult<()> {
use std::borrow::Cow;
use rostra_core::Timestamp;
use rostra_core::id::ToShort;
use crate::event::ContentStoreRecord;
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let event_a = build_test_event(id_secret, None);
let event_a_id = event_a.event_id.to_short();
let event_b = build_test_event(id_secret, event_a.event_id);
let event_b_id = event_b.event_id.to_short();
let content_hash = event_a.content_hash();
assert_eq!(
content_hash,
event_b.content_hash(),
"Both events should have same content hash"
);
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
Database::insert_event_tx(
event_a,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
assert_eq!(
Database::get_content_rc_tx(content_hash, &content_rc_table)?,
1,
"RC=1 after A arrives (content_len=0 now gets RC increment)"
);
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_a_id))?
.is_none(),
"A should NOT be in missing (content_len=0)"
);
let test_content = EventContentRaw::new(vec![]);
if content_store_table.get(&content_hash)?.is_none() {
content_store_table
.insert(&content_hash, &ContentStoreRecord(Cow::Owned(test_content)))?;
}
assert_eq!(
Database::get_content_rc_tx(content_hash, &content_rc_table)?,
1,
"RC=1 - content arrival doesn't change RC"
);
Database::insert_event_tx(
event_b,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
assert_eq!(
Database::get_content_rc_tx(content_hash, &content_rc_table)?,
2,
"RC=2 after B arrives (both A and B increment RC)"
);
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_b_id))?
.is_none(),
"B should NOT be in missing (content_len=0)"
);
assert!(
Database::get_event_content_state_tx(event_b_id, &events_content_state_table)?
.is_none(),
"B should have no content state entry (content_len=0)"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_multiple_events_waiting_for_content() -> BoxedErrorResult<()> {
use std::borrow::Cow;
use rostra_core::Timestamp;
use rostra_core::id::ToShort;
use crate::event::ContentStoreRecord;
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let event_a = build_test_event(id_secret, None);
let event_a_id = event_a.event_id.to_short();
let event_b = build_test_event(id_secret, event_a.event_id);
let event_b_id = event_b.event_id.to_short();
let content_hash = event_a.content_hash();
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
Database::insert_event_tx(
event_a,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Database::insert_event_tx(
event_b,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_a_id))?
.is_none()
);
assert!(
events_content_missing_table
.get(&(Timestamp::ZERO, event_b_id))?
.is_none()
);
assert_eq!(
Database::get_content_rc_tx(content_hash, &content_rc_table)?,
2,
"RC=2 — both content_len=0 events increment RC"
);
let test_content = EventContentRaw::new(vec![]);
if content_store_table.get(&content_hash)?.is_none() {
content_store_table
.insert(&content_hash, &ContentStoreRecord(Cow::Owned(test_content)))?;
}
assert_eq!(
Database::get_content_rc_tx(content_hash, &content_rc_table)?,
2
);
assert!(
Database::is_content_available_for_event_tx(
event_a_id,
content_hash,
&events_content_state_table,
&content_store_table
)?,
"Content should be available for A"
);
assert!(
Database::is_content_available_for_event_tx(
event_b_id,
content_hash,
&events_content_state_table,
&content_store_table
)?,
"Content should be available for B"
);
assert!(
Database::get_event_content_state_tx(event_a_id, &events_content_state_table)?
.is_none(),
"A should have no content state entry"
);
assert!(
Database::get_event_content_state_tx(event_b_id, &events_content_state_table)?
.is_none(),
"B should have no content state entry"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_delete_event_arrives_before_target() -> BoxedErrorResult<()> {
use rostra_core::id::ToShort as _;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let fake_event_a = {
let content = EventContentRaw::new(vec![1, 2, 3]);
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content)
.build();
event.signed_by(id_secret)
};
let fake_event_a_id = fake_event_a.compute_id();
let fake_event_d = {
let content = EventContentRaw::new(vec![4, 5, 6]);
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content)
.build();
event.signed_by(id_secret)
};
let fake_event_d_id = fake_event_d.compute_id();
let event_b = {
let content = EventContentRaw::new(vec![10, 11, 12]);
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.delete(fake_event_a_id.to_short()) .content(&content)
.build();
let signed = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed).expect("Valid event")
};
let event_b_id = event_b.event_id.to_short();
let event_c = {
let content = EventContentRaw::new(vec![13, 14, 15]);
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.parent_aux(fake_event_d_id.to_short()) .content(&content)
.build();
let signed = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed).expect("Valid event")
};
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
Database::insert_event_tx(
event_b,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
let missing_a = events_missing_table
.get(&(author, fake_event_a_id.to_short()))?
.map(|g| g.value());
assert!(
missing_a.is_some(),
"A should be in events_missing (referenced by B)"
);
assert_eq!(
missing_a.unwrap().deleted_by,
Some(event_b_id),
"A should be marked as deleted_by = B (delete event targeting missing parent_aux)"
);
Database::insert_event_tx(
event_c,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
let missing_d = events_missing_table
.get(&(author, fake_event_d_id.to_short()))?
.map(|g| g.value());
assert!(
missing_d.is_some(),
"D should be in events_missing (referenced by C)"
);
assert_eq!(
missing_d.unwrap().deleted_by,
None,
"D should NOT be marked as deleted (C is not a delete event)"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_follow_unfollow_timestamp_ordering() -> BoxedErrorResult<()> {
use rostra_core::Timestamp;
use rostra_core::event::content_kind;
use crate::{ids_follow_events, ids_followees, ids_followers, ids_unfollowed};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(author).await?;
db.write_with(|tx| {
let mut followees_table = tx.open_table(&ids_followees::TABLE)?;
let mut followers_table = tx.open_table(&ids_followers::TABLE)?;
let mut follow_events_table = tx.open_table(&ids_follow_events::TABLE)?;
let mut unfollowed_table = tx.open_table(&ids_unfollowed::TABLE)?;
let ts_100 = Timestamp::from(100);
let ts_200 = Timestamp::from(200);
let ts_150 = Timestamp::from(150);
let follow_content = content_kind::Follow {
followee,
persona: None,
selector: None,
persona_tags_selector: None,
};
let result = Database::insert_follow_tx(
author,
EventOrder::new(ts_100, rostra_core::ShortEventId::ZERO),
follow_content.clone(),
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Initial follow should succeed");
let record = followees_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.latest_ts, ts_100);
let result = Database::insert_follow_tx(
author,
EventOrder::new(Timestamp::from(50), rostra_core::ShortEventId::ZERO),
follow_content.clone(),
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Older same-epoch follow should update first_ts");
let record = followees_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.latest_ts, ts_100);
assert_eq!(record.first_ts, Timestamp::from(50));
let result = Database::insert_follow_tx(
author,
EventOrder::new(ts_100, rostra_core::ShortEventId::ZERO),
follow_content.clone(),
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(!result, "Duplicate follow should be rejected");
let result = Database::insert_follow_tx(
author,
EventOrder::new(ts_200, rostra_core::ShortEventId::ZERO),
follow_content,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Follow with newer timestamp should succeed");
let record = followees_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.latest_ts, ts_200);
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_150, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Older unfollow should update the epoch boundary");
let record = followees_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.latest_ts, ts_200);
assert_eq!(record.first_ts, ts_200);
let ts_300 = Timestamp::from(300);
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_300, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Unfollow with newer timestamp should succeed");
let follow_content2 = content_kind::Follow {
followee,
persona: None,
selector: None,
persona_tags_selector: None,
};
let result = Database::insert_follow_tx(
author,
EventOrder::new(ts_200, rostra_core::ShortEventId::ZERO),
follow_content2.clone(),
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(
!result,
"Follow with timestamp older than unfollow should be rejected"
);
let ts_400 = Timestamp::from(400);
let result = Database::insert_follow_tx(
author,
EventOrder::new(ts_400, rostra_core::ShortEventId::ZERO),
follow_content2,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(
result,
"Follow with timestamp newer than unfollow should succeed"
);
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_300, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(
!result,
"Unfollow with timestamp older than current state should be rejected"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_get_random_self_event() -> BoxedErrorResult<()> {
use rostra_core::id::ToShort as _;
use crate::events_self;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event_a = build_test_event(id_secret, None);
let event_b = build_test_event(id_secret, event_a.event_id);
let event_a_short = event_a.event_id.to_short();
let event_b_short = event_b.event_id.to_short();
db.write_with(|tx| {
let mut events_self_table = tx.open_table(&events_self::TABLE)?;
let result = Database::get_random_self_event(&events_self_table)?;
assert!(result.is_none(), "Empty table should return None");
events_self_table.insert(&event_a_short, &())?;
let result = Database::get_random_self_event(&events_self_table)?;
assert_eq!(result, Some(event_a_short), "Should return the only event");
events_self_table.insert(&event_b_short, &())?;
let result = Database::get_random_self_event(&events_self_table)?;
assert!(
result == Some(event_a_short) || result == Some(event_b_short),
"Should return one of the events"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_get_random_self_event_fallback_paths() -> BoxedErrorResult<()> {
use rostra_core::ShortEventId;
use rostra_core::id::ToShort as _;
use crate::events_self;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event = build_test_event(id_secret, None);
let event_short = event.event_id.to_short();
db.write_with(|tx| {
let mut events_self_table = tx.open_table(&events_self::TABLE)?;
events_self_table.insert(&event_short, &())?;
for _ in 0..100 {
let result = Database::get_random_self_event(&events_self_table)?;
assert_eq!(
result,
Some(event_short),
"Should always find the single event via primary or fallback path"
);
}
events_self_table.remove(&event_short)?;
let low_event_id =
ShortEventId::from_bytes([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
events_self_table.insert(&low_event_id, &())?;
for _ in 0..50 {
let result = Database::get_random_self_event(&events_self_table)?;
assert_eq!(
result,
Some(low_event_id),
"Should find low event ID via primary or fallback"
);
}
events_self_table.remove(&low_event_id)?;
let high_event_id = ShortEventId::from_bytes([
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFE,
]);
events_self_table.insert(&high_event_id, &())?;
for _ in 0..50 {
let result = Database::get_random_self_event(&events_self_table)?;
assert_eq!(
result,
Some(high_event_id),
"Should find high event ID via primary or fallback"
);
}
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_duplicate_unfollow_rejected() -> BoxedErrorResult<()> {
use rostra_core::Timestamp;
use crate::{ids_follow_events, ids_followees, ids_followers, ids_unfollowed};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(author).await?;
db.write_with(|tx| {
let mut followees_table = tx.open_table(&ids_followees::TABLE)?;
let mut followers_table = tx.open_table(&ids_followers::TABLE)?;
let mut follow_events_table = tx.open_table(&ids_follow_events::TABLE)?;
let mut unfollowed_table = tx.open_table(&ids_unfollowed::TABLE)?;
let ts_100 = Timestamp::from(100);
let ts_200 = Timestamp::from(200);
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_100, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Initial unfollow should succeed");
let record = unfollowed_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.ts, ts_100);
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_100, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(!result, "Duplicate unfollow should be rejected");
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(Timestamp::from(50), rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(!result, "Unfollow with older timestamp should be rejected");
let result = Database::insert_unfollow_tx(
author,
EventOrder::new(ts_200, rostra_core::ShortEventId::ZERO),
followee,
&mut followees_table,
&mut followers_table,
&mut follow_events_table,
&mut unfollowed_table,
)?;
assert!(result, "Unfollow with newer timestamp should succeed");
let record = unfollowed_table.get(&(author, followee))?.unwrap().value();
assert_eq!(record.ts, ts_200);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_insert_latest_value_timestamp_ordering() -> BoxedErrorResult<()> {
use rostra_core::Timestamp;
use rostra_core::id::ToShort as _;
use crate::{IdSocialProfileRecord, social_profiles};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event = build_test_event(id_secret, None);
let event_short = event.event_id.to_short();
db.write_with(|tx| {
let mut profiles_table = tx.open_table(&social_profiles::TABLE)?;
let ts_100 = Timestamp::from(100);
let ts_200 = Timestamp::from(200);
let profile_alice = IdSocialProfileRecord {
event_id: event_short,
display_name: "Alice".to_string(),
bio: "".to_string(),
avatar: None,
};
let result = Database::insert_latest_value_tx(
ts_100,
&author,
profile_alice.clone(),
&mut profiles_table,
)?;
assert!(result, "Initial insert should succeed");
let record = profiles_table.get(&author)?.unwrap().value();
assert_eq!(record.ts, ts_100);
assert_eq!(record.inner.display_name, "Alice");
let profile_bob = IdSocialProfileRecord {
event_id: event_short,
display_name: "Bob".to_string(),
bio: "".to_string(),
avatar: None,
};
let result = Database::insert_latest_value_tx(
ts_100,
&author,
profile_bob.clone(),
&mut profiles_table,
)?;
assert!(!result, "Duplicate value should be rejected");
let record = profiles_table.get(&author)?.unwrap().value();
assert_eq!(record.inner.display_name, "Alice");
let profile_charlie = IdSocialProfileRecord {
event_id: event_short,
display_name: "Charlie".to_string(),
bio: "".to_string(),
avatar: None,
};
let result = Database::insert_latest_value_tx(
Timestamp::from(50),
&author,
profile_charlie,
&mut profiles_table,
)?;
assert!(!result, "Insert with older timestamp should be rejected");
let record = profiles_table.get(&author)?.unwrap().value();
assert_eq!(record.inner.display_name, "Alice");
let result =
Database::insert_latest_value_tx(ts_200, &author, profile_bob, &mut profiles_table)?;
assert!(result, "Insert with newer timestamp should succeed");
let record = profiles_table.get(&author)?.unwrap().value();
assert_eq!(record.ts, ts_200);
assert_eq!(record.inner.display_name, "Bob");
Ok(())
})
.await?;
Ok(())
}
fn build_test_event_with_invalid_content(
id_secret: RostraIdSecretKey,
parent: impl Into<Option<EventId>>,
content_size: usize,
) -> (VerifiedEvent, EventContentRaw) {
let parent = parent.into();
let content = EventContentRaw::new(vec![0u8; content_size]);
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.content(&content)
.build();
let signed = event.signed_by(id_secret);
let verified = VerifiedEvent::verify_signed(author, signed).expect("Valid event");
(verified, content)
}
fn build_test_event_with_valid_content(
id_secret: RostraIdSecretKey,
parent: impl Into<Option<EventId>>,
text: &str,
) -> (VerifiedEvent, EventContentRaw) {
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
let parent = parent.into();
let post = content_kind::SocialPost::new(
text.to_string(),
None, Default::default(), );
let content = post.serialize_cbor().expect("valid cbor");
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.content(&content)
.build();
let signed = event.signed_by(id_secret);
let verified = VerifiedEvent::verify_signed(author, signed).expect("Valid event");
(verified, content)
}
fn build_delete_event(
id_secret: RostraIdSecretKey,
parent: EventId,
delete: EventId,
) -> VerifiedEvent {
let content = EventContentRaw::new(vec![]);
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.parent_prev(parent.into())
.delete(delete.into())
.content(&content)
.build();
let signed = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed).expect("Valid event")
}
fn build_delete_event_at(
id_secret: RostraIdSecretKey,
parent: EventId,
delete: EventId,
content: &EventContentRaw,
timestamp: i64,
) -> VerifiedEvent {
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.parent_prev(parent.into())
.delete(delete.into())
.content(content)
.timestamp(
time::OffsetDateTime::from_unix_timestamp(timestamp).expect("valid test timestamp"),
)
.build();
let signed = event.signed_by(id_secret);
VerifiedEvent::verify_signed(author, signed).expect("Valid event")
}
async fn get_deleted_by(
db: &Database,
event_id: impl Into<rostra_core::ShortEventId>,
) -> BoxedErrorResult<rostra_core::ShortEventId> {
let event_id = event_id.into();
Ok(db
.read_with(|tx| {
let states = tx.open_table(&events_content_state::TABLE)?;
Ok(
match Database::get_event_content_state_tx(event_id, &states)? {
Some(EventContentState::Deleted { deleted_by }) => Some(deleted_by),
_ => None,
},
)
})
.await?
.expect("event content must be deleted"))
}
async fn get_test_content_rc(
db: &Database,
content_hash: rostra_core::ContentHash,
) -> BoxedErrorResult<u64> {
Ok(db
.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
Database::get_content_rc_tx(content_hash, &content_rc_table)
})
.await?)
}
async fn get_test_reply_count(
db: &Database,
event_id: impl Into<rostra_core::ShortEventId>,
) -> BoxedErrorResult<u64> {
let event_id = event_id.into();
Ok(db
.read_with(|tx| {
let social_posts = tx.open_table(&crate::social_posts::TABLE)?;
Ok(social_posts
.get(&event_id)?
.map(|record| record.value().reply_count)
.unwrap_or_default())
})
.await?)
}
const THREE_EVENT_PERMUTATIONS: [[usize; 3]; 6] = [
[0, 1, 2],
[0, 2, 1],
[1, 0, 2],
[1, 2, 0],
[2, 0, 1],
[2, 1, 0],
];
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_deletion_is_monotone_across_delivery_permutations() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (target, target_content) =
build_test_event_with_valid_content(id_secret, None, "monotone target");
let target_id = target.event_id;
let target_hash = target.content_hash();
let deleting = build_delete_event(id_secret, target_id, target_id);
let deleting_id = deleting.event_id.to_short();
let ordinary = build_test_event(id_secret, target_id);
let events = [deleting, ordinary, target];
for permutation in THREE_EVENT_PERMUTATIONS {
let (_dir, db) = temp_db(author).await?;
for index in permutation {
db.process_event(&events[index]).await;
}
let verified_content = rostra_core::event::VerifiedEventContent::assume_verified(
target,
target_content.clone(),
);
db.process_event_content(&verified_content).await;
assert_eq!(get_deleted_by(&db, target_id).await?, deleting_id);
assert_eq!(get_test_content_rc(&db, target_hash).await?, 0);
assert!(!db.is_event_content_missing(target_id.to_short()).await);
assert!(db.get_event_content(target_id).await.is_none());
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_direct_deleters_converge_across_delivery_permutations() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (target, target_content) =
build_test_event_with_valid_content(id_secret, None, "canonical target");
let target_id = target.event_id;
let target_hash = target.content_hash();
let empty = EventContentRaw::new(vec![]);
let delete_1 = build_delete_event_at(id_secret, target_id, target_id, &empty, 1_000);
let delete_2 = build_delete_event_at(id_secret, delete_1.event_id, target_id, &empty, 1_001);
let expected = delete_2.event_id.to_short();
let events = [delete_1, delete_2, target];
for permutation in THREE_EVENT_PERMUTATIONS {
let (_dir, db) = temp_db(author).await?;
for index in permutation {
db.process_event(&events[index]).await;
}
let verified_content = rostra_core::event::VerifiedEventContent::assume_verified(
target,
target_content.clone(),
);
db.process_event_content(&verified_content).await;
assert_eq!(get_deleted_by(&db, target_id).await?, expected);
assert_eq!(get_test_content_rc(&db, target_hash).await?, 0);
assert!(!db.is_event_content_missing(target_id.to_short()).await);
assert!(db.get_event_content(target_id).await.is_none());
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_equal_timestamp_deleters_use_event_id_tiebreak() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (target, _) = build_test_event_with_valid_content(id_secret, None, "equal-time target");
let target_id = target.event_id;
let empty = EventContentRaw::new(vec![]);
let delete_1 = build_delete_event_at(id_secret, target_id, target_id, &empty, 2_000);
let delete_2 = build_delete_event_at(id_secret, delete_1.event_id, target_id, &empty, 2_000);
let expected = delete_1
.event_id
.to_short()
.max(delete_2.event_id.to_short());
let events = [delete_1, delete_2, target];
for permutation in THREE_EVENT_PERMUTATIONS {
let (_dir, db) = temp_db(author).await?;
for index in permutation {
db.process_event(&events[index]).await;
}
assert_eq!(get_deleted_by(&db, target_id).await?, expected);
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_deleter_attribution_update_does_not_repeat_reversion() -> BoxedErrorResult<()> {
use rostra_core::ExternalEventId;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{EventContentKind as _, SocialPost};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let parent_content =
SocialPost::new("parent".to_owned(), None, Default::default()).serialize_cbor()?;
let parent = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&parent_content)
.build()
.signed_by(id_secret);
let parent = VerifiedEvent::verify_signed(author, parent).expect("valid parent event");
let reply_content = SocialPost::new(
"reply".to_owned(),
Some(ExternalEventId::new(author, parent.event_id)),
Default::default(),
)
.serialize_cbor()?;
let reply = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.parent_prev(parent.event_id.into())
.content(&reply_content)
.build()
.signed_by(id_secret);
let reply = VerifiedEvent::verify_signed(author, reply).expect("valid reply event");
db.process_event_with_content(&VerifiedEventContent::assume_verified(
parent,
parent_content,
))
.await;
db.process_event_with_content(&VerifiedEventContent::assume_verified(reply, reply_content))
.await;
assert_eq!(get_test_reply_count(&db, parent.event_id).await?, 1);
let empty = EventContentRaw::new(vec![]);
let delete_1 = build_delete_event_at(id_secret, reply.event_id, reply.event_id, &empty, 5_000);
let delete_2 =
build_delete_event_at(id_secret, delete_1.event_id, reply.event_id, &empty, 5_001);
let losing_delete =
build_delete_event_at(id_secret, delete_2.event_id, reply.event_id, &empty, 4_999);
db.process_event(&delete_1).await;
assert_eq!(
get_deleted_by(&db, reply.event_id).await?,
delete_1.event_id.to_short()
);
assert_eq!(get_test_reply_count(&db, parent.event_id).await?, 0);
db.process_event(&delete_2).await;
assert_eq!(
get_deleted_by(&db, reply.event_id).await?,
delete_2.event_id.to_short()
);
assert_eq!(get_test_reply_count(&db, parent.event_id).await?, 0);
db.process_event(&losing_delete).await;
assert_eq!(
get_deleted_by(&db, reply.event_id).await?,
delete_2.event_id.to_short()
);
assert_eq!(get_test_reply_count(&db, parent.event_id).await?, 0);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_deletion_chain_preserves_header_effects() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (target, _) = build_test_event_with_valid_content(id_secret, None, "chain target");
let target_id = target.event_id;
let (_, delete_1_content) =
build_test_event_with_valid_content(id_secret, None, "deleting event content");
let delete_1 = build_delete_event_at(id_secret, target_id, target_id, &delete_1_content, 3_000);
let delete_1_id = delete_1.event_id;
let delete_2 = build_delete_event_at(
id_secret,
delete_1_id,
delete_1_id,
&EventContentRaw::new(vec![]),
3_001,
);
let delete_2_id = delete_2.event_id;
let events = [target, delete_1, delete_2];
for permutation in THREE_EVENT_PERMUTATIONS {
let (_dir, db) = temp_db(author).await?;
for index in permutation {
db.process_event(&events[index]).await;
}
assert_eq!(
get_deleted_by(&db, target_id).await?,
delete_1_id.to_short()
);
assert_eq!(
get_deleted_by(&db, delete_1_id).await?,
delete_2_id.to_short()
);
assert!(db.get_event(target_id).await.is_some());
assert!(db.get_event(delete_1_id).await.is_some());
assert!(db.get_event(delete_2_id).await.is_some());
assert!(!db.is_event_content_missing(target_id.to_short()).await);
assert!(!db.is_event_content_missing(delete_1_id.to_short()).await);
}
let ordinary = build_test_event(id_secret, delete_1_id);
let (_dir, db) = temp_db(author).await?;
for event in [delete_2, ordinary, delete_1, target] {
db.process_event(&event).await;
}
assert_eq!(
get_deleted_by(&db, target_id).await?,
delete_1_id.to_short()
);
assert_eq!(
get_deleted_by(&db, delete_1_id).await?,
delete_2_id.to_short()
);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_new_event_metadata() -> BoxedErrorResult<()> {
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event_a = build_test_event(id_secret, None);
let event_b = build_test_event(id_secret, event_a.event_id);
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_metadata_size, 0);
assert_eq!(usage.current_metadata_num, 0);
Database::insert_event_tx(
event_a,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
Some(&mut ids_data_usage_table),
)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_metadata_size, Database::EVENT_METADATA_SIZE);
assert_eq!(usage.total_metadata_size, Database::EVENT_METADATA_SIZE);
assert_eq!(usage.current_metadata_num, 1);
assert_eq!(usage.total_metadata_num, 1);
Database::insert_event_tx(
event_b,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
Some(&mut ids_data_usage_table),
)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(
usage.current_metadata_size,
Database::EVENT_METADATA_SIZE * 2
);
assert_eq!(usage.total_metadata_size, Database::EVENT_METADATA_SIZE * 2);
assert_eq!(usage.current_metadata_num, 2);
assert_eq!(usage.total_metadata_num, 2);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_empty_content_event_skips_missing_state() -> BoxedErrorResult<()> {
use rostra_core::Timestamp;
use rostra_core::id::ToShort as _;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let event = build_test_event(id_secret, None);
let event_id = event.event_id;
let content_hash = event.content_hash();
assert_eq!(
event.content_len(),
0,
"Test event should have content_len 0"
);
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let state =
Database::get_event_content_state_tx(event_id.to_short(), &events_content_state_table)?;
assert!(
state.is_none(),
"Empty-content event should have no content state, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "Empty-content event should increment RC");
let missing = events_content_missing_table.get(&(Timestamp::ZERO, event_id.to_short()))?;
assert!(
missing.is_none(),
"Empty-content event should not be in events_content_missing"
);
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_metadata_num, 1, "Should have 1 event");
assert_eq!(usage.missing_payload_num, 0, "No missing payloads");
assert_eq!(usage.missing_payload_size, 0, "No missing payload size");
assert_eq!(
usage.total_payload_num, 1,
"1 total payload (content_len=0 tracked)"
);
assert_eq!(
usage.total_content_size, 0,
"No total content size (content_len=0)"
);
assert_eq!(
usage.current_payload_num, 1,
"1 current payload (content_len=0 tracked)"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_new_payload_starts_missing() -> BoxedErrorResult<()> {
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, _content) = build_test_event_with_invalid_content(id_secret, None, 500);
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_metadata_num, 1);
assert_eq!(usage.total_metadata_num, 1);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 1);
assert_eq!(usage.missing_payload_size, content_len);
assert_eq!(usage.missing_payload_num, 1);
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 0);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_payload_processing() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) = build_test_event_with_valid_content(id_secret, None, "Test post");
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.current_content_size, content_len);
assert_eq!(usage.current_payload_num, 1);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 1);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_payload_deletion() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) = build_test_event_with_valid_content(id_secret, None, "Delete me");
let event_id = event.event_id;
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
let delete_event = build_delete_event(id_secret, event_id, event_id);
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 1, "Delete event payload tracked");
assert_eq!(usage.deleted_payload_size, content_len);
assert_eq!(usage.deleted_payload_num, 1);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 2, "Original + delete event");
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.current_metadata_num, 2);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_missing_payload_deletion() -> BoxedErrorResult<()> {
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, _content) = build_test_event_with_invalid_content(id_secret, None, 500);
let event_id = event.event_id;
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let delete_event = build_delete_event(id_secret, event_id, event_id);
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.deleted_payload_size, content_len);
assert_eq!(usage.deleted_payload_num, 1);
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 1, "Delete event payload tracked");
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 2, "Original + delete event");
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_payload_pruning() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use rostra_core::id::ToShort as _;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) = build_test_event_with_valid_content(id_secret, None, "Prune me");
let event_id = event.event_id;
let content_hash = event.content_hash();
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
db.write_with(|tx| {
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
Database::prune_event_content_tx(
event_id.to_short(),
content_hash,
&mut events_content_state_table,
&mut content_rc_table,
&mut events_content_missing_table,
Some((author, content_len as u32, &mut ids_data_usage_table)),
)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 0);
assert_eq!(usage.pruned_payload_size, content_len);
assert_eq!(usage.pruned_payload_num, 1);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 1);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_unprocessed_payload_pruning() -> BoxedErrorResult<()> {
use rostra_core::id::ToShort as _;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, _content) = build_test_event_with_invalid_content(id_secret, None, 500);
let event_id = event.event_id;
let content_hash = event.content_hash();
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
db.write_with(|tx| {
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let mut ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
Database::prune_event_content_tx(
event_id.to_short(),
content_hash,
&mut events_content_state_table,
&mut content_rc_table,
&mut events_content_missing_table,
Some((author, content_len as u32, &mut ids_data_usage_table)),
)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.pruned_payload_size, content_len);
assert_eq!(usage.pruned_payload_num, 1);
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 0);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 1);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_payload_invalid() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::{content_rc, ids_data_usage};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) = build_test_event_with_invalid_content(id_secret, None, 500);
let content_hash = event.content_hash();
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.invalid_payload_size, content_len);
assert_eq!(usage.invalid_payload_num, 1);
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 0);
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 1);
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let rc = content_rc_table.get(&content_hash)?;
assert!(
rc.is_none(),
"RC entry should be removed when count reaches 0"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_data_usage_invalid_payload_deletion() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::{content_rc, ids_data_usage};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) = build_test_event_with_invalid_content(id_secret, None, 500);
let event_id = event.event_id;
let content_hash = event.content_hash();
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
let delete_event = build_delete_event(id_secret, event_id, event_id);
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.invalid_payload_size, 0);
assert_eq!(usage.invalid_payload_num, 0);
assert_eq!(usage.deleted_payload_size, content_len);
assert_eq!(usage.deleted_payload_num, 1);
assert_eq!(usage.current_content_size, 0);
assert_eq!(usage.current_payload_num, 1, "Delete event payload tracked");
assert_eq!(usage.total_content_size, content_len);
assert_eq!(usage.total_payload_num, 2, "Original + delete event");
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let rc = content_rc_table.get(&content_hash)?;
assert!(rc.is_none(), "RC entry should remain removed after delete");
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_follow_unfollow_refollow_flow() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind::{EventContentKind as _, Follow};
use rostra_core::event::{
Event, EventKind, PersonaSelector, VerifiedEvent, VerifiedEventContent,
};
use crate::{ids_followees, ids_followers, ids_unfollowed};
let user_a_secret = RostraIdSecretKey::generate();
let user_a = user_a_secret.id();
let user_b_secret = RostraIdSecretKey::generate();
let user_b = user_b_secret.id();
let (_dir, db) = temp_db(user_a).await?;
let make_follow_event = |secret: RostraIdSecretKey,
followee: rostra_core::id::RostraId,
selector: Option<PersonaSelector>,
timestamp: time::OffsetDateTime|
-> (VerifiedEvent, rostra_core::event::EventContentRaw) {
let follow = Follow {
followee,
persona: None,
selector,
persona_tags_selector: None,
};
let content = follow.serialize_cbor().expect("valid");
let event = Event::builder_raw_content()
.author(secret.id())
.kind(EventKind::FOLLOW)
.content(&content)
.timestamp(timestamp)
.build();
let signed = event.signed_by(secret);
let verified = VerifiedEvent::verify_signed(secret.id(), signed).expect("Valid event");
(verified, content)
};
let base_time = time::OffsetDateTime::now_utc();
let follow_time = base_time;
let unfollow_time = base_time + time::Duration::seconds(1);
let refollow_time = base_time + time::Duration::seconds(2);
let (follow_event_1, follow_content_1) = make_follow_event(
user_a_secret,
user_b,
Some(PersonaSelector::Except { ids: vec![] }),
follow_time,
);
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
Database::insert_event_tx(
follow_event_1,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(())
})
.await?;
let verified_content_1 =
VerifiedEventContent::assume_verified(follow_event_1, follow_content_1);
db.process_event_content(&verified_content_1).await;
db.write_with(|tx| {
let followees_table = tx.open_table(&ids_followees::TABLE)?;
let followers_table = tx.open_table(&ids_followers::TABLE)?;
let unfollowed_table = tx.open_table(&ids_unfollowed::TABLE)?;
assert!(
followees_table.get(&(user_a, user_b))?.is_some(),
"User A should be following User B after follow"
);
assert!(
followers_table.get(&(user_b, user_a))?.is_some(),
"User B should have User A as follower"
);
assert!(
unfollowed_table.get(&(user_a, user_b))?.is_none(),
"No unfollow record should exist"
);
Ok(())
})
.await?;
let (unfollow_event, unfollow_content) =
make_follow_event(user_a_secret, user_b, None, unfollow_time);
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
Database::insert_event_tx(
unfollow_event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(())
})
.await?;
let verified_content_2 =
VerifiedEventContent::assume_verified(unfollow_event, unfollow_content);
db.process_event_content(&verified_content_2).await;
db.write_with(|tx| {
let followees_table = tx.open_table(&ids_followees::TABLE)?;
let followers_table = tx.open_table(&ids_followers::TABLE)?;
let unfollowed_table = tx.open_table(&ids_unfollowed::TABLE)?;
assert!(
followees_table.get(&(user_a, user_b))?.is_none(),
"User A should not be following User B after unfollow"
);
assert!(
followers_table.get(&(user_b, user_a))?.is_none(),
"User B should not have User A as follower after unfollow"
);
assert!(
unfollowed_table.get(&(user_a, user_b))?.is_some(),
"Unfollow record should exist"
);
Ok(())
})
.await?;
let (refollow_event, refollow_content) = make_follow_event(
user_a_secret,
user_b,
Some(PersonaSelector::Except { ids: vec![] }),
refollow_time,
);
db.write_with(|tx| {
let mut ids_full_tbl = ids_full::Table::open(tx)?;
let mut events_table = tx.open_table(&events::TABLE)?;
let mut events_missing_table = tx.open_table(&events_missing::TABLE)?;
let mut events_heads_table = tx.open_table(&events_heads::TABLE)?;
let mut events_by_time_table = tx.open_table(&events_by_time::TABLE)?;
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_store_table = tx.open_table(&content_store::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
Database::insert_event_tx(
refollow_event,
&mut ids_full_tbl,
&mut events_table,
&mut events_missing_table,
&mut events_heads_table,
&mut events_by_time_table,
&mut events_content_state_table,
&mut content_store_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(())
})
.await?;
let verified_content_3 =
VerifiedEventContent::assume_verified(refollow_event, refollow_content);
db.process_event_content(&verified_content_3).await;
db.write_with(|tx| {
let followees_table = tx.open_table(&ids_followees::TABLE)?;
let followers_table = tx.open_table(&ids_followers::TABLE)?;
let unfollowed_table = tx.open_table(&ids_unfollowed::TABLE)?;
assert!(
followees_table.get(&(user_a, user_b))?.is_some(),
"User A should be following User B after re-follow"
);
assert!(
followers_table.get(&(user_b, user_a))?.is_some(),
"User B should have User A as follower after re-follow"
);
assert!(
unfollowed_table.get(&(user_a, user_b))?.is_some(),
"Unfollow boundary should remain after re-follow"
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_social_posts_by_received_at_pagination() -> BoxedErrorResult<()> {
use rostra_core::event::{VerifiedEventContent, content_kind};
use rostra_core::{ExternalEventId, Timestamp};
let user_a_secret = RostraIdSecretKey::generate();
let user_a = user_a_secret.id();
let user_b_secret = RostraIdSecretKey::generate();
let user_b = user_b_secret.id();
let (_dir, db) = temp_db(user_a).await?;
let build_social_post_event = |id_secret: RostraIdSecretKey,
parent: Option<EventId>,
djot_content: &str,
reply_to: Option<ExternalEventId>|
-> (VerifiedEvent, EventContentRaw) {
use rostra_core::event::content_kind::EventContentKind as _;
let content = content_kind::SocialPost::new(
djot_content.to_string(),
reply_to,
Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
(verified, content_raw)
};
let (post_b1, post_b1_content) =
build_social_post_event(user_b_secret, None, "Post by B", None);
let post_b1_id = post_b1.event_id;
let reply_to_b1 = ExternalEventId::new(user_b, post_b1_id);
let (reply_a1, reply_a1_content) =
build_social_post_event(user_a_secret, None, "Reply from A to B", Some(reply_to_b1));
let reply_a1_id = reply_a1.event_id;
let (post_b2, post_b2_content) =
build_social_post_event(user_b_secret, Some(post_b1_id), "Second post by B", None);
let post_b2_id = post_b2.event_id;
let events_with_ts = [
(&post_b1, &post_b1_content, Timestamp::from(100u64)),
(&reply_a1, &reply_a1_content, Timestamp::from(200u64)),
(&post_b2, &post_b2_content, Timestamp::from(300u64)),
];
for (event, content_raw, received_ts) in events_with_ts {
db.write_with(|tx| {
db.process_event_tx(event, received_ts, tx)?;
let verified_content =
VerifiedEventContent::assume_verified(*event, content_raw.clone());
db.process_event_content_tx(&verified_content, received_ts, tx)?;
Ok(())
})
.await?;
}
let (posts_rev, _cursor) = db
.paginate_social_posts_by_received_at_rev(None, 10, |_| true)
.await;
assert_eq!(posts_rev.len(), 3, "Should have 3 posts");
assert_eq!(
posts_rev[0].event_id,
post_b2_id.into(),
"First post should be post_b2 (most recent)"
);
assert_eq!(
posts_rev[1].event_id,
reply_a1_id.into(),
"Second post should be reply_a1"
);
assert_eq!(
posts_rev[2].event_id,
post_b1_id.into(),
"Third post should be post_b1 (oldest)"
);
let (posts_fwd, _cursor) = db
.paginate_social_posts_by_received_at(None, 10, |_| true)
.await;
assert_eq!(posts_fwd.len(), 3, "Should have 3 posts");
assert_eq!(
posts_fwd[0].event_id,
post_b1_id.into(),
"First post should be post_b1 (oldest)"
);
assert_eq!(
posts_fwd[1].event_id,
reply_a1_id.into(),
"Second post should be reply_a1"
);
assert_eq!(
posts_fwd[2].event_id,
post_b2_id.into(),
"Third post should be post_b2 (most recent)"
);
let (notifications, _cursor) = db
.paginate_social_posts_by_received_at_rev(None, 10, move |post| {
post.author != user_a && post.reply_to.map(|ext_id| ext_id.rostra_id()) == Some(user_a)
})
.await;
assert_eq!(
notifications.len(),
0,
"No notifications for user_a (no one replied to them)"
);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_total_migration() -> BoxedErrorResult<()> {
use rostra_core::Timestamp;
use rostra_core::event::content_kind::PersonaSelector;
use rostra_core::event::{VerifiedEventContent, content_kind};
use crate::{
EventReceivedSource, db_init_time, db_version, events_received_at, ids_followees,
ids_followers, reception_order_next, social_posts_by_received_at, social_posts_by_time,
social_posts_received_at_keys,
};
const EXTENSION_TABLE: redb_bincode::TableDefinition<'_, u64, String> =
redb_bincode::TableDefinition::new("tests::total_migration::extension");
let user_a_secret = RostraIdSecretKey::from_bytes([1; 32]);
let user_a = user_a_secret.id();
let user_b_secret = RostraIdSecretKey::from_bytes([2; 32]);
let user_b = user_b_secret.id();
let dir = tempfile::tempdir()?;
let db_path = dir.path().join("db.redb");
let expected_follow_event_id;
let expected_post_event_id;
let expected_missing_event_id;
let db_init_time_before;
let iroh_secret_before;
{
let db = Database::open(&db_path, user_a).await.boxed()?;
iroh_secret_before = db.iroh_secret();
db_init_time_before = db
.read_with(|tx| {
Ok(tx
.open_table(&db_init_time::TABLE)?
.get(&())?
.map(|g| g.value())
.expect("database initialization time"))
})
.await?;
let follow_content = content_kind::Follow {
followee: user_b,
persona: None,
selector: Some(PersonaSelector::default()), persona_tags_selector: None,
};
let follow_content_raw = {
use rostra_core::event::content_kind::EventContentKind as _;
follow_content.serialize_cbor().unwrap()
};
let follow_event = {
let event = Event::builder_raw_content()
.author(user_a)
.kind(EventKind::FOLLOW)
.content(&follow_content_raw)
.timestamp(time::OffsetDateTime::from_unix_timestamp(100).expect("valid timestamp"))
.build();
let signed = event.signed_by(user_a_secret);
VerifiedEvent::verify_signed(user_a, signed).expect("Valid event")
};
expected_follow_event_id = follow_event.event_id.to_short();
let reverse_follow_content = content_kind::Follow {
followee: user_a,
persona: None,
selector: Some(PersonaSelector::default()),
persona_tags_selector: None,
};
let reverse_follow_content_raw = {
use rostra_core::event::content_kind::EventContentKind as _;
reverse_follow_content.serialize_cbor().unwrap()
};
let reverse_follow_event = {
let event = Event::builder_raw_content()
.author(user_b)
.kind(EventKind::FOLLOW)
.content(&reverse_follow_content_raw)
.build();
let signed = event.signed_by(user_b_secret);
VerifiedEvent::verify_signed(user_b, signed).expect("Valid event")
};
let post_content = content_kind::SocialPost::new(
"Hello world!".to_string(),
None, Default::default(), );
let post_content_raw = {
use rostra_core::event::content_kind::EventContentKind as _;
post_content.serialize_cbor().unwrap()
};
let post_event = {
let event = Event::builder_raw_content()
.author(user_a)
.kind(EventKind::SOCIAL_POST)
.content(&post_content_raw)
.build();
let signed = event.signed_by(user_a_secret);
VerifiedEvent::verify_signed(user_a, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
expected_post_event_id = post_event_id.to_short();
let (missing_event, _missing_content) =
build_test_event_with_valid_content(user_b_secret, None, "still missing after replay");
expected_missing_event_id = missing_event.event_id.to_short();
let now = Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&follow_event, now, tx)?;
let verified_follow =
VerifiedEventContent::assume_verified(follow_event, follow_content_raw);
db.process_event_content_tx(&verified_follow, now, tx)?;
db.process_event_tx(&reverse_follow_event, now, tx)?;
let verified_reverse_follow = VerifiedEventContent::assume_verified(
reverse_follow_event,
reverse_follow_content_raw,
);
db.process_event_content_tx(&verified_reverse_follow, now, tx)?;
db.process_event_tx(&post_event, now, tx)?;
let verified_post = VerifiedEventContent::assume_verified(post_event, post_content_raw);
db.process_event_content_tx(&verified_post, now, tx)?;
db.process_event_tx(&missing_event, now, tx)?;
Ok(())
})
.await?;
db.write_with(|tx| {
tx.open_table(&EXTENSION_TABLE)?
.insert(&1, &"preserved".to_owned())?;
let mut receipts = tx.open_table(&events_received_at::TABLE)?;
let post_receipt = receipts
.range(..)?
.find_map(|entry| match entry {
Ok((key, receipt)) if receipt.value().event_id == expected_post_event_id => {
Some(Ok((key.value(), receipt.value())))
}
Ok(_) => None,
Err(error) => Some(Err(error)),
})
.transpose()?
.expect("post receipt");
let mut post_receipt_record = post_receipt.1;
post_receipt_record.source = EventReceivedSource::Local;
receipts.insert(&post_receipt.0, &post_receipt_record)?;
Ok(())
})
.await?;
db.write_with(|tx| {
let mut queue = tx.open_table(&events_content_missing::TABLE)?;
queue.insert(&(Timestamp::from(123), expected_missing_event_id), &())?;
queue.insert(&(Timestamp::from(1), expected_post_event_id), &())?;
Ok(())
})
.await?;
db.read_with(|tx| {
let followees = tx.open_table(&ids_followees::TABLE)?;
info!("Followees table contents before migration:");
for entry in followees.range(..)? {
let (key, value) = entry?;
info!(" {:?} -> {:?}", key.value(), value.value());
}
let followee_record = followees
.get(&(user_a, user_b))?
.map(|g| g.value())
.expect("Follow should exist before migration");
info!(
"Followee record before migration: latest_ts={:?}",
followee_record.latest_ts,
);
let followers = tx.open_table(&ids_followers::TABLE)?;
info!("Followers table contents before migration:");
for entry in followers.range(..)? {
let (key, _value) = entry?;
info!(" {:?}", key.value());
}
assert!(
followers.get(&(user_b, user_a))?.is_some(),
"Follower record should exist before migration"
);
let posts_by_time = tx.open_table(&social_posts_by_time::TABLE)?;
let post_exists = posts_by_time.range(..)?.any(|r| {
r.map(|(k, _)| k.value().1 == post_event_id.into())
.unwrap_or(false)
});
assert!(
post_exists,
"Post should exist in time index before migration"
);
Ok(())
})
.await?;
let followees_before = db.get_followees(user_a).await;
info!(
"get_followees(user_a) before migration: {:?}",
followees_before
);
assert_eq!(
followees_before.len(),
1,
"Should have 1 followee before migration"
);
assert_eq!(followees_before[0].0, user_b, "Followee should be user_b");
let followers_before = db.get_followers(user_b).await;
info!(
"get_followers(user_b) before migration: {:?}",
followers_before
);
assert_eq!(
followers_before.len(),
1,
"user_b should have 1 follower before migration"
);
assert_eq!(followers_before[0], user_a, "Follower should be user_a");
let self_followers_before = db.get_self_followers().await;
info!(
"get_self_followers() before migration: {:?}",
self_followers_before
);
assert_eq!(
self_followers_before.len(),
1,
"user_a should have 1 follower before migration"
);
assert_eq!(
self_followers_before[0], user_b,
"user_a's follower should be user_b"
);
let (posts_before, _) = db.paginate_social_posts_rev(None, 10, |_| true).await;
info!(
"paginate_social_posts_rev before migration: {} posts",
posts_before.len()
);
assert_eq!(posts_before.len(), 1, "Should have 1 post before migration");
db.write_with(|tx| {
tx.open_table(&ids_followees::TABLE)?
.remove(&(user_a, user_b))?;
tx.open_table(&ids_followers::TABLE)?
.remove(&(user_b, user_a))?;
Ok(())
})
.await?;
}
{
let raw_db = redb_bincode::Database::from(redb::Database::open(&db_path).boxed()?);
let write_txn = raw_db.begin_write().boxed()?;
{
let mut table = write_txn.open_table(&db_version::TABLE).boxed()?;
let old_version: u64 = 24;
table.insert(&(), &old_version).boxed()?;
}
write_txn.commit().boxed()?;
}
let db = Database::open(&db_path, user_a).await.boxed()?;
db.read_with(|tx| {
let db_ver_table = tx.open_table(&db_version::TABLE)?;
let current_ver = db_ver_table.first()?.map(|g| g.1.value());
info!("DB version after migration: {:?}", current_ver);
assert_eq!(current_ver, Some(26), "DB version should be updated");
assert_eq!(
tx.open_table(&EXTENSION_TABLE)?
.get(&1)?
.map(|value| value.value())
.as_deref(),
Some("preserved"),
"total migration must preserve caller-owned extension tables"
);
let followees = tx.open_table(&ids_followees::TABLE)?;
info!("Followees table contents after migration:");
for entry in followees.range(..)? {
let (key, value) = entry?;
info!(" {:?} -> {:?}", key.value(), value.value());
}
let followee_record = followees
.get(&(user_a, user_b))?
.map(|g| g.value())
.expect("Follow should exist after migration");
info!(
"Followee record after migration: latest_ts={:?}",
followee_record.latest_ts,
);
assert_eq!(followee_record.latest_event_id, expected_follow_event_id);
let db_init_time_after = tx
.open_table(&db_init_time::TABLE)?
.get(&())?
.map(|g| g.value());
assert_eq!(db_init_time_after, Some(db_init_time_before));
let followers = tx.open_table(&ids_followers::TABLE)?;
info!("Followers table contents after migration:");
for entry in followers.range(..)? {
let (key, _value) = entry?;
info!(" {:?}", key.value());
}
assert!(
followers.get(&(user_b, user_a))?.is_some(),
"Follower record should exist after migration"
);
let posts_by_time = tx.open_table(&social_posts_by_time::TABLE)?;
let post_count = posts_by_time.range(..)?.count();
info!("Posts in time index after migration: {}", post_count);
assert!(
post_count > 0,
"Posts should exist in time index after migration"
);
let event_receipts = tx
.open_table(&events_received_at::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, receipt)| (key.value(), receipt.value())))
.collect::<Result<Vec<_>, _>>()?;
let social_receipts = tx
.open_table(&social_posts_by_received_at::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, event_id)| (key.value(), event_id.value())))
.collect::<Result<Vec<_>, _>>()?;
let social_receipt_keys = tx
.open_table(&social_posts_received_at_keys::TABLE)?
.range(..)?
.map(|entry| entry.map(|(event_id, key)| (event_id.value(), key.value())))
.collect::<Result<Vec<_>, _>>()?;
let next_reception_order = tx
.open_table(&reception_order_next::TABLE)?
.get(&())?
.map(|value| value.value());
assert_eq!(event_receipts.len(), 4);
for ((received_at, _), receipt) in &event_receipts {
let authored_at = tx
.open_table(&events::TABLE)?
.get(&receipt.event_id)?
.expect("receipt event")
.value()
.timestamp();
assert_eq!(
*received_at, authored_at,
"rebuilt event receipts must use authored timestamps"
);
}
assert_eq!(
event_receipts
.iter()
.find(|(_, receipt)| receipt.event_id == expected_post_event_id)
.map(|(_, receipt)| &receipt.source),
Some(&EventReceivedSource::Local),
"migration must retain event acquisition provenance"
);
assert_eq!(social_receipts.len(), 1);
assert_eq!(social_receipts[0].1, expected_post_event_id);
assert_eq!(
social_receipts[0].0.0,
tx.open_table(&events::TABLE)?
.get(&expected_post_event_id)?
.expect("post event")
.value()
.timestamp(),
"rebuilt social receipts must use authored timestamps"
);
assert_eq!(
social_receipt_keys,
vec![(expected_post_event_id, social_receipts[0].0)],
"total replay must rebuild the exact social-receipt reverse mapping"
);
assert_eq!(
next_reception_order,
Some((event_receipts.len() + social_receipts.len()) as u64),
"total replay must rebuild the sequence from its receipt allocations"
);
let missing_queue = tx
.open_table(&events_content_missing::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value()))
.collect::<Result<Vec<_>, _>>()?;
assert_eq!(
missing_queue,
vec![(Timestamp::ZERO, expected_missing_event_id)],
"total replay must derive one exact row for each queued Missing event"
);
assert!(matches!(
tx.open_table(&events_content_state::TABLE)?
.get(&expected_missing_event_id)?
.map(|state| state.value()),
Some(EventContentState::Missing {
next_fetch_attempt: Timestamp::ZERO,
..
})
));
Ok(())
})
.await?;
assert_eq!(
db.iroh_secret().to_bytes(),
iroh_secret_before.to_bytes(),
"migration must preserve the database iroh secret"
);
info!("=== Verifying Database methods after migration ===");
let followees_after = db.get_followees(user_a).await;
info!(
"get_followees(user_a) after migration: {:?}",
followees_after
);
assert_eq!(
followees_after.len(),
1,
"Should have 1 followee after migration"
);
assert_eq!(
followees_after[0].0, user_b,
"Followee should be user_b after migration"
);
let followers_after = db.get_followers(user_b).await;
info!(
"get_followers(user_b) after migration: {:?}",
followers_after
);
assert_eq!(
followers_after.len(),
1,
"user_b should have 1 follower after migration"
);
assert_eq!(
followers_after[0], user_a,
"Follower should be user_a after migration"
);
let self_followees = db.get_self_followees().await;
info!("get_self_followees() after migration: {:?}", self_followees);
assert_eq!(
self_followees.len(),
1,
"Self should have 1 followee after migration"
);
let self_followers_after = db.get_self_followers().await;
info!(
"get_self_followers() after migration: {:?}",
self_followers_after
);
assert_eq!(
self_followers_after.len(),
1,
"user_a should have 1 follower after migration"
);
assert_eq!(
self_followers_after[0], user_b,
"user_a's follower should be user_b after migration"
);
let migrated_followees = db.self_followees_subscribe();
let migrated_followers = db.self_followers_subscribe();
let migrated_wot = db.self_wot_subscribe();
let migrated_head = db.self_head_subscribe();
assert!(migrated_followees.snapshot().contains_key(&user_b));
assert!(migrated_followers.snapshot().contains_key(&user_b));
assert!(migrated_wot.snapshot().followees.contains_key(&user_b));
let authoritative_head = db.get_self_current_head().await;
assert_eq!(migrated_head.snapshot(), authoritative_head);
let (posts_after, _) = db.paginate_social_posts_rev(None, 10, |_| true).await;
info!(
"paginate_social_posts_rev after migration: {} posts",
posts_after.len()
);
assert_eq!(posts_after.len(), 1, "Should have 1 post after migration");
assert_eq!(
posts_after[0].content.djot_content,
Some("Hello world!".to_string()),
"Post content should match after migration"
);
let (received_posts_after, _) = db
.paginate_social_posts_by_received_at(None, 10, |_| true)
.await;
assert_eq!(
received_posts_after
.iter()
.map(|post| post.event_id)
.collect::<Vec<_>>(),
vec![expected_post_event_id],
"total replay must retain reception-index membership"
);
info!("=== All migration verifications passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn total_migration_preserves_legacy_receipt_sources() -> BoxedErrorResult<()> {
use rostra_core::event::IrohNodeId;
use crate::migration_ops::LegacyEventReceivedRecord;
use crate::{EventReceivedSource, db_version, events_received_at};
for source_version in [6, 11, 12] {
let secret = RostraIdSecretKey::from_bytes([source_version as u8; 32]);
let peer_secret = RostraIdSecretKey::from_bytes([source_version as u8 + 40; 32]);
let self_id = secret.id();
let peer_id = peer_secret.id();
let dir = tempfile::tempdir()?;
let db_path = dir.path().join("db.redb");
let events = [
build_test_event(secret, None),
build_test_event(peer_secret, None),
];
let sources = [
EventReceivedSource::Local,
EventReceivedSource::Pulled {
from_id: Some(peer_id),
from_node: Some(IrohNodeId::MAX),
task: Some("legacy sync".to_owned()),
},
];
{
let db = Database::open(&db_path, self_id).await.boxed()?;
db.write_with(|tx| {
for (index, event) in events.iter().enumerate() {
db.process_event_tx_with_source(
event,
Timestamp::from(500 + index as u64),
sources[index].clone(),
tx,
)?;
}
Ok(())
})
.await?;
}
{
let db = redb_bincode::Database::from(redb::Database::open(&db_path)?);
let tx = db.begin_write()?;
assert!(
tx.as_raw()
.delete_table(events_received_at::TABLE.as_raw())?
);
if source_version <= 11 {
let legacy_receipts: redb_bincode::TableDefinition<
'_,
(Timestamp, rostra_core::ShortEventId),
LegacyEventReceivedRecord,
> = redb_bincode::TableDefinition::new("events_received_at");
let mut receipts = tx.open_table(&legacy_receipts)?;
for (index, event) in events.iter().enumerate() {
receipts.insert(
&(
Timestamp::from(500 + index as u64),
event.event_id.to_short(),
),
&LegacyEventReceivedRecord {
source: sources[index].clone(),
},
)?;
}
} else {
let legacy_receipts: redb_bincode::TableDefinition<
'_,
(Timestamp, u64, rostra_core::ShortEventId),
LegacyEventReceivedRecord,
> = redb_bincode::TableDefinition::new("events_received_at");
let mut receipts = tx.open_table(&legacy_receipts)?;
for (index, event) in events.iter().enumerate() {
receipts.insert(
&(
Timestamp::from(500 + index as u64),
index as u64 + 7,
event.event_id.to_short(),
),
&LegacyEventReceivedRecord {
source: sources[index].clone(),
},
)?;
}
}
tx.open_table(&db_version::TABLE)?
.insert(&(), &source_version)?;
tx.commit()?;
}
let db = Database::open(&db_path, self_id).await.boxed()?;
db.read_with(|tx| {
let receipts = tx.open_table(&events_received_at::TABLE)?;
let rebuilt = receipts
.range(..)?
.map(|entry| {
entry.map(|(key, receipt)| {
(
key.value().0,
receipt.value().event_id,
receipt.value().source,
)
})
})
.collect::<Result<Vec<_>, _>>()?;
for (event, source) in events.iter().zip(&sources) {
assert!(rebuilt.contains(&(
event.timestamp(),
event.event_id.to_short(),
source.clone()
)));
}
Ok(())
})
.await?;
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn version_25_adopts_pending_version_24_legacy_content_stash() -> BoxedErrorResult<()> {
use std::borrow::Cow;
use redb::TableHandle as _;
use crate::migration_ops::{LegacyContentStoreRecord, LegacyContentStoreRecordOwned};
use crate::{DbError, db_init_time, db_version};
const EVENTS_STASH: &str = "_total_migration_events";
const CONTENT_STASH: &str = "_total_migration_content_store";
const SOURCE_VERSION_STASH: &str = "_total_migration_source_ver";
let secret = RostraIdSecretKey::from_bytes([0x16; 32]);
let self_id = secret.id();
let dir = tempfile::tempdir()?;
let db_path = dir.path().join("db.redb");
let (event, content) = build_test_event_with_valid_content(secret, None, "held legacy content");
let event_id = event.event_id.to_short();
let content_hash = event.content_hash();
{
let db = Database::open(&db_path, self_id).await.boxed()?;
let verified = VerifiedEventContent::assume_verified(event, content.clone());
db.write_with(|tx| {
db.process_event_tx(&verified.event, Timestamp::from(700), tx)?;
db.process_event_content_tx(&verified, Timestamp::from(700), tx)
})
.await?;
}
let raw_db = redb_bincode::Database::from(redb::Database::open(&db_path)?);
Database::write_with_inner(&raw_db, |tx| {
tx.as_raw().delete_table(content_store::TABLE.as_raw())?;
let legacy_content: redb_bincode::TableDefinition<
'_,
rostra_core::ContentHash,
LegacyContentStoreRecordOwned,
> = redb_bincode::TableDefinition::new("content_store");
tx.open_table(&legacy_content)?.insert(
&content_hash,
&LegacyContentStoreRecord::Present(Cow::Owned(content.clone())),
)?;
tx.open_table(&db_version::TABLE)?.insert(&(), &16)?;
Ok(())
})
.await?;
Database::write_with_inner(&raw_db, |tx| {
Database::prepare_total_migration(tx, 16)?;
Ok(())
})
.await?;
Database::write_with_inner(&raw_db, |tx| {
tx.as_raw()
.delete_table(redb::TableDefinition::<&[u8], &[u8]>::new(
"_total_migration_db_init_time",
))?;
tx.as_raw()
.delete_table(redb::TableDefinition::<&[u8], &[u8]>::new(
"_total_migration_event_sources",
))?;
tx.as_raw()
.delete_table(redb::TableDefinition::<&[u8], &[u8]>::new(
"_total_migration_social_posts_replaced_by",
))?;
tx.open_table(&db_init_time::TABLE)?
.insert(&(), &Timestamp::from(4242))?;
tx.open_table(&db_version::TABLE)?.insert(&(), &24)?;
Ok(())
})
.await?;
let bad_event_id = rostra_core::ShortEventId::from_bytes([0xee; 16]);
let bad_key = bincode::encode_to_vec(bad_event_id, redb_bincode::BINCODE_CONFIG)?;
{
let tx = raw_db.begin_write()?;
let mut events = tx
.as_raw()
.open_table(redb::TableDefinition::<&[u8], &[u8]>::new(EVENTS_STASH))?;
events.insert(bad_key.as_slice(), &[0xff][..])?;
drop(events);
tx.commit()?;
}
drop(raw_db);
let first_open = Database::open(&db_path, self_id).await;
let Err(first_error) = first_open else {
panic!("malformed stash must fail replay");
};
assert!(
matches!(first_error, DbError::StoredDecode { .. }),
"unexpected replay error: {first_error:?}"
);
let raw_db = redb_bincode::Database::from(redb::Database::open(&db_path)?);
{
let tx = raw_db.begin_read()?;
let source_version: redb_bincode::TableDefinition<'_, (), u64> =
redb_bincode::TableDefinition::new(SOURCE_VERSION_STASH);
assert_eq!(
tx.open_table(&source_version)?
.get(&())?
.map(|value| value.value_try())
.transpose()?,
Some(16)
);
assert_eq!(
tx.open_table(&db_init_time::TABLE)?
.get(&())?
.map(|value| value.value_try())
.transpose()?,
Some(Timestamp::from(4242))
);
let legacy_content: redb_bincode::TableDefinition<
'_,
rostra_core::ContentHash,
LegacyContentStoreRecordOwned,
> = redb_bincode::TableDefinition::new(CONTENT_STASH);
let retained = tx
.open_table(&legacy_content)?
.get(&content_hash)?
.expect("held content remains")
.value_try()?;
let LegacyContentStoreRecord::Present(retained) = retained;
assert_eq!(retained.as_ref().as_slice(), content.as_ref());
}
{
let tx = raw_db.begin_write()?;
let mut events = tx
.as_raw()
.open_table(redb::TableDefinition::<&[u8], &[u8]>::new(EVENTS_STASH))?;
assert!(events.remove(bad_key.as_slice())?.is_some());
drop(events);
tx.commit()?;
}
drop(raw_db);
let db = Database::open(&db_path, self_id).await.boxed()?;
assert_eq!(db.db_init_time(), Timestamp::from(4242));
assert_eq!(
db.get_event_content(event_id)
.await
.map(|content| content.as_ref().to_vec()),
Some(content.as_ref().to_vec())
);
let (posts, _) = db.paginate_social_posts_rev(None, 10, |_| true).await;
assert_eq!(posts.len(), 1);
drop(db);
let raw_db = redb::Database::open(&db_path)?;
assert!(
raw_db
.begin_read()?
.list_tables()?
.all(|table| !table.name().starts_with("_total_migration_"))
);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn too_new_version_precedes_identity_decode() -> BoxedErrorResult<()> {
use crate::{DbError, db_version, ids_self};
let secret = RostraIdSecretKey::from_bytes([0x26; 32]);
let self_id = secret.id();
let dir = tempfile::tempdir()?;
let db_path = dir.path().join("db.redb");
drop(Database::open(&db_path, self_id).await.boxed()?);
{
let db = redb_bincode::Database::from(redb::Database::open(&db_path)?);
let tx = db.begin_write()?;
tx.open_table(&db_version::TABLE)?.insert(&(), &27)?;
let mut ids_self_raw = tx.as_raw().open_table(ids_self::TABLE.as_raw())?;
ids_self_raw.insert(&[][..], &[0xff][..])?;
drop(ids_self_raw);
tx.commit()?;
}
assert!(matches!(
Database::open(&db_path, self_id).await,
Err(DbError::DbVersionTooHigh {
db_ver: 27,
code_ver: 26,
..
})
));
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_two_phase_replay_converges_across_event_orders() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind::PersonaSelector;
use crate::{
events_received_at, ids_followees, social_posts_by_received_at, social_posts_by_time,
};
let author_secret = RostraIdSecretKey::from_bytes([71; 32]);
let author = author_secret.id();
let followee = RostraIdSecretKey::from_bytes([72; 32]).id();
let follow_content = content_kind::Follow {
followee,
persona: None,
selector: Some(PersonaSelector::default()),
persona_tags_selector: None,
}
.serialize_cbor()?;
let follow = {
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::FOLLOW)
.content(&follow_content)
.timestamp(time::OffsetDateTime::from_unix_timestamp(100)?)
.build();
let event = VerifiedEvent::verify_signed(author, event.signed_by(author_secret))?;
VerifiedEventContent::assume_verified(event, follow_content)
};
let post_content =
content_kind::SocialPost::new_text("survives".to_owned(), None, Default::default())
.serialize_cbor()?;
let post = {
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&post_content)
.timestamp(time::OffsetDateTime::from_unix_timestamp(101)?)
.build();
let event = VerifiedEvent::verify_signed(author, event.signed_by(author_secret))?;
VerifiedEventContent::assume_verified(event, post_content)
};
let deleting_follow = {
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::NULL)
.delete(follow.event_id().to_short())
.timestamp(time::OffsetDateTime::from_unix_timestamp(102)?)
.build();
let event = VerifiedEvent::verify_signed(author, event.signed_by(author_secret))?;
VerifiedEventContent::assume_verified(event, Option::<EventContentRaw>::None)
};
let events = [follow, post, deleting_follow];
let post_id = events[1].event_id().to_short();
let follow_id = events[0].event_id().to_short();
let mut baseline = None;
for envelope_order in [[0, 1, 2], [2, 1, 0]] {
for content_order in [[0, 1, 2], [2, 1, 0]] {
let (_dir, db) = temp_db(author).await?;
db.write_with(|tx| {
tx.discard_commit_hooks();
for index in envelope_order {
db.process_event_tx(&events[index].event, events[index].timestamp(), tx)?;
}
for index in content_order {
db.process_event_content_tx(&events[index], events[index].timestamp(), tx)?;
}
Ok(())
})
.await?;
let snapshot = db
.read_with(|tx| {
let mut received_events = tx
.open_table(&events_received_at::TABLE)?
.range(..)?
.map(|entry| entry.map(|(_, receipt)| receipt.value().event_id))
.collect::<Result<Vec<_>, _>>()?;
received_events.sort_unstable();
let mut received_posts = tx
.open_table(&social_posts_by_received_at::TABLE)?
.range(..)?
.map(|entry| entry.map(|(_, event_id)| event_id.value()))
.collect::<Result<Vec<_>, _>>()?;
received_posts.sort_unstable();
Ok((
tx.open_table(&events::TABLE)?.range(..)?.count(),
tx.open_table(&ids_followees::TABLE)?
.get(&(author, followee))?
.is_some(),
tx.open_table(&events_content_state::TABLE)?
.get(&follow_id)?
.map(|state| state.value()),
tx.open_table(&social_posts_by_time::TABLE)?
.get(&(events[1].timestamp(), post_id))?
.is_some(),
received_events,
received_posts,
))
})
.await?;
assert!(!snapshot.1, "predeleted FOLLOW content must not project");
assert!(matches!(
snapshot.2,
Some(EventContentState::Deleted { .. })
));
assert!(snapshot.3, "unrelated retained post must project");
assert_eq!(snapshot.5, vec![post_id]);
if let Some(expected) = baseline.as_ref() {
assert_eq!(
&snapshot, expected,
"two-phase semantic state changed for envelope order \
{envelope_order:?}, content order {content_order:?}"
);
} else {
baseline = Some(snapshot);
}
}
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
#[ignore = "manual large-database migration benchmark"]
async fn benchmark_large_total_migration_streaming() -> BoxedErrorResult<()> {
const EVENT_COUNT: usize = 10_000;
let secret = RostraIdSecretKey::from_bytes([73; 32]);
let author = secret.id();
let dir = tempfile::tempdir()?;
let path = dir.path().join("db.redb");
let db = Database::open(&path, author).await?;
db.write_with(|tx| {
tx.discard_commit_hooks();
let mut parent = None;
for timestamp in 0..EVENT_COUNT {
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::NULL)
.maybe_parent_prev(parent)
.timestamp(
time::OffsetDateTime::from_unix_timestamp(
timestamp.try_into().expect("benchmark timestamp"),
)
.expect("benchmark timestamp is valid"),
)
.build();
let event = VerifiedEvent::verify_signed(author, event.signed_by(secret))
.expect("benchmark event verifies");
parent = Some(event.event_id.to_short());
db.process_event_tx(&event, event.timestamp(), tx)?;
}
Ok(())
})
.await?;
drop(db);
let before_bytes = std::fs::metadata(&path)?.len();
let raw = redb_bincode::Database::from(redb::Database::open(&path)?);
let tx = raw.begin_write()?;
tx.open_table(&crate::db_version::TABLE)?.insert(&(), &24)?;
tx.commit()?;
drop(raw);
let started = std::time::Instant::now();
let replayed = Database::open(&path, author).await?;
let elapsed = started.elapsed();
let after_bytes = std::fs::metadata(&path)?.len();
let event_count = replayed
.read_with(|tx| Ok(tx.open_table(&events::TABLE)?.range(..)?.count()))
.await?;
assert_eq!(event_count, EVENT_COUNT);
eprintln!(
"streamed {EVENT_COUNT} events in {elapsed:?}; file bytes {before_bytes} -> {after_bytes}"
);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_mention_detection() -> BoxedErrorResult<()> {
use rostra_core::ExternalEventId;
use rostra_core::event::{VerifiedEventContent, content_kind};
let user_a_secret = RostraIdSecretKey::generate();
let user_a = user_a_secret.id();
let user_b_secret = RostraIdSecretKey::generate();
let _user_b = user_b_secret.id();
let (_dir, db) = temp_db(user_a).await?;
let build_social_post_event = |id_secret: RostraIdSecretKey,
parent: Option<EventId>,
djot_content: &str,
reply_to: Option<ExternalEventId>|
-> (VerifiedEvent, EventContentRaw) {
use rostra_core::event::content_kind::EventContentKind as _;
let content = content_kind::SocialPost::new(
djot_content.to_string(),
reply_to,
Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let author = id_secret.id();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.maybe_parent_prev(parent.map(Into::into))
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
(verified, content_raw)
};
let mention_content = format!("Hello <rostra:{user_a}>!");
let (post_mention, post_mention_content) =
build_social_post_event(user_b_secret, None, &mention_content, None);
let post_mention_id = post_mention.event_id;
let (post_no_mention, post_no_mention_content) = build_social_post_event(
user_b_secret,
Some(post_mention_id),
"Just a regular post",
None,
);
let post_no_mention_id = post_no_mention.event_id;
let (post_self, post_self_content) =
build_social_post_event(user_a_secret, None, "My own post", None);
let post_self_id = post_self.event_id;
let self_mention_content = format!("I am <rostra:{user_a}>!");
let (post_self_mention, post_self_mention_content) = build_social_post_event(
user_a_secret,
Some(post_self_id),
&self_mention_content,
None,
);
let post_self_mention_id = post_self_mention.event_id;
let reply_to_a = ExternalEventId::new(user_a, post_self_id);
let (post_reply, post_reply_content) = build_social_post_event(
user_b_secret,
Some(post_no_mention_id),
"Reply to A",
Some(reply_to_a),
);
let post_reply_id = post_reply.event_id;
let reply_mention_content = format!("Hey <rostra:{user_a}>, replying to you!");
let (post_reply_mention, post_reply_mention_content) = build_social_post_event(
user_b_secret,
Some(post_reply_id),
&reply_mention_content,
Some(reply_to_a),
);
let post_reply_mention_id = post_reply_mention.event_id;
let events_with_content = [
(&post_mention, &post_mention_content),
(&post_no_mention, &post_no_mention_content),
(&post_self, &post_self_content),
(&post_self_mention, &post_self_mention_content),
(&post_reply, &post_reply_content),
(&post_reply_mention, &post_reply_mention_content),
];
let now = rostra_core::Timestamp::now();
for (event, content_raw) in events_with_content {
db.write_with(|tx| {
db.process_event_tx(event, now, tx)?;
let verified_content =
VerifiedEventContent::assume_verified(*event, content_raw.clone());
db.process_event_content_tx(&verified_content, now, tx)?;
Ok(())
})
.await?;
}
assert!(
db.is_self_mention(post_mention_id.into()).await,
"Post with mention should be recorded as self-mention"
);
assert!(
!db.is_self_mention(post_no_mention_id.into()).await,
"Post without mention should NOT be recorded as self-mention"
);
assert!(
!db.is_self_mention(post_self_id.into()).await,
"Self-post should NOT be recorded as self-mention"
);
assert!(
!db.is_self_mention(post_self_mention_id.into()).await,
"Self-post mentioning self should NOT be recorded as self-mention"
);
assert!(
!db.is_self_mention(post_reply_id.into()).await,
"Reply without mention should NOT be recorded as self-mention"
);
assert!(
db.is_self_mention(post_reply_mention_id.into()).await,
"Reply with mention should be recorded as self-mention"
);
let self_mentions = db.get_self_mentions().await;
assert_eq!(
self_mentions.len(),
2,
"Should have exactly 2 self-mentions (post_mention and post_reply_mention)"
);
assert!(
self_mentions.contains(&post_mention_id.into()),
"Self-mentions should contain post_mention"
);
assert!(
self_mentions.contains(&post_reply_mention_id.into()),
"Self-mentions should contain post_reply_mention"
);
assert!(
!self_mentions.contains(&post_no_mention_id.into()),
"Self-mentions should NOT contain post_no_mention"
);
info!("=== Self-mention detection test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_content_processing_idempotency() -> BoxedErrorResult<()> {
use rostra_core::ExternalEventId;
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::id::ToShort as _;
let _ = tracing_subscriber::fmt::try_init();
let id_secret_a = RostraIdSecretKey::generate();
let user_a = id_secret_a.id();
let id_secret_b = RostraIdSecretKey::generate();
let user_b = id_secret_b.id();
let (_tmp, db) = temp_db(user_a).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user_a)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(id_secret_a);
VerifiedEvent::verify_signed(user_a, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
let post_id = post_event_id.to_short();
let reply_content = content_kind::SocialPost::new(
"Reply".to_string(),
Some(ExternalEventId::new(user_a, post_event_id)),
Default::default(), );
let reply_raw = reply_content.serialize_cbor().unwrap();
let reply_event = {
let event = Event::builder_raw_content()
.author(user_b)
.kind(EventKind::SOCIAL_POST)
.content(&reply_raw)
.build();
let signed = event.signed_by(id_secret_b);
VerifiedEvent::verify_signed(user_b, signed).expect("Valid event")
};
let reply_event_id = reply_event.event_id;
let reply_id = reply_event_id.to_short();
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&post_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Missing { .. })),
"Post should be Unprocessed before content arrives"
);
Ok(())
})
.await?;
let verified_post =
rostra_core::event::VerifiedEventContent::assume_verified(post_event, post_raw.clone());
db.write_with(|tx| {
db.process_event_content_tx(&verified_post, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
state.is_none(),
"Post should have no content state after processing"
);
Ok(())
})
.await?;
db.write_with(|tx| {
db.process_event_tx(&reply_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let state = Database::get_event_content_state_tx(reply_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Missing { .. })),
"Reply should be Unprocessed before content arrives"
);
Ok(())
})
.await?;
let verified_reply =
rostra_core::event::VerifiedEventContent::assume_verified(reply_event, reply_raw.clone());
db.write_with(|tx| {
db.process_event_content_tx(&verified_reply, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let social_posts_table = tx.open_table(&crate::social_posts::TABLE)?;
let reply_state =
Database::get_event_content_state_tx(reply_id, &events_content_state_table)?;
assert!(
reply_state.is_none(),
"Reply should have no content state after processing"
);
let post_record = social_posts_table.get(&post_id)?.map(|g| g.value());
assert_eq!(
post_record.map(|r| r.reply_count).unwrap_or(0),
1,
"Post should have reply_count = 1"
);
Ok(())
})
.await?;
db.write_with(|tx| {
db.process_event_content_tx(&verified_reply, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let social_posts_table = tx.open_table(&crate::social_posts::TABLE)?;
let post_record = social_posts_table.get(&post_id)?.map(|g| g.value());
assert_eq!(
post_record.map(|r| r.reply_count).unwrap_or(0),
1,
"Post should still have reply_count = 1 after reprocessing"
);
Ok(())
})
.await?;
info!("=== Content processing idempotency test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_delete_while_unprocessed() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
let post_id = post_event_id.to_short();
let content_hash = post_event.content_hash();
let delete_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.parent_prev(post_event_id.into())
.delete(post_event_id.into())
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&post_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Missing { .. })),
"Post should be Unprocessed"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 after post insertion");
Ok(())
})
.await?;
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should be Deleted after delete event, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after deletion");
Ok(())
})
.await?;
let verified_post =
rostra_core::event::VerifiedEventContent::assume_verified(post_event, post_raw.clone());
db.write_with(|tx| {
db.process_event_content_tx(&verified_post, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let social_posts_table = tx.open_table(&crate::social_posts::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should still be Deleted after attempted content processing"
);
let post_record = social_posts_table.get(&post_id)?;
assert!(
post_record.is_none(),
"No social post record should exist for deleted post"
);
Ok(())
})
.await?;
info!("=== Delete while Unprocessed test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_two_deletes_same_target() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
let post_id = post_event_id.to_short();
let content_hash = post_event.content_hash();
let delete1_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.parent_prev(post_event_id.into())
.delete(post_event_id.into())
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let delete1_id = delete1_event.event_id;
let delete2_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.parent_prev(delete1_id.into())
.delete(post_event_id.into())
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let expected_deleted_by = [
(delete1_event.timestamp(), delete1_event.event_id.to_short()),
(delete2_event.timestamp(), delete2_event.event_id.to_short()),
]
.into_iter()
.max()
.expect("two deletion candidates")
.1;
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&post_event, now, tx)?;
Ok(())
})
.await?;
db.write_with(|tx| {
db.process_event_tx(&delete1_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after first delete");
Ok(())
})
.await?;
let usage_after_first_delete = db.get_data_usage(user).await;
db.write_with(|tx| {
db.process_event_tx(&delete2_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should still be 0 after second delete");
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert_eq!(
state,
Some(EventContentState::Deleted {
deleted_by: expected_deleted_by
}),
"Post should retain canonical direct attribution"
);
Ok(())
})
.await?;
let usage_after_second_delete = db.get_data_usage(user).await;
assert_eq!(
usage_after_second_delete.deleted_payload_num, usage_after_first_delete.deleted_payload_num,
"attribution-only updates must not repeat payload deletion accounting"
);
assert_eq!(
usage_after_second_delete.deleted_payload_size,
usage_after_first_delete.deleted_payload_size,
"attribution-only updates must not repeat payload deletion accounting"
);
info!("=== Two deletes same target test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_prune_then_delete() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
let post_id = post_event_id.to_short();
let content_hash = post_event.content_hash();
let delete_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.parent_prev(post_event_id.into())
.delete(post_event_id.into())
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&post_event, now, tx)?;
Ok(())
})
.await?;
db.write_with(|tx| {
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
Database::prune_event_content_tx(
post_id,
content_hash,
&mut events_content_state_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Pruned)),
"Post should be Pruned, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after prune");
Ok(())
})
.await?;
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should be Deleted after delete event, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should still be 0 (no double decrement)");
Ok(())
})
.await?;
info!("=== Prune then delete test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_delete_then_prune() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind;
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let post_event_id = post_event.event_id;
let post_id = post_event_id.to_short();
let content_hash = post_event.content_hash();
let delete_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.parent_prev(post_event_id.into())
.delete(post_event_id.into())
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&post_event, now, tx)?;
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should be Deleted"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after delete");
Ok(())
})
.await?;
let prune_result = db
.write_with(|tx| {
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let result = Database::prune_event_content_tx(
post_id,
content_hash,
&mut events_content_state_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(result)
})
.await?;
assert!(!prune_result, "Prune should return false for deleted event");
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should still be Deleted"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should still be 0");
Ok(())
})
.await?;
info!("=== Delete then prune test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_invalid_then_prune() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let (event, content) = build_test_event_with_invalid_content(user_secret, None, 500);
let event_id = event.event_id;
let post_id = event_id.to_short();
let content_hash = event.content_hash();
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Invalid)),
"Post should be Invalid, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after invalid");
Ok(())
})
.await?;
let prune_result = db
.write_with(|tx| {
let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
let mut events_content_missing_table = tx.open_table(&events_content_missing::TABLE)?;
let result = Database::prune_event_content_tx(
post_id,
content_hash,
&mut events_content_state_table,
&mut content_rc_table,
&mut events_content_missing_table,
None,
)?;
Ok(result)
})
.await?;
assert!(!prune_result, "Prune should return false for invalid event");
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state = Database::get_event_content_state_tx(post_id, &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Invalid)),
"Post should still be Invalid, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should still be 0");
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_predeleted_envelope_bookkeeping_converges() -> BoxedErrorResult<()> {
use rostra_core::{ContentHash, ShortEventId};
use crate::{IdsDataUsageRecord, db_version, events_self, ids_data_usage};
#[derive(Debug, PartialEq, Eq)]
struct PayloadUsage {
current_content_size: u64,
total_content_size: u64,
current_payload_num: u64,
total_payload_num: u64,
missing_payload_size: u64,
missing_payload_num: u64,
deleted_payload_size: u64,
deleted_payload_num: u64,
pruned_payload_size: u64,
pruned_payload_num: u64,
invalid_payload_size: u64,
invalid_payload_num: u64,
}
fn payload_usage(
IdsDataUsageRecord {
current_metadata_size: _,
total_metadata_size: _,
current_metadata_num: _,
total_metadata_num: _,
current_content_size,
total_content_size,
current_payload_num,
total_payload_num,
missing_payload_size,
missing_payload_num,
deleted_payload_size,
deleted_payload_num,
pruned_payload_size,
pruned_payload_num,
invalid_payload_size,
invalid_payload_num,
}: IdsDataUsageRecord,
) -> PayloadUsage {
PayloadUsage {
current_content_size,
total_content_size,
current_payload_num,
total_payload_num,
missing_payload_size,
missing_payload_num,
deleted_payload_size,
deleted_payload_num,
pruned_payload_size,
pruned_payload_num,
invalid_payload_size,
invalid_payload_num,
}
}
#[derive(Debug, PartialEq, Eq)]
struct Snapshot {
self_events: Vec<ShortEventId>,
payload_usage: PayloadUsage,
target_rc: Option<u64>,
queue: Vec<(Timestamp, ShortEventId)>,
target_state: Option<EventContentState>,
}
async fn snapshot(
db: &Database,
author: RostraId,
target_id: ShortEventId,
target_hash: ContentHash,
) -> BoxedErrorResult<Snapshot> {
Ok(db
.read_with(|tx| {
let self_events = tx
.open_table(&events_self::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value()))
.collect::<Result<Vec<_>, _>>()?;
let usage =
Database::get_data_usage_tx(author, &tx.open_table(&ids_data_usage::TABLE)?)?;
assert_eq!(
usage.total_content_size,
usage.current_content_size
+ usage.missing_payload_size
+ usage.deleted_payload_size
+ usage.pruned_payload_size
+ usage.invalid_payload_size,
"payload-size buckets must sum to total"
);
assert_eq!(
usage.total_payload_num,
usage.current_payload_num
+ usage.missing_payload_num
+ usage.deleted_payload_num
+ usage.pruned_payload_num
+ usage.invalid_payload_num,
"payload-count buckets must sum to total"
);
let target_rc = tx
.open_table(&content_rc::TABLE)?
.get(&target_hash)?
.map(|entry| entry.value());
let queue = tx
.open_table(&events_content_missing::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value()))
.collect::<Result<Vec<_>, _>>()?;
let target_state = tx
.open_table(&events_content_state::TABLE)?
.get(&target_id)?
.map(|entry| entry.value());
Ok(Snapshot {
self_events,
payload_usage: payload_usage(usage),
target_rc,
queue,
target_state,
})
})
.await?)
}
fn force_total_replay(path: &std::path::Path) -> BoxedErrorResult<()> {
let raw_db = redb_bincode::Database::from(redb::Database::open(path)?);
let write_txn = raw_db.begin_write()?;
{
let mut table = write_txn.open_table(&db_version::TABLE)?;
table.insert(&(), &24)?;
}
write_txn.commit()?;
Ok(())
}
let self_secret = RostraIdSecretKey::from_bytes([31; 32]);
let self_id = self_secret.id();
let other_secret = RostraIdSecretKey::from_bytes([32; 32]);
for (case, author_secret) in [("self", self_secret), ("non-self", other_secret)] {
let author = author_secret.id();
let (target, _content) =
build_test_event_with_valid_content(author_secret, None, "deleted target payload");
let target_id = target.event_id.to_short();
let target_hash = target.content_hash();
let content_len = u64::from(target.content_len());
let deletion = build_delete_event(author_secret, target.event_id, target.event_id);
let deletion_id = deletion.event_id.to_short();
let mut final_snapshots = vec![];
for delete_first in [false, true] {
let dir = tempdir()?;
let path = dir.path().join("db.redb");
let db = Database::open(&path, self_id).await.boxed()?;
let ordered_events = if delete_first {
[deletion, target]
} else {
[target, deletion]
};
for (index, event) in ordered_events.into_iter().enumerate() {
db.write_with(|tx| {
db.process_event_tx(&event, Timestamp::from(1), tx)?;
Ok(())
})
.await?;
if index == 0 {
let observed = snapshot(&db, author, target_id, target_hash).await?;
let first_self_events = if case == "self" {
vec![event.event_id.to_short()]
} else {
vec![]
};
let expected = if delete_first {
Snapshot {
self_events: first_self_events,
payload_usage: PayloadUsage {
current_content_size: 0,
total_content_size: 0,
current_payload_num: 1,
total_payload_num: 1,
missing_payload_size: 0,
missing_payload_num: 0,
deleted_payload_size: 0,
deleted_payload_num: 0,
pruned_payload_size: 0,
pruned_payload_num: 0,
invalid_payload_size: 0,
invalid_payload_num: 0,
},
target_rc: None,
queue: vec![],
target_state: None,
}
} else {
Snapshot {
self_events: first_self_events,
payload_usage: PayloadUsage {
current_content_size: 0,
total_content_size: content_len,
current_payload_num: 0,
total_payload_num: 1,
missing_payload_size: content_len,
missing_payload_num: 1,
deleted_payload_size: 0,
deleted_payload_num: 0,
pruned_payload_size: 0,
pruned_payload_num: 0,
invalid_payload_size: 0,
invalid_payload_num: 0,
},
target_rc: Some(1),
queue: vec![(Timestamp::ZERO, target_id)],
target_state: Some(EventContentState::Missing {
last_fetch_attempt: None,
fetch_attempt_count: 0,
next_fetch_attempt: Timestamp::ZERO,
}),
}
};
assert_eq!(
observed, expected,
"{case}, delete_first={delete_first}: first transaction"
);
}
}
let expected_self_events = if case == "self" {
let mut ids = vec![target_id, deletion_id];
ids.sort_unstable();
ids
} else {
vec![]
};
let final_snapshot = snapshot(&db, author, target_id, target_hash).await?;
assert_eq!(
final_snapshot.self_events, expected_self_events,
"{case}, delete_first={delete_first}: self-envelope index"
);
assert_eq!(
final_snapshot.payload_usage,
PayloadUsage {
current_content_size: 0,
total_content_size: content_len,
current_payload_num: 1,
total_payload_num: 2,
missing_payload_size: 0,
missing_payload_num: 0,
deleted_payload_size: content_len,
deleted_payload_num: 1,
pruned_payload_size: 0,
pruned_payload_num: 0,
invalid_payload_size: 0,
invalid_payload_num: 0,
},
"{case}, delete_first={delete_first}: all payload usage fields"
);
assert_eq!(
final_snapshot.target_rc, None,
"{case}, delete_first={delete_first}: target must not retain RC"
);
assert!(
final_snapshot.queue.is_empty(),
"{case}, delete_first={delete_first}: fetch queue must be empty"
);
assert_eq!(
final_snapshot.target_state,
Some(EventContentState::Deleted {
deleted_by: deletion_id,
}),
"{case}, delete_first={delete_first}: target state"
);
drop(db);
let reopened = Database::open(&path, self_id).await.boxed()?;
assert_eq!(
snapshot(&reopened, author, target_id, target_hash).await?,
final_snapshot,
"{case}, delete_first={delete_first}: ordinary reopen"
);
drop(reopened);
force_total_replay(&path)?;
let replayed = Database::open(&path, self_id).await.boxed()?;
assert_eq!(
snapshot(&replayed, author, target_id, target_hash).await?,
final_snapshot,
"{case}, delete_first={delete_first}: total replay"
);
final_snapshots.push(final_snapshot);
}
assert_eq!(
final_snapshots[0], final_snapshots[1],
"{case}: target-first and delete-first must converge"
);
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_delete_processed_content() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use rostra_core::id::ToShort as _;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event, content) =
build_test_event_with_valid_content(id_secret, None, "Process then delete");
let event_id = event.event_id;
let content_hash = event.content_hash();
let content_len = u64::from(event.content_len());
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event, now, tx)?;
Ok(())
})
.await?;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let state =
Database::get_event_content_state_tx(event_id.to_short(), &events_content_state_table)?;
assert!(
state.is_none(),
"Processed event should have no entry, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 after processing");
Ok(())
})
.await?;
let delete_event = build_delete_event(id_secret, event_id, event_id);
db.write_with(|tx| {
db.process_event_tx(&delete_event, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let state =
Database::get_event_content_state_tx(event_id.to_short(), &events_content_state_table)?;
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"Post should be Deleted, got {state:?}"
);
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after delete");
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(usage.current_content_size, 0, "Current size should be 0");
assert_eq!(
usage.current_payload_num, 1,
"Current count should be 1 (delete event)"
);
assert_eq!(
usage.deleted_payload_size, content_len,
"Deleted should have the payload"
);
assert_eq!(usage.deleted_payload_num, 1, "Deleted count should be 1");
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_two_events_same_invalid_content() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::ids_data_usage;
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let (event_a, content_a) = build_test_event_with_invalid_content(id_secret, None, 300);
let event_a_id = event_a.event_id;
let content_hash = event_a.content_hash();
let (event_b, content_b) = build_test_event_with_invalid_content(id_secret, event_a_id, 300);
let content_hash_b = event_b.content_hash();
assert_eq!(
content_hash, content_hash_b,
"Same content should produce same hash"
);
let now = rostra_core::Timestamp::now();
db.write_with(|tx| {
db.process_event_tx(&event_a, now, tx)?;
db.process_event_tx(&event_b, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 2, "RC should be 2 after inserting both events");
Ok(())
})
.await?;
let verified_a = VerifiedEventContent::assume_verified(event_a, content_a);
db.process_event_content(&verified_a).await;
db.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 1, "RC should be 1 after first invalid processing");
Ok(())
})
.await?;
let verified_b = VerifiedEventContent::assume_verified(event_b, content_b);
db.process_event_content(&verified_b).await;
db.read_with(|tx| {
let content_rc_table = tx.open_table(&content_rc::TABLE)?;
let ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
let rc = Database::get_content_rc_tx(content_hash, &content_rc_table)?;
assert_eq!(rc, 0, "RC should be 0 after both invalid");
let usage = Database::get_data_usage_tx(author, &ids_data_usage_table)?;
assert_eq!(
usage.invalid_payload_num, 2,
"Should have 2 invalid payloads"
);
assert_eq!(usage.missing_payload_num, 0, "No unprocessed payloads left");
assert_eq!(usage.current_payload_num, 0, "No current payloads");
Ok(())
})
.await?;
Ok(())
}
#[cfg(not(debug_assertions))]
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_process_content_for_nonexistent_event() -> BoxedErrorResult<()> {
use rostra_core::event::content_kind::EventContentKind as _;
use rostra_core::event::{VerifiedEventContent, content_kind};
use rostra_core::id::ToShort as _;
let user_secret = RostraIdSecretKey::generate();
let user = user_secret.id();
let (_tmp, db) = temp_db(user).await?;
let post_content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let post_raw = post_content.serialize_cbor().unwrap();
let post_event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&post_raw)
.build();
let signed = event.signed_by(user_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let now = rostra_core::Timestamp::now();
let verified_post = VerifiedEventContent::assume_verified(post_event, post_raw);
db.write_with(|tx| {
db.process_event_content_tx(&verified_post, now, tx)?;
Ok(())
})
.await?;
db.read_with(|tx| {
let social_posts_table = tx.open_table(&crate::social_posts::TABLE)?;
let events_table = tx.open_table(&events::TABLE)?;
assert!(
events_table
.get(&verified_post.event_id().to_short())?
.is_none(),
"Event should not exist"
);
let post_record = social_posts_table.get(&verified_post.event_id().to_short())?;
assert!(post_record.is_none(), "No social post record should exist");
Ok(())
})
.await?;
info!("=== Process content for nonexistent event test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_wants_content_basic() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::ProcessEventState;
info!("=== Testing wants_content behavior ===");
let id_secret = RostraIdSecretKey::generate();
let user = id_secret.id();
let (_dir, db) = temp_db(user).await?;
let (event, content) = build_test_event_with_valid_content(id_secret, None, "wants test");
let event_id = event.event_id.to_short();
let (_, process_state) = db.process_event(&event).await;
info!(?process_state, "Event processed");
assert!(
db.wants_content(event_id, ProcessEventState::New).await,
"wants_content should return true for ProcessEventState::New"
);
assert!(
db.wants_content(event_id, ProcessEventState::Existing)
.await,
"wants_content should return true when content is NOT in store"
);
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
assert!(
!db.wants_content(event_id, ProcessEventState::Existing)
.await,
"wants_content should return false when content IS in store"
);
assert!(
!db.wants_content(event_id, ProcessEventState::Deleted).await,
"wants_content should return false for ProcessEventState::Deleted"
);
assert!(
!db.wants_content(event_id, ProcessEventState::Pruned).await,
"wants_content should return false for ProcessEventState::Pruned"
);
info!("=== wants_content basic test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_wants_content_no_repeated_downloads() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use crate::ProcessEventState;
info!("=== Testing wants_content doesn't cause repeated downloads ===");
let id_secret = RostraIdSecretKey::generate();
let user = id_secret.id();
let (_dir, db) = temp_db(user).await?;
let (event, content) = build_test_event_with_valid_content(id_secret, None, "no repeat");
let event_id = event.event_id.to_short();
db.process_event(&event).await;
let verified_content = VerifiedEventContent::assume_verified(event, content);
db.process_event_content(&verified_content).await;
for i in 0..5 {
let wants = db
.wants_content(event_id, ProcessEventState::Existing)
.await;
assert!(
!wants,
"Iteration {i}: wants_content should return false for existing content"
);
}
info!("=== wants_content repeated check test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_wants_content_for_missing_content() -> BoxedErrorResult<()> {
use crate::ProcessEventState;
info!("=== Testing wants_content for genuinely missing content ===");
let id_secret = RostraIdSecretKey::generate();
let user = id_secret.id();
let (_dir, db) = temp_db(user).await?;
let content = EventContentRaw::new(vec![9, 10, 11, 12]);
let event = {
let event = Event::builder_raw_content()
.author(user)
.kind(EventKind::SOCIAL_POST)
.content(&content)
.build();
let signed = event.signed_by(id_secret);
VerifiedEvent::verify_signed(user, signed).expect("Valid event")
};
let event_id = event.event_id.to_short();
db.process_event(&event).await;
for i in 0..5 {
let wants = db
.wants_content(event_id, ProcessEventState::Existing)
.await;
assert!(
wants,
"Iteration {i}: wants_content should return true for missing content"
);
}
info!("=== wants_content missing content test passed ===");
Ok(())
}
async fn read_missing_content_queue(
db: &Database,
) -> BoxedErrorResult<Vec<(Timestamp, rostra_core::ShortEventId)>> {
Ok(db
.read_with(|tx| {
tx.open_table(&events_content_missing::TABLE)?
.range(..)?
.map(|entry| entry.map(|(key, _)| key.value()).map_err(Into::into))
.collect()
})
.await?)
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_failed_fetch_completions_are_compare_and_set() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::from_bytes([31; 32]);
let author = id_secret.id();
let (event, content) =
build_test_event_with_valid_content(id_secret, None, "fetch completion CAS");
let event_id = event.event_id.to_short();
let event_content = VerifiedEventContent::assume_verified(event, content);
let deletion = build_delete_event(id_secret, event.event_id, event.event_id);
let first_attempt = Timestamp::from(10);
let first_retry = Timestamp::from(100);
let stale_attempt = Timestamp::from(20);
let stale_retry = Timestamp::from(200);
for (scenario, process_content, stale_before_terminal) in [
("F1,F2,P", true, true),
("F1,P,F2", true, false),
("F1,F2,D", false, true),
("F1,D,F2", false, false),
] {
let (_dir, db) = temp_db(author).await?;
db.process_event(&event).await;
db.record_failed_content_fetch(event_id, Timestamp::ZERO, first_attempt, first_retry)
.await;
if stale_before_terminal {
db.record_failed_content_fetch(event_id, Timestamp::ZERO, stale_attempt, stale_retry)
.await;
assert_eq!(
read_missing_content_queue(&db).await?,
vec![(first_retry, event_id)],
"{scenario}: stale or non-forward completion must not replace the current schedule"
);
db.read_with(|tx| {
assert!(
matches!(
tx.open_table(&events_content_state::TABLE)?
.get(&event_id)?
.map(|state| state.value()),
Some(EventContentState::Missing {
last_fetch_attempt: Some(last_fetch_attempt),
fetch_attempt_count: 1,
next_fetch_attempt,
}) if last_fetch_attempt == first_attempt
&& next_fetch_attempt == first_retry
),
"{scenario}: stale or non-forward completion changed retry metadata"
);
Ok(())
})
.await?;
}
if process_content {
db.process_event_content(&event_content).await;
} else {
db.process_event(&deletion).await;
}
if !stale_before_terminal {
db.record_failed_content_fetch(event_id, Timestamp::ZERO, stale_attempt, stale_retry)
.await;
}
assert!(
read_missing_content_queue(&db).await?.is_empty(),
"{scenario}: terminal content state must have no fetch rows"
);
db.read_with(|tx| {
let state = tx
.open_table(&events_content_state::TABLE)?
.get(&event_id)?
.map(|state| state.value());
if process_content {
assert_eq!(state, None, "{scenario}");
} else {
assert!(
matches!(state, Some(EventContentState::Deleted { .. })),
"{scenario}"
);
}
Ok(())
})
.await?;
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_failed_fetch_rejects_non_forward_schedule() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::from_bytes([33; 32]);
let author = id_secret.id();
let (event, _content) =
build_test_event_with_valid_content(id_secret, None, "non-forward fetch schedule");
let event_id = event.event_id.to_short();
let (_dir, db) = temp_db(author).await?;
let attempted_at = Timestamp::from(10);
let current_schedule = Timestamp::from(100);
db.process_event(&event).await;
db.record_failed_content_fetch(event_id, Timestamp::ZERO, attempted_at, current_schedule)
.await;
for invalid_schedule in [current_schedule, Timestamp::from(99)] {
db.record_failed_content_fetch(
event_id,
current_schedule,
Timestamp::from(20),
invalid_schedule,
)
.await;
}
assert_eq!(
read_missing_content_queue(&db).await?,
vec![(current_schedule, event_id)]
);
db.read_with(|tx| {
assert!(matches!(
tx.open_table(&events_content_state::TABLE)?
.get(&event_id)?
.map(|state| state.value()),
Some(EventContentState::Missing {
last_fetch_attempt: Some(last_fetch_attempt),
fetch_attempt_count: 1,
next_fetch_attempt,
}) if last_fetch_attempt == attempted_at
&& next_fetch_attempt == current_schedule
));
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_missing_content_peek_repairs_stale_front_rows() -> BoxedErrorResult<()> {
let id_secret = RostraIdSecretKey::from_bytes([32; 32]);
let author = id_secret.id();
let dir = tempdir()?;
let db_path = dir.path().join("db.redb");
let db = Database::open(&db_path, author).await.boxed()?;
let processed = build_post_event_content(
id_secret,
time::OffsetDateTime::UNIX_EPOCH,
None,
"processed",
);
let missing = build_post_event_content(
id_secret,
time::OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(1),
Some(processed.event_id()),
"valid queued work",
);
let processed_id = processed.event_id().to_short();
let missing_id = missing.event_id().to_short();
let valid_schedule = Timestamp::from(100);
db.process_event_with_content(&processed).await;
db.process_event(&missing.event).await;
db.record_failed_content_fetch(
missing_id,
Timestamp::ZERO,
Timestamp::from(50),
valid_schedule,
)
.await;
db.write_with(|tx| {
let mut queue = tx.open_table(&events_content_missing::TABLE)?;
queue.insert(&(Timestamp::from(1), processed_id), &())?;
queue.insert(&(Timestamp::from(2), missing_id), &())?;
queue.insert(&(Timestamp::from(3), rostra_core::ShortEventId::ZERO), &())?;
queue.insert(&(Timestamp::from(101), processed_id), &())?;
queue.insert(&(Timestamp::from(102), missing_id), &())?;
Ok(())
})
.await?;
let next = db
.peek_next_missing_content()
.await
.expect("valid work behind stale rows");
assert_eq!(next.event_id, missing_id);
assert_eq!(next.scheduled_time, valid_schedule);
assert_eq!(next.fetch_attempt_count, 1);
assert_eq!(
read_missing_content_queue(&db).await?,
vec![
(valid_schedule, missing_id),
(Timestamp::from(101), processed_id),
(Timestamp::from(102), missing_id),
]
);
let (paginated, cursor) = db.paginate_missing_events_contents(None, 10).await;
assert_eq!(paginated, vec![(author, missing_id)]);
assert_eq!(cursor, None);
drop(db);
let reopened = Database::open(&db_path, author).await.boxed()?;
assert_eq!(
read_missing_content_queue(&reopened).await?,
vec![
(valid_schedule, missing_id),
(Timestamp::from(101), processed_id),
(Timestamp::from(102), missing_id),
],
"front-row repair must survive restart without exposing stale tail rows"
);
let (paginated, cursor) = reopened.paginate_missing_events_contents(None, 10).await;
assert_eq!(paginated, vec![(author, missing_id)]);
assert_eq!(cursor, None);
reopened.process_event_content(&missing).await;
reopened
.write_with(|tx| {
tx.open_table(&events_content_missing::TABLE)?
.insert(&(Timestamp::from(1), processed_id), &())?;
Ok(())
})
.await?;
assert!(
reopened.peek_next_missing_content().await.is_none(),
"a stale terminal row must be removed instead of returned for refetch"
);
assert!(read_missing_content_queue(&reopened).await?.is_empty());
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_current_state_watches_retain_state_and_match_restart() -> BoxedErrorResult<()> {
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let direct_followee_secret = RostraIdSecretKey::generate();
let direct_followee = direct_followee_secret.id();
let extended_followee = RostraIdSecretKey::generate().id();
let follower_secret = RostraIdSecretKey::generate();
let follower = follower_secret.id();
let dir = tempdir()?;
let db_path = dir.path().join("db.redb");
let db = Database::open(&db_path, self_id).await.boxed()?;
let base_time = time::OffsetDateTime::UNIX_EPOCH;
let self_follow = build_follow_event_content(self_secret, direct_followee, base_time, None);
let self_post_a = build_post_event_content(
self_secret,
base_time + time::Duration::seconds(1),
Some(self_follow.event_id()),
"retained head A",
);
let self_post_b = build_post_event_content(
self_secret,
base_time + time::Duration::seconds(2),
Some(self_follow.event_id()),
"retained head B",
);
let follower_event = build_follow_event_content(follower_secret, self_id, base_time, None);
let extended_event =
build_follow_event_content(direct_followee_secret, extended_followee, base_time, None);
let expected_head = std::cmp::min(
self_post_a.event_id().to_short(),
self_post_b.event_id().to_short(),
);
db.write_with(|tx| {
for event_content in [
&self_follow,
&extended_event,
&follower_event,
&self_post_a,
&self_post_b,
] {
db.process_event_tx(&event_content.event, Timestamp::ZERO, tx)?;
db.process_event_content_tx(event_content, Timestamp::ZERO, tx)?;
}
Ok(())
})
.await?;
let followees_rx = db.self_followees_subscribe();
let followers_rx = db.self_followers_subscribe();
let wot_rx = db.self_wot_subscribe();
let head_rx = db.self_head_subscribe();
assert!(followees_rx.snapshot().contains_key(&direct_followee));
assert!(followers_rx.snapshot().contains_key(&follower));
assert!(wot_rx.snapshot().followees.contains_key(&direct_followee));
assert!(wot_rx.snapshot().extended.contains(&extended_followee));
assert_eq!(head_rx.snapshot(), Some(expected_head));
let continuous_head = head_rx.snapshot();
drop((followees_rx, followers_rx, wot_rx, head_rx));
drop(db);
let reopened = Database::open(&db_path, self_id).await.boxed()?;
let reopened_followees = reopened.self_followees_subscribe();
let reopened_followers = reopened.self_followers_subscribe();
let reopened_wot = reopened.self_wot_subscribe();
let reopened_head = reopened.self_head_subscribe();
assert_eq!(reopened_followees.snapshot().len(), 1);
assert!(reopened_followees.snapshot().contains_key(&direct_followee));
assert_eq!(reopened_followers.snapshot().len(), 1);
assert!(reopened_followers.snapshot().contains_key(&follower));
assert_eq!(reopened_wot.snapshot().followees.len(), 1);
assert!(
reopened_wot
.snapshot()
.followees
.contains_key(&direct_followee)
);
assert_eq!(reopened_wot.snapshot().extended.len(), 1);
assert!(
reopened_wot
.snapshot()
.extended
.contains(&extended_followee)
);
assert_eq!(reopened_head.snapshot(), continuous_head);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_owned_current_state_snapshot_does_not_block_database_writes() -> BoxedErrorResult<()>
{
use std::time::Duration;
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let mut followees = db.self_followees_subscribe();
let initial = followees.snapshot();
let follow = build_follow_event_content(
self_secret,
followee,
time::OffsetDateTime::UNIX_EPOCH,
None,
);
tokio::time::timeout(
Duration::from_secs(1),
db.process_event_with_content(&follow),
)
.await
.expect("an owned snapshot must not block current-state publication");
assert!(initial.is_empty(), "the earlier snapshot remains immutable");
let updated = tokio::time::timeout(Duration::from_secs(1), followees.changed())
.await
.expect("committed state must be published")
.expect("database still owns the publisher");
assert!(updated.contains_key(&followee));
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_current_state_snapshot_and_clone_have_independent_cursors() -> BoxedErrorResult<()> {
use std::time::Duration;
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let mut first = db.self_followees_subscribe();
let mut second = first.clone();
let mut closes_with_unseen_update = first.clone();
let follow = build_follow_event_content(
self_secret,
followee,
time::OffsetDateTime::UNIX_EPOCH,
None,
);
db.process_event_with_content(&follow).await;
let snapshot = first.snapshot();
assert!(snapshot.contains_key(&followee));
let first_update = tokio::time::timeout(Duration::from_secs(1), first.changed())
.await
.expect("snapshot must not advance the first cursor")
.expect("database still owns the publisher");
let second_update = tokio::time::timeout(Duration::from_secs(1), second.changed())
.await
.expect("the cloned cursor must advance independently")
.expect("database still owns the publisher");
assert!(first_update.contains_key(&followee));
assert!(second_update.contains_key(&followee));
assert!(
tokio::time::timeout(Duration::from_millis(50), first.changed())
.await
.is_err(),
"the first cursor must consume the publication"
);
assert!(
tokio::time::timeout(Duration::from_millis(50), second.changed())
.await
.is_err(),
"the cloned cursor must consume the publication independently"
);
drop(db);
assert_eq!(first.snapshot().len(), 1);
assert!(matches!(
first.changed().await,
Err(crate::CurrentStateClosed)
));
assert!(
closes_with_unseen_update
.changed()
.await
.expect("closure must not hide the last unseen publication")
.contains_key(&followee)
);
assert!(matches!(
closes_with_unseen_update.changed().await,
Err(crate::CurrentStateClosed)
));
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_current_state_watches_cannot_regress_between_commits() -> BoxedErrorResult<()> {
use std::sync::{Arc, mpsc};
use std::time::Duration;
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let direct_a_secret = RostraIdSecretKey::generate();
let direct_a = direct_a_secret.id();
let direct_b = RostraIdSecretKey::generate().id();
let extended = RostraIdSecretKey::generate().id();
let follower_a_secret = RostraIdSecretKey::generate();
let follower_a = follower_a_secret.id();
let follower_b_secret = RostraIdSecretKey::generate();
let follower_b = follower_b_secret.id();
let (_dir, db) = temp_db(self_id).await?;
let db = Arc::new(db);
let followees_rx = db.self_followees_subscribe();
let followers_rx = db.self_followers_subscribe();
let wot_rx = db.self_wot_subscribe();
let head_rx = db.self_head_subscribe();
let base_time = time::OffsetDateTime::UNIX_EPOCH;
let older_self_follow = build_follow_event_content(self_secret, direct_a, base_time, None);
let older_self_post = build_post_event_content(
self_secret,
base_time + time::Duration::seconds(1),
Some(older_self_follow.event_id()),
"older head",
);
let older_follower = build_follow_event_content(follower_a_secret, self_id, base_time, None);
let newer_self_follow = build_follow_event_content(
self_secret,
direct_b,
base_time + time::Duration::seconds(2),
Some(older_self_post.event_id()),
);
let newer_self_post = build_post_event_content(
self_secret,
base_time + time::Duration::seconds(3),
Some(newer_self_follow.event_id()),
"newer head",
);
let newer_follower = build_follow_event_content(
follower_b_secret,
self_id,
base_time + time::Duration::seconds(1),
None,
);
let newer_extended = build_follow_event_content(
direct_a_secret,
extended,
base_time + time::Duration::seconds(1),
None,
);
let expected_head = newer_self_post.event_id().to_short();
let (older_hook_entered_tx, older_hook_entered_rx) = mpsc::channel();
let (release_older_hook_tx, release_older_hook_rx) = mpsc::channel();
let older_db = db.clone();
let older_task = tokio::spawn(async move {
older_db
.write_with(|tx| {
tx.on_commit(move || {
let _ = older_hook_entered_tx.send(());
release_older_hook_rx
.recv()
.expect("Test must release older hook");
});
for event_content in [&older_self_follow, &older_follower, &older_self_post] {
older_db.process_event_tx(&event_content.event, Timestamp::ZERO, tx)?;
older_db.process_event_content_tx(event_content, Timestamp::ZERO, tx)?;
}
Ok(())
})
.await
});
let older_hook_entered = tokio::task::spawn_blocking(move || {
older_hook_entered_rx.recv_timeout(Duration::from_secs(5))
})
.await;
let (newer_started_tx, newer_started_rx) = tokio::sync::oneshot::channel();
let newer_db = db.clone();
let newer_task = tokio::spawn(async move {
let _ = newer_started_tx.send(());
newer_db
.write_with(|tx| {
for event_content in [
&newer_self_follow,
&newer_follower,
&newer_extended,
&newer_self_post,
] {
newer_db.process_event_tx(&event_content.event, Timestamp::ZERO, tx)?;
newer_db.process_event_content_tx(event_content, Timestamp::ZERO, tx)?;
}
Ok(())
})
.await
});
let newer_started = tokio::time::timeout(Duration::from_secs(5), newer_started_rx).await;
tokio::time::sleep(Duration::from_millis(100)).await;
let newer_waited = !newer_task.is_finished();
let release_result = release_older_hook_tx.send(());
let older_result = older_task.await;
let newer_result = newer_task.await;
older_hook_entered
.expect("Hook waiter must not panic")
.expect("Older transaction must reach its first commit hook");
newer_started
.expect("Newer transaction start must not time out")
.expect("Newer transaction must start");
assert!(
newer_waited,
"Newer commit must wait for older current-state publication"
);
release_result.expect("Older hook must still be waiting");
older_result
.expect("Older task must not panic")
.expect("Older transaction must commit");
newer_result
.expect("Newer task must not panic")
.expect("Newer transaction must commit");
assert!(followees_rx.snapshot().contains_key(&direct_a));
assert!(followees_rx.snapshot().contains_key(&direct_b));
assert!(followers_rx.snapshot().contains_key(&follower_a));
assert!(followers_rx.snapshot().contains_key(&follower_b));
assert!(wot_rx.snapshot().followees.contains_key(&direct_a));
assert!(wot_rx.snapshot().followees.contains_key(&direct_b));
assert!(wot_rx.snapshot().extended.contains(&extended));
assert_eq!(head_rx.snapshot(), Some(expected_head));
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_current_state_publication_survives_earlier_hook_panic() -> BoxedErrorResult<()> {
use std::sync::Arc;
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let db = Arc::new(db);
let follow = build_follow_event_content(
self_secret,
followee,
time::OffsetDateTime::UNIX_EPOCH,
None,
);
let post = build_post_event_content(
self_secret,
time::OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(1),
Some(follow.event_id()),
"write after hook panic",
);
let panic_db = db.clone();
let panic_task = tokio::spawn(async move {
panic_db
.write_with(|tx| {
tx.on_commit(|| panic!("controlled commit-hook panic"));
panic_db.process_event_tx(&follow.event, Timestamp::ZERO, tx)?;
panic_db.process_event_content_tx(&follow, Timestamp::ZERO, tx)?;
Ok(())
})
.await
});
assert!(
panic_task
.await
.expect_err("Commit hook must propagate its panic")
.is_panic()
);
let followees_rx = db.self_followees_subscribe();
let wot_rx = db.self_wot_subscribe();
assert!(followees_rx.snapshot().contains_key(&followee));
assert!(wot_rx.snapshot().followees.contains_key(&followee));
db.process_event_with_content(&post).await;
assert_eq!(
db.self_head_subscribe().snapshot(),
Some(post.event_id().to_short())
);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_new_heads_broadcast() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let mut new_heads_rx = db.new_heads_subscribe();
let content = content_kind::SocialPost::new(
"Test post".to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified_event = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
let event_id = verified_event.event_id;
db.process_event(&verified_event).await;
let result = tokio::time::timeout(Duration::from_secs(1), new_heads_rx.recv()).await;
assert!(result.is_ok(), "Should receive new head notification");
let (received_author, received_head) = result.unwrap().expect("Channel should not be closed");
assert_eq!(received_author, author);
assert_eq!(received_head, event_id.into());
info!("=== new_heads_broadcast test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_new_heads_broadcast_not_for_non_head() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let content = content_kind::SocialPost::new(
"Parent post".to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let parent_event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let parent_signed = parent_event.signed_by(id_secret);
let parent_verified = VerifiedEvent::verify_signed(author, parent_signed).expect("Valid event");
let parent_id = parent_verified.event_id;
let child_content = content_kind::SocialPost::new(
"Child post".to_string(),
None, Default::default(), );
let child_content_raw = child_content.serialize_cbor().unwrap();
let child_event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.parent_prev(parent_id.into())
.content(&child_content_raw)
.build();
let child_signed = child_event.signed_by(id_secret);
let child_verified = VerifiedEvent::verify_signed(author, child_signed).expect("Valid event");
db.process_event(&child_verified).await;
let mut new_heads_rx = db.new_heads_subscribe();
db.process_event(&parent_verified).await;
let result = tokio::time::timeout(Duration::from_millis(100), new_heads_rx.recv()).await;
assert!(
result.is_err(),
"Should NOT receive new head notification for non-head event"
);
info!("=== new_heads_broadcast_not_for_non_head test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_head_updated_broadcast() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let mut self_head_rx = db.self_head_subscribe();
let content = content_kind::SocialPost::new(
"Self post".to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified_event = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
let event_id = verified_event.event_id;
db.process_event(&verified_event).await;
let result = tokio::time::timeout(Duration::from_secs(1), self_head_rx.changed()).await;
assert!(
result.is_ok(),
"Should receive self head update notification"
);
assert!(result.unwrap().is_ok(), "Channel should not be closed");
let received_head = self_head_rx.snapshot();
assert_eq!(received_head, Some(event_id.into()));
info!("=== self_head_updated_broadcast test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_head_updated_not_for_others() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let other_secret = RostraIdSecretKey::generate();
let other_id = other_secret.id();
let (_dir, db) = temp_db(self_id).await?;
let mut self_head_rx = db.self_head_subscribe();
let content = content_kind::SocialPost::new(
"Other user post".to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(other_id)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let signed_event = event.signed_by(other_secret);
let verified_event = VerifiedEvent::verify_signed(other_id, signed_event).expect("Valid event");
db.process_event(&verified_event).await;
let result = tokio::time::timeout(Duration::from_millis(100), self_head_rx.changed()).await;
assert!(
result.is_err(),
"Should NOT receive self head update for other user's event"
);
info!("=== self_head_updated_not_for_others test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_new_content_broadcast() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let mut new_content_rx = db.new_content_subscribe();
let content = content_kind::SocialPost::new(
"Test content".to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified_event = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
let event_id = verified_event.event_id;
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let result = tokio::time::timeout(Duration::from_secs(1), new_content_rx.recv()).await;
assert!(result.is_ok(), "Should receive new content notification");
let received_content = result.unwrap().expect("Channel should not be closed");
assert_eq!(received_content.event_id(), event_id);
info!("=== new_content_broadcast test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_new_posts_broadcast() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let author = id_secret.id();
let (_dir, db) = temp_db(author).await?;
let mut new_posts_rx = db.new_posts_subscribe();
let post_text = "Test social post";
let content = content_kind::SocialPost::new(
post_text.to_string(),
None, Default::default(), );
let content_raw = content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::SOCIAL_POST)
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified_event = VerifiedEvent::verify_signed(author, signed_event).expect("Valid event");
let event_id = verified_event.event_id;
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let result = tokio::time::timeout(Duration::from_secs(1), new_posts_rx.recv()).await;
assert!(result.is_ok(), "Should receive new post notification");
let (received_event_content, received_post) =
result.unwrap().expect("Channel should not be closed");
assert_eq!(received_event_content.event_id(), event_id);
assert_eq!(received_post.djot_content, Some(post_text.to_string()));
info!("=== new_posts_broadcast test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_followees_watch_channel() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let id_secret = RostraIdSecretKey::generate();
let self_id = id_secret.id();
let followee = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let mut followees_rx = db.self_followees_subscribe();
assert!(
followees_rx.snapshot().is_empty(),
"Should start with no followees"
);
let follow_content = content_kind::Follow {
followee,
persona: None,
selector: Some(rostra_core::event::PersonaSelector::Except { ids: vec![] }),
persona_tags_selector: None,
};
let content_raw = follow_content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(self_id)
.kind(EventKind::FOLLOW)
.content(&content_raw)
.build();
let signed_event = event.signed_by(id_secret);
let verified_event = VerifiedEvent::verify_signed(self_id, signed_event).expect("Valid event");
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let result = tokio::time::timeout(Duration::from_secs(1), followees_rx.changed()).await;
assert!(
result.is_ok(),
"Should receive followees update notification"
);
assert!(result.unwrap().is_ok(), "Channel should not be closed");
let followees = followees_rx.snapshot();
assert!(
followees.contains_key(&followee),
"Followee should be in the map"
);
assert_eq!(followees.len(), 1, "Should have exactly one followee");
info!("=== self_followees_watch_channel test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_followers_watch_channel() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let other_secret = RostraIdSecretKey::generate();
let other_id = other_secret.id();
let (_dir, db) = temp_db(self_id).await?;
let mut followers_rx = db.self_followers_subscribe();
assert!(
followers_rx.snapshot().is_empty(),
"Should start with no followers"
);
let follow_content = content_kind::Follow {
followee: self_id,
persona: None,
selector: Some(rostra_core::event::PersonaSelector::Except { ids: vec![] }),
persona_tags_selector: None,
};
let content_raw = follow_content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(other_id)
.kind(EventKind::FOLLOW)
.content(&content_raw)
.build();
let signed_event = event.signed_by(other_secret);
let verified_event = VerifiedEvent::verify_signed(other_id, signed_event).expect("Valid event");
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let result = tokio::time::timeout(Duration::from_secs(1), followers_rx.changed()).await;
assert!(
result.is_ok(),
"Should receive followers update notification"
);
assert!(result.unwrap().is_ok(), "Channel should not be closed");
let followers = followers_rx.snapshot();
assert!(
followers.contains_key(&other_id),
"Follower should be in the map"
);
assert_eq!(followers.len(), 1, "Should have exactly one follower");
info!("=== self_followers_watch_channel test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_self_wot_watch_channel() -> BoxedErrorResult<()> {
use std::time::Duration;
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let followee_a = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let mut wot_rx = db.self_wot_subscribe();
assert!(wot_rx.snapshot().is_empty(), "Should start with empty WoT");
let follow_a_content = content_kind::Follow {
followee: followee_a,
persona: None,
selector: Some(rostra_core::event::PersonaSelector::Except { ids: vec![] }),
persona_tags_selector: None,
};
let content_raw = follow_a_content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(self_id)
.kind(EventKind::FOLLOW)
.content(&content_raw)
.build();
let signed_event = event.signed_by(self_secret);
let verified_event = VerifiedEvent::verify_signed(self_id, signed_event).expect("Valid event");
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let result = tokio::time::timeout(Duration::from_secs(1), wot_rx.changed()).await;
assert!(result.is_ok(), "Should receive WoT update notification");
assert!(result.unwrap().is_ok(), "Channel should not be closed");
{
let wot = wot_rx.snapshot();
assert!(
wot.followees.contains_key(&followee_a),
"A should be in direct followees"
);
assert!(
wot.extended.is_empty(),
"Extended should be empty (A hasn't followed anyone)"
);
assert_eq!(wot.len(), 1, "WoT should have 1 entry");
}
info!("=== self_wot_watch_channel test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_wot_contains() -> BoxedErrorResult<()> {
use rostra_core::event::VerifiedEventContent;
use rostra_core::event::content_kind::{self, EventContentKind as _};
let self_secret = RostraIdSecretKey::generate();
let self_id = self_secret.id();
let followee = RostraIdSecretKey::generate().id();
let stranger = RostraIdSecretKey::generate().id();
let (_dir, db) = temp_db(self_id).await?;
let wot_rx = db.self_wot_subscribe();
let follow_content = content_kind::Follow {
followee,
persona: None,
selector: Some(rostra_core::event::PersonaSelector::Except { ids: vec![] }),
persona_tags_selector: None,
};
let content_raw = follow_content.serialize_cbor().unwrap();
let event = Event::builder_raw_content()
.author(self_id)
.kind(EventKind::FOLLOW)
.content(&content_raw)
.build();
let signed_event = event.signed_by(self_secret);
let verified_event = VerifiedEvent::verify_signed(self_id, signed_event).expect("Valid event");
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
let wot = wot_rx.snapshot();
assert!(wot.contains(self_id, self_id), "Self should be in WoT");
assert!(wot.contains(followee, self_id), "Followee should be in WoT");
assert!(
!wot.contains(stranger, self_id),
"Stranger should NOT be in WoT"
);
info!("=== wot_contains test passed ===");
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_content_length_limit_is_exclusive() -> BoxedErrorResult<()> {
use crate::ids_data_usage;
for separate_delivery in [false, true] {
for content_len in [
Database::MAX_CONTENT_LEN - 1,
Database::MAX_CONTENT_LEN,
Database::MAX_CONTENT_LEN + 1,
] {
let secret = RostraIdSecretKey::generate();
let author = secret.id();
let (_dir, db) = temp_db(author).await?;
let content = EventContentRaw::new(vec![0x5a; content_len as usize]);
let event = Event::builder_raw_content()
.author(author)
.kind(EventKind::RAW)
.content(&content)
.build();
let signed = event.signed_by(secret);
let event =
VerifiedEvent::verify_signed(author, signed).expect("event signature must verify");
let event_id = event.event_id.to_short();
let content_hash = event.content_hash();
let event_content = VerifiedEventContent::assume_verified(event, content);
let envelope_state = if separate_delivery {
let (_, state) = db.process_event(&event).await;
db.process_event_content(&event_content).await;
state
} else {
db.process_event_with_content(&event_content).await.1
};
let exceeds_limit = Database::MAX_CONTENT_LEN <= content_len;
assert_eq!(
envelope_state,
if exceeds_limit {
crate::ProcessEventState::Pruned
} else {
crate::ProcessEventState::New
},
"unexpected envelope result for length {content_len}, separate={separate_delivery}"
);
db.read_with(|tx| {
let state = tx
.open_table(&events_content_state::TABLE)?
.get(&event_id)?
.map(|entry| entry.value());
assert_eq!(
state,
exceeds_limit.then_some(EventContentState::Pruned),
"unexpected content state for length {content_len}, separate={separate_delivery}"
);
let queue_len = tx
.open_table(&events_content_missing::TABLE)?
.range(..)?
.count();
assert_eq!(queue_len, 0, "fetch queue must be empty");
let rc = Database::get_content_rc_tx(
content_hash,
&tx.open_table(&content_rc::TABLE)?,
)?;
assert_eq!(rc, u64::from(!exceeds_limit), "unexpected reference count");
let usage = Database::get_data_usage_tx(
author,
&tx.open_table(&ids_data_usage::TABLE)?,
)?;
assert_eq!(usage.total_content_size, u64::from(content_len));
assert_eq!(usage.total_payload_num, 1);
assert_eq!(
usage.current_content_size,
if exceeds_limit {
0
} else {
u64::from(content_len)
}
);
assert_eq!(usage.current_payload_num, u64::from(!exceeds_limit));
assert_eq!(
usage.pruned_payload_size,
if exceeds_limit {
u64::from(content_len)
} else {
0
}
);
assert_eq!(usage.pruned_payload_num, u64::from(exceeds_limit));
assert_eq!(usage.missing_payload_size, 0);
assert_eq!(usage.missing_payload_num, 0);
assert_eq!(usage.invalid_payload_size, 0);
assert_eq!(usage.invalid_payload_num, 0);
assert_eq!(usage.deleted_payload_size, 0);
assert_eq!(usage.deleted_payload_num, 0);
assert_eq!(
tx.open_table(&content_store::TABLE)?
.get(&content_hash)?
.is_some(),
!exceeds_limit,
"content retention must match eligibility"
);
Ok(())
})
.await?;
}
}
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_process_social_vote_with_content() -> BoxedErrorResult<()> {
use rostra_core::ExternalEventId;
use rostra_core::event::{VerifiedEventContent, content_kind};
let voter_secret = RostraIdSecretKey::generate();
let voter = voter_secret.id();
let post_author = RostraIdSecretKey::generate().id();
let post_id = ExternalEventId::new(post_author, rostra_core::ShortEventId::ZERO);
let (_dir, db) = temp_db(voter).await?;
let vote = content_kind::SocialVote::new(post_id, Some(true));
let (event, content_raw) = Event::builder(&vote).author(voter).build()?;
let signed_event = event.signed_by(voter_secret);
let verified_event = VerifiedEvent::verify_signed(voter, signed_event).expect("Valid event");
let verified_content = VerifiedEventContent::assume_verified(verified_event, content_raw);
db.process_event_with_content(&verified_content).await;
assert_eq!(db.get_social_vote_sum(post_id).await, 1);
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_expired_news_rank_removed_on_score_recalculation() -> BoxedErrorResult<()> {
use rostra_core::{ExternalEventId, ShortEventId, Timestamp};
use crate::{
SocialNewsRankRecord, social_news_rank_by_post_id, social_news_rank_by_score,
social_news_rank_by_time,
};
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let post_id = ExternalEventId::new(id_secret.id(), ShortEventId::ZERO);
let creation_ts = Timestamp::from(1_000);
let score = 42;
let now = creation_ts.saturating_add_secs(crate::news::NEWS_MAX_AGE_SECS + 1);
db.write_with(|tx| {
tx.open_table(&social_news_rank_by_post_id::TABLE)?
.insert(&post_id, &SocialNewsRankRecord { creation_ts, score })?;
tx.open_table(&social_news_rank_by_score::TABLE)?
.insert(&(score, post_id), &())?;
tx.open_table(&social_news_rank_by_time::TABLE)?
.insert(&(creation_ts, post_id), &())?;
let updated = Database::recalculate_news_post_score_tx(post_id, now, tx)?;
assert!(!updated);
assert!(
tx.open_table(&social_news_rank_by_post_id::TABLE)?
.get(&post_id)?
.is_none()
);
assert!(
tx.open_table(&social_news_rank_by_score::TABLE)?
.get(&(score, post_id))?
.is_none()
);
assert!(
tx.open_table(&social_news_rank_by_time::TABLE)?
.get(&(creation_ts, post_id))?
.is_none()
);
Ok(())
})
.await?;
Ok(())
}
#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn test_news_rank_at_max_age_not_removed_on_score_recalculation() -> BoxedErrorResult<()> {
use rostra_core::{ExternalEventId, ShortEventId, Timestamp};
use crate::{
SocialNewsRankRecord, social_news_rank_by_post_id, social_news_rank_by_score,
social_news_rank_by_time,
};
let id_secret = RostraIdSecretKey::generate();
let (_dir, db) = temp_db(id_secret.id()).await?;
let post_id = ExternalEventId::new(id_secret.id(), ShortEventId::ZERO);
let creation_ts = Timestamp::from(1_000);
let now = creation_ts.saturating_add_secs(crate::news::NEWS_MAX_AGE_SECS);
let score = Database::calculate_news_score(creation_ts, 0, now);
db.write_with(|tx| {
tx.open_table(&social_news_rank_by_post_id::TABLE)?
.insert(&post_id, &SocialNewsRankRecord { creation_ts, score })?;
tx.open_table(&social_news_rank_by_score::TABLE)?
.insert(&(score, post_id), &())?;
tx.open_table(&social_news_rank_by_time::TABLE)?
.insert(&(creation_ts, post_id), &())?;
let updated = Database::recalculate_news_post_score_tx(post_id, now, tx)?;
assert!(updated);
assert!(
tx.open_table(&social_news_rank_by_post_id::TABLE)?
.get(&post_id)?
.is_some()
);
assert!(
tx.open_table(&social_news_rank_by_score::TABLE)?
.get(&(score, post_id))?
.is_some()
);
assert!(
tx.open_table(&social_news_rank_by_time::TABLE)?
.get(&(creation_ts, post_id))?
.is_some()
);
Ok(())
})
.await?;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn missing_event_author_pagination_is_unique_bounded_and_exclusive() -> BoxedErrorResult<()> {
let (_dir, db) = temp_db_rng().await?;
let mut authors = [
RostraIdSecretKey::from_bytes([71; 32]).id(),
RostraIdSecretKey::from_bytes([72; 32]).id(),
RostraIdSecretKey::from_bytes([73; 32]).id(),
];
authors.sort_unstable();
db.write_with(|tx| {
let mut missing = tx.open_table(&events_missing::TABLE)?;
let record = crate::event::EventsMissingRecord { deleted_by: None };
missing.insert(&(authors[0], rostra_core::ShortEventId::ZERO), &record)?;
missing.insert(&(authors[0], rostra_core::ShortEventId::MAX), &record)?;
missing.insert(&(authors[1], rostra_core::ShortEventId::ZERO), &record)?;
missing.insert(&(authors[2], rostra_core::ShortEventId::ZERO), &record)?;
Ok(())
})
.await?;
assert!(db.get_ids_with_missing_events(None, 0).await.is_empty());
assert_eq!(db.get_ids_with_missing_events(None, 2).await, authors[..2]);
assert_eq!(
db.get_ids_with_missing_events(Some(authors[1]), 2).await,
authors[2..]
);
assert_eq!(
db.get_ids_with_missing_events(Some(authors[2]), 2).await,
Vec::<RostraId>::new()
);
assert_eq!(db.get_last_id_with_missing_events().await, Some(authors[2]));
Ok(())
}