lib

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

listing_media.rs (4396B)


      1 use super::*;
      2 
      3 fn reference() -> Media {
      4     Media::new(
      5         "https://media.fixture.invalid/carrot?version=1",
      6         [0xab; 32],
      7         "image/jpeg",
      8         "Carrot 🥕\nExact alternative text",
      9     )
     10     .unwrap()
     11 }
     12 
     13 #[test]
     14 fn media_preserves_bounded_claims_and_exact_digests_without_normalization_or_trust() {
     15     let value = reference();
     16     assert_eq!(
     17         value.url(),
     18         "https://media.fixture.invalid/carrot?version=1"
     19     );
     20     assert_eq!(value.sha256(), &[0xab; 32]);
     21     assert_eq!(value.mime(), "image/jpeg");
     22     assert_eq!(value.alt(), "Carrot 🥕\nExact alternative text");
     23     assert_eq!(
     24         Media::from_hex_digest(value.url(), &"ab".repeat(32), value.mime(), value.alt()).unwrap(),
     25         value
     26     );
     27     let debug = format!("{value:?}");
     28     assert!(!debug.contains("fixture"));
     29     assert!(!debug.contains("image/jpeg"));
     30     assert!(!debug.contains("Carrot"));
     31     assert_eq!(value.clone(), value);
     32     for bad in [
     33         "ab".repeat(31),
     34         "ab".repeat(33),
     35         "AB".repeat(32),
     36         "g0".repeat(32),
     37         "0g".repeat(32),
     38         "é".repeat(32),
     39     ] {
     40         assert_eq!(
     41             Media::from_hex_digest(value.url(), &bad, value.mime(), value.alt()).unwrap_err(),
     42             ListingError::InvalidMediaDigest
     43         );
     44     }
     45     assert!(
     46         !ListingError::InvalidMediaDigest
     47             .to_string()
     48             .contains(value.url())
     49     );
     50 }
     51 
     52 #[test]
     53 fn media_text_and_collection_bounds_reject_before_owned_capture() {
     54     let prefix = "https://media.fixture.invalid/";
     55     let url = prefix.to_owned() + &"a".repeat(2048 - prefix.len());
     56     let mime = "application/".to_owned() + &"x".repeat(68);
     57     let alt = "🥕".repeat(240);
     58     assert_eq!(mime.len(), 80);
     59     let value = Media::new(&url, [0; 32], &mime, &alt).unwrap();
     60     assert_eq!(value.alt(), alt);
     61     for (url, mime, alt) in [
     62         (String::new(), mime.clone(), alt.clone()),
     63         (url.clone() + "a", mime.clone(), alt.clone()),
     64         (url.clone(), String::new(), alt.clone()),
     65         (url.clone(), mime.clone() + "x", alt.clone()),
     66         (url.clone(), mime.clone(), alt + "🥕"),
     67     ] {
     68         assert_eq!(
     69             Media::new(&url, [0; 32], &mime, &alt).unwrap_err(),
     70             ListingError::InvalidText
     71         );
     72     }
     73     assert!(
     74         Media::new(
     75             "urn:sha256:declared-object",
     76             [0; 32],
     77             "application/octet-stream",
     78             ""
     79         )
     80         .is_ok()
     81     );
     82     let make = |media| {
     83         ListingTerms::new(
     84             ListingState::Active,
     85             product(),
     86             ListingOptionId::from_bytes([1; 32]),
     87             vec![option(1, SaleUnit::measured(MeasurementUnit::Each), "1", "1", "0").unwrap()],
     88             fulfillment(),
     89             None,
     90             media,
     91         )
     92     };
     93     assert_eq!(ListingTerms::MAX_MEDIA, 8);
     94     assert!(make(vec![]).unwrap().media().is_empty());
     95     let mut spare = Vec::with_capacity(4096);
     96     for _ in 0..8 {
     97         spare.push(reference());
     98     }
     99     let terms = make(spare).unwrap();
    100     assert_eq!(terms.media(), vec![reference(); 8]);
    101     assert_eq!(
    102         make(vec![reference(); 9]).unwrap_err(),
    103         ListingError::TooManyMedia
    104     );
    105     assert!(!ListingError::TooManyMedia.to_string().contains("fixture"));
    106 }
    107 
    108 #[cfg(feature = "serde")]
    109 #[test]
    110 fn media_serializes_closed_exact_strings_and_preserves_full_profile_order() {
    111     use serde_json::json;
    112     let value = reference();
    113     assert_eq!(
    114         serde_json::to_value(&value).unwrap(),
    115         json!({
    116         "url":"https://media.fixture.invalid/carrot?version=1","sha256":"ab".repeat(32),
    117         "mime":"image/jpeg","alt":"Carrot 🥕\nExact alternative text"})
    118     );
    119     let second = Media::new(
    120         "ipfs://declared-object",
    121         [0; 32],
    122         "application/octet-stream",
    123         "",
    124     )
    125     .unwrap();
    126     let terms = ListingTerms::new(
    127         ListingState::Active,
    128         product(),
    129         ListingOptionId::from_bytes([1; 32]),
    130         vec![option(1, SaleUnit::measured(MeasurementUnit::Each), "1", "1", "0").unwrap()],
    131         fulfillment(),
    132         None,
    133         vec![value.clone(), second.clone()],
    134     )
    135     .unwrap();
    136     let wire = serde_json::to_value(&terms).unwrap();
    137     assert_eq!(wire["media"], json!([value, second]));
    138     assert_eq!(wire.as_object().unwrap().len(), 7);
    139     assert!(!format!("{terms:?}").contains("fixture"));
    140 }