lib

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

order_acceptance.rs (7722B)


      1 #![cfg(feature = "commands")]
      2 use radroots_protocol::command::{
      3     CapturedCommand, CapturedInventoryCommand, CapturedOrderAcceptance,
      4 };
      5 use serde_json::{Value, json};
      6 fn cases() -> Value {
      7     serde_json::from_str(include_str!("fixtures/order_acceptance.v1.json")).unwrap()
      8 }
      9 fn parse(
     10     value: &Value,
     11 ) -> Result<CapturedOrderAcceptance, radroots_protocol::command::CommandError> {
     12     CapturedOrderAcceptance::parse(&serde_json::to_vec(value).unwrap())
     13 }
     14 
     15 #[test]
     16 fn acceptance_capture_matches_independent_automatic_and_explicit_hash_vectors() {
     17     for case in cases()["cases"].as_array().unwrap() {
     18         let captured = parse(&case["wire"]).unwrap();
     19         assert_eq!(
     20             captured.digest().to_string(),
     21             case["command_digest"].as_str().unwrap()
     22         );
     23         assert_eq!(
     24             captured.approval_intent_digest().to_string(),
     25             case["approval_intent_digest"].as_str().unwrap()
     26         );
     27         assert_eq!(
     28             serde_json::from_slice::<Value>(captured.protected_wire()).unwrap(),
     29             case["wire"]
     30         );
     31         assert_eq!(
     32             CapturedOrderAcceptance::parse(captured.protected_wire())
     33                 .unwrap()
     34                 .digest(),
     35             captured.digest()
     36         );
     37         assert_eq!(
     38             format!("{captured:?}"),
     39             "CapturedOrderAcceptance(<redacted>)"
     40         );
     41     }
     42     let data = cases();
     43     let automatic = parse(&data["cases"][0]["wire"]).unwrap();
     44     assert!(automatic.input().allocation().is_automatic());
     45     assert!(
     46         automatic
     47             .input()
     48             .allocation()
     49             .explicit_allocations()
     50             .is_none()
     51     );
     52     let explicit = parse(&data["cases"][1]["wire"]).unwrap();
     53     let allocations = explicit
     54         .input()
     55         .allocation()
     56         .explicit_allocations()
     57         .unwrap();
     58     assert_eq!(allocations.len(), 2);
     59     assert_eq!(allocations[0].quantity().amount().to_string(), "250");
     60     assert_eq!(allocations[1].expected_pool_version().get(), 4);
     61     // Preparation cannot enter either existing outbox or inventory execution.
     62     assert!(CapturedCommand::parse(automatic.protected_wire()).is_err());
     63     assert!(CapturedInventoryCommand::parse(automatic.protected_wire()).is_err());
     64 }
     65 
     66 #[test]
     67 fn expected_order_terms_request_and_allocation_are_part_of_the_original_intent() {
     68     let data = cases();
     69     let wire = &data["cases"][0]["wire"];
     70     let original = parse(wire).unwrap();
     71     for (path, value) in [
     72         ("/input/request", json!("31".repeat(32))),
     73         ("/input/terms_digest", json!("32".repeat(32))),
     74         ("/context/expected/buyer_head", json!("33".repeat(32))),
     75         ("/context/expected/seller_sequence", json!("1")),
     76         (
     77             "/input/allocation",
     78             data["cases"][1]["wire"]["input"]["allocation"].clone(),
     79         ),
     80     ] {
     81         let mut changed = wire.clone();
     82         *changed.pointer_mut(path).unwrap() = value;
     83         let changed = parse(&changed).unwrap();
     84         assert_ne!(changed.digest(), original.digest());
     85         assert_ne!(
     86             changed.approval_intent_digest(),
     87             original.approval_intent_digest()
     88         );
     89     }
     90     let mut correlated = wire.clone();
     91     correlated["context"]["correlation_id"] = json!("T0 diagnostic");
     92     assert_eq!(parse(&correlated).unwrap().digest(), original.digest());
     93     let mut approved = wire.clone();
     94     approved["context"]["approval"] = json!({"intent_digest":original.approval_intent_digest(),"scope":"orders.accept","expires_at":"200"});
     95     let approved = parse(&approved).unwrap();
     96     assert_ne!(approved.digest(), original.digest());
     97     assert_eq!(
     98         approved.approval_intent_digest(),
     99         original.approval_intent_digest()
    100     );
    101 }
    102 
    103 #[test]
    104 fn capture_requires_closed_seller_order_data_and_distinguishes_allocation_choices() {
    105     let data = cases();
    106     let automatic = &data["cases"][0]["wire"];
    107     for (path, value) in [
    108         ("/type", json!("orders.decline")),
    109         ("/context/actor/role", json!("buyer")),
    110         ("/context/expected", Value::Null),
    111         ("/input/request", json!("2A".repeat(32))),
    112         ("/input/terms_digest", json!("2A".repeat(32))),
    113         ("/input/allocation", json!([])),
    114         (
    115             "/input/allocation",
    116             json!({"type":"automatic","allocations":null}),
    117         ),
    118         (
    119             "/input/allocation",
    120             json!({"type":"automatic","allocations":[]}),
    121         ),
    122         (
    123             "/input/allocation",
    124             json!({"type":"explicit","allocations":[]}),
    125         ),
    126         ("/input/allocation", json!({"type":"explicit"})),
    127         ("/input/allocation", json!({"type":"unknown"})),
    128         (
    129             "/input/allocation",
    130             json!({"type":"automatic","stock_free":true}),
    131         ),
    132     ] {
    133         let mut changed = automatic.clone();
    134         *changed.pointer_mut(path).unwrap() = value;
    135         assert!(parse(&changed).is_err(), "{path}");
    136     }
    137     for field in ["request", "terms_digest", "allocation"] {
    138         let mut changed = automatic.clone();
    139         changed["input"].as_object_mut().unwrap().remove(field);
    140         assert!(parse(&changed).is_err());
    141     }
    142     let mut extra = automatic.clone();
    143     extra["input"]["terms"] = json!({});
    144     assert!(parse(&extra).is_err());
    145     let raw = serde_json::to_string(automatic).unwrap();
    146     let duplicate=raw.replacen("\"request\":","\"request\":\"3131313131313131313131313131313131313131313131313131313131313131\",\"request\":",1);
    147     assert!(CapturedOrderAcceptance::parse(duplicate.as_bytes()).is_err());
    148 }
    149 
    150 #[test]
    151 fn advanced_claims_are_positive_versioned_unique_closed_and_bounded_before_capture() {
    152     let data = cases();
    153     let wire = &data["cases"][1]["wire"];
    154     for (path, value) in [
    155         (
    156             "/input/allocation/allocations/0/quantity/amount",
    157             json!("0"),
    158         ),
    159         (
    160             "/input/allocation/allocations/0/quantity/amount",
    161             json!(250),
    162         ),
    163         (
    164             "/input/allocation/allocations/0/quantity",
    165             json!(["250", "g"]),
    166         ),
    167         (
    168             "/input/allocation/allocations/0/expected_pool_version",
    169             json!("0"),
    170         ),
    171         (
    172             "/input/allocation/allocations/0/expected_pool_version",
    173             json!(1),
    174         ),
    175         ("/input/allocation/allocations/0", json!([])),
    176     ] {
    177         let mut changed = wire.clone();
    178         *changed.pointer_mut(path).unwrap() = value;
    179         assert!(parse(&changed).is_err(), "{path}");
    180     }
    181     let mut duplicate = wire.clone();
    182     duplicate["input"]["allocation"]["allocations"][1] =
    183         duplicate["input"]["allocation"]["allocations"][0].clone();
    184     assert!(parse(&duplicate).is_err());
    185     let mut extra = wire.clone();
    186     extra["input"]["allocation"]["allocations"][0]["allow_deficit"] = json!(true);
    187     assert!(parse(&extra).is_err());
    188     let mut bounded = wire.clone();
    189     let values = (1..=64)
    190         .map(|index| {
    191             let mut value = wire["input"]["allocation"]["allocations"][0].clone();
    192             value["pool_id"] = json!(format!("{index:064x}"));
    193             value
    194         })
    195         .collect::<Vec<_>>();
    196     bounded["input"]["allocation"]["allocations"] = json!(values);
    197     assert_eq!(
    198         parse(&bounded)
    199             .unwrap()
    200             .input()
    201             .allocation()
    202             .explicit_allocations()
    203             .unwrap()
    204             .len(),
    205         64
    206     );
    207     bounded["input"]["allocation"]["allocations"].as_array_mut().unwrap().push(json!({"line_id":"25".repeat(32),"pool_id":format!("{:064x}",65),"quantity":{"amount":"1","unit":"g"},"expected_pool_version":"1"}));
    208     assert!(parse(&bounded).is_err());
    209 }