lib

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

native_stock_rewrap_tests.rs (22348B)


      1 //! Ordinary explicit wrapping and exact recovery use the real protected owner.
      2 use super::*;
      3 fn peer_index(r: &Rig, status: &crate::orders::AcceptanceStatus) -> usize {
      4     status
      5         .recipients()
      6         .iter()
      7         .position(|entry| entry.recipient != r.enrollment.input().participant())
      8         .unwrap()
      9 }
     10 #[tokio::test]
     11 async fn ordinary_rewrap_is_explicit_preserves_originals_and_resumes_exact_bytes_without_signing() {
     12     let r = Rig::new().await;
     13     let (command, initial) = r.accept().await;
     14     let index = peer_index(&r, &initial);
     15     let recipient = initial.recipients()[index].recipient;
     16     let original = initial.delivery().unwrap()[index].source().unwrap();
     17     let id = OperationId::from_bytes([71; 32]);
     18     let (_, _, minimum) = r.minima().await;
     19     r.io.missing_ack.store(true, Ordering::SeqCst);
     20     let first = r
     21         .client
     22         .orders(&r.scope)
     23         .rewrap_acceptance(
     24             minimum,
     25             command.context().operation_id(),
     26             command.digest(),
     27             recipient,
     28             id,
     29         )
     30         .await
     31         .unwrap();
     32     let state = first.state().unwrap();
     33     let outer = state.envelope().unwrap();
     34     assert_eq!(state.admission().original(), original);
     35     assert_ne!(outer.event_id(), original.event_id());
     36     assert_eq!(outer.evidence(), original.evidence());
     37     assert_eq!(
     38         outer.installation_transaction_id(),
     39         original.installation_transaction_id()
     40     );
     41     let summary = first.delivery().unwrap();
     42     assert_eq!(summary.attempt_count(), 2);
     43     assert_eq!(summary.selected_attempt_count(), 1);
     44     assert!(!summary.acceptance_satisfied().unwrap());
     45     assert_eq!(summary.publication_policy_source(), Some(original));
     46     assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
     47     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
     48     let sent = r.io.sent.lock().unwrap().clone();
     49     assert_eq!(sent.len(), 3);
     50     let raw = sent[2].clone();
     51     let repeated = r
     52         .client
     53         .orders(&r.scope)
     54         .rewrap_acceptance(
     55             minimum,
     56             command.context().operation_id(),
     57             command.digest(),
     58             recipient,
     59             id,
     60         )
     61         .await
     62         .unwrap();
     63     assert_eq!(repeated.state(), Some(state));
     64     assert_eq!(r.io.sent.lock().unwrap().len(), 3);
     65     assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
     66     let observed = r
     67         .client
     68         .orders(&r.scope)
     69         .acceptance_status(minimum, command.context().operation_id(), command.digest())
     70         .await
     71         .unwrap();
     72     assert_eq!(observed.installation(), initial.installation());
     73     let old = &observed.delivery().unwrap()[index];
     74     assert_eq!(old.source(), Some(original));
     75     assert_eq!(old.attempt_count(), 2);
     76     assert_eq!(old.selected_attempt_count(), 1);
     77     assert!(old.acceptance_satisfied().unwrap());
     78     let read = r
     79         .client
     80         .orders(&r.scope)
     81         .acceptance_rewrap_status(
     82             minimum,
     83             command.context().operation_id(),
     84             command.digest(),
     85             recipient,
     86             id,
     87         )
     88         .await
     89         .unwrap();
     90     assert_eq!(read.state(), Some(state));
     91     assert_eq!(r.io.sent.lock().unwrap().len(), 3);
     92     r.io.missing_ack.store(false, Ordering::SeqCst);
     93     let resumed = r
     94         .client
     95         .orders(&r.scope)
     96         .resume_acceptance_rewrap(
     97             minimum,
     98             command.context().operation_id(),
     99             command.digest(),
    100             recipient,
    101             id,
    102         )
    103         .await
    104         .unwrap();
    105     assert_eq!(resumed.state(), Some(state));
    106     assert_eq!(resumed.delivery().unwrap().attempt_count(), 3);
    107     assert_eq!(resumed.delivery().unwrap().selected_attempt_count(), 2);
    108     assert!(resumed.delivery().unwrap().acceptance_satisfied().unwrap());
    109     assert_eq!(r.io.sent.lock().unwrap()[3], raw);
    110     assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
    111     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    112     r.client.close().await.unwrap();
    113 }
    114 
    115 async fn fault_connection(r: &Rig) -> sqlx::SqliteConnection {
    116     use sqlx::Connection;
    117     let path = r._temp.path().join("stock/stock_execution_v1.sqlite");
    118     sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display()))
    119         .await
    120         .unwrap()
    121 }
    122 async fn original_entries(c: &mut sqlx::SqliteConnection) -> (Vec<Vec<u8>>, Vec<Vec<u8>>) {
    123     let outers = sqlx::query_scalar("SELECT entry_id FROM stock_envelopes ORDER BY entry_id")
    124         .fetch_all(&mut *c)
    125         .await
    126         .unwrap();
    127     let seals = sqlx::query_scalar("SELECT entry_id FROM stock_signing_evidence ORDER BY entry_id")
    128         .fetch_all(c)
    129         .await
    130         .unwrap();
    131     (outers, seals)
    132 }
    133 
    134 #[tokio::test]
    135 async fn obtained_rewrap_survives_statement_and_commit_failure_and_clockless_failed_close() {
    136     use sqlx::Connection;
    137     for uncertain in [false, true] {
    138         let r = Rig::new().await;
    139         let (command, initial) = r.accept().await;
    140         let recipient = initial.recipients()[peer_index(&r, &initial)].recipient;
    141         let (_, _, minimum) = r.minima().await;
    142         let mut fault = fault_connection(&r).await;
    143         let originals = original_entries(&mut fault).await;
    144         if uncertain {
    145             sqlx::raw_sql("CREATE TABLE rewrap_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_failure AFTER INSERT ON stock_rewraps BEGIN INSERT INTO rewrap_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap();
    146         } else {
    147             sqlx::query("CREATE TRIGGER controlled_rewrap_failure BEFORE INSERT ON stock_rewraps BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_failure'); END").execute(&mut fault).await.unwrap();
    148         }
    149         let error = r
    150             .client
    151             .orders(&r.scope)
    152             .rewrap_acceptance(
    153                 minimum,
    154                 command.context().operation_id(),
    155                 command.digest(),
    156                 recipient,
    157                 OperationId::from_bytes([72; 32]),
    158             )
    159             .await
    160             .unwrap_err();
    161         assert_eq!(
    162             error.code(),
    163             if uncertain {
    164                 crate::Code::RecoveryRequired
    165             } else {
    166                 crate::Code::StorageFailure
    167             }
    168         );
    169         assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
    170         assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    171         assert_eq!(r.io.sent.lock().unwrap().len(), 2);
    172         r.clock.0.store(0, Ordering::SeqCst);
    173         assert!(r.client.close().await.is_err());
    174         assert!(r.provider.upgrade().is_some());
    175         sqlx::raw_sql(
    176             "DROP TRIGGER controlled_rewrap_failure; DROP TABLE IF EXISTS rewrap_deferred_fault",
    177         )
    178         .execute(&mut fault)
    179         .await
    180         .unwrap();
    181         r.client.close().await.unwrap();
    182         assert!(r.provider.upgrade().is_none());
    183         assert_eq!(original_entries(&mut fault).await, originals);
    184         let counts: (i64, i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_rewrap_admissions),(SELECT count(*) FROM stock_rewraps)").fetch_one(&mut fault).await.unwrap();
    185         assert_eq!(counts, (1, 1));
    186         assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
    187         assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    188         assert_eq!(r.io.sent.lock().unwrap().len(), 2);
    189         fault.close().await.unwrap();
    190     }
    191 }
    192 
    193 #[tokio::test]
    194 async fn failed_rewrap_admission_repairs_without_a_key_or_renewed_invocation() {
    195     use sqlx::Connection;
    196     for uncertain in [false, true] {
    197         let r = Rig::new().await;
    198         let (command, initial) = r.accept().await;
    199         let recipient = initial.recipients()[peer_index(&r, &initial)].recipient;
    200         let (_, _, minimum) = r.minima().await;
    201         let id = OperationId::from_bytes([73; 32]);
    202         let mut fault = fault_connection(&r).await;
    203         let originals = original_entries(&mut fault).await;
    204         if uncertain {
    205             sqlx::raw_sql("CREATE TABLE admission_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_admission_failure AFTER INSERT ON stock_rewrap_admissions BEGIN INSERT INTO admission_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap();
    206         } else {
    207             sqlx::query("CREATE TRIGGER controlled_admission_failure BEFORE INSERT ON stock_rewrap_admissions BEGIN SELECT RAISE(ABORT, 'controlled_admission_failure'); END").execute(&mut fault).await.unwrap();
    208         }
    209         let error = r
    210             .client
    211             .orders(&r.scope)
    212             .rewrap_acceptance(
    213                 minimum,
    214                 command.context().operation_id(),
    215                 command.digest(),
    216                 recipient,
    217                 id,
    218             )
    219             .await
    220             .unwrap_err();
    221         assert_eq!(
    222             error.code(),
    223             if uncertain {
    224                 crate::Code::RecoveryRequired
    225             } else {
    226                 crate::Code::StorageFailure
    227             }
    228         );
    229         r.clock.0.store(0, Ordering::SeqCst);
    230         sqlx::raw_sql("DROP TRIGGER controlled_admission_failure; DROP TABLE IF EXISTS admission_deferred_fault").execute(&mut fault).await.unwrap();
    231         // Restore the exact catalog before uncertain-connection reopen. Repair
    232         // then resolves only the original writer fence, without a current clock,
    233         // a fresh admission or an invocation right.
    234         r.client.stock(&r.scope).drain_evidence().await.unwrap();
    235         r.clock.0.store(150, Ordering::SeqCst);
    236         let view = r
    237             .client
    238             .orders(&r.scope)
    239             .resume_acceptance_rewrap(
    240                 minimum,
    241                 command.context().operation_id(),
    242                 command.digest(),
    243                 recipient,
    244                 id,
    245             )
    246             .await
    247             .unwrap();
    248         assert!(view.state().is_none());
    249         assert!(view.delivery().is_none());
    250         assert_eq!(original_entries(&mut fault).await, originals);
    251         assert_eq!(r.io.wraps.load(Ordering::SeqCst), 2);
    252         assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    253         assert_eq!(r.io.sent.lock().unwrap().len(), 2);
    254         r.client.close().await.unwrap();
    255         fault.close().await.unwrap();
    256     }
    257 }
    258 
    259 #[tokio::test]
    260 async fn obtained_rewrap_delivery_survives_lost_waiter_commit_failure_and_clock_loss() {
    261     use sqlx::Connection;
    262     for uncertain in [false, true] {
    263         let r = Rig::new().await;
    264         let (command, initial) = r.accept().await;
    265         let recipient = initial.recipients()[peer_index(&r, &initial)].recipient;
    266         let (_, _, minimum) = r.minima().await;
    267         r.io.pause_delivery.store(true, Ordering::SeqCst);
    268         let client = r.client.clone();
    269         let scope = r.scope.clone();
    270         let waiter = tokio::spawn(async move {
    271             client
    272                 .orders(&scope)
    273                 .rewrap_acceptance(
    274                     minimum,
    275                     command.context().operation_id(),
    276                     command.digest(),
    277                     recipient,
    278                     OperationId::from_bytes([74; 32]),
    279                 )
    280                 .await
    281         });
    282         tokio::time::timeout(std::time::Duration::from_secs(120), r.io.entered.notified())
    283             .await
    284             .unwrap();
    285         waiter.abort();
    286         assert!(waiter.await.unwrap_err().is_cancelled());
    287         let mut fault = fault_connection(&r).await;
    288         let originals = original_entries(&mut fault).await;
    289         let attempts: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as(
    290             "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id",
    291         )
    292         .fetch_all(&mut fault)
    293         .await
    294         .unwrap();
    295         let observations: i64 =
    296             sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations")
    297                 .fetch_one(&mut fault)
    298                 .await
    299                 .unwrap();
    300         if uncertain {
    301             sqlx::raw_sql("CREATE TABLE rewrap_observation_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_observation AFTER INSERT ON stock_delivery_observations BEGIN INSERT INTO rewrap_observation_fault VALUES(2); END").execute(&mut fault).await.unwrap();
    302         } else {
    303             sqlx::query("CREATE TRIGGER controlled_rewrap_observation BEFORE INSERT ON stock_delivery_observations BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_observation'); END").execute(&mut fault).await.unwrap();
    304         }
    305         r.clock.0.store(0, Ordering::SeqCst);
    306         r.io.release.notify_one();
    307         let error = r.client.close().await.unwrap_err();
    308         assert_eq!(
    309             error.code(),
    310             if uncertain {
    311                 crate::Code::RecoveryRequired
    312             } else {
    313                 crate::Code::StorageFailure
    314             }
    315         );
    316         assert!(r.provider.upgrade().is_some());
    317         sqlx::raw_sql("DROP TRIGGER controlled_rewrap_observation; DROP TABLE IF EXISTS rewrap_observation_fault").execute(&mut fault).await.unwrap();
    318         r.client.close().await.unwrap();
    319         assert!(r.provider.upgrade().is_none());
    320         assert_eq!(original_entries(&mut fault).await, originals);
    321         let actual: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as(
    322             "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id",
    323         )
    324         .fetch_all(&mut fault)
    325         .await
    326         .unwrap();
    327         assert_eq!(actual, attempts);
    328         let actual: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations")
    329             .fetch_one(&mut fault)
    330             .await
    331             .unwrap();
    332         assert_eq!(actual, observations + 1);
    333         assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
    334         assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    335         assert_eq!(r.io.sent.lock().unwrap().len(), 3);
    336         fault.close().await.unwrap();
    337     }
    338 }
    339 
    340 #[tokio::test]
    341 async fn rewrap_loopback_scopes_partial_acknowledgement_and_retries_exact_bytes_without_signing() {
    342     use futures::{SinkExt, StreamExt};
    343     use radroots_transport_nostr::{
    344         Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
    345     };
    346     use std::time::{Duration, SystemTime, UNIX_EPOCH};
    347     use tokio_tungstenite::{accept_async, tungstenite::Message};
    348     async fn relay(listener: tokio::net::TcpListener, partial: bool) -> Vec<String> {
    349         let (tcp, _) = listener.accept().await.unwrap();
    350         let mut socket = accept_async(tcp).await.unwrap();
    351         let mut frames = Vec::new();
    352         for index in 0..if partial { 2 } else { 1 } {
    353             let frame = tokio::time::timeout(Duration::from_secs(300), async {
    354                 loop {
    355                     if let Message::Text(raw) = socket.next().await.unwrap().unwrap() {
    356                         let event: serde_json::Value = serde_json::from_str(&raw).unwrap();
    357                         if event[0] == "EVENT" {
    358                             break (raw.to_string(), event[1]["id"].clone());
    359                         }
    360                     }
    361                 }
    362             })
    363             .await
    364             .unwrap();
    365             socket
    366                 .send(Message::Text(
    367                     serde_json::json!(["OK", "ff".repeat(32), true, ""])
    368                         .to_string()
    369                         .into(),
    370                 ))
    371                 .await
    372                 .unwrap();
    373             socket
    374                 .send(Message::Text(
    375                     serde_json::json!(["OK", frame.1, !partial || index > 0, ""])
    376                         .to_string()
    377                         .into(),
    378                 ))
    379                 .await
    380                 .unwrap();
    381             frames.push(frame.0);
    382         }
    383         // Keep the accepted relay connected through the second invocation, so
    384         // skipping it is actual target selection rather than disconnect luck.
    385         if !partial {
    386             while let Some(message) = socket.next().await {
    387                 match message.unwrap() {
    388                     Message::Text(raw) => {
    389                         let value: serde_json::Value = serde_json::from_str(&raw).unwrap();
    390                         assert_ne!(value[0], "EVENT", "accepted target must not be retried");
    391                     }
    392                     Message::Close(_) => break,
    393                     _ => {}
    394                 }
    395             }
    396         }
    397         frames
    398     }
    399     let first = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    400     let second = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    401     let uris = vec![
    402         format!("ws://{}", first.local_addr().unwrap()),
    403         format!("ws://{}", second.local_addr().unwrap()),
    404     ];
    405     let now = SystemTime::now()
    406         .duration_since(UNIX_EPOCH)
    407         .unwrap()
    408         .as_secs();
    409     let r = Rig::configured(Some(uris.clone()), now + 1800).await;
    410     r.io.missing_ack.store(true, Ordering::SeqCst);
    411     let (command, initial) = r.accept().await;
    412     let index = peer_index(&r, &initial);
    413     let recipient = initial.recipients()[index].recipient;
    414     let original = initial.delivery().unwrap()[index].source().unwrap();
    415     let originals = r.io.sent.lock().unwrap().clone();
    416     let accepted = tokio::spawn(relay(first, false));
    417     let partial = tokio::spawn(relay(second, true));
    418     let config = Config::from_profile(
    419         RelayProfile::explicit(
    420             RelayProfileKind::Simulator,
    421             uris.iter().map(|uri| {
    422                 RelayEndpoint::new(uri, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()
    423             }),
    424         )
    425         .unwrap(),
    426     )
    427     .with_timeouts(1000, 1000, 500)
    428     .unwrap();
    429     let transport = Arc::new(radroots_transport_nostr_native::create_transport(config));
    430     *r.io.transport.lock().unwrap() = Some(transport.clone());
    431     r.clock.enable_realtime();
    432     let (_, _, minimum) = r.minima().await;
    433     let grant = StockGrantEnrollment::prepare(
    434         &SellerAuthoritySelection::from_attachment(r.enrollment.input()),
    435         "explicit wrapping recovery".into(),
    436         UnixSeconds::new(now + 1500).unwrap(),
    437         StockGrantScope::full_inventory(),
    438     )
    439     .unwrap();
    440     r.native
    441         .enroll_stock_grant(
    442             r.scope.binding().clone(),
    443             minimum,
    444             r.enrollment.proof(),
    445             &grant,
    446         )
    447         .await
    448         .unwrap();
    449     let (_, _, minimum) = r.minima().await;
    450     let capture = StockConsentCapture::prepare(
    451         SellerAuthoritySelection::from_attachment(r.enrollment.input()),
    452         grant.input().grant_id(),
    453         StockConsentMode::RecoverOnly,
    454         StockResources::all_pools(),
    455         UnixSeconds::new(now + 1200).unwrap(),
    456         CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(),
    457     )
    458     .unwrap();
    459     r.native
    460         .issue_stock_consent(
    461             r.scope.binding().clone(),
    462             minimum,
    463             &capture,
    464             r.enrollment.proof(),
    465         )
    466         .await
    467         .unwrap();
    468     let (_, _, minimum) = r.minima().await;
    469     let recovery = r
    470         .client
    471         .attach(grant.input().clone(), proof(grant.proof()))
    472         .await
    473         .unwrap();
    474     let id = OperationId::from_bytes([75; 32]);
    475     let first = r
    476         .client
    477         .orders(&recovery)
    478         .rewrap_acceptance(
    479             minimum,
    480             command.context().operation_id(),
    481             command.digest(),
    482             recipient,
    483             id,
    484         )
    485         .await
    486         .unwrap();
    487     let state = first.state().unwrap();
    488     let summary = first.delivery().unwrap();
    489     assert_eq!(state.admission().original(), original);
    490     assert_eq!(summary.attempt_count(), 2);
    491     assert_eq!(summary.selected_attempt_count(), 1);
    492     assert!(!summary.acceptance_satisfied().unwrap());
    493     assert_eq!(summary.targets().iter().filter(|v| v.accepted()).count(), 1);
    494     let repeated = r
    495         .client
    496         .orders(&recovery)
    497         .rewrap_acceptance(
    498             minimum,
    499             command.context().operation_id(),
    500             command.digest(),
    501             recipient,
    502             id,
    503         )
    504         .await
    505         .unwrap();
    506     assert_eq!(repeated.state(), Some(state));
    507     assert_eq!(r.io.sent.lock().unwrap().len(), 3);
    508     let resumed = r
    509         .client
    510         .orders(&recovery)
    511         .resume_acceptance_rewrap(
    512             minimum,
    513             command.context().operation_id(),
    514             command.digest(),
    515             recipient,
    516             id,
    517         )
    518         .await
    519         .unwrap();
    520     assert_eq!(resumed.state(), Some(state));
    521     let summary = resumed.delivery().unwrap();
    522     assert_eq!(summary.attempt_count(), 3);
    523     assert_eq!(summary.selected_attempt_count(), 2);
    524     assert!(summary.acceptance_satisfied().unwrap());
    525     let mut counts: Vec<_> = summary
    526         .targets()
    527         .iter()
    528         .map(|v| v.potential_attempts())
    529         .collect();
    530     counts.sort();
    531     assert_eq!(counts, [2, 3]);
    532     let observed = r
    533         .client
    534         .orders(&recovery)
    535         .acceptance_status(minimum, command.context().operation_id(), command.digest())
    536         .await
    537         .unwrap();
    538     assert_eq!(observed.installation(), initial.installation());
    539     let old = &observed.delivery().unwrap()[index];
    540     assert_eq!(old.source(), Some(original));
    541     assert_eq!(old.selected_attempt_count(), 1);
    542     assert!(!old.acceptance_satisfied().unwrap());
    543     let sent = r.io.sent.lock().unwrap().clone();
    544     assert_eq!(&sent[..2], originals.as_slice());
    545     assert_eq!(sent[2], sent[3]);
    546     assert!(!originals.contains(&sent[2]));
    547     assert_eq!(r.control.signs.load(Ordering::SeqCst), 2);
    548     assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3);
    549     transport.shutdown().await;
    550     let accepted = tokio::time::timeout(Duration::from_secs(10), accepted)
    551         .await
    552         .unwrap()
    553         .unwrap();
    554     let partial = tokio::time::timeout(Duration::from_secs(10), partial)
    555         .await
    556         .unwrap()
    557         .unwrap();
    558     assert_eq!(accepted.len(), 1);
    559     assert_eq!(partial.len(), 2);
    560     assert_eq!(accepted[0], partial[0]);
    561     assert_eq!(partial[0], partial[1]);
    562     assert_eq!(accepted[0], format!("[\"EVENT\",{}]", sent[2]));
    563     r.client.close().await.unwrap();
    564 }