lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

memory_mutation_tests.rs (2689B)


      1 use super::*;
      2 use futures_executor::block_on;
      3 use radroots_event::{
      4     SignedEvent,
      5     admission::{RawEvent, SignatureVerifier},
      6     wire::Nip01EventWire,
      7 };
      8 use radroots_transport::{Target, TransportId, source::ObservedEvent};
      9 
     10 fn admission() -> EventAdmission {
     11     let raw = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#;
     12     let event =
     13         SignedEvent::from_wire_verified_id(Nip01EventWire::parse_json(raw).unwrap(), raw).unwrap();
     14     let target = Target::nostr_relay("wss://relay.example").unwrap();
     15     let provenance =
     16         EventProvenance::new(TransportId::NOSTR, target.fingerprint().clone(), 100).unwrap();
     17     EventAdmission::raw(ObservedEvent::new(event, provenance))
     18 }
     19 
     20 struct Allow;
     21 impl SignatureVerifier for Allow {
     22     fn verify_signature(&self, _: &radroots_event::Event) -> Result<(), radroots_event::Error> {
     23         Ok(())
     24     }
     25 }
     26 
     27 #[test]
     28 fn u64_epoch_maximum_rejects_semantic_mutation_without_partial_effects() {
     29     let generation = SourceGeneration::new([78; 32]).unwrap();
     30     let storage = MemoryStorage::new(generation);
     31     storage.state().unwrap().event_mutation_epoch = u64::MAX - 1;
     32     let original = admission();
     33     block_on(storage.admit(original.clone())).unwrap();
     34     let maximum = EventSourceToken::new(generation, u64::MAX);
     35     assert_eq!(block_on(storage.source_token()).unwrap(), maximum);
     36     block_on(storage.admit(original.clone())).unwrap();
     37     let verified = RawEvent::new(original.event().envelope().clone())
     38         .verify_id()
     39         .unwrap()
     40         .verify_signature(&Allow)
     41         .unwrap();
     42     let advanced = EventAdmission::verified(
     43         ObservedEvent::new(original.event().clone(), original.provenance().clone()),
     44         verified,
     45     )
     46     .unwrap();
     47     assert_eq!(
     48         block_on(storage.admit(advanced)),
     49         Err(Error::EventMutationOverflow)
     50     );
     51     assert_eq!(block_on(storage.source_token()).unwrap(), maximum);
     52     let state = storage.state().unwrap();
     53     assert_eq!(state.events.len(), 1);
     54     assert_eq!(state.events[0].admission.stage(), AdmissionStage::Raw);
     55     assert_eq!(state.events[0].provenance.len(), 1);
     56     let mut candidate = State {
     57         event_mutation_epoch: u64::MAX,
     58         ..State::default()
     59     };
     60     assert_eq!(
     61         storage.admit_locked(&mut candidate, original),
     62         Err(Error::EventMutationOverflow)
     63     );
     64     assert!(candidate.events.is_empty());
     65 }