lib

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

mod.rs (3532B)

      1 #![forbid(unsafe_code)]
      2 
      3 pub mod decode;
      4 pub mod encode;
      5 
      6 #[cfg(test)]
      7 mod tests {
      8     use crate::error::EventEncodeError;
      9     use crate::resource_cap::encode::resource_harvest_cap_build_tags;
     10     use radroots_core::{RadrootsCoreDecimal, RadrootsCoreQuantity, RadrootsCoreUnit};
     11     use radroots_events::resource_area::RadrootsResourceAreaRef;
     12     use radroots_events::resource_cap::{
     13         RadrootsResourceHarvestCap, RadrootsResourceHarvestProduct,
     14     };
     15 
     16     #[test]
     17     fn resource_harvest_cap_tags_include_required_fields() {
     18         let cap = RadrootsResourceHarvestCap {
     19             d_tag: "DAAAAAAAAAAAAAAAAAAAAA".to_string(),
     20             resource_area: RadrootsResourceAreaRef {
     21                 pubkey: "area_pubkey".to_string(),
     22                 d_tag: "AAAAAAAAAAAAAAAAAAAAAw".to_string(),
     23             },
     24             product: RadrootsResourceHarvestProduct {
     25                 key: "nutmeg".to_string(),
     26                 category: Some("spice".to_string()),
     27             },
     28             start: 1735689600,
     29             end: 1767225600,
     30             cap_quantity: RadrootsCoreQuantity::new(
     31                 RadrootsCoreDecimal::from(100000u32),
     32                 RadrootsCoreUnit::MassG,
     33             ),
     34             display_amount: None,
     35             display_unit: None,
     36             display_label: None,
     37             tags: Some(vec!["community".to_string()]),
     38         };
     39 
     40         let tags = resource_harvest_cap_build_tags(&cap).expect("tags");
     41         assert!(
     42             tags.iter()
     43                 .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("d"))
     44         );
     45         assert!(
     46             tags.iter()
     47                 .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("a"))
     48         );
     49         assert!(
     50             tags.iter()
     51                 .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("key"))
     52         );
     53         assert!(
     54             tags.iter()
     55                 .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("start"))
     56         );
     57         assert!(
     58             tags.iter()
     59                 .any(|tag| tag.get(0).map(|v| v.as_str()) == Some("end"))
     60         );
     61     }
     62 
     63     #[test]
     64     fn resource_harvest_cap_build_tags_rejects_invalid_d_tags() {
     65         let mut cap = RadrootsResourceHarvestCap {
     66             d_tag: "DAAAAAAAAAAAAAAAAAAAAA".to_string(),
     67             resource_area: RadrootsResourceAreaRef {
     68                 pubkey: "area_pubkey".to_string(),
     69                 d_tag: "AAAAAAAAAAAAAAAAAAAAAw".to_string(),
     70             },
     71             product: RadrootsResourceHarvestProduct {
     72                 key: "nutmeg".to_string(),
     73                 category: Some("spice".to_string()),
     74             },
     75             start: 1735689600,
     76             end: 1767225600,
     77             cap_quantity: RadrootsCoreQuantity::new(
     78                 RadrootsCoreDecimal::from(100000u32),
     79                 RadrootsCoreUnit::MassG,
     80             ),
     81             display_amount: None,
     82             display_unit: None,
     83             display_label: None,
     84             tags: None,
     85         };
     86 
     87         cap.resource_area.d_tag = "invalid".to_string();
     88         let err = resource_harvest_cap_build_tags(&cap).expect_err("invalid resource area d_tag");
     89         assert!(matches!(
     90             err,
     91             EventEncodeError::InvalidField("resource_area.d_tag")
     92         ));
     93 
     94         cap.resource_area.d_tag = "AAAAAAAAAAAAAAAAAAAAAw".to_string();
     95         cap.d_tag = "invalid".to_string();
     96         let err = resource_harvest_cap_build_tags(&cap).expect_err("invalid cap d_tag");
     97         assert!(matches!(err, EventEncodeError::InvalidField("d_tag")));
     98     }
     99 }