lib

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

listing_time.rs (6359B)


      1 use radroots_domain::{
      2     FulfillmentError, ListingOptionId, PrivateFulfillment, TIME_ZONE_DATABASE_VERSION, TimeError,
      3     TimeZoneId, UnixSeconds, Window, listing::*,
      4 };
      5 
      6 fn window() -> Window {
      7     Window::new(
      8         UnixSeconds::new(100).unwrap(),
      9         UnixSeconds::new(101).unwrap(),
     10         TimeZoneId::from_name("America/Toronto").unwrap(),
     11     )
     12     .unwrap()
     13 }
     14 
     15 #[test]
     16 fn pinned_zone_names_are_exact_and_all_dataset_entries_are_admitted() {
     17     assert_eq!(jiff_tzdb::VERSION, Some(TIME_ZONE_DATABASE_VERSION));
     18     for name in jiff_tzdb::available() {
     19         assert_eq!(TimeZoneId::from_name(name).unwrap().name(), name);
     20     }
     21     for name in [
     22         "",
     23         "america/toronto",
     24         " America/Toronto",
     25         "America/Toronto ",
     26         "Invented/Zone",
     27         "+05:00",
     28         "America/Toronto\0",
     29         &"a".repeat(81),
     30         &"🥕".repeat(21),
     31     ] {
     32         assert_eq!(TimeZoneId::from_name(name), Err(TimeError::InvalidTimeZone));
     33     }
     34     let zone = TimeZoneId::from_name("Etc/UTC").unwrap();
     35     assert_eq!(zone.name(), "Etc/UTC");
     36     assert!(!format!("{zone:?}").contains("UTC"));
     37 }
     38 
     39 #[test]
     40 fn windows_preserve_ordered_absolute_bounds_without_civil_time_conversion() {
     41     let zone = TimeZoneId::from_name("America/Toronto").unwrap();
     42     let start = UnixSeconds::new(0).unwrap();
     43     let end = UnixSeconds::new(253_402_300_799).unwrap();
     44     let value = Window::new(start, end, zone).unwrap();
     45     assert_eq!(
     46         (value.start(), value.end(), value.timezone()),
     47         (start, end, zone)
     48     );
     49     for (start, end) in [(end, start), (start, start), (end, end)] {
     50         assert_eq!(Window::new(start, end, zone), Err(TimeError::InvalidWindow));
     51     }
     52     // Absolute instants remain exact; no local fold/offset is inferred.
     53     let transition = Window::new(
     54         UnixSeconds::new(1_793_480_400).unwrap(),
     55         UnixSeconds::new(1_793_487_600).unwrap(),
     56         zone,
     57     )
     58     .unwrap();
     59     assert_eq!(transition.end().get() - transition.start().get(), 7200);
     60     assert_eq!(format!("{transition:?}"), "Window(<redacted>)");
     61     assert_eq!(
     62         TimeError::InvalidWindow.to_string(),
     63         "invalid absolute window"
     64     );
     65     assert_eq!(TimeError::InvalidTimeZone.to_string(), "invalid time zone");
     66     assert_eq!(
     67         TimeError::UnsupportedDatabase.to_string(),
     68         "unsupported time zone database"
     69     );
     70     #[cfg(feature = "serde")]
     71     assert_eq!(
     72         serde_json::to_value(value).unwrap(),
     73         serde_json::json!({
     74         "start":"0","end":"253402300799","timezone":"America/Toronto"})
     75     );
     76 }
     77 
     78 #[test]
     79 fn private_fulfillment_bounds_unicode_and_redacts_without_public_terms_or_effects() {
     80     let address = "🥕".repeat(2048);
     81     let instructions = "é".repeat(2048);
     82     let contact = "☎".repeat(256);
     83     for mode in [FulfillmentMode::Pickup, FulfillmentMode::Delivery] {
     84         let value =
     85             PrivateFulfillment::new(mode, window(), &address, &instructions, Some(&contact))
     86                 .unwrap();
     87         assert_eq!(value.mode(), mode);
     88         assert_eq!(value.window(), window());
     89         assert_eq!(value.address(), address);
     90         assert_eq!(value.instructions(), instructions);
     91         assert_eq!(value.contact(), Some(contact.as_str()));
     92         assert_eq!(value, value.clone());
     93         assert_eq!(format!("{value:?}"), "PrivateFulfillment(<redacted>)");
     94         let empty = PrivateFulfillment::new(mode, window(), "", "", None).unwrap();
     95         assert_eq!(empty.contact(), None);
     96         assert_eq!(empty.address(), "");
     97         assert_eq!(empty.instructions(), "");
     98         assert_eq!(
     99             PrivateFulfillment::new(mode, window(), "", "", Some(""))
    100                 .unwrap()
    101                 .contact(),
    102             Some("")
    103         );
    104     }
    105     for (address, instructions, contact) in [
    106         ("a".repeat(2049), String::new(), None),
    107         ("a".repeat(8193), String::new(), None),
    108         (String::new(), "é".repeat(2049), None),
    109         (String::new(), String::new(), Some("☎".repeat(257))),
    110         (String::new(), String::new(), Some("a".repeat(1025))),
    111     ] {
    112         assert_eq!(
    113             PrivateFulfillment::new(
    114                 FulfillmentMode::Pickup,
    115                 window(),
    116                 &address,
    117                 &instructions,
    118                 contact.as_deref()
    119             ),
    120             Err(FulfillmentError::InvalidText)
    121         );
    122     }
    123     assert_eq!(
    124         FulfillmentError::InvalidText.to_string(),
    125         "invalid private fulfillment text"
    126     );
    127 }
    128 
    129 #[test]
    130 fn estimates_allow_zero_and_measured_fractions_but_keep_count_units_integral() {
    131     for unit in [
    132         SaleUnit::package_unspecified("bunch").unwrap(),
    133         SaleUnit::measured(MeasurementUnit::Each),
    134         SaleUnit::measured(MeasurementUnit::Kilogram),
    135     ] {
    136         for amount in ["0", "2", "0.5"] {
    137             for window in [None, Some(window())] {
    138                 let result = ListingOption::quote_required(
    139                     ListingOptionId::from_bytes([9; 32]),
    140                     "expected",
    141                     unit.clone(),
    142                     "1".parse().unwrap(),
    143                     "1".parse().unwrap(),
    144                     Supply::Estimated {
    145                         amount: amount.parse().unwrap(),
    146                         window,
    147                     },
    148                     LeadSeconds::new(0).unwrap(),
    149                 );
    150                 if amount == "0.5" && unit.integral() {
    151                     assert_eq!(result.unwrap_err(), ListingError::InvalidQuantity);
    152                 } else {
    153                     let value = result.unwrap();
    154                     assert_eq!(
    155                         value.supply(),
    156                         Supply::Estimated {
    157                             amount: amount.parse().unwrap(),
    158                             window
    159                         }
    160                     );
    161                     // Advertised estimate is neither a ceiling nor reservation.
    162                     assert!(value.validate_amount("100".parse().unwrap()).is_ok());
    163                     #[cfg(feature = "serde")]
    164                     assert_eq!(
    165                         serde_json::to_value(value.supply()).unwrap(),
    166                         serde_json::json!({
    167                         "type":"estimated","amount":amount,"window":window})
    168                     );
    169                 }
    170             }
    171         }
    172     }
    173 }