stock_mapping.rs (6058B)
1 use radroots_domain::{ 2 Decimal, ListingOptionId, PoolId, PositiveDecimal, PublicKey, Quantity, QuantityError, 3 Sequence, 4 listing::{ListingCoordinate, ListingId, MeasurementUnit}, 5 stock::{MappingError, OptionMappingKey, OptionPoolMapping, PoolUnit, StockError}, 6 }; 7 fn key() -> OptionMappingKey { 8 OptionMappingKey::new( 9 ListingCoordinate::new( 10 PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798") 11 .unwrap(), 12 ListingId::from_bytes([1; 16]), 13 ), 14 ListingOptionId::from_bytes([2; 32]), 15 ) 16 } 17 fn quantity(amount: &str, unit: MeasurementUnit) -> Quantity { 18 Quantity::new(amount.parse::<Decimal>().unwrap(), unit).unwrap() 19 } 20 fn mapping( 21 amount: &str, 22 unit: MeasurementUnit, 23 pool_unit: PoolUnit, 24 version: u64, 25 ) -> Result<OptionPoolMapping, MappingError> { 26 OptionPoolMapping::new( 27 key(), 28 PoolId::from_bytes([3; 32]), 29 pool_unit, 30 quantity(amount, unit), 31 Sequence::new(version).unwrap(), 32 ) 33 } 34 #[test] 35 fn exact_mapping_preserves_the_declared_si_basis_and_multiplies_without_tick_rounding() { 36 let value = mapping( 37 "250", 38 MeasurementUnit::Gram, 39 PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap(), 40 1, 41 ) 42 .unwrap(); 43 assert_eq!(value.key(), key()); 44 assert_eq!(value.pool_id(), PoolId::from_bytes([3; 32])); 45 assert_eq!( 46 value.per_sale_unit(), 47 quantity("250", MeasurementUnit::Gram) 48 ); 49 assert_eq!(value.per_sale_ticks().get(), 250); 50 assert_eq!( 51 value 52 .draw_for_sales("2".parse::<PositiveDecimal>().unwrap()) 53 .unwrap() 54 .get(), 55 500 56 ); 57 assert_eq!( 58 value.draw_for_sales("1.5".parse().unwrap()).unwrap().get(), 59 375 60 ); 61 let volume = mapping( 62 "250", 63 MeasurementUnit::Millilitre, 64 PoolUnit::new(MeasurementUnit::Litre, 3).unwrap(), 65 1, 66 ) 67 .unwrap(); 68 assert_eq!(volume.per_sale_ticks().get(), 250); 69 let one_tick = mapping( 70 "1", 71 MeasurementUnit::Each, 72 PoolUnit::new(MeasurementUnit::Each, 0).unwrap(), 73 1, 74 ) 75 .unwrap(); 76 assert_eq!( 77 one_tick.draw_for_sales("0.5".parse().unwrap()), 78 Err(MappingError::Stock(StockError::PrecisionLoss)) 79 ); 80 assert_eq!( 81 format!("{value:?}"), 82 "OptionPoolMapping(<private metadata>)" 83 ); 84 } 85 #[test] 86 fn zero_absent_versions_unjustified_dimensions_precision_loss_and_capacity_are_refused() { 87 let kg = PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap(); 88 assert_eq!( 89 mapping("0", MeasurementUnit::Gram, kg, 1), 90 Err(MappingError::ZeroDraw) 91 ); 92 assert_eq!( 93 mapping("250", MeasurementUnit::Gram, kg, 0), 94 Err(MappingError::InvalidVersion) 95 ); 96 for unit in [ 97 MeasurementUnit::Litre, 98 MeasurementUnit::Millilitre, 99 MeasurementUnit::Each, 100 ] { 101 assert_eq!( 102 mapping("1", unit, kg, 1), 103 Err(MappingError::Quantity(QuantityError::IncompatibleDimension)) 104 ); 105 } 106 assert_eq!( 107 mapping( 108 "1", 109 MeasurementUnit::Gram, 110 PoolUnit::new(MeasurementUnit::Kilogram, 0).unwrap(), 111 1 112 ), 113 Err(MappingError::Stock(StockError::PrecisionLoss)) 114 ); 115 assert_eq!( 116 mapping("0.000001", MeasurementUnit::Gram, kg, 1), 117 Err(MappingError::Quantity(QuantityError::PrecisionLoss)) 118 ); 119 let large = mapping( 120 "999999999999", 121 MeasurementUnit::Kilogram, 122 PoolUnit::new(MeasurementUnit::Kilogram, 6).unwrap(), 123 1, 124 ) 125 .unwrap(); 126 assert_eq!( 127 large.draw_for_sales("2".parse().unwrap()), 128 Err(MappingError::Stock(StockError::OutOfRange)) 129 ); 130 assert_eq!( 131 large.draw_for_sales("999999999999".parse().unwrap()), 132 Err(MappingError::Stock(StockError::OutOfRange)) 133 ); 134 assert_eq!( 135 large 136 .draw_for_sales("0.000001".parse().unwrap()) 137 .unwrap() 138 .get(), 139 999999999999 140 ); 141 } 142 #[cfg(feature = "serde")] 143 #[test] 144 fn closed_mapping_codecs_recompute_derived_ticks_and_refuse_coordinate_or_value_aliases() { 145 use serde_json::json; 146 let value = mapping( 147 "250", 148 MeasurementUnit::Gram, 149 PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap(), 150 1, 151 ) 152 .unwrap(); 153 let wire = serde_json::to_value(value).unwrap(); 154 assert_eq!(wire["per_sale_ticks"], json!("250")); 155 assert_eq!( 156 serde_json::from_value::<OptionPoolMapping>(wire.clone()).unwrap(), 157 value 158 ); 159 for (path, bad) in [ 160 ("/per_sale_ticks", json!("251")), 161 ("/per_sale_ticks", json!(250)), 162 ("/version", json!("0")), 163 ("/version", json!(1)), 164 ("/per_sale_unit/amount", json!("0")), 165 ("/pool_unit/scale", json!("2")), 166 ("/listing/kind", json!(1)), 167 ("/listing/kind", json!(30402.0)), 168 ("/listing/kind", json!("30402")), 169 ("/listing", json!([30402, "00".repeat(32), "00".repeat(16)])), 170 ("/pool_unit", json!(["kg", "3"])), 171 ] { 172 let mut changed = wire.clone(); 173 *changed.pointer_mut(path).unwrap() = bad; 174 assert!( 175 serde_json::from_value::<OptionPoolMapping>(changed).is_err(), 176 "{path}" 177 ); 178 } 179 for field in [ 180 "listing", 181 "option_id", 182 "pool_id", 183 "pool_unit", 184 "per_sale_unit", 185 "per_sale_ticks", 186 "version", 187 ] { 188 let mut changed = wire.clone(); 189 changed.as_object_mut().unwrap().remove(field); 190 assert!( 191 serde_json::from_value::<OptionPoolMapping>(changed).is_err(), 192 "{field}" 193 ); 194 } 195 let mut changed = wire.clone(); 196 changed["available"] = json!("999"); 197 assert!(serde_json::from_value::<OptionPoolMapping>(changed).is_err()); 198 assert!(serde_json::from_value::<OptionPoolMapping>(json!([wire])).is_err()); 199 }