lib

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

variable_price.rs (8290B)


      1 use radroots_domain::listing::MeasurementUnit::{self, Each, Gram, Kilogram, Litre};
      2 use radroots_domain::{Money, MoneyError, PricingError, Quantity, VariableWeight};
      3 use std::error::Error;
      4 
      5 fn money(value: &str) -> Money {
      6     Money::from_parts("CAD", value, 2).unwrap()
      7 }
      8 fn quantity(value: &str, unit: MeasurementUnit) -> Quantity {
      9     Quantity::new(value.parse().unwrap(), unit).unwrap()
     10 }
     11 fn bounds(minimum: &str, maximum: &str, rate: &str, basis: &str, cap: &str) -> VariableWeight {
     12     VariableWeight::new(
     13         Kilogram,
     14         minimum.parse().unwrap(),
     15         maximum.parse().unwrap(),
     16         money(rate),
     17         basis.parse().unwrap(),
     18         money(cap),
     19     )
     20     .unwrap()
     21 }
     22 
     23 #[test]
     24 fn inclusive_measurement_bounds_recompute_exact_minor_prices_with_the_shared_rule() {
     25     let value = bounds("0.8", "1.2", "325", "1", "400");
     26     assert_eq!(value.measurement_unit(), Kilogram);
     27     assert_eq!(value.minimum().to_string(), "0.8");
     28     assert_eq!(value.maximum().to_string(), "1.2");
     29     assert_eq!(value.rate(), money("325"));
     30     assert_eq!(value.basis().to_string(), "1");
     31     assert_eq!(value.maximum_total(), money("400"));
     32     for (measurement, expected) in [
     33         ("0.8", "260"),
     34         ("0.9", "292"),
     35         ("0.98", "318"),
     36         ("1.02", "332"),
     37         ("1.2", "390"),
     38     ] {
     39         assert_eq!(
     40             value.total_at(quantity(measurement, Kilogram)).unwrap(),
     41             money(expected)
     42         );
     43     }
     44 }
     45 
     46 #[test]
     47 fn final_measurements_cannot_silently_convert_units_or_extend_the_range() {
     48     let value = bounds("0.8", "1.2", "325", "1", "400");
     49     for measurement in ["0", "0.799999", "1.200001", "999999999999"] {
     50         assert_eq!(
     51             value.total_at(quantity(measurement, Kilogram)),
     52             Err(PricingError::MeasurementOutOfRange)
     53         );
     54     }
     55     for measurement in [
     56         quantity("800", Gram),
     57         quantity("1", Litre),
     58         quantity("1", Each),
     59     ] {
     60         assert_eq!(
     61             value.total_at(measurement),
     62             Err(PricingError::MeasurementUnitMismatch)
     63         );
     64     }
     65     assert_eq!(
     66         value
     67             .total_at(quantity("800", Gram).convert(Kilogram).unwrap())
     68             .unwrap(),
     69         money("260")
     70     );
     71 }
     72 
     73 #[test]
     74 fn cap_and_physical_range_are_joint_constraints_without_implicit_amendment() {
     75     let value = bounds("0.8", "1.2", "325", "1", "300");
     76     assert_eq!(
     77         value.total_at(quantity("0.8", Kilogram)).unwrap(),
     78         money("260")
     79     );
     80     assert_eq!(
     81         value.total_at(quantity("0.9", Kilogram)).unwrap(),
     82         money("292")
     83     );
     84     assert_eq!(
     85         value.total_at(quantity("1", Kilogram)),
     86         Err(PricingError::CapExceeded)
     87     );
     88     assert_eq!(
     89         value.total_at(quantity("1.2", Kilogram)),
     90         Err(PricingError::CapExceeded)
     91     );
     92     assert_eq!(value.maximum().to_string(), "1.2");
     93     assert_eq!(value.maximum_total(), money("300"));
     94     assert_eq!(
     95         VariableWeight::new(
     96             Kilogram,
     97             "0.8".parse().unwrap(),
     98             "1.2".parse().unwrap(),
     99             money("325"),
    100             "1".parse().unwrap(),
    101             money("259")
    102         ),
    103         Err(PricingError::CapExceeded)
    104     );
    105     assert!(
    106         VariableWeight::new(
    107             Kilogram,
    108             "0.8".parse().unwrap(),
    109             "1.2".parse().unwrap(),
    110             money("325"),
    111             "1".parse().unwrap(),
    112             money("260")
    113         )
    114         .is_ok()
    115     );
    116 }
    117 
    118 #[test]
    119 fn constructors_validate_order_count_units_and_exact_currency_before_capture() {
    120     assert_eq!(
    121         VariableWeight::new(
    122             Kilogram,
    123             "1.2".parse().unwrap(),
    124             "0.8".parse().unwrap(),
    125             money("325"),
    126             "1".parse().unwrap(),
    127             money("400")
    128         ),
    129         Err(PricingError::InvalidMeasurementRange)
    130     );
    131     for (minimum, maximum) in [("1.5", "3"), ("1", "3.5")] {
    132         assert_eq!(
    133             VariableWeight::new(
    134                 Each,
    135                 minimum.parse().unwrap(),
    136                 maximum.parse().unwrap(),
    137                 money("100"),
    138                 "1".parse().unwrap(),
    139                 money("400")
    140             ),
    141             Err(PricingError::InvalidMeasurementRange)
    142         );
    143     }
    144     let value = VariableWeight::new(
    145         Each,
    146         "2".parse().unwrap(),
    147         "4".parse().unwrap(),
    148         money("101"),
    149         "2".parse().unwrap(),
    150         money("202"),
    151     )
    152     .unwrap();
    153     assert_eq!(value.total_at(quantity("3", Each)).unwrap(), money("152"));
    154     assert_eq!(value.total_at(quantity("4", Each)).unwrap(), money("202"));
    155     for cap in [
    156         Money::from_parts("USD", "400", 2).unwrap(),
    157         Money::from_parts("JPY", "400", 0).unwrap(),
    158     ] {
    159         assert_eq!(
    160             VariableWeight::new(
    161                 Kilogram,
    162                 "0.8".parse().unwrap(),
    163                 "1.2".parse().unwrap(),
    164                 money("325"),
    165                 "1".parse().unwrap(),
    166                 cap
    167             ),
    168             Err(PricingError::Money(MoneyError::CurrencyMismatch))
    169         );
    170     }
    171     let exact = bounds("1", "1", "325", "1", "325");
    172     assert_eq!(
    173         exact.total_at(quantity("1", Kilogram)).unwrap(),
    174         money("325")
    175     );
    176 }
    177 
    178 #[test]
    179 fn free_and_large_exact_inputs_remain_bounded_without_float_or_zero_fallbacks() {
    180     let free = bounds("0.000001", "999999999999", "0", "0.000001", "0");
    181     for amount in ["0.000001", "1", "999999999999"] {
    182         assert_eq!(
    183             free.total_at(quantity(amount, Kilogram)).unwrap(),
    184             money("0")
    185         );
    186     }
    187     let maximum = bounds(
    188         "1",
    189         "999999999999",
    190         "999999999999999",
    191         "999999999999",
    192         "999999999999999",
    193     );
    194     assert_eq!(
    195         maximum.total_at(quantity("1", Kilogram)).unwrap(),
    196         money("1000")
    197     );
    198     assert_eq!(
    199         maximum
    200             .total_at(quantity("999999999999", Kilogram))
    201             .unwrap(),
    202         money("999999999999999")
    203     );
    204     let over = bounds(
    205         "0.000001",
    206         "999999999999",
    207         "999999999999999",
    208         "1",
    209         "999999999999999",
    210     );
    211     assert_eq!(
    212         over.total_at(quantity("999999999999", Kilogram)),
    213         Err(PricingError::Money(MoneyError::MinorOutOfRange))
    214     );
    215     assert_eq!(
    216         VariableWeight::new(
    217             Kilogram,
    218             "1".parse().unwrap(),
    219             "2".parse().unwrap(),
    220             money("999999999999999"),
    221             "0.000001".parse().unwrap(),
    222             money("999999999999999")
    223         ),
    224         Err(PricingError::Money(MoneyError::MinorOutOfRange))
    225     );
    226 }
    227 
    228 #[test]
    229 fn currency_exponents_do_not_change_the_minor_unit_rounding_rule() {
    230     for (code, exponent) in [("JPY", 0), ("CAD", 2), ("KWD", 3), ("CLF", 4)] {
    231         let rate = Money::from_parts(code, "101", exponent).unwrap();
    232         let value = VariableWeight::new(
    233             Gram,
    234             "0.5".parse().unwrap(),
    235             "1".parse().unwrap(),
    236             rate,
    237             "1".parse().unwrap(),
    238             rate,
    239         )
    240         .unwrap();
    241         assert_eq!(
    242             value.total_at(quantity("0.5", Gram)).unwrap(),
    243             Money::from_parts(code, "50", exponent).unwrap()
    244         );
    245     }
    246 }
    247 
    248 #[test]
    249 fn measurement_diagnostics_redact_terms_and_keep_fixed_failure_messages() {
    250     let value = bounds("0.8", "1.2", "928174615", "1", "999999999999999");
    251     let debug = format!("{value:?}");
    252     assert!(!debug.contains("928174615"));
    253     assert!(!debug.contains("CAD"));
    254     for error in [
    255         PricingError::InvalidMeasurementRange,
    256         PricingError::MeasurementUnitMismatch,
    257         PricingError::MeasurementOutOfRange,
    258         PricingError::CapExceeded,
    259     ] {
    260         assert!(!error.to_string().is_empty());
    261         assert!(!error.to_string().contains("928174615"));
    262         assert!(error.source().is_none());
    263     }
    264 }
    265 
    266 #[cfg(feature = "serde")]
    267 #[test]
    268 fn serialization_retains_complete_exact_bounded_measurement_terms() {
    269     let value = bounds("0.8", "1.2", "325", "1", "400");
    270     assert_eq!(
    271         serde_json::to_value(value).unwrap(),
    272         serde_json::json!({"measurement_unit":"kg","minimum":"0.8","maximum":"1.2","rate":{"currency":"CAD","minor":"325","exponent":2},"basis":"1","maximum_total":{"currency":"CAD","minor":"400","exponent":2}})
    273     );
    274 }