lib

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

app_data.rs (4771B)

      1 mod common;
      2 
      3 use common::{AUTHOR, EVENT_ID, EVENT_SIG};
      4 use radroots_event::{
      5     envelope::kind::KIND_POST,
      6     social::app_data::{AppData, KIND_APP_DATA},
      7 };
      8 use radroots_event_codec::decode::EventParseError;
      9 use radroots_event_codec::decode::app_data::{
     10     app_data_from_tags, data_from_event, parsed_from_event,
     11 };
     12 use radroots_event_codec::encode::EventEncodeError;
     13 use radroots_event_codec::encode::app_data::{
     14     app_data_build_tags, to_wire_parts, to_wire_parts_with_kind,
     15 };
     16 
     17 #[test]
     18 fn app_data_build_tags_requires_d_tag() {
     19     let app_data = AppData {
     20         d_tag: "  ".to_string(),
     21         content: "payload".to_string(),
     22     };
     23 
     24     let err = app_data_build_tags(&app_data).unwrap_err();
     25     assert!(matches!(err, EventEncodeError::EmptyRequiredField("d_tag")));
     26 }
     27 
     28 #[test]
     29 fn app_data_to_wire_parts_sets_kind_tags_content() {
     30     let app_data = AppData {
     31         d_tag: "radroots.app".to_string(),
     32         content: "payload".to_string(),
     33     };
     34 
     35     let parts = to_wire_parts(&app_data).unwrap();
     36     assert_eq!(parts.kind, KIND_APP_DATA);
     37     assert_eq!(parts.content, "payload");
     38     assert_eq!(
     39         parts.tags,
     40         vec![vec!["d".to_string(), "radroots.app".to_string()]]
     41     );
     42 }
     43 
     44 #[test]
     45 fn app_data_to_wire_parts_propagates_tag_build_errors() {
     46     let app_data = AppData {
     47         d_tag: "  ".to_string(),
     48         content: "payload".to_string(),
     49     };
     50     let err = to_wire_parts(&app_data).unwrap_err();
     51     assert!(matches!(err, EventEncodeError::EmptyRequiredField("d_tag")));
     52 }
     53 
     54 #[test]
     55 fn app_data_to_wire_parts_with_kind_rejects_wrong_kind() {
     56     let app_data = AppData {
     57         d_tag: "radroots.app".to_string(),
     58         content: "payload".to_string(),
     59     };
     60     let err = to_wire_parts_with_kind(&app_data, KIND_POST).unwrap_err();
     61     assert!(matches!(err, EventEncodeError::InvalidKind(KIND_POST)));
     62 }
     63 
     64 #[test]
     65 fn app_data_from_tags_requires_kind() {
     66     let tags = vec![vec!["d".to_string(), "radroots.app".to_string()]];
     67     let err = app_data_from_tags(KIND_POST, &tags, "payload").unwrap_err();
     68     assert!(matches!(
     69         err,
     70         EventParseError::InvalidKind {
     71             expected: "30078",
     72             got: KIND_POST
     73         }
     74     ));
     75 }
     76 
     77 #[test]
     78 fn app_data_from_tags_requires_d_tag() {
     79     let err = app_data_from_tags(KIND_APP_DATA, &[], "payload").unwrap_err();
     80     assert!(matches!(err, EventParseError::MissingTag("d")));
     81 }
     82 
     83 #[test]
     84 fn app_data_roundtrip_from_tags() {
     85     let tags = vec![vec!["d".to_string(), "radroots.app".to_string()]];
     86     let app_data = app_data_from_tags(KIND_APP_DATA, &tags, "payload").unwrap();
     87 
     88     assert_eq!(app_data.d_tag, "radroots.app");
     89     assert_eq!(app_data.content, "payload");
     90 }
     91 
     92 #[test]
     93 fn app_data_from_tags_rejects_invalid_d_tag_shape() {
     94     let err = app_data_from_tags(KIND_APP_DATA, &[vec!["d".to_string()]], "payload").unwrap_err();
     95     assert!(matches!(err, EventParseError::InvalidTag("d")));
     96 
     97     let err = app_data_from_tags(
     98         KIND_APP_DATA,
     99         &[vec!["d".to_string(), " ".to_string()]],
    100         "payload",
    101     )
    102     .unwrap_err();
    103     assert!(matches!(err, EventParseError::InvalidTag("d")));
    104 }
    105 
    106 #[test]
    107 fn app_data_metadata_and_index_from_event_roundtrip() {
    108     let tags = vec![vec!["d".to_string(), "radroots.app".to_string()]];
    109     let metadata = data_from_event(
    110         "id".to_string(),
    111         "author".to_string(),
    112         42,
    113         KIND_APP_DATA,
    114         "payload".to_string(),
    115         tags.clone(),
    116     )
    117     .unwrap();
    118     assert_eq!(metadata.id, "id");
    119     assert_eq!(metadata.author, "author");
    120     assert_eq!(metadata.published_at, 42);
    121     assert_eq!(metadata.kind, KIND_APP_DATA);
    122     assert_eq!(metadata.data.d_tag, "radroots.app");
    123     assert_eq!(metadata.data.content, "payload");
    124 
    125     let index = parsed_from_event(
    126         EVENT_ID.to_string(),
    127         AUTHOR.to_string(),
    128         42,
    129         KIND_APP_DATA,
    130         "payload".to_string(),
    131         tags,
    132         EVENT_SIG.to_string(),
    133     )
    134     .unwrap();
    135     assert_eq!(index.event.id_hex(), EVENT_ID);
    136     assert_eq!(index.event.author().to_hex(), AUTHOR);
    137     assert_eq!(index.event.created_at_u64(), 42);
    138     assert_eq!(index.event.kind_u32(), KIND_APP_DATA);
    139     assert_eq!(index.event.content(), "payload");
    140     assert_eq!(index.event.signature_hex(), EVENT_SIG);
    141     assert_eq!(index.data.data.d_tag, "radroots.app");
    142 }
    143 
    144 #[test]
    145 fn app_data_index_from_event_propagates_parse_errors() {
    146     let err = parsed_from_event(
    147         "id".to_string(),
    148         "author".to_string(),
    149         42,
    150         KIND_POST,
    151         "payload".to_string(),
    152         Vec::new(),
    153         "sig".to_string(),
    154     )
    155     .unwrap_err();
    156     assert!(matches!(
    157         err,
    158         EventParseError::InvalidKind {
    159             expected: "30078",
    160             got: KIND_POST
    161         }
    162     ));
    163 }