lib

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

commerce_coverage.rs (8680B)


      1 #![cfg(feature = "commerce")]
      2 use radroots_domain::{causal::*, *};
      3 use radroots_protocol::commerce::{CapturedCausalCoverage, DecodedRecord, RecordWireError, decode};
      4 use serde_json::Value;
      5 use std::collections::BTreeMap;
      6 
      7 fn fixture() -> Value {
      8     serde_json::from_str(include_str!("fixtures/commerce_coverage.v1.json")).unwrap()
      9 }
     10 fn scope(value: &Value) -> CausalScope {
     11     CausalScope::new(
     12         value["thread"].as_str().unwrap().parse().unwrap(),
     13         value["order"].as_str().unwrap().parse().unwrap(),
     14         value["buyer"].as_str().unwrap().parse().unwrap(),
     15         value["seller"].as_str().unwrap().parse().unwrap(),
     16     )
     17     .unwrap()
     18 }
     19 fn records(value: &Value) -> BTreeMap<String, DecodedRecord> {
     20     value["records"]
     21         .as_object()
     22         .unwrap()
     23         .iter()
     24         .map(|(name, row)| {
     25             (
     26                 name.clone(),
     27                 decode(row["wire"].as_str().unwrap().as_bytes()).unwrap(),
     28             )
     29         })
     30         .collect()
     31 }
     32 fn ids(value: &Value) -> Vec<SourceId> {
     33     value
     34         .as_array()
     35         .unwrap()
     36         .iter()
     37         .map(|id| id.as_str().unwrap().parse().unwrap())
     38         .collect()
     39 }
     40 fn readiness(value: CausalReadiness) -> &'static str {
     41     match value {
     42         CausalReadiness::Complete => "complete",
     43         CausalReadiness::MissingHistory => "missing_history",
     44         CausalReadiness::Conflicted => "conflicted",
     45         CausalReadiness::Uninterpreted => "uninterpreted",
     46     }
     47 }
     48 
     49 #[test]
     50 fn independent_fixed_width_scope_transcripts_match_complete_graphs_without_transport_churn() {
     51     let fixture = fixture();
     52     let decoded = records(&fixture);
     53     let scope = scope(&fixture["scope"]);
     54     for row in fixture["vectors"].as_array().unwrap() {
     55         let nodes = row["records"]
     56             .as_array()
     57             .unwrap()
     58             .iter()
     59             .map(|name| {
     60                 let record = &decoded[name.as_str().unwrap()];
     61                 CausalRecord::new(record.record_id(), record.content())
     62             })
     63             .collect::<Vec<_>>();
     64         let capture = CapturedCausalCoverage::capture(
     65             scope,
     66             &nodes,
     67             &ids(&row["external"]),
     68             &ids(&row["uninterpreted"]),
     69         )
     70         .unwrap();
     71         assert_eq!(
     72             readiness(capture.analysis().readiness()),
     73             row["readiness"].as_str().unwrap()
     74         );
     75         if row["checkpoint"].is_null() {
     76             assert!(capture.checkpoint().is_none(), "{}", row["name"]);
     77         } else {
     78             let checkpoint = capture.checkpoint().unwrap();
     79             assert_eq!(
     80                 checkpoint.digest().to_string(),
     81                 row["checkpoint"]["digest"].as_str().unwrap(),
     82                 "{}",
     83                 row["name"]
     84             );
     85             assert_eq!(
     86                 checkpoint.sequence().get(),
     87                 row["checkpoint"]["sequence"].as_u64().unwrap()
     88             );
     89             assert_eq!(checkpoint.coverage(), Coverage::ScopeSatisfied);
     90             assert!(checkpoint.missing().is_empty());
     91         }
     92         assert_eq!(
     93             format!("{capture:?}"),
     94             "CapturedCausalCoverage(<local coverage claims>)"
     95         );
     96         let analysis = capture.analysis().clone();
     97         let checkpoint = capture.checkpoint().cloned();
     98         let parts = capture.into_parts();
     99         assert_eq!(parts, (analysis, checkpoint));
    100     }
    101     assert_eq!(
    102         fixture["vectors"][0]["checkpoint"],
    103         fixture["vectors"][1]["checkpoint"]
    104     );
    105     assert_ne!(
    106         fixture["vectors"][0]["checkpoint"],
    107         fixture["vectors"][2]["checkpoint"]
    108     );
    109 }
    110 
    111 #[test]
    112 fn claimed_ids_scope_and_limits_are_checked_before_a_coverage_descriptor_is_available() {
    113     let fixture = fixture();
    114     let decoded = records(&fixture);
    115     let scope = scope(&fixture["scope"]);
    116     let record = &decoded["request"];
    117     let fake = CausalRecord::new(RecordId::from_bytes([0; 32]), record.content());
    118     assert_eq!(
    119         CapturedCausalCoverage::capture(scope, &[fake], &[], &[]).unwrap_err(),
    120         RecordWireError::IdentityMismatch
    121     );
    122     let correct = CausalRecord::new(record.record_id(), record.content());
    123     assert_eq!(correct.record_id(), record.record_id());
    124     assert_eq!(correct.content(), record.content());
    125     let different = CausalScope::new(
    126         ThreadId::from_bytes([0x55; 32]),
    127         scope.order_id(),
    128         scope.buyer(),
    129         scope.seller(),
    130     )
    131     .unwrap();
    132     assert_eq!(
    133         CapturedCausalCoverage::capture(different, &[correct], &[], &[]).unwrap_err(),
    134         RecordWireError::InvalidInput
    135     );
    136     assert_eq!(
    137         CapturedCausalCoverage::capture(scope, &vec![correct; 1001], &[], &[]).unwrap_err(),
    138         RecordWireError::LimitExceeded
    139     );
    140     assert_eq!(
    141         CapturedCausalCoverage::capture(
    142             scope,
    143             &[],
    144             &vec![SourceId::from_bytes([0; 32]); 8001],
    145             &[]
    146         )
    147         .unwrap_err(),
    148         RecordWireError::LimitExceeded
    149     );
    150 }
    151 
    152 #[test]
    153 fn scope_binding_remains_explicit_even_for_empty_claims_and_does_not_invent_a_request() {
    154     let fixture = fixture();
    155     let scope = scope(&fixture["scope"]);
    156     let first = CapturedCausalCoverage::capture(scope, &[], &[], &[]).unwrap();
    157     let different = CausalScope::new(
    158         scope.thread_id(),
    159         OrderId::from_bytes([0x55; 32]),
    160         scope.buyer(),
    161         scope.seller(),
    162     )
    163     .unwrap();
    164     let second = CapturedCausalCoverage::capture(different, &[], &[], &[]).unwrap();
    165     assert_ne!(
    166         first.checkpoint().unwrap().digest(),
    167         second.checkpoint().unwrap().digest()
    168     );
    169     assert_eq!(first.checkpoint().unwrap().sequence().get(), 0);
    170     assert!(first.analysis().buyer_head().is_none());
    171     assert!(first.analysis().seller_head().is_none());
    172 }
    173 
    174 #[test]
    175 fn initial_request_claims_require_live_exact_sources_and_refuse_observed_withdrawal_or_decline() {
    176     let fixture = fixture();
    177     let decoded = records(&fixture);
    178     let scope = scope(&fixture["scope"]);
    179     let request = decoded["request"].record_id();
    180     let base = fixture["vectors"][0].clone();
    181     let external = ids(&base["external"]);
    182     let nodes = |names: &[&str]| {
    183         names
    184             .iter()
    185             .map(|name| {
    186                 let record = &decoded[*name];
    187                 CausalRecord::new(record.record_id(), record.content())
    188             })
    189             .collect::<Vec<_>>()
    190     };
    191     let base_nodes = nodes(&["quote", "request"]);
    192     let claim = prepare_initial_request(
    193         scope,
    194         request,
    195         &base_nodes,
    196         &external,
    197         &[],
    198         UnixSeconds::new(150).unwrap(),
    199     )
    200     .unwrap();
    201     assert_eq!(claim.request(), request);
    202     assert_eq!(claim.quote(), Some(decoded["quote"].record_id()));
    203     assert_eq!(claim.expires_at().get(), 240);
    204     let CommercePayload::Request(original) = decoded["request"].content().payload() else {
    205         panic!()
    206     };
    207     assert_eq!(claim.terms(), original.terms());
    208     assert_eq!(format!("{claim:?}"), "InitialRequestClaim(<private data>)");
    209     for (names, at, expected) in [
    210         (vec!["quote", "request"], 240, RequestClaimError::Expired),
    211         (vec!["quote", "request"], 100, RequestClaimError::ClockAhead),
    212         (
    213             vec!["quote", "request", "withdrawal"],
    214             150,
    215             RequestClaimError::Withdrawn,
    216         ),
    217         (
    218             vec!["quote", "request", "decline"],
    219             150,
    220             RequestClaimError::Declined,
    221         ),
    222         (
    223             vec!["quote", "request", "withdrawal", "buyer_fork"],
    224             150,
    225             RequestClaimError::Conflicted,
    226         ),
    227         (vec!["request"], 150, RequestClaimError::MissingHistory),
    228     ] {
    229         assert_eq!(
    230             prepare_initial_request(
    231                 scope,
    232                 request,
    233                 &nodes(&names),
    234                 &external,
    235                 &[],
    236                 UnixSeconds::new(at).unwrap()
    237             )
    238             .unwrap_err(),
    239             expected
    240         );
    241     }
    242     assert_eq!(
    243         prepare_initial_request(
    244             scope,
    245             decoded["quote"].record_id(),
    246             &base_nodes,
    247             &external,
    248             &[],
    249             UnixSeconds::new(150).unwrap()
    250         )
    251         .unwrap_err(),
    252         RequestClaimError::WrongRequest
    253     );
    254     let unknown = ids(&fixture["vectors"][7]["uninterpreted"]);
    255     assert_eq!(
    256         prepare_initial_request(
    257             scope,
    258             request,
    259             &base_nodes,
    260             &external,
    261             &unknown,
    262             UnixSeconds::new(150).unwrap()
    263         )
    264         .unwrap_err(),
    265         RequestClaimError::Uninterpreted
    266     );
    267 }