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 }