lib

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

tests.rs (3093B)

      1 use super::*;
      2 use radroots_event::envelope::EventEnvelopeParts;
      3 
      4 #[test]
      5 fn id_verification_returns_the_exact_envelope() {
      6     let event = signed_max_kind_event();
      7     let verified = verify_event_id(event.clone()).expect("canonical event id");
      8 
      9     assert_eq!(verified.event(), &event);
     10     assert_eq!(verified.into_event(), event);
     11 }
     12 
     13 #[test]
     14 fn signature_verification_returns_the_exact_envelope() {
     15     let event = signed_max_kind_event();
     16     let verified = verify_nip01_event(event.clone()).expect("valid Schnorr signature");
     17 
     18     assert_eq!(verified.event(), &event);
     19     assert_eq!(verified.into_event(), event);
     20 }
     21 
     22 #[test]
     23 fn verification_error_codes_are_stable() {
     24     let errors = [
     25         (
     26             RadrootsNip01VerificationError::MalformedEnvelope,
     27             "malformed_envelope",
     28         ),
     29         (
     30             RadrootsNip01VerificationError::KindOutOfRange { kind: 65_536 },
     31             "kind_out_of_range",
     32         ),
     33         (
     34             RadrootsNip01VerificationError::IdMismatch {
     35                 expected: "expected".to_string(),
     36                 actual: "actual".to_string(),
     37             },
     38             "id_mismatch",
     39         ),
     40         (
     41             RadrootsNip01VerificationError::SignatureInvalid,
     42             "signature_invalid",
     43         ),
     44     ];
     45 
     46     for (error, expected) in errors {
     47         assert_eq!(error.code(), expected);
     48         assert!(!error.to_string().is_empty());
     49     }
     50 }
     51 
     52 #[test]
     53 fn id_verification_rejects_an_out_of_range_kind_before_hashing() {
     54     let original = signed_max_kind_event();
     55     let kind = u32::from(u16::MAX) + 1;
     56     let id = compute_canonical_nip01_event_id_v1(
     57         &original.author().to_hex(),
     58         original.created_at_u64(),
     59         kind,
     60         &original.tags_as_vec(),
     61         original.content(),
     62     )
     63     .expect("canonical hash remains mechanically computable")
     64     .into_string();
     65     let event = EventEnvelope::new(EventEnvelopeParts {
     66         id,
     67         author: original.author().to_hex().to_owned(),
     68         created_at: original.created_at_u64(),
     69         kind,
     70         tags: original.tags_as_vec(),
     71         content: original.content().to_owned(),
     72         sig: original.signature_hex(),
     73     })
     74     .expect("base envelope permits the wider internal kind representation");
     75 
     76     assert_eq!(
     77         verify_event_id(event),
     78         Err(RadrootsNip01VerificationError::KindOutOfRange { kind })
     79     );
     80 }
     81 
     82 fn signed_max_kind_event() -> EventEnvelope {
     83     EventEnvelope::new(EventEnvelopeParts {
     84             id: "a07878757d705d3cd848b9264791d699069068a5f0a575112f351367b0987958"
     85                 .to_string(),
     86             author: "1b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f"
     87                 .to_string(),
     88             created_at: 1_800_000_104,
     89             kind: u32::from(u16::MAX),
     90             tags: Vec::new(),
     91             content: "maximum-kind".to_string(),
     92             sig: "d79b19843a0bfd769c02c73866d44a3a06f7b11e107a5257971b60e700aa25565802fd3a7eed4042fe8db7d709a465e5f61478eb8291178831bf48f6b0980671"
     93                 .to_string(),
     94         })
     95         .expect("valid event envelope")
     96 }