stock_accounting.rs (11390B)
1 use radroots_domain::stock::{ 2 HeldStockCategory, HeldStockLoss, ObligationBacking, PhysicalBalances, PoolBalances, 3 StockError, StockTicks, 4 }; 5 6 fn ticks(value: u64) -> StockTicks { 7 StockTicks::new(value).unwrap() 8 } 9 10 fn total(physical: PhysicalBalances) -> u128 { 11 [ 12 physical.available, 13 physical.preparatory_hold, 14 physical.committed_hold, 15 physical.physical_quarantine, 16 physical.consumed, 17 physical.waste, 18 physical.removed, 19 ] 20 .into_iter() 21 .map(|quantity| u128::from(quantity.get())) 22 .sum() 23 } 24 25 #[test] 26 fn shortage_handover_and_residual_release_never_convert_deficits_into_physical_stock() { 27 let physical = PoolBalances::new( 28 ticks(100), 29 PhysicalBalances { 30 available: ticks(20), 31 committed_hold: ticks(80), 32 ..PhysicalBalances::ZERO 33 }, 34 ) 35 .unwrap(); 36 let obligation = ObligationBacking::new(ticks(100), ticks(80), ticks(20)).unwrap(); 37 let depleted = physical 38 .deplete_held( 39 HeldStockCategory::Committed, 40 HeldStockLoss::Spoilage, 41 ticks(30), 42 ) 43 .unwrap(); 44 let shortage = obligation.lose_backing(ticks(30)).unwrap(); 45 assert_eq!(shortage.remaining(), ticks(100)); 46 assert_eq!(shortage.backed(), ticks(50)); 47 assert_eq!(shortage.deficit(), ticks(50)); 48 assert_eq!(depleted.physical().waste, ticks(30)); 49 assert_eq!(depleted.physical().available, ticks(20)); 50 51 let delivered = depleted.consume_committed(ticks(20)).unwrap(); 52 let remaining = shortage.consume_backed(ticks(20)).unwrap(); 53 assert_eq!(remaining.remaining(), ticks(80)); 54 assert_eq!(remaining.backed(), ticks(30)); 55 assert_eq!(remaining.deficit(), ticks(50)); 56 assert_eq!(delivered.physical().consumed, ticks(20)); 57 assert_eq!( 58 delivered.release_committed(ticks(80)), 59 Err(StockError::Underflow) 60 ); 61 62 let released = delivered.release_committed(ticks(30)).unwrap(); 63 let closed = remaining.release_residual(ticks(30), ticks(50)).unwrap(); 64 assert_eq!(closed.remaining(), StockTicks::ZERO); 65 assert_eq!(closed.backed(), StockTicks::ZERO); 66 assert_eq!(closed.deficit(), StockTicks::ZERO); 67 assert_eq!(released.physical().available, ticks(50)); 68 assert_eq!(released.physical().consumed, ticks(20)); 69 assert_eq!(released.physical().waste, ticks(30)); 70 assert_eq!(total(released.physical()), 100); 71 assert_eq!(physical.physical().committed_hold, ticks(80)); 72 assert_eq!(obligation.backed(), ticks(80)); 73 } 74 75 #[test] 76 fn quarantine_stays_nonspendable_until_an_explicit_proposed_resolution() { 77 let original = PoolBalances::new( 78 ticks(10), 79 PhysicalBalances { 80 preparatory_hold: ticks(4), 81 committed_hold: ticks(6), 82 ..PhysicalBalances::ZERO 83 }, 84 ) 85 .unwrap(); 86 let held = original 87 .quarantine_preparatory(ticks(4)) 88 .unwrap() 89 .quarantine_committed(ticks(6)) 90 .unwrap(); 91 assert_eq!(held.physical().physical_quarantine, ticks(10)); 92 assert_eq!(held.physical().available, StockTicks::ZERO); 93 assert_eq!(held.consume_committed(ticks(1)), Err(StockError::Underflow)); 94 assert_eq!(held.hold_available(ticks(1)), Err(StockError::Underflow)); 95 96 let reconciled = held 97 .restore_quarantined(ticks(3)) 98 .unwrap() 99 .consume_committed(ticks(3)) 100 .unwrap() 101 .consume_quarantined(ticks(2)) 102 .unwrap() 103 .release_quarantined(ticks(5)) 104 .unwrap(); 105 assert_eq!(reconciled.physical().available, ticks(5)); 106 assert_eq!(reconciled.physical().consumed, ticks(5)); 107 assert_eq!(reconciled.physical().physical_quarantine, StockTicks::ZERO); 108 assert_eq!(total(reconciled.physical()), 10); 109 assert_eq!(original.physical().committed_hold, ticks(6)); 110 } 111 112 type Movement = fn(PoolBalances, StockTicks) -> Result<PoolBalances, StockError>; 113 114 #[test] 115 fn every_held_transition_conserves_lifetime_stock_and_refuses_zero_or_overdrawn_sources() { 116 let movements: [(HeldStockCategory, Movement); 7] = [ 117 ( 118 HeldStockCategory::Committed, 119 PoolBalances::release_committed, 120 ), 121 ( 122 HeldStockCategory::Committed, 123 PoolBalances::consume_committed, 124 ), 125 ( 126 HeldStockCategory::Preparatory, 127 PoolBalances::quarantine_preparatory, 128 ), 129 ( 130 HeldStockCategory::Committed, 131 PoolBalances::quarantine_committed, 132 ), 133 ( 134 HeldStockCategory::Quarantined, 135 PoolBalances::restore_quarantined, 136 ), 137 ( 138 HeldStockCategory::Quarantined, 139 PoolBalances::release_quarantined, 140 ), 141 ( 142 HeldStockCategory::Quarantined, 143 PoolBalances::consume_quarantined, 144 ), 145 ]; 146 for seed in 0..=16 { 147 let physical = PhysicalBalances { 148 available: ticks(seed), 149 preparatory_hold: ticks(seed + 1), 150 committed_hold: ticks(seed + 2), 151 physical_quarantine: ticks(seed + 3), 152 consumed: ticks(seed + 4), 153 waste: ticks(seed + 5), 154 removed: ticks(seed + 6), 155 }; 156 let introduced = ticks(7 * seed + 21); 157 let original = PoolBalances::new(introduced, physical).unwrap(); 158 for (category, movement) in movements { 159 let source = match category { 160 HeldStockCategory::Preparatory => seed + 1, 161 HeldStockCategory::Committed => seed + 2, 162 HeldStockCategory::Quarantined => seed + 3, 163 }; 164 assert_eq!( 165 movement(original, StockTicks::ZERO), 166 Err(StockError::ZeroMovement) 167 ); 168 assert_eq!( 169 movement(original, ticks(source + 1)), 170 Err(StockError::Underflow) 171 ); 172 for quantity in [ticks(1), ticks(source)] { 173 let changed = movement(original, quantity).unwrap(); 174 assert_eq!(changed.introduced(), introduced); 175 assert_eq!(total(changed.physical()), u128::from(introduced.get())); 176 assert!(changed.physical().consumed >= physical.consumed); 177 assert_eq!(changed.physical().waste, physical.waste); 178 assert_eq!(changed.physical().removed, physical.removed); 179 } 180 for loss in [HeldStockLoss::Spoilage, HeldStockLoss::Removal] { 181 let changed = original 182 .deplete_held(category, loss, ticks(source)) 183 .unwrap(); 184 assert_eq!(changed.introduced(), introduced); 185 assert_eq!(total(changed.physical()), u128::from(introduced.get())); 186 assert_eq!(changed.physical().available, physical.available); 187 assert_eq!(changed.physical().consumed, physical.consumed); 188 assert_eq!( 189 original.deplete_held(category, loss, StockTicks::ZERO), 190 Err(StockError::ZeroMovement) 191 ); 192 assert_eq!( 193 original.deplete_held(category, loss, ticks(source + 1)), 194 Err(StockError::Underflow) 195 ); 196 } 197 } 198 assert_eq!(original.physical(), physical); 199 } 200 } 201 202 #[test] 203 fn maximum_backing_can_be_consumed_released_or_lost_without_minting_capacity() { 204 let original = PoolBalances::new( 205 StockTicks::MAX, 206 PhysicalBalances { 207 committed_hold: StockTicks::MAX, 208 ..PhysicalBalances::ZERO 209 }, 210 ) 211 .unwrap(); 212 let consumed = original.consume_committed(StockTicks::MAX).unwrap(); 213 assert_eq!(consumed.physical().consumed, StockTicks::MAX); 214 assert_eq!(consumed.physical().available, StockTicks::ZERO); 215 assert_eq!( 216 consumed.consume_committed(ticks(1)), 217 Err(StockError::Underflow) 218 ); 219 let released = original.release_committed(StockTicks::MAX).unwrap(); 220 assert_eq!(released.physical().available, StockTicks::MAX); 221 assert_eq!(released.introduced(), StockTicks::MAX); 222 let quarantined = original.quarantine_committed(StockTicks::MAX).unwrap(); 223 assert_eq!( 224 quarantined.consume_quarantined(StockTicks::MAX).unwrap(), 225 consumed 226 ); 227 let lost = original 228 .deplete_held( 229 HeldStockCategory::Committed, 230 HeldStockLoss::Removal, 231 StockTicks::MAX, 232 ) 233 .unwrap(); 234 assert_eq!(lost.physical().removed, StockTicks::MAX); 235 assert_eq!(lost.physical().available, StockTicks::ZERO); 236 assert_eq!(total(lost.physical()), u128::from(StockTicks::MAX.get())); 237 } 238 239 #[test] 240 fn obligation_bounds_never_clamp_deficits_or_consume_unbacked_quantities() { 241 assert_eq!( 242 ObligationBacking::new(ticks(3), ticks(1), ticks(1)), 243 Err(StockError::ObligationMismatch) 244 ); 245 assert_eq!( 246 ObligationBacking::new(StockTicks::MAX, StockTicks::MAX, ticks(1)), 247 Err(StockError::OutOfRange) 248 ); 249 let original = 250 ObligationBacking::new(StockTicks::MAX, StockTicks::MAX, StockTicks::ZERO).unwrap(); 251 let lost = original.lose_backing(StockTicks::MAX).unwrap(); 252 assert_eq!(lost.remaining(), StockTicks::MAX); 253 assert_eq!(lost.backed(), StockTicks::ZERO); 254 assert_eq!(lost.deficit(), StockTicks::MAX); 255 assert_eq!(lost.consume_backed(ticks(1)), Err(StockError::Underflow)); 256 assert_eq!( 257 original.restore_backing(ticks(1)), 258 Err(StockError::Underflow) 259 ); 260 assert_eq!(lost.restore_backing(StockTicks::MAX).unwrap(), original); 261 for proposal in [ 262 original.lose_backing(StockTicks::ZERO), 263 lost.restore_backing(StockTicks::ZERO), 264 original.consume_backed(StockTicks::ZERO), 265 original.release_residual(StockTicks::ZERO, StockTicks::ZERO), 266 ] { 267 assert_eq!(proposal, Err(StockError::ZeroMovement)); 268 } 269 let closed = lost 270 .release_residual(StockTicks::ZERO, StockTicks::MAX) 271 .unwrap(); 272 assert_eq!(closed.remaining(), StockTicks::ZERO); 273 assert_eq!( 274 closed.release_residual(StockTicks::ZERO, ticks(1)), 275 Err(StockError::Underflow) 276 ); 277 assert_eq!( 278 format!("{original:?}"), 279 "ObligationBacking(<private proposal>)" 280 ); 281 } 282 283 #[cfg(feature = "serde")] 284 #[test] 285 fn backing_codec_uses_closed_exact_strings_and_revalidates_the_obligation_equation() { 286 let original = ObligationBacking::new(ticks(100), ticks(80), ticks(20)).unwrap(); 287 let raw = serde_json::to_string(&original).unwrap(); 288 assert_eq!(raw, r#"{"remaining":"100","backed":"80","deficit":"20"}"#); 289 assert_eq!( 290 serde_json::from_str::<ObligationBacking>(&raw).unwrap(), 291 original 292 ); 293 for bad in [ 294 r#"{"remaining":"100","backed":"80","deficit":"19"}"#, 295 r#"{"remaining":"100","backed":80,"deficit":"20"}"#, 296 r#"{"remaining":"100","backed":"080","deficit":"20"}"#, 297 r#"{"remaining":"100","backed":"80","deficit":"20","available":"20"}"#, 298 r#"{"remaining":"100","remaining":"100","backed":"80","deficit":"20"}"#, 299 r#"{"remaining":"100","backed":"80"}"#, 300 r#"["100","80","20"]"#, 301 ] { 302 assert!( 303 serde_json::from_str::<ObligationBacking>(bad).is_err(), 304 "{bad}" 305 ); 306 } 307 }