state_delivery_tests.rs (15689B)
1 //! Isolated native coverage for delivery selection through the real repository. 2 3 use std::{fs, os::unix::fs::PermissionsExt}; 4 5 use radroots_storage::event::SourceGeneration; 6 7 use crate::nip46_wave_080_a::{ 8 RECEIVED_AT_MS, configuration, connection_time, keys, metadata, migration_evidence, runtime, 9 }; 10 use crate::nip46_wave_080_b::{active_connection, atomic_response_request}; 11 use crate::{ 12 MycConfigProfile, MycDeliveryAttemptNonce, MycDeliveryAttemptOutcome, MycDeliveryClaim, 13 MycDeliveryJobStatus, MycDeliveryRelayId, MycDeliveryRetryJitter, MycDeliveryTargetStatus, 14 MycDeliveryTimeUnixMs, MycNip46CommitRequest, MycStateMetadata, initialize_myc_state, 15 open_myc_state_read_write, parse_myc_config_v1, 16 }; 17 18 fn time(offset_ms: u64) -> MycDeliveryTimeUnixMs { 19 MycDeliveryTimeUnixMs::new(RECEIVED_AT_MS + offset_ms).expect("fixture time") 20 } 21 22 #[tokio::test] 23 async fn ready_target_selection_is_read_only_ordered_and_respects_delivery_state() { 24 let directory = tempfile::tempdir().expect("temporary state root"); 25 let runtime = runtime(directory.path()); 26 fs::create_dir_all(runtime.context().paths().state()).expect("state directory"); 27 fs::set_permissions( 28 runtime.context().paths().state(), 29 fs::Permissions::from_mode(0o700), 30 ) 31 .expect("state directory mode"); 32 let metadata = metadata(&runtime); 33 let configuration = configuration(); 34 let (applied_at, build) = migration_evidence(); 35 initialize_myc_state(&runtime, &metadata, applied_at, &build) 36 .await 37 .expect("state initialization"); 38 let host = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) 39 .await 40 .expect("writable state"); 41 let repository = host.repository(); 42 assert_eq!( 43 repository 44 .next_ready_delivery_target(time(4_000)) 45 .await 46 .expect("empty outbox selection"), 47 None 48 ); 49 50 let (work, _, decision) = active_connection(&repository, &configuration).await; 51 let completion = MycNip46CommitRequest::new( 52 &work, 53 Some(&decision), 54 None, 55 connection_time(RECEIVED_AT_MS + 2_001), 56 ) 57 .expect("connection completion"); 58 let (request, signed_bytes) = atomic_response_request(&configuration, &completion); 59 let committed = repository 60 .commit_nip46_response(&request) 61 .await 62 .expect("atomic response and delivery commit"); 63 let job_id = committed.record().response().delivery_job().id(); 64 let primary = MycDeliveryRelayId::new("primary").expect("primary target"); 65 let secondary = MycDeliveryRelayId::new("secondary").expect("secondary target"); 66 let before = repository 67 .read_delivery_job(job_id) 68 .await 69 .expect("initial job read") 70 .expect("initial job"); 71 assert_eq!(before.targets().len(), 2); 72 assert_eq!(before.targets()[0].relay_id(), &primary); 73 assert_eq!(before.targets()[1].relay_id(), &secondary); 74 assert!(before.targets().iter().all(|target| { 75 target.status() == MycDeliveryTargetStatus::Pending && target.attempt_count() == 0 76 })); 77 78 for _ in 0..2 { 79 assert_eq!( 80 repository 81 .next_ready_delivery_target(time(4_000)) 82 .await 83 .expect("two ready targets must select the first"), 84 Some((job_id, primary.clone())) 85 ); 86 } 87 assert_eq!( 88 repository 89 .read_delivery_job(job_id) 90 .await 91 .expect("job after selection") 92 .expect("retained job"), 93 before, 94 "selection must not mutate job or target state" 95 ); 96 97 let first = match repository 98 .claim_delivery_target( 99 job_id, 100 &primary, 101 MycDeliveryAttemptNonce::from_injected_entropy([0xb1; 32]), 102 time(4_000), 103 ) 104 .await 105 .expect("primary claim") 106 { 107 MycDeliveryClaim::Claimed(attempt) => attempt, 108 other => panic!("expected fresh primary claim: {other:?}"), 109 }; 110 assert_eq!( 111 repository 112 .next_ready_delivery_target(time(4_001)) 113 .await 114 .expect("skip leased primary"), 115 Some((job_id, secondary.clone())) 116 ); 117 let second = match repository 118 .claim_delivery_target( 119 job_id, 120 &secondary, 121 MycDeliveryAttemptNonce::from_injected_entropy([0xb2; 32]), 122 time(4_001), 123 ) 124 .await 125 .expect("secondary claim") 126 { 127 MycDeliveryClaim::Claimed(attempt) => attempt, 128 other => panic!("expected fresh secondary claim: {other:?}"), 129 }; 130 assert_eq!( 131 repository 132 .next_ready_delivery_target(time(4_002)) 133 .await 134 .expect("all targets leased"), 135 None 136 ); 137 for (relay, attempt) in [(&primary, &first), (&secondary, &second)] { 138 repository 139 .mark_delivery_attempt_submitted(job_id, relay, attempt.id(), time(4_002)) 140 .await 141 .expect("record synthetic submission evidence"); 142 } 143 assert_eq!( 144 repository 145 .next_ready_delivery_target(time(4_003)) 146 .await 147 .expect("all targets submitted"), 148 None 149 ); 150 repository 151 .record_delivery_attempt_outcome( 152 job_id, 153 &primary, 154 first.id(), 155 MycDeliveryAttemptOutcome::Delivered, 156 MycDeliveryRetryJitter::new(0).expect("zero jitter"), 157 time(4_003), 158 ) 159 .await 160 .expect("synthetic primary acknowledgement"); 161 let retryable = repository 162 .record_delivery_attempt_outcome( 163 job_id, 164 &secondary, 165 second.id(), 166 MycDeliveryAttemptOutcome::TransportFailed, 167 MycDeliveryRetryJitter::new(200).expect("bounded jitter"), 168 time(4_003), 169 ) 170 .await 171 .expect("synthetic retryable secondary outcome"); 172 assert_eq!(retryable.status(), MycDeliveryJobStatus::Active); 173 assert_eq!(retryable.targets()[1].next_attempt_at(), Some(time(4_203))); 174 assert_eq!( 175 repository 176 .next_ready_delivery_target(time(4_202)) 177 .await 178 .expect("retry not yet due"), 179 None 180 ); 181 assert_eq!( 182 repository 183 .next_ready_delivery_target(time(4_203)) 184 .await 185 .expect("retry due at exact boundary"), 186 Some((job_id, secondary.clone())) 187 ); 188 let retry = match repository 189 .claim_delivery_target( 190 job_id, 191 &secondary, 192 MycDeliveryAttemptNonce::from_injected_entropy([0xb3; 32]), 193 time(4_203), 194 ) 195 .await 196 .expect("secondary retry claim") 197 { 198 MycDeliveryClaim::Claimed(attempt) => attempt, 199 other => panic!("expected fresh retry claim: {other:?}"), 200 }; 201 assert_eq!(retry.number(), 2); 202 repository 203 .mark_delivery_attempt_submitted(job_id, &secondary, retry.id(), time(4_204)) 204 .await 205 .expect("record retry submission evidence"); 206 let delivered = repository 207 .record_delivery_attempt_outcome( 208 job_id, 209 &secondary, 210 retry.id(), 211 MycDeliveryAttemptOutcome::Delivered, 212 MycDeliveryRetryJitter::new(0).expect("zero jitter"), 213 time(4_205), 214 ) 215 .await 216 .expect("synthetic retry acknowledgement"); 217 assert_eq!(delivered.status(), MycDeliveryJobStatus::Delivered); 218 assert_eq!( 219 repository 220 .next_ready_delivery_target(time(4_206)) 221 .await 222 .expect("terminal job is ineligible"), 223 None 224 ); 225 let retained = repository 226 .read_nip46_response(job_id) 227 .await 228 .expect("response read") 229 .expect("retained response"); 230 assert_eq!(retained.signed_response_bytes(), signed_bytes); 231 repository 232 .verify_delivery_invariants() 233 .await 234 .expect("delivery invariants after selection and claims"); 235 host.close().await.expect("state close"); 236 237 let reopened = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) 238 .await 239 .expect("reopen state"); 240 let repository = reopened.repository(); 241 assert_eq!( 242 repository 243 .next_ready_delivery_target(time(4_207)) 244 .await 245 .expect("terminal job remains ineligible after reopen"), 246 None 247 ); 248 assert_eq!( 249 repository 250 .read_nip46_response(job_id) 251 .await 252 .expect("reopened response read") 253 .expect("reopened response") 254 .signed_response_bytes(), 255 signed_bytes 256 ); 257 reopened.close().await.expect("reopened state close"); 258 } 259 260 #[tokio::test] 261 async fn ready_target_selection_skips_optional_unknown_at_attempt_ceiling() { 262 let directory = tempfile::tempdir().expect("temporary state root"); 263 let runtime = runtime(directory.path()); 264 fs::create_dir_all(runtime.context().paths().state()).expect("state directory"); 265 fs::set_permissions( 266 runtime.context().paths().state(), 267 fs::Permissions::from_mode(0o700), 268 ) 269 .expect("state directory mode"); 270 let source = include_str!("../contracts/services_hardening/config.v1.example.toml") 271 .replacen( 272 "4444444444444444444444444444444444444444444444444444444444444444", 273 &keys(2).public_key().to_hex(), 274 1, 275 ) 276 .replacen( 277 "2222222222222222222222222222222222222222222222222222222222222222", 278 &keys(3).public_key().to_hex(), 279 1, 280 ) 281 .replacen("required = true", "required = false", 1) 282 .replacen("max_attempts = 5", "max_attempts = 1", 1); 283 let configuration = parse_myc_config_v1(source.as_bytes(), MycConfigProfile::RepoLocal) 284 .expect("one optional target with one attempt"); 285 let metadata = MycStateMetadata::new( 286 &runtime, 287 &configuration, 288 SourceGeneration::new([0x5a; 32]).expect("fixture generation"), 289 RECEIVED_AT_MS, 290 ) 291 .expect("configuration-bound metadata"); 292 let (applied_at, build) = migration_evidence(); 293 initialize_myc_state(&runtime, &metadata, applied_at, &build) 294 .await 295 .expect("state initialization"); 296 let host = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) 297 .await 298 .expect("writable state"); 299 let repository = host.repository(); 300 let (work, _, decision) = active_connection(&repository, &configuration).await; 301 let completion = MycNip46CommitRequest::new( 302 &work, 303 Some(&decision), 304 None, 305 connection_time(RECEIVED_AT_MS + 2_001), 306 ) 307 .expect("connection completion"); 308 let (request, signed_bytes) = atomic_response_request(&configuration, &completion); 309 let committed = repository 310 .commit_nip46_response(&request) 311 .await 312 .expect("atomic response and delivery commit"); 313 let job_id = committed.record().response().delivery_job().id(); 314 let primary = MycDeliveryRelayId::new("primary").expect("optional primary target"); 315 let secondary = MycDeliveryRelayId::new("secondary").expect("required secondary target"); 316 assert_eq!( 317 committed.record().response().delivery_job().max_attempts(), 318 1 319 ); 320 assert!(!committed.record().response().delivery_job().targets()[0].required()); 321 assert!(committed.record().response().delivery_job().targets()[1].required()); 322 let optional = match repository 323 .claim_delivery_target( 324 job_id, 325 &primary, 326 MycDeliveryAttemptNonce::from_injected_entropy([0xc1; 32]), 327 time(4_000), 328 ) 329 .await 330 .expect("optional target claim") 331 { 332 MycDeliveryClaim::Claimed(attempt) => attempt, 333 other => panic!("expected fresh optional claim: {other:?}"), 334 }; 335 repository 336 .mark_delivery_attempt_submitted(job_id, &primary, optional.id(), time(4_001)) 337 .await 338 .expect("record synthetic submission evidence"); 339 let active = repository 340 .record_delivery_attempt_outcome( 341 job_id, 342 &primary, 343 optional.id(), 344 MycDeliveryAttemptOutcome::UnknownAcknowledgement, 345 MycDeliveryRetryJitter::new(0).expect("zero jitter at attempt ceiling"), 346 time(4_002), 347 ) 348 .await 349 .expect("retain synthetic unknown acknowledgement"); 350 assert_eq!(active.status(), MycDeliveryJobStatus::Active); 351 let unknown = active.targets()[0].clone(); 352 assert_eq!(unknown.status(), MycDeliveryTargetStatus::Unknown); 353 assert_eq!(unknown.attempt_count(), 1); 354 assert_eq!(unknown.next_attempt_at(), None); 355 assert!(matches!( 356 repository 357 .claim_delivery_target( 358 job_id, 359 &primary, 360 MycDeliveryAttemptNonce::from_injected_entropy([0xc2; 32]), 361 time(4_003), 362 ) 363 .await 364 .expect("optional target has no remaining attempt"), 365 MycDeliveryClaim::Terminal 366 )); 367 assert_eq!( 368 repository 369 .next_ready_delivery_target(time(4_003)) 370 .await 371 .expect("select claimable required target"), 372 Some((job_id, secondary.clone())), 373 "an optional unknown target at its attempt ceiling must not starve required work" 374 ); 375 let required = match repository 376 .claim_delivery_target( 377 job_id, 378 &secondary, 379 MycDeliveryAttemptNonce::from_injected_entropy([0xc3; 32]), 380 time(4_003), 381 ) 382 .await 383 .expect("required target claim") 384 { 385 MycDeliveryClaim::Claimed(attempt) => attempt, 386 other => panic!("expected fresh required claim: {other:?}"), 387 }; 388 repository 389 .mark_delivery_attempt_submitted(job_id, &secondary, required.id(), time(4_004)) 390 .await 391 .expect("record required submission evidence"); 392 let delivered = repository 393 .record_delivery_attempt_outcome( 394 job_id, 395 &secondary, 396 required.id(), 397 MycDeliveryAttemptOutcome::Delivered, 398 MycDeliveryRetryJitter::new(0).expect("zero jitter"), 399 time(4_005), 400 ) 401 .await 402 .expect("synthetic required acknowledgement"); 403 assert_eq!(delivered.status(), MycDeliveryJobStatus::Delivered); 404 assert_eq!(delivered.targets()[0], unknown); 405 repository 406 .verify_delivery_invariants() 407 .await 408 .expect("delivery invariants retain the optional unknown evidence"); 409 host.close().await.expect("state close"); 410 411 let reopened = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) 412 .await 413 .expect("reopen state"); 414 let repository = reopened.repository(); 415 let retained = repository 416 .read_delivery_job(job_id) 417 .await 418 .expect("reopened job read") 419 .expect("retained job"); 420 assert_eq!(retained.status(), MycDeliveryJobStatus::Delivered); 421 assert_eq!(retained.targets()[0], unknown); 422 assert_eq!( 423 repository 424 .read_delivery_attempts(job_id, &primary) 425 .await 426 .expect("retained optional attempt") 427 .len(), 428 1 429 ); 430 assert_eq!( 431 repository 432 .read_nip46_response(job_id) 433 .await 434 .expect("reopened response read") 435 .expect("retained response") 436 .signed_response_bytes(), 437 signed_bytes 438 ); 439 reopened.close().await.expect("reopened state close"); 440 }