lib

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

offering_prices.rs (6876B)


      1 use radroots_domain::{
      2     ContentMeasure, DiscountBps, FixedPrice, ListingOptionId, Money, PriceTier, Quantity,
      3     VariableWeight, listing::*,
      4 };
      5 
      6 fn money(minor: &str) -> Money {
      7     Money::from_parts("CAD", minor, 2).unwrap()
      8 }
      9 fn option(price: Price, unit: SaleUnit) -> ListingOption {
     10     ListingOption::new(
     11         ListingOptionId::from_bytes([1; 32]),
     12         "Carrot bunch",
     13         unit,
     14         "1".parse().unwrap(),
     15         "2".parse().unwrap(),
     16         price,
     17         Supply::Available {
     18             amount: "0".parse().unwrap(),
     19         },
     20         LeadSeconds::new(0).unwrap(),
     21     )
     22     .unwrap()
     23 }
     24 fn fixed() -> FixedPrice {
     25     FixedPrice::new(
     26         money("325"),
     27         "1".parse().unwrap(),
     28         DiscountBps::new(1000).unwrap(),
     29         vec![PriceTier::new("3".parse().unwrap(), money("299"))],
     30     )
     31     .unwrap()
     32 }
     33 fn variable() -> VariableWeight {
     34     VariableWeight::new(
     35         MeasurementUnit::Kilogram,
     36         "0.8".parse().unwrap(),
     37         "1.2".parse().unwrap(),
     38         money("325"),
     39         "1".parse().unwrap(),
     40         money("400"),
     41     )
     42     .unwrap()
     43 }
     44 
     45 #[test]
     46 fn fixed_options_admit_purchase_rules_before_resolving_tiers_and_rounding() {
     47     let value = option(
     48         Price::Fixed(fixed()),
     49         SaleUnit::package_unspecified("bunch").unwrap(),
     50     );
     51     assert_eq!(
     52         value.fixed_line("2".parse().unwrap()).unwrap().total(),
     53         money("585")
     54     );
     55     let selected = value.fixed_line("3".parse().unwrap()).unwrap();
     56     assert_eq!(selected.rate(), money("299"));
     57     assert_eq!(selected.selected_tier_from().unwrap().to_string(), "3");
     58     assert_eq!(selected.total(), money("807"));
     59     for amount in ["1", "2.5"] {
     60         assert_eq!(
     61             value.fixed_line(amount.parse().unwrap()),
     62             Err(ListingError::InvalidQuantity)
     63         );
     64     }
     65     // Explicit advertised zero is not a purchase ceiling or physical claim.
     66     assert_eq!(
     67         value.fixed_line("10".parse().unwrap()).unwrap().total(),
     68         money("2691")
     69     );
     70     let free = option(
     71         Price::Fixed(
     72             FixedPrice::new(money("0"), "1".parse().unwrap(), DiscountBps::NONE, vec![]).unwrap(),
     73         ),
     74         SaleUnit::measured(MeasurementUnit::Each),
     75     );
     76     assert_eq!(
     77         free.fixed_line("2".parse().unwrap()).unwrap().total(),
     78         money("0")
     79     );
     80 }
     81 
     82 #[test]
     83 fn quote_and_per_sale_unit_variable_modes_never_invent_fixed_line_totals() {
     84     for price in [Price::QuoteRequired, Price::VariableWeight(variable())] {
     85         let value = option(price, SaleUnit::package_unspecified("bag").unwrap());
     86         assert_eq!(
     87             value.fixed_line("2".parse().unwrap()),
     88             Err(ListingError::NotFixedPrice)
     89         );
     90         assert_eq!(
     91             value.fixed_line("1".parse().unwrap()),
     92             Err(ListingError::InvalidQuantity)
     93         );
     94     }
     95     let value = variable();
     96     assert_eq!(
     97         value
     98             .total_at(Quantity::new("1.2".parse().unwrap(), MeasurementUnit::Kilogram).unwrap())
     99             .unwrap(),
    100         money("390")
    101     );
    102     // Selecting two bags does not silently double a per-sale-unit value here.
    103     assert_eq!(value.maximum().to_string(), "1.2");
    104     assert_eq!(value.maximum_total(), money("400"));
    105 }
    106 
    107 #[test]
    108 fn package_content_modes_preserve_counts_and_do_not_turn_estimates_into_conversions() {
    109     let quantity = Quantity::new("0.5".parse().unwrap(), MeasurementUnit::Kilogram).unwrap();
    110     for contents in [
    111         ContentMeasure::Fixed { quantity },
    112         ContentMeasure::Estimated { quantity },
    113         ContentMeasure::Unspecified,
    114     ] {
    115         let unit = SaleUnit::package("bag", contents).unwrap();
    116         assert_eq!(unit.contents(), Some(contents));
    117         assert!(unit.integral());
    118         assert_eq!(unit.label(), "bag");
    119         assert!(!format!("{unit:?}").contains("bag"));
    120         let value = option(Price::Fixed(fixed()), unit);
    121         assert!(value.validate_amount("2".parse().unwrap()).is_ok());
    122         assert_eq!(
    123             value.validate_amount("2.5".parse().unwrap()),
    124             Err(ListingError::InvalidQuantity)
    125         );
    126         assert_eq!(
    127             contents.fixed_quantity(),
    128             match contents {
    129                 ContentMeasure::Fixed { quantity } => Some(quantity),
    130                 _ => None,
    131             }
    132         );
    133     }
    134     assert_eq!(
    135         SaleUnit::measured(MeasurementUnit::Kilogram).contents(),
    136         None
    137     );
    138     assert!(SaleUnit::package("", ContentMeasure::Unspecified).is_err());
    139     assert!(SaleUnit::package(&"x".repeat(81), ContentMeasure::Unspecified).is_err());
    140 }
    141 
    142 #[test]
    143 fn failed_fixed_calculations_remain_typed_and_redacted() {
    144     use std::error::Error;
    145     let value = option(
    146         Price::Fixed(
    147             FixedPrice::new(
    148                 money("999999999999999"),
    149                 "0.000001".parse().unwrap(),
    150                 DiscountBps::NONE,
    151                 vec![],
    152             )
    153             .unwrap(),
    154         ),
    155         SaleUnit::package_unspecified("private label").unwrap(),
    156     );
    157     let error = value.fixed_line("2".parse().unwrap()).unwrap_err();
    158     assert!(matches!(error, ListingError::Pricing(_)));
    159     assert!(error.source().is_some());
    160     assert!(ListingError::NotFixedPrice.source().is_none());
    161     assert!(!format!("{value:?} {error}").contains("999999999999999"));
    162     assert!(!format!("{:?}", value.price()).contains("999999999999999"));
    163 }
    164 
    165 #[cfg(feature = "serde")]
    166 #[test]
    167 fn all_price_and_package_modes_serialize_the_exact_closed_public_shapes() {
    168     use serde_json::json;
    169     let fixed = serde_json::to_value(Price::Fixed(fixed())).unwrap();
    170     assert_eq!(
    171         fixed,
    172         json!({"type":"fixed","rate":{"currency":"CAD","minor":"325","exponent":2},
    173         "basis":"1","discount_bps":1000,"tiers":[{"from":"3","rate":{"currency":"CAD","minor":"299","exponent":2}}]})
    174     );
    175     assert_eq!(
    176         serde_json::to_value(Price::QuoteRequired).unwrap(),
    177         json!({"type":"quote_required"})
    178     );
    179     assert_eq!(
    180         serde_json::to_value(Price::VariableWeight(variable())).unwrap(),
    181         json!({"type":"variable_weight","measurement_unit":"kg","minimum_per_sale_unit":"0.8",
    182             "maximum_per_sale_unit":"1.2","rate":{"currency":"CAD","minor":"325","exponent":2},
    183             "basis":"1","maximum_per_sale_unit_total":{"currency":"CAD","minor":"400","exponent":2}})
    184     );
    185     let quantity = Quantity::new("0.5".parse().unwrap(), MeasurementUnit::Kilogram).unwrap();
    186     for (name, contents) in [
    187         ("fixed", ContentMeasure::Fixed { quantity }),
    188         ("estimated", ContentMeasure::Estimated { quantity }),
    189     ] {
    190         let unit = SaleUnit::package("bag", contents).unwrap();
    191         assert_eq!(
    192             serde_json::to_value(unit).unwrap(),
    193             json!({"type":"package","label":"bag",
    194             "contents":{"type":name,"quantity":{"amount":"0.5","unit":"kg"}}})
    195         );
    196     }
    197 }