inventory_delivery.rs (13550B)
1 //! Synthetic report shape only; actual stock linkage is a native-store duty. 2 use super::*; 3 use radroots_storage::{ 4 command::{DeliveryIntent, DeliveryObservationKind}, 5 inventory::{ 6 StockDeliveryObservationPage, StockDeliveryRequest, StockDeliverySummary, 7 StockDeliveryTargetProgress, StockRewrapAdmission, StockRewrapPage, StockRewrapRequest, 8 StockRewrapState, 9 }, 10 }; 11 use radroots_transport::{ 12 Target, TargetSet, 13 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 14 }; 15 16 fn fixture() -> (StockEnvelopeRequest, StockEnvelopeReceipt, DeliveryIntent) { 17 let original = attempt(1, 7, 8, true); 18 let request = StockEnvelopeRequest::new( 19 binding(WorkspaceScope::SellerStockOwner), 20 checkpoint(0), 21 original.operation_id(), 22 original.command_digest(), 23 key(), 24 None, 25 ) 26 .unwrap(); 27 let source = StockEnvelopeReceipt::from_committed_store( 28 &request, 29 original, 30 evidence(original, key()), 31 TransactionId::from_bytes([12; 32]), 32 EnvelopeEventId::from_bytes([14; 32]), 33 [15; 32], 34 checkpoint(1), 35 ) 36 .unwrap(); 37 let targets = TargetSet::new(vec![ 38 Target::nostr_relay("wss://one.example").unwrap(), 39 Target::nostr_relay("wss://two.example").unwrap(), 40 ]) 41 .unwrap(); 42 let intent = DeliveryIntent::new( 43 &"a".repeat(64), 44 source.event_id(), 45 &targets, 46 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 47 core::num::NonZeroU64::new(300000).unwrap(), 48 ) 49 .unwrap(); 50 (request, source, intent) 51 } 52 fn admission( 53 request: &StockEnvelopeRequest, 54 original: StockEnvelopeReceipt, 55 index: u8, 56 ) -> StockRewrapAdmission { 57 StockRewrapAdmission::from_store_report( 58 &StockRewrapRequest::new( 59 StockEnvelopeRequest::new( 60 request.binding().clone(), 61 request.minimum_checkpoint(), 62 request.operation_id(), 63 request.command_digest(), 64 request.recipient(), 65 None, 66 ) 67 .unwrap(), 68 OperationId::from_bytes([index + 1; 32]), 69 ), 70 original, 71 TransactionId::from_bytes([index + 128; 32]), 72 radroots_domain::UnixSeconds::new(150).unwrap(), 73 radroots_domain::UnixSeconds::new(180).unwrap(), 74 checkpoint(u64::from(index) + 2), 75 ) 76 .unwrap() 77 } 78 fn rewrapped( 79 request: &StockEnvelopeRequest, 80 original: StockEnvelopeReceipt, 81 index: u8, 82 ) -> StockEnvelopeReceipt { 83 let event = EnvelopeEventId::from_bytes([index + 64; 32]); 84 let selected = StockEnvelopeRequest::new( 85 request.binding().clone(), 86 request.minimum_checkpoint(), 87 request.operation_id(), 88 request.command_digest(), 89 request.recipient(), 90 None, 91 ) 92 .unwrap() 93 .with_envelope(event); 94 StockEnvelopeReceipt::from_committed_store( 95 &selected, 96 radroots_storage::command::CommitAttempt::new( 97 original.attempt().workspace_id(), 98 original.attempt().operation_id(), 99 original.attempt().command_digest(), 100 Some(TransactionId::from_bytes([index + 32; 32])), 101 ), 102 original.evidence(), 103 original.installation_transaction_id(), 104 event, 105 [index + 96; 32], 106 checkpoint(u64::from(index) + 3), 107 ) 108 .unwrap() 109 .with_rewrap_admission(&admission(request, original, index)) 110 .unwrap() 111 } 112 113 #[test] 114 fn selected_envelope_retains_a_separate_first_policy_source_without_weakening_original_reports() { 115 let (request, original, intent) = fixture(); 116 let new = rewrapped(&request, original, 1); 117 let selected = StockEnvelopeRequest::new( 118 request.binding().clone(), 119 request.minimum_checkpoint(), 120 request.operation_id(), 121 request.command_digest(), 122 request.recipient(), 123 None, 124 ) 125 .unwrap() 126 .with_envelope(new.event_id()); 127 assert!( 128 StockDeliverySummary::from_store_report( 129 &selected, 130 Some(new), 131 Some(intent.clone()), 132 1, 133 progress(&intent, &[false, false]), 134 checkpoint(4) 135 ) 136 .is_err() 137 ); 138 let summary = StockDeliverySummary::from_store_report_with_policy_source( 139 &selected, 140 Some(new), 141 Some(original), 142 Some(intent.clone()), 143 1, 144 1, 145 progress(&intent, &[false, false]), 146 checkpoint(4), 147 ) 148 .unwrap(); 149 assert_eq!(summary.source(), Some(new)); 150 assert_eq!(summary.publication_policy_source(), Some(original)); 151 assert_eq!(summary.original_intent(), Some(&intent)); 152 assert!(!summary.acceptance_satisfied().unwrap()); 153 let wrong_policy = rewrapped(&request, original, 2); 154 assert!( 155 StockDeliverySummary::from_store_report_with_policy_source( 156 &selected, 157 Some(new), 158 Some(wrong_policy), 159 Some(intent.clone()), 160 1, 161 1, 162 progress(&intent, &[false, false]), 163 checkpoint(5) 164 ) 165 .is_err() 166 ); 167 assert!( 168 StockDeliveryRequest::new( 169 request.binding().clone(), 170 request.minimum_checkpoint(), 171 request.operation_id(), 172 request.command_digest(), 173 request.recipient(), 174 intent 175 ) 176 .unwrap() 177 .with_envelope(new.event_id()) 178 .is_err() 179 ); 180 } 181 182 #[test] 183 fn additional_envelope_pages_reject_duplicate_identities_oversized_pages_and_false_cursors() { 184 let (request, original, _) = fixture(); 185 let entries = (0..16) 186 .map(|index| { 187 StockRewrapState::from_store_report( 188 admission(&request, original, index), 189 Some(rewrapped(&request, original, index)), 190 ) 191 .unwrap() 192 }) 193 .collect::<Vec<_>>(); 194 let cursor = entries[15].admission().checkpoint().revision(); 195 let page = StockRewrapPage::from_store_report(&request, entries.clone(), true, checkpoint(18)) 196 .unwrap(); 197 assert_eq!(page.entries(), entries.as_slice()); 198 assert_eq!(page.next_after(), Some(cursor)); 199 assert_eq!(page.checkpoint(), checkpoint(18)); 200 assert!( 201 StockRewrapPage::from_store_report( 202 &request, 203 vec![entries[0], entries[0]], 204 false, 205 checkpoint(18) 206 ) 207 .is_err() 208 ); 209 assert!( 210 StockRewrapPage::from_store_report( 211 &request, 212 (0..17) 213 .map(|index| StockRewrapState::from_store_report( 214 admission(&request, original, index), 215 Some(rewrapped(&request, original, index)) 216 ) 217 .unwrap()) 218 .collect(), 219 false, 220 checkpoint(19) 221 ) 222 .is_err() 223 ); 224 assert!( 225 StockRewrapPage::from_store_report(&request, entries.clone(), false, checkpoint(1)) 226 .is_err() 227 ); 228 assert!( 229 StockRewrapPage::from_store_report(&request, vec![entries[0]], true, checkpoint(18)) 230 .is_err() 231 ); 232 } 233 fn progress(intent: &DeliveryIntent, accepted: &[bool; 2]) -> Vec<StockDeliveryTargetProgress> { 234 intent 235 .targets() 236 .targets() 237 .iter() 238 .zip(accepted) 239 .map(|(target, accepted)| { 240 StockDeliveryTargetProgress::from_store_report( 241 target.fingerprint().clone(), 242 1, 243 *accepted, 244 Some(if *accepted { 245 DeliveryObservationKind::Accepted 246 } else { 247 DeliveryObservationKind::Disconnected 248 }), 249 None, 250 ) 251 .unwrap() 252 }) 253 .collect() 254 } 255 256 #[test] 257 fn summary_keeps_the_complete_original_transport_criterion_and_never_promotes_capture_only() { 258 let (request, source, intent) = fixture(); 259 let captured = StockDeliverySummary::from_store_report( 260 &request, 261 Some(source), 262 None, 263 0, 264 vec![], 265 checkpoint(3), 266 ) 267 .unwrap(); 268 assert!(!captured.acceptance_satisfied().unwrap()); 269 assert!(captured.original_intent().is_none()); 270 for (accepted, expected) in [([true, false], false), ([true, true], true)] { 271 let value = StockDeliverySummary::from_store_report( 272 &request, 273 Some(source), 274 Some(intent.clone()), 275 1, 276 progress(&intent, &accepted), 277 checkpoint(3), 278 ) 279 .unwrap(); 280 assert_eq!(value.acceptance_satisfied().unwrap(), expected); 281 assert_eq!(value.original_intent(), Some(&intent)); 282 assert_eq!(value.attempt_count(), 1); 283 assert_eq!(value.targets().len(), 2); 284 assert_eq!(format!("{value:?}"), "StockDeliverySummary(<redacted>)"); 285 } 286 } 287 288 #[test] 289 fn endpoint_caps_and_summary_scope_reject_inconsistent_reports() { 290 let (request, source, intent) = fixture(); 291 let fp = intent.targets().targets()[0].fingerprint(); 292 assert!( 293 StockDeliveryTargetProgress::from_store_report(fp.clone(), 13, false, None, None).is_err() 294 ); 295 assert!( 296 StockDeliveryTargetProgress::from_store_report(fp.clone(), 0, true, None, None).is_err() 297 ); 298 assert!( 299 StockDeliveryTargetProgress::from_store_report( 300 fp.clone(), 301 1, 302 false, 303 None, 304 core::num::NonZeroU64::new(1) 305 ) 306 .is_err() 307 ); 308 for count in [0, 3, 193] { 309 assert!( 310 StockDeliverySummary::from_store_report( 311 &request, 312 Some(source), 313 Some(intent.clone()), 314 count, 315 progress(&intent, &[false, false]), 316 checkpoint(3) 317 ) 318 .is_err() 319 ); 320 } 321 let mut wrong_order = progress(&intent, &[false, false]); 322 wrong_order.reverse(); 323 assert!( 324 StockDeliverySummary::from_store_report( 325 &request, 326 Some(source), 327 Some(intent.clone()), 328 1, 329 wrong_order, 330 checkpoint(3) 331 ) 332 .is_err() 333 ); 334 assert!( 335 StockDeliverySummary::from_store_report( 336 &request, 337 None, 338 Some(intent.clone()), 339 1, 340 progress(&intent, &[false, false]), 341 checkpoint(3) 342 ) 343 .is_err() 344 ); 345 } 346 347 #[test] 348 fn stock_intent_refuses_public_artifacts_and_empty_outcome_pages_do_not_advance() { 349 let (request, source, intent) = fixture(); 350 let public = DeliveryIntent::public( 351 &"b".repeat(64), 352 source.event_id(), 353 intent.targets(), 354 intent.policy(), 355 intent.deadline_unix_ms(), 356 ) 357 .unwrap(); 358 assert!( 359 StockDeliveryRequest::new( 360 request.binding().clone(), 361 checkpoint(0), 362 request.operation_id(), 363 request.command_digest(), 364 request.recipient(), 365 public 366 ) 367 .is_err() 368 ); 369 assert!( 370 StockDeliveryObservationPage::from_store_report(&request, vec![], true, checkpoint(3)) 371 .is_err() 372 ); 373 let page = 374 StockDeliveryObservationPage::from_store_report(&request, vec![], false, checkpoint(3)) 375 .unwrap(); 376 assert!(page.entries().is_empty()); 377 assert!(page.next_after().is_none()); 378 assert_eq!( 379 format!("{page:?}"), 380 "StockDeliveryObservationPage(<redacted>)" 381 ); 382 } 383 384 #[test] 385 fn scoped_delivery_counts_refuse_observations_without_a_selected_invocation() { 386 let (request, original, intent) = fixture(); 387 let new = rewrapped(&request, original, 1); 388 let selected = StockEnvelopeRequest::new( 389 request.binding().clone(), 390 request.minimum_checkpoint(), 391 request.operation_id(), 392 request.command_digest(), 393 request.recipient(), 394 None, 395 ) 396 .unwrap() 397 .with_envelope(new.event_id()); 398 let none = StockDeliverySummary::from_store_report_with_policy_source( 399 &selected, 400 Some(new), 401 Some(original), 402 Some(intent.clone()), 403 1, 404 0, 405 progress(&intent, &[false, false]) 406 .into_iter() 407 .map(|target| { 408 StockDeliveryTargetProgress::from_store_report( 409 target.target().clone(), 410 target.potential_attempts(), 411 false, 412 None, 413 None, 414 ) 415 .unwrap() 416 }) 417 .collect(), 418 checkpoint(5), 419 ) 420 .unwrap(); 421 assert_eq!(none.attempt_count(), 1); 422 assert_eq!(none.selected_attempt_count(), 0); 423 assert!(!none.acceptance_satisfied().unwrap()); 424 assert!( 425 StockDeliverySummary::from_store_report_with_policy_source( 426 &selected, 427 Some(new), 428 Some(original), 429 Some(intent.clone()), 430 1, 431 2, 432 progress(&intent, &[false, false]), 433 checkpoint(5) 434 ) 435 .is_err() 436 ); 437 assert!( 438 StockDeliverySummary::from_store_report_with_policy_source( 439 &selected, 440 Some(new), 441 Some(original), 442 Some(intent.clone()), 443 1, 444 0, 445 progress(&intent, &[true, false]), 446 checkpoint(5) 447 ) 448 .is_err() 449 ); 450 }