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 }