myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

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 }