lib

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

app_data.rs (4654B)

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