lib

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

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 }