lib

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

seal.rs (3439B)

      1 use radroots_events::kinds::{KIND_MESSAGE, KIND_SEAL};
      2 use radroots_events::seal::RadrootsSeal;
      3 
      4 use radroots_events_codec::error::{EventEncodeError, EventParseError};
      5 use radroots_events_codec::seal::decode::{data_from_event, parsed_from_event, seal_from_parts};
      6 use radroots_events_codec::seal::encode::{
      7     seal_build_tags, to_wire_parts, to_wire_parts_with_kind,
      8 };
      9 
     10 #[test]
     11 fn seal_to_wire_parts_requires_content() {
     12     let seal = RadrootsSeal {
     13         content: "  ".to_string(),
     14     };
     15 
     16     let err = to_wire_parts(&seal).unwrap_err();
     17     assert!(matches!(
     18         err,
     19         EventEncodeError::EmptyRequiredField("content")
     20     ));
     21 }
     22 
     23 #[test]
     24 fn seal_to_wire_parts_sets_kind_and_content() {
     25     let seal = RadrootsSeal {
     26         content: "payload".to_string(),
     27     };
     28 
     29     let parts = to_wire_parts(&seal).unwrap();
     30     assert_eq!(parts.kind, KIND_SEAL);
     31     assert_eq!(parts.content, "payload");
     32     assert!(parts.tags.is_empty());
     33 }
     34 
     35 #[test]
     36 fn seal_from_parts_rejects_wrong_kind() {
     37     let err = seal_from_parts(KIND_MESSAGE, &[], "payload").unwrap_err();
     38     assert!(matches!(
     39         err,
     40         EventParseError::InvalidKind {
     41             expected: "13",
     42             got: KIND_MESSAGE
     43         }
     44     ));
     45 }
     46 
     47 #[test]
     48 fn seal_from_parts_requires_empty_tags() {
     49     let err = seal_from_parts(
     50         KIND_SEAL,
     51         &[vec!["p".to_string(), "x".to_string()]],
     52         "payload",
     53     )
     54     .unwrap_err();
     55     assert!(matches!(err, EventParseError::InvalidTag("tags")));
     56 }
     57 
     58 #[test]
     59 fn seal_from_parts_requires_content() {
     60     let err = seal_from_parts(KIND_SEAL, &[], " ").unwrap_err();
     61     assert!(matches!(err, EventParseError::InvalidTag("content")));
     62 }
     63 
     64 #[test]
     65 fn seal_metadata_and_index_from_event_roundtrip() {
     66     let metadata = data_from_event(
     67         "id".to_string(),
     68         "author".to_string(),
     69         14,
     70         KIND_SEAL,
     71         "payload".to_string(),
     72         Vec::new(),
     73     )
     74     .unwrap();
     75     assert_eq!(metadata.id, "id");
     76     assert_eq!(metadata.author, "author");
     77     assert_eq!(metadata.published_at, 14);
     78     assert_eq!(metadata.kind, KIND_SEAL);
     79     assert_eq!(metadata.data.content, "payload");
     80 
     81     let index = parsed_from_event(
     82         "id".to_string(),
     83         "author".to_string(),
     84         14,
     85         KIND_SEAL,
     86         "payload".to_string(),
     87         Vec::new(),
     88         "sig".to_string(),
     89     )
     90     .unwrap();
     91     assert_eq!(index.event.kind, KIND_SEAL);
     92     assert_eq!(index.event.sig, "sig");
     93     assert_eq!(index.data.data.content, "payload");
     94 }
     95 
     96 #[test]
     97 fn seal_index_from_event_propagates_parse_errors() {
     98     let err = parsed_from_event(
     99         "id".to_string(),
    100         "author".to_string(),
    101         14,
    102         KIND_MESSAGE,
    103         "payload".to_string(),
    104         Vec::new(),
    105         "sig".to_string(),
    106     )
    107     .unwrap_err();
    108     assert!(matches!(
    109         err,
    110         EventParseError::InvalidKind {
    111             expected: "13",
    112             got: KIND_MESSAGE
    113         }
    114     ));
    115 }
    116 
    117 #[test]
    118 fn seal_build_tags_and_kind_validation_cover_paths() {
    119     let seal = RadrootsSeal {
    120         content: "payload".to_string(),
    121     };
    122     assert!(seal_build_tags(&seal).unwrap().is_empty());
    123 
    124     let parts = to_wire_parts_with_kind(&seal, KIND_SEAL).unwrap();
    125     assert_eq!(parts.kind, KIND_SEAL);
    126     assert_eq!(parts.content, "payload");
    127 
    128     let err = to_wire_parts_with_kind(&seal, KIND_MESSAGE).unwrap_err();
    129     assert!(matches!(err, EventEncodeError::InvalidKind(KIND_MESSAGE)));
    130 }