lib

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

stock_allocation.rs (4274B)


      1 use radroots_domain::{
      2     AgreementLineId, PoolId, Quantity, Sequence, listing::MeasurementUnit, stock::*,
      3 };
      4 
      5 fn ticks(value: u64) -> StockTicks {
      6     StockTicks::new(value).unwrap()
      7 }
      8 fn pool(version: u64) -> PoolSnapshot {
      9     PoolSnapshot::new(
     10         PoolId::from_bytes([1; 32]),
     11         PoolUnit::new(MeasurementUnit::Each, 0).unwrap(),
     12         PoolBalances::new(
     13             ticks(10),
     14             PhysicalBalances {
     15                 available: ticks(10),
     16                 ..PhysicalBalances::ZERO
     17             },
     18         )
     19         .unwrap(),
     20         Sequence::new(version).unwrap(),
     21     )
     22 }
     23 #[test]
     24 fn positive_proposals_are_data_and_reject_missing_versions_or_unavailable_backing() {
     25     let before = pool(1);
     26     let proposal = PoolHoldProposal::new(before, ticks(3)).unwrap();
     27     assert_eq!(proposal.before(), before);
     28     assert_eq!(proposal.after().balances().physical().available, ticks(7));
     29     assert_eq!(
     30         proposal.after().balances().physical().preparatory_hold,
     31         ticks(3)
     32     );
     33     assert_eq!(proposal.after().version().get(), 2);
     34     assert_eq!(proposal.after().balances().introduced(), ticks(10));
     35     assert_eq!(
     36         PoolHoldProposal::new(before, ticks(11)),
     37         Err(AllocationPlanError::StaleState)
     38     );
     39     assert_eq!(
     40         PoolHoldProposal::new(before, StockTicks::ZERO),
     41         Err(AllocationPlanError::InvalidInput)
     42     );
     43     assert_eq!(
     44         PoolHoldProposal::new(pool(0), ticks(1)),
     45         Err(AllocationPlanError::InvalidInput)
     46     );
     47     let quantity = Quantity::new("1".parse().unwrap(), MeasurementUnit::Each).unwrap();
     48     assert!(
     49         AllocationClaim::new(
     50             AgreementLineId::from_bytes([2; 32]),
     51             before.id(),
     52             quantity,
     53             Sequence::new(0).unwrap()
     54         )
     55         .is_err()
     56     );
     57     assert!(
     58         StockAllocation::new(
     59             AgreementLineId::from_bytes([2; 32]),
     60             before.id(),
     61             StockTicks::ZERO
     62         )
     63         .is_err()
     64     );
     65     assert_eq!(
     66         format!("{proposal:?}"),
     67         "PoolHoldProposal(<private proposal>)"
     68     );
     69 }
     70 #[cfg(feature = "serde")]
     71 #[test]
     72 fn restored_hold_proposal_must_recompute_the_entire_after_image() {
     73     let proposal = PoolHoldProposal::new(pool(1), ticks(3)).unwrap();
     74     let original = serde_json::to_value(proposal).unwrap();
     75     let restored: PoolHoldProposal = serde_json::from_value(original.clone()).unwrap();
     76     assert_eq!(restored, proposal);
     77     for path in ["/after/version", "/after/id"] {
     78         let mut changed = original.clone();
     79         if path.ends_with("version") {
     80             *changed.pointer_mut(path).unwrap() = serde_json::json!("3");
     81         } else {
     82             *changed.pointer_mut(path).unwrap() = serde_json::json!("ab".repeat(32));
     83         }
     84         assert!(
     85             serde_json::from_value::<PoolHoldProposal>(changed).is_err(),
     86             "{path}"
     87         );
     88     }
     89     let mut changed = original.clone();
     90     changed["quantity"] = serde_json::json!("2");
     91     assert!(serde_json::from_value::<PoolHoldProposal>(changed).is_err());
     92     let mut changed = original;
     93     changed["unexpected"] = serde_json::json!(true);
     94     assert!(serde_json::from_value::<PoolHoldProposal>(changed).is_err());
     95 }
     96 #[cfg(feature = "serde")]
     97 #[test]
     98 fn restored_allocations_cannot_create_zero_draws_or_ambiguous_objects() {
     99     let allocation = StockAllocation::new(
    100         AgreementLineId::from_bytes([2; 32]),
    101         PoolId::from_bytes([1; 32]),
    102         ticks(3),
    103     )
    104     .unwrap();
    105     let original = serde_json::to_value(allocation).unwrap();
    106     assert_eq!(
    107         serde_json::from_value::<StockAllocation>(original.clone()).unwrap(),
    108         allocation
    109     );
    110     let mut changed = original.clone();
    111     changed["ticks"] = serde_json::json!("0");
    112     assert!(serde_json::from_value::<StockAllocation>(changed).is_err());
    113     let mut changed = original;
    114     changed["unexpected"] = serde_json::json!(true);
    115     assert!(serde_json::from_value::<StockAllocation>(changed).is_err());
    116     let duplicate = format!(
    117         "{{\"line\":\"{}\",\"line\":\"{}\",\"pool\":\"{}\",\"ticks\":\"3\"}}",
    118         allocation.line_id(),
    119         allocation.line_id(),
    120         allocation.pool_id()
    121     );
    122     assert!(serde_json::from_str::<StockAllocation>(&duplicate).is_err());
    123 }