lib

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

pool_correction.rs (7576B)


      1 #![cfg(feature = "commands")]
      2 use radroots_domain::{PoolId, PositiveDecimal, Sequence, stock::AvailableStockCorrection};
      3 use radroots_protocol::command::{CapturedPoolCorrection, PoolCorrectionInput};
      4 use serde_json::json;
      5 fn wire(kind: &str) -> serde_json::Value {
      6     let fixture: serde_json::Value =
      7         serde_json::from_str(include_str!("fixtures/pool_creation.v1.json")).unwrap();
      8     let mut input = json!({"pool_id":"08".repeat(32),"expected_version":"1","amount":"0.125","reason":"counted during harvest"});
      9     if kind == "stock.adjust" {
     10         input["direction"] = json!("add");
     11     }
     12     json!({"type":kind,"context":fixture["wire"]["context"],"input":input})
     13 }
     14 
     15 #[test]
     16 fn correction_hashes_match_independent_vectors_and_common_dispatch_retains_the_exact_family() {
     17     use radroots_protocol::command::{CapturedInventoryCommand, InventoryCommandKind};
     18     let vectors: serde_json::Value =
     19         serde_json::from_str(include_str!("fixtures/pool_correction.v1.json")).unwrap();
     20     for (case, kind) in vectors["cases"].as_array().unwrap().iter().zip([
     21         InventoryCommandKind::AddStock,
     22         InventoryCommandKind::RemoveStock,
     23         InventoryCommandKind::SpoilStock,
     24     ]) {
     25         let captured =
     26             CapturedInventoryCommand::parse(&serde_json::to_vec(&case["wire"]).unwrap()).unwrap();
     27         assert_eq!(
     28             captured.digest().to_string(),
     29             case["command_digest"].as_str().unwrap()
     30         );
     31         assert_eq!(
     32             captured.approval_intent_digest().to_string(),
     33             case["approval_intent_digest"].as_str().unwrap()
     34         );
     35         assert_eq!(captured.kind(), kind);
     36         assert_eq!(captured.pool_id(), PoolId::from_bytes([8; 32]));
     37         assert!(captured.creation_input().is_none());
     38         assert_eq!(
     39             captured.correction_input().unwrap().reason(),
     40             "counted 🥕\nexactly"
     41         );
     42     }
     43     let original: serde_json::Value =
     44         serde_json::from_str(include_str!("fixtures/pool_creation.v1.json")).unwrap();
     45     let created =
     46         CapturedInventoryCommand::parse(&serde_json::to_vec(&original["wire"]).unwrap()).unwrap();
     47     assert_eq!(created.kind(), InventoryCommandKind::CreatePool);
     48     assert_eq!(
     49         created.digest().to_string(),
     50         original["command_digest"].as_str().unwrap()
     51     );
     52     assert!(created.creation_input().is_some());
     53     assert!(created.correction_input().is_none());
     54     assert!(CapturedInventoryCommand::parse(br#"{"type":"inbox.inquire"}"#).is_err());
     55 }
     56 #[test]
     57 fn adjustment_and_spoilage_capture_exact_semantics_without_unit_conversion() {
     58     for (kind, correction) in [
     59         ("stock.adjust", AvailableStockCorrection::Add),
     60         ("stock.spoil", AvailableStockCorrection::Spoil),
     61     ] {
     62         let raw = wire(kind);
     63         let captured = CapturedPoolCorrection::parse(&serde_json::to_vec(&raw).unwrap()).unwrap();
     64         assert_eq!(captured.input().kind(), correction);
     65         assert_eq!(
     66             captured.input().amount(),
     67             "0.125".parse::<PositiveDecimal>().unwrap()
     68         );
     69         assert_eq!(captured.input().expected_version().get(), 1);
     70         assert_eq!(
     71             serde_json::from_slice::<serde_json::Value>(captured.protected_wire()).unwrap(),
     72             raw
     73         );
     74         assert_eq!(
     75             CapturedPoolCorrection::parse(captured.protected_wire())
     76                 .unwrap()
     77                 .digest(),
     78             captured.digest()
     79         );
     80         for (path, value) in [
     81             ("/input/amount", json!("0.25")),
     82             ("/input/expected_version", json!("2")),
     83             ("/input/pool_id", json!("09".repeat(32))),
     84             ("/input/reason", json!("counted 🥕\nexactly")),
     85         ] {
     86             let mut changed = raw.clone();
     87             *changed.pointer_mut(path).unwrap() = value;
     88             assert_ne!(
     89                 CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap())
     90                     .unwrap()
     91                     .digest(),
     92                 captured.digest(),
     93                 "{path}"
     94             );
     95         }
     96     }
     97     let mut changed = wire("stock.adjust");
     98     changed["input"]["direction"] = json!("remove");
     99     let removed = CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).unwrap();
    100     assert_eq!(removed.input().kind(), AvailableStockCorrection::Remove);
    101     assert_ne!(
    102         removed.digest(),
    103         CapturedPoolCorrection::parse(&serde_json::to_vec(&wire("stock.adjust")).unwrap())
    104             .unwrap()
    105             .digest()
    106     );
    107 }
    108 #[test]
    109 fn closed_correction_inputs_refuse_unknown_fields_numeric_values_and_zero_movements() {
    110     for kind in ["stock.adjust", "stock.spoil"] {
    111         let original = wire(kind);
    112         for (path, value) in [
    113             ("/input/amount", json!("0")),
    114             ("/input/amount", json!(0.125)),
    115             ("/input/amount", json!("0.1250")),
    116             ("/input/expected_version", json!(1)),
    117             ("/input/expected_version", json!("0")),
    118             ("/input/expected_version", json!("01")),
    119             ("/input/reason", json!("🧺".repeat(1025))),
    120         ] {
    121             let mut changed = original.clone();
    122             *changed.pointer_mut(path).unwrap() = value;
    123             assert!(
    124                 CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err(),
    125                 "{path}"
    126             );
    127         }
    128         for field in ["pool_id", "expected_version", "amount", "reason"] {
    129             let mut changed = original.clone();
    130             changed["input"].as_object_mut().unwrap().remove(field);
    131             assert!(
    132                 CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err(),
    133                 "{field}"
    134             );
    135         }
    136         let mut changed = original.clone();
    137         changed["input"]["ignored"] = json!(true);
    138         assert!(CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err());
    139         let mut changed = original.clone();
    140         changed["input"] = json!(["08".repeat(32), "1", "0.125", "reason"]);
    141         assert!(CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err());
    142     }
    143     let mut changed = wire("stock.spoil");
    144     changed["input"]["direction"] = json!("remove");
    145     assert!(CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err());
    146     let mut changed = wire("stock.adjust");
    147     changed["input"]["direction"] = json!("spoil");
    148     assert!(CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).is_err());
    149 }
    150 #[test]
    151 fn reasons_are_exact_bounded_private_text_and_diagnostic_correlation_is_excluded() {
    152     let raw = wire("stock.adjust");
    153     let base = CapturedPoolCorrection::parse(&serde_json::to_vec(&raw).unwrap()).unwrap();
    154     let input = PoolCorrectionInput::new(
    155         PoolId::from_bytes([8; 32]),
    156         Sequence::new(1).unwrap(),
    157         AvailableStockCorrection::Add,
    158         "0.125".parse().unwrap(),
    159         &"🧺".repeat(1024),
    160     )
    161     .unwrap();
    162     assert_eq!(input.reason().chars().count(), 1024);
    163     assert!(!format!("{input:?}").contains('🧺'));
    164     let mut changed = raw.clone();
    165     changed["context"]["correlation_id"] = json!("display-only");
    166     let changed = CapturedPoolCorrection::parse(&serde_json::to_vec(&changed).unwrap()).unwrap();
    167     assert_eq!(changed.digest(), base.digest());
    168     assert_eq!(
    169         changed.approval_intent_digest(),
    170         base.approval_intent_digest()
    171     );
    172     assert_ne!(changed.protected_wire(), base.protected_wire());
    173     assert!(!format!("{base:?}").contains("harvest"));
    174 }