event_store.rs (27716B)
1 use futures_executor::block_on; 2 use radroots_event::{ 3 EventId, SignedEvent, VerifiedEvent, 4 admission::{AdmissionPolicy, RawEvent, VisibilityPolicy, VisibleEvent}, 5 wire::Nip01EventWire, 6 }; 7 use radroots_storage::{ 8 Error, EventStore, 9 event::{ 10 AdmissionDisposition, AdmissionReceipt, AdmissionStage, EventAdmission, EventPage, 11 EventPosition, EventQuery, EventQueryBounds, EventSequence, SourceGeneration, 12 StoredEventProvenance, StoredRawEvent, StoredVerifiedEvent, StoredVisibleEvent, 13 VisibilityInput, VisibilitySnapshot, evaluate_visibility, 14 }, 15 status::{EventStoreHealth, EventStoreMode, EventStoreStatus}, 16 }; 17 use radroots_transport::{ 18 BoxFuture, Target, TransportId, 19 source::{EventProvenance, ObservedEvent}, 20 }; 21 use std::sync::Mutex; 22 23 #[derive(Clone)] 24 struct Entry { 25 position: EventPosition, 26 admission: EventAdmission, 27 provenance: Vec<EventProvenance>, 28 } 29 30 struct MemoryEventStore { 31 generation: SourceGeneration, 32 entries: Mutex<Vec<Entry>>, 33 } 34 35 impl MemoryEventStore { 36 fn new() -> Self { 37 Self { 38 generation: SourceGeneration::new([7; 32]).expect("non-zero generation"), 39 entries: Mutex::new(Vec::new()), 40 } 41 } 42 43 fn selected(&self, query: &EventQuery) -> Result<Vec<Entry>, Error> { 44 if let Some(cursor) = query.bounds().cursor() 45 && cursor.generation() != self.generation 46 { 47 return Err(Error::SourceGenerationChanged); 48 } 49 let after = query 50 .bounds() 51 .cursor() 52 .map_or(0, |cursor| cursor.sequence().get()); 53 Ok(self 54 .entries 55 .lock() 56 .expect("test store lock") 57 .iter() 58 .filter(|entry| { 59 entry.position.sequence().get() > after && query.selects(entry.admission.event_id()) 60 }) 61 .take(usize::from(query.bounds().limit())) 62 .cloned() 63 .collect()) 64 } 65 } 66 67 #[test] 68 fn unsupported_adapter_cannot_invent_a_source_fence() { 69 assert_eq!( 70 block_on(MemoryEventStore::new().source_token()), 71 Err(Error::BackendUnavailable) 72 ); 73 assert_eq!( 74 block_on(MemoryEventStore::new().query_visible_at( 75 EventQuery::all(EventQueryBounds::first(5).unwrap()), 76 radroots_storage::event::EventSourceToken::new( 77 SourceGeneration::new([1; 32]).unwrap(), 78 0 79 ), 80 )), 81 Err(Error::BackendUnavailable) 82 ); 83 assert_eq!( 84 block_on(MemoryEventStore::new().maintain_visibility( 85 radroots_storage::event::VisibilityIndexBounds::new(64, 16 * 1024 * 1024).unwrap() 86 )), 87 Err(Error::BackendUnavailable) 88 ); 89 } 90 91 impl EventStore for MemoryEventStore { 92 fn status(&self) -> BoxFuture<'_, Result<EventStoreStatus, Error>> { 93 Box::pin(async move { 94 let entries = self.entries.lock().expect("test store lock"); 95 let raw = entries.len() as u64; 96 let verified = entries 97 .iter() 98 .filter(|entry| entry.admission.stage() >= AdmissionStage::Verified) 99 .count() as u64; 100 let visible = entries 101 .iter() 102 .filter(|entry| entry.admission.stage() == AdmissionStage::Visible) 103 .count() as u64; 104 EventStoreStatus::new( 105 self.generation, 106 EventStoreMode::ReadWrite, 107 EventStoreHealth::Available, 108 raw, 109 verified, 110 visible, 111 ) 112 }) 113 } 114 115 fn admit(&self, admission: EventAdmission) -> BoxFuture<'_, Result<AdmissionReceipt, Error>> { 116 Box::pin(async move { 117 let mut entries = self.entries.lock().expect("test store lock"); 118 if let Some(entry) = entries 119 .iter_mut() 120 .find(|entry| entry.admission.event_id() == admission.event_id()) 121 { 122 if entry.admission.event() != admission.event() { 123 return Err(Error::EventConflict); 124 } 125 if admission.stage() < entry.admission.stage() { 126 return Err(Error::AdmissionRegression); 127 } 128 let disposition = if admission.stage() == entry.admission.stage() { 129 AdmissionDisposition::Duplicate 130 } else { 131 AdmissionDisposition::Advanced 132 }; 133 if !entry.provenance.contains(admission.provenance()) { 134 entry.provenance.push(admission.provenance().clone()); 135 } 136 entry.admission = admission; 137 return Ok(AdmissionReceipt::new( 138 *entry.admission.event_id(), 139 entry.position, 140 entry.admission.stage(), 141 disposition, 142 )); 143 } 144 145 let sequence = EventSequence::new(entries.len() as u64 + 1)?; 146 let position = EventPosition::new(self.generation, sequence); 147 let receipt = AdmissionReceipt::new( 148 *admission.event_id(), 149 position, 150 admission.stage(), 151 AdmissionDisposition::Inserted, 152 ); 153 let provenance = vec![admission.provenance().clone()]; 154 entries.push(Entry { 155 position, 156 admission, 157 provenance, 158 }); 159 Ok(receipt) 160 }) 161 } 162 163 fn query_raw( 164 &self, 165 query: EventQuery, 166 ) -> BoxFuture<'_, Result<EventPage<StoredRawEvent>, Error>> { 167 Box::pin(async move { 168 let items = self 169 .selected(&query)? 170 .into_iter() 171 .map(|entry| { 172 StoredRawEvent::new( 173 entry.position, 174 entry.admission.event().clone(), 175 entry.admission.stage(), 176 ) 177 }) 178 .collect(); 179 EventPage::new(self.generation, items, None, query.bounds()) 180 }) 181 } 182 183 fn query_verified( 184 &self, 185 query: EventQuery, 186 ) -> BoxFuture<'_, Result<EventPage<StoredVerifiedEvent>, Error>> { 187 Box::pin(async move { 188 let items = self 189 .selected(&query)? 190 .into_iter() 191 .filter_map(|entry| { 192 (entry.admission.stage() >= AdmissionStage::Verified).then(|| { 193 StoredVerifiedEvent::new(entry.position, entry.admission.event().clone()) 194 }) 195 }) 196 .collect(); 197 EventPage::new(self.generation, items, None, query.bounds()) 198 }) 199 } 200 201 fn query_visible( 202 &self, 203 query: EventQuery, 204 ) -> BoxFuture<'_, Result<EventPage<StoredVisibleEvent>, Error>> { 205 Box::pin(async move { 206 let items = self 207 .selected(&query)? 208 .into_iter() 209 .filter_map(|entry| { 210 (entry.admission.stage() == AdmissionStage::Visible).then(|| { 211 StoredVisibleEvent::new(entry.position, entry.admission.event().clone()) 212 }) 213 }) 214 .collect(); 215 EventPage::new(self.generation, items, None, query.bounds()) 216 }) 217 } 218 219 fn rebuild_visibility(&self) -> BoxFuture<'_, Result<VisibilitySnapshot, Error>> { 220 Box::pin(async move { 221 let entries = self.entries.lock().expect("test store lock"); 222 evaluate_visibility( 223 self.generation, 224 entries.iter().map(|entry| { 225 VisibilityInput::new( 226 entry.position, 227 entry.admission.event(), 228 entry.admission.stage(), 229 ) 230 }), 231 ) 232 .map(|evaluation| evaluation.into_snapshot()) 233 }) 234 } 235 236 fn query_provenance( 237 &self, 238 event_id: EventId, 239 bounds: EventQueryBounds, 240 ) -> BoxFuture<'_, Result<EventPage<StoredEventProvenance>, Error>> { 241 Box::pin(async move { 242 let entries = self.entries.lock().expect("test store lock"); 243 let entry = entries 244 .iter() 245 .find(|entry| entry.admission.event_id() == &event_id) 246 .ok_or(Error::EventNotFound)?; 247 let items = entry 248 .provenance 249 .iter() 250 .take(usize::from(bounds.limit())) 251 .cloned() 252 .map(|provenance| StoredEventProvenance::new(entry.position, provenance)) 253 .collect(); 254 EventPage::new(self.generation, items, None, bounds) 255 }) 256 } 257 } 258 259 struct Allow; 260 261 impl radroots_event::admission::SignatureVerifier for Allow { 262 fn verify_signature( 263 &self, 264 _event: &radroots_event::Event, 265 ) -> Result<(), radroots_event::Error> { 266 Ok(()) 267 } 268 } 269 270 impl AdmissionPolicy for Allow { 271 type Error = core::convert::Infallible; 272 273 fn policy_id(&self) -> &'static str { 274 "test.storage.admission.v1" 275 } 276 277 fn admit( 278 &self, 279 _event: &radroots_event::admission::ContractValidatedEvent, 280 ) -> Result<(), Self::Error> { 281 Ok(()) 282 } 283 } 284 285 impl VisibilityPolicy for Allow { 286 type Error = core::convert::Infallible; 287 288 fn policy_id(&self) -> &'static str { 289 "test.storage.visibility.v1" 290 } 291 292 fn make_visible( 293 &self, 294 _event: &radroots_event::admission::AdmittedEvent, 295 ) -> Result<(), Self::Error> { 296 Ok(()) 297 } 298 } 299 300 fn signed_event_with_signature(signature_byte: &str) -> SignedEvent { 301 let mut wire = Nip01EventWire { 302 id: "0".repeat(64), 303 pubkey: "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df".to_owned(), 304 created_at: 1_800_000_100, 305 kind: 0, 306 tags: vec![], 307 content: "{\"display_name\":\"Moss Street Farm\",\"bot\":false}".to_owned(), 308 sig: signature_byte.repeat(64), 309 extra: Default::default(), 310 }; 311 wire.id = wire 312 .computed_event_id() 313 .expect("canonical event id") 314 .to_hex(); 315 let raw_json = serde_json::json!({ 316 "id": &wire.id, 317 "pubkey": &wire.pubkey, 318 "created_at": wire.created_at, 319 "kind": wire.kind, 320 "tags": &wire.tags, 321 "content": &wire.content, 322 "sig": &wire.sig, 323 }) 324 .to_string(); 325 SignedEvent::from_wire_verified_id(wire, raw_json).expect("signed event") 326 } 327 328 fn signed_event() -> SignedEvent { 329 signed_event_with_signature("42") 330 } 331 332 fn observed(event: SignedEvent, observed_at: u64) -> ObservedEvent { 333 let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("relay target"); 334 let provenance = EventProvenance::new( 335 TransportId::NOSTR, 336 target.fingerprint().clone(), 337 observed_at, 338 ) 339 .expect("provenance"); 340 ObservedEvent::new(event, provenance) 341 } 342 343 fn verified(event: &SignedEvent) -> VerifiedEvent { 344 RawEvent::new(event.envelope().clone()) 345 .verify_id() 346 .expect("event id") 347 .verify_signature(&Allow) 348 .expect("signature") 349 } 350 351 fn visible(event: &SignedEvent) -> VisibleEvent { 352 let verified = verified(event); 353 let validated = if event.envelope().kind_u32() == 5 { 354 verified 355 .validate_contract_for_admission("radroots.social.deletion_request.v1") 356 .expect("deletion contract") 357 } else { 358 verified.validate_contract().expect("contract") 359 }; 360 validated 361 .admit_with(&Allow) 362 .expect("admission") 363 .make_visible_with(&Allow) 364 .expect("visibility") 365 } 366 367 fn indexed_event( 368 author: &str, 369 time: u64, 370 kind: u32, 371 tags: Vec<Vec<String>>, 372 content: &str, 373 ) -> SignedEvent { 374 let mut wire = Nip01EventWire { 375 id: "0".repeat(64), 376 pubkey: author.to_owned(), 377 created_at: time, 378 kind, 379 tags, 380 content: content.to_owned(), 381 sig: "42".repeat(64), 382 extra: Default::default(), 383 }; 384 wire.id = wire.computed_event_id().unwrap().to_hex(); 385 let raw = serde_json::to_string(&wire).unwrap(); 386 SignedEvent::from_wire_verified_id(wire, raw).unwrap() 387 } 388 389 #[test] 390 fn memory_indexed_address_deletion_head_ties_and_unsupported_authority_match_reference() { 391 use radroots_storage::memory::MemoryStorage; 392 const AUTHOR: &str = "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df"; 393 const OTHER: &str = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"; 394 let storage = MemoryStorage::new(SourceGeneration::new([101; 32]).unwrap()); 395 let address = format!("0:{AUTHOR}:"); 396 let addressable = format!("30023:{AUTHOR}:"); 397 let cases = [ 398 ( 399 indexed_event(AUTHOR, 10, 0, vec![], r#"{"name":"old"}"#), 400 true, 401 ), 402 ( 403 indexed_event(AUTHOR, 20, 0, vec![], r#"{"name":"first tie"}"#), 404 true, 405 ), 406 ( 407 indexed_event(AUTHOR, 20, 0, vec![], r#"{"name":"second tie"}"#), 408 true, 409 ), 410 ( 411 indexed_event( 412 OTHER, 413 25, 414 5, 415 vec![vec!["a".into(), address.clone()]], 416 "wrong author", 417 ), 418 true, 419 ), 420 ( 421 indexed_event(AUTHOR, 25, 5, vec![vec!["a".into(), address]], "cutoff"), 422 true, 423 ), 424 ( 425 indexed_event(AUTHOR, 30, 0, vec![], r#"{"name":"later"}"#), 426 true, 427 ), 428 ( 429 indexed_event(AUTHOR, 5, 0, vec![], r#"{"name":"older arrives late"}"#), 430 true, 431 ), 432 ( 433 indexed_event(AUTHOR, 40, 0, vec![], "unsupported profile content"), 434 false, 435 ), 436 ( 437 indexed_event(AUTHOR, 50, 30023, vec![], "missing identifier"), 438 false, 439 ), 440 ( 441 indexed_event( 442 AUTHOR, 443 51, 444 30023, 445 vec![vec!["d".into(), "".into()]], 446 "explicit empty", 447 ), 448 false, 449 ), 450 ( 451 indexed_event(AUTHOR, 52, 30023, vec![], "missing again"), 452 false, 453 ), 454 ( 455 indexed_event( 456 AUTHOR, 457 60, 458 5, 459 vec![vec!["a".into(), addressable]], 460 "address cutoff", 461 ), 462 true, 463 ), 464 ]; 465 for (event, make_visible) in cases { 466 let admission = if make_visible { 467 EventAdmission::visible(observed(event.clone(), 100), visible(&event)).unwrap() 468 } else { 469 EventAdmission::verified(observed(event.clone(), 100), verified(&event)).unwrap() 470 }; 471 block_on(storage.admit(admission.clone())).unwrap(); 472 block_on(storage.admit(admission)).unwrap(); 473 let oracle = block_on(storage.rebuild_visibility()).unwrap(); 474 let mut actual = 475 block_on(storage.query_visible(EventQuery::all(EventQueryBounds::first(100).unwrap()))) 476 .unwrap() 477 .items() 478 .iter() 479 .map(|item| *item.event().id()) 480 .collect::<Vec<_>>(); 481 actual.sort(); 482 assert_eq!(actual, oracle.visible_event_ids()); 483 assert_eq!( 484 block_on(storage.status()).unwrap().visible_events(), 485 actual.len() as u64 486 ); 487 } 488 } 489 490 #[test] 491 fn memory_indexed_scoped_byte_pages_and_fences_preserve_continuation() { 492 use radroots_storage::{event::EventSourceToken, memory::MemoryStorage}; 493 let generation = SourceGeneration::new([102; 32]).unwrap(); 494 let storage = MemoryStorage::new(generation); 495 let author = "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df"; 496 let mut ids = Vec::new(); 497 for time in 0..12 { 498 let event = indexed_event(author, time, 1, vec![], &"x".repeat(120_000)); 499 ids.push(*event.id()); 500 block_on(storage.admit( 501 EventAdmission::visible(observed(event.clone(), 100), visible(&event)).unwrap(), 502 )) 503 .unwrap(); 504 } 505 let token = block_on(storage.source_token()).unwrap(); 506 let first = block_on( 507 storage.query_visible_at(EventQuery::all(EventQueryBounds::first(12).unwrap()), token), 508 ) 509 .unwrap(); 510 assert!(first.items().len() < 12); 511 let next = block_on( 512 storage.query_visible_at( 513 EventQuery::all( 514 EventQueryBounds::first(12) 515 .unwrap() 516 .after(first.next_cursor().unwrap()), 517 ), 518 token, 519 ), 520 ) 521 .unwrap(); 522 assert_eq!(first.items().len() + next.items().len(), 12); 523 assert!(next.next_cursor().is_none()); 524 let selected = EventQuery::for_ids( 525 EventQueryBounds::first(5).unwrap(), 526 vec![ids[11], EventId::from_bytes([255; 32]), ids[0]], 527 ) 528 .unwrap(); 529 let page = block_on(storage.query_visible_at(selected, token)).unwrap(); 530 assert_eq!( 531 page.items() 532 .iter() 533 .map(|item| *item.event().id()) 534 .collect::<Vec<_>>(), 535 vec![ids[0], ids[11]] 536 ); 537 assert_eq!( 538 block_on(storage.query_visible_at( 539 EventQuery::all(EventQueryBounds::first(5).unwrap()), 540 EventSourceToken::new(generation, token.epoch() - 1) 541 )), 542 Err(Error::SourceEpochChanged) 543 ); 544 let cursor = EventPosition::new( 545 SourceGeneration::new([103; 32]).unwrap(), 546 EventSequence::new(1).unwrap(), 547 ); 548 assert_eq!( 549 block_on(storage.query_visible(EventQuery::all( 550 EventQueryBounds::first(5).unwrap().after(cursor) 551 ))), 552 Err(Error::SourceGenerationChanged) 553 ); 554 } 555 556 #[test] 557 fn event_store_is_dyn_compatible_and_enforces_monotonic_admission() { 558 let store = MemoryEventStore::new(); 559 let dynamic: &dyn EventStore = &store; 560 let event = signed_event(); 561 562 let inserted = block_on(dynamic.admit(EventAdmission::raw(observed(event.clone(), 1)))) 563 .expect("raw insertion"); 564 assert_eq!(inserted.disposition(), AdmissionDisposition::Inserted); 565 assert_eq!(inserted.stage(), AdmissionStage::Raw); 566 567 let advanced = block_on( 568 dynamic.admit( 569 EventAdmission::verified(observed(event.clone(), 2), verified(&event)) 570 .expect("verified admission"), 571 ), 572 ) 573 .expect("verified advancement"); 574 assert_eq!(advanced.disposition(), AdmissionDisposition::Advanced); 575 assert_eq!(advanced.position(), inserted.position()); 576 577 let visible_event = visible(&event); 578 let advanced = block_on( 579 dynamic.admit( 580 EventAdmission::visible(observed(event.clone(), 3), visible_event) 581 .expect("visible admission"), 582 ), 583 ) 584 .expect("visible advancement"); 585 assert_eq!(advanced.stage(), AdmissionStage::Visible); 586 587 let duplicate = block_on( 588 dynamic.admit( 589 EventAdmission::visible(observed(event.clone(), 3), visible(&event)) 590 .expect("duplicate visible admission"), 591 ), 592 ) 593 .expect("idempotent duplicate"); 594 assert_eq!(duplicate.disposition(), AdmissionDisposition::Duplicate); 595 596 assert_eq!( 597 block_on(dynamic.admit(EventAdmission::raw(observed(event, 4)))), 598 Err(Error::AdmissionRegression) 599 ); 600 601 let conflicting = signed_event_with_signature("43"); 602 assert_eq!( 603 EventAdmission::verified(observed(conflicting.clone(), 5), verified(&signed_event())), 604 Err(Error::AdmissionEventMismatch) 605 ); 606 assert_eq!( 607 block_on(dynamic.admit(EventAdmission::raw(observed(conflicting, 6)))), 608 Err(Error::EventConflict) 609 ); 610 } 611 612 #[test] 613 fn event_queries_preserve_stage_generation_bounds_and_provenance() { 614 let store = MemoryEventStore::new(); 615 let event = signed_event(); 616 let event_id = *event.id(); 617 block_on( 618 store.admit( 619 EventAdmission::visible(observed(event.clone(), 5), visible(&event)) 620 .expect("visible admission"), 621 ), 622 ) 623 .expect("insert visible event"); 624 625 let bounds = EventQueryBounds::first(1).expect("query bounds"); 626 let query = EventQuery::for_ids(bounds, vec![event_id]).expect("id query"); 627 let raw = block_on(store.query_raw(query.clone())).expect("raw page"); 628 let verified = block_on(store.query_verified(query.clone())).expect("verified page"); 629 let visible = block_on(store.query_visible(query)).expect("visible page"); 630 let provenance = block_on(store.query_provenance(event_id, bounds)).expect("provenance page"); 631 632 assert_eq!(raw.items().len(), 1); 633 assert_eq!(raw.items()[0].stage(), AdmissionStage::Visible); 634 assert_eq!(verified.items().len(), 1); 635 assert_eq!(visible.items().len(), 1); 636 assert_eq!(provenance.items().len(), 1); 637 assert_eq!(raw.generation(), store.generation); 638 639 let status = block_on(store.status()).expect("status"); 640 assert_eq!(status.raw_events(), 1); 641 assert_eq!(status.verified_events(), 1); 642 assert_eq!(status.visible_events(), 1); 643 } 644 645 #[test] 646 fn bounds_generations_and_status_reject_invalid_state() { 647 assert_eq!( 648 SourceGeneration::new([0; 32]), 649 Err(Error::InvalidSourceGeneration) 650 ); 651 assert_eq!(EventSequence::new(0), Err(Error::InvalidEventSequence)); 652 assert_eq!( 653 EventQueryBounds::first(0), 654 Err(Error::InvalidEventQueryLimit) 655 ); 656 assert_eq!( 657 EventStoreStatus::new( 658 SourceGeneration::new([1; 32]).expect("generation"), 659 EventStoreMode::ReadOnly, 660 EventStoreHealth::Degraded, 661 1, 662 2, 663 0, 664 ), 665 Err(Error::CorruptStoredEvent) 666 ); 667 } 668 669 #[test] 670 fn event_value_models_cover_bounds_accessors_and_durable_reconstruction() { 671 let generation = SourceGeneration::new([1; 32]).expect("generation"); 672 let other_generation = SourceGeneration::new([2; 32]).expect("other generation"); 673 let sequence = EventSequence::new(1).expect("sequence"); 674 let position = EventPosition::new(generation, sequence); 675 assert_eq!(generation.as_bytes(), &[1; 32]); 676 assert_eq!(sequence.get(), 1); 677 assert_eq!(position.generation(), generation); 678 assert_eq!(position.sequence(), sequence); 679 680 assert_eq!( 681 EventQueryBounds::first(radroots_storage::event::EVENT_QUERY_LIMIT_MAX + 1), 682 Err(Error::InvalidEventQueryLimit) 683 ); 684 let bounds = EventQueryBounds::first(1).expect("bounds").after(position); 685 assert_eq!(bounds.limit(), 1); 686 assert_eq!(bounds.cursor(), Some(position)); 687 let event = signed_event(); 688 let event_id = *event.id(); 689 assert_eq!( 690 EventQuery::for_ids(bounds, Vec::new()), 691 Err(Error::EmptyEventQueryIds) 692 ); 693 assert_eq!( 694 EventQuery::for_ids(bounds, vec![event_id, event_id]), 695 Err(Error::DuplicateEventQueryId) 696 ); 697 assert_eq!( 698 EventQuery::for_ids( 699 bounds, 700 vec![event_id; radroots_storage::event::EVENT_QUERY_ID_MAX + 1] 701 ), 702 Err(Error::TooManyEventQueryIds) 703 ); 704 let all = EventQuery::all(bounds); 705 assert!(all.event_ids().is_empty()); 706 assert!(all.selects(&event_id)); 707 let selected = EventQuery::for_ids(bounds, vec![event_id]).expect("selected query"); 708 assert_eq!(selected.bounds(), bounds); 709 assert_eq!(selected.event_ids(), &[event_id]); 710 assert!(selected.selects(&event_id)); 711 let other_event_id = EventId::parse("f".repeat(64)).expect("other event id"); 712 assert!(!selected.selects(&other_event_id)); 713 714 let raw_admission = EventAdmission::raw(observed(event.clone(), 1)); 715 assert_eq!(raw_admission.stage(), AdmissionStage::Raw); 716 assert_eq!(raw_admission.event(), &event); 717 assert_eq!(raw_admission.event_id(), &event_id); 718 assert_eq!(raw_admission.provenance().observed_at_unix_ms(), 1); 719 assert!(raw_admission.verified_event().is_none()); 720 assert!(raw_admission.visible_event().is_none()); 721 let verified_admission = 722 EventAdmission::verified(observed(event.clone(), 2), verified(&event)).expect("verified"); 723 assert!(verified_admission.verified_event().is_some()); 724 assert!(verified_admission.visible_event().is_none()); 725 let visible_admission = 726 EventAdmission::visible(observed(event.clone(), 3), visible(&event)).expect("visible"); 727 assert!(visible_admission.verified_event().is_some()); 728 assert!(visible_admission.visible_event().is_some()); 729 assert_eq!( 730 EventAdmission::visible( 731 observed(signed_event_with_signature("43"), 4), 732 visible(&event) 733 ), 734 Err(Error::AdmissionEventMismatch) 735 ); 736 737 let receipt = AdmissionReceipt::new( 738 event_id, 739 position, 740 AdmissionStage::Raw, 741 AdmissionDisposition::Inserted, 742 ); 743 assert_eq!(receipt.event_id(), &event_id); 744 assert_eq!(receipt.position(), position); 745 assert_eq!(receipt.stage(), AdmissionStage::Raw); 746 assert_eq!(receipt.disposition(), AdmissionDisposition::Inserted); 747 let stored_raw = StoredRawEvent::new(position, event.clone(), AdmissionStage::Raw); 748 assert_eq!(stored_raw.position(), position); 749 assert_eq!(stored_raw.event(), &event); 750 assert_eq!(stored_raw.stage(), AdmissionStage::Raw); 751 let stored_verified = StoredVerifiedEvent::new(position, event.clone()); 752 assert_eq!(stored_verified.position(), position); 753 assert_eq!(stored_verified.event(), &event); 754 let stored_visible = StoredVisibleEvent::new(position, event); 755 assert_eq!(stored_visible.position(), position); 756 assert_eq!(stored_visible.event().id(), &event_id); 757 758 assert_eq!( 759 EventPage::new( 760 generation, 761 vec![1, 2], 762 None, 763 EventQueryBounds::first(1).unwrap() 764 ), 765 Err(Error::EventPageLimitExceeded) 766 ); 767 assert_eq!( 768 EventPage::<u8>::new( 769 generation, 770 vec![], 771 Some(EventPosition::new(other_generation, sequence)), 772 EventQueryBounds::first(1).unwrap(), 773 ), 774 Err(Error::CursorGenerationMismatch) 775 ); 776 let page = EventPage::new(generation, vec![1], Some(position), bounds).expect("page"); 777 assert_eq!(page.generation(), generation); 778 assert_eq!(page.items(), &[1]); 779 assert_eq!(page.next_cursor(), Some(position)); 780 781 let provenance = observed(signed_event(), 5).provenance().clone(); 782 let stored = StoredEventProvenance::new(position, provenance.clone()); 783 assert_eq!(stored.position(), position); 784 assert_eq!(stored.provenance(), &provenance); 785 let reconstructed = StoredEventProvenance::from_stored_parts( 786 position, 787 "nostr", 788 provenance.target().as_str(), 789 5, 790 Some("cursor"), 791 ) 792 .expect("stored provenance"); 793 assert_eq!( 794 reconstructed.provenance().cursor().unwrap().as_str(), 795 "cursor" 796 ); 797 for (transport, target, observed_at, cursor) in [ 798 ("BAD ID", provenance.target().as_str(), 5, None), 799 ("nostr", "bad", 5, None), 800 ("nostr", provenance.target().as_str(), 0, None), 801 ("nostr", provenance.target().as_str(), 5, Some(" bad")), 802 ] { 803 assert_eq!( 804 StoredEventProvenance::from_stored_parts( 805 position, 806 transport, 807 target, 808 observed_at, 809 cursor, 810 ), 811 Err(Error::CorruptStoredEvent) 812 ); 813 } 814 }