lib

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

fetch_windows.rs (5798B)


      1 use futures::{SinkExt, StreamExt};
      2 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp};
      3 use radroots_transport::{
      4     EventSource, FetchRequest, TargetSet,
      5     outcome::FetchTargetState,
      6     source::{FetchBounds, NextPage},
      7 };
      8 use radroots_transport_nostr::{
      9     Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
     10 };
     11 use serde_json::Value;
     12 use std::{
     13     collections::BTreeSet,
     14     sync::{
     15         Arc,
     16         atomic::{AtomicUsize, Ordering},
     17     },
     18     time::{Duration, SystemTime, UNIX_EPOCH},
     19 };
     20 use tokio::net::TcpListener;
     21 use tokio_tungstenite::{accept_async, tungstenite::Message};
     22 
     23 #[tokio::test(flavor = "multi_thread")]
     24 async fn real_capped_eose_preserves_received_ties_and_yields_explicit_older_history() {
     25     let keys =
     26         Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap();
     27     let mut history = (0..1001)
     28         .map(|index| {
     29             let event = EventBuilder::new(Kind::TextNote, format!("equal-time {index}"))
     30                 .custom_created_at(Timestamp::from_secs(100))
     31                 .finalize(&keys)
     32                 .unwrap();
     33             serde_json::from_str::<Value>(&event.as_json()).unwrap()
     34         })
     35         .collect::<Vec<_>>();
     36     history.sort_by(|left, right| right["id"].as_str().cmp(&left["id"].as_str()));
     37     let expected = history[..1000]
     38         .iter()
     39         .map(|event| event["id"].as_str().unwrap().to_owned())
     40         .collect::<BTreeSet<_>>();
     41     let older = EventBuilder::new(Kind::TextNote, "older")
     42         .custom_created_at(Timestamp::from_secs(99))
     43         .finalize(&keys)
     44         .unwrap();
     45     history.push(serde_json::from_str(&older.as_json()).unwrap());
     46     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     47     let url = format!("ws://{}", listener.local_addr().unwrap());
     48     let calls = Arc::new(AtomicUsize::new(0));
     49     let server_calls = calls.clone();
     50     let server = tokio::spawn(async move {
     51         let (stream, _) = listener.accept().await.unwrap();
     52         let mut socket = accept_async(stream).await.unwrap();
     53         while let Some(Ok(message)) = socket.next().await {
     54             let Message::Text(message) = message else {
     55                 continue;
     56             };
     57             let request: Value = serde_json::from_str(&message).unwrap();
     58             if request[0] != "REQ" {
     59                 continue;
     60             }
     61             server_calls.fetch_add(1, Ordering::SeqCst);
     62             assert_eq!(request[2]["limit"], 1000);
     63             let until = request[2]["until"].as_u64().unwrap_or(u64::MAX);
     64             for event in history
     65                 .iter()
     66                 .filter(|event| event["created_at"].as_u64().unwrap() <= until)
     67                 .take(1000)
     68             {
     69                 socket
     70                     .send(Message::Text(
     71                         serde_json::to_string(&("EVENT", &request[1], event))
     72                             .unwrap()
     73                             .into(),
     74                     ))
     75                     .await
     76                     .unwrap();
     77             }
     78             socket
     79                 .send(Message::Text(
     80                     serde_json::to_string(&("EOSE", &request[1]))
     81                         .unwrap()
     82                         .into(),
     83                 ))
     84                 .await
     85                 .unwrap();
     86         }
     87     });
     88     let profile = RelayProfile::explicit(
     89         RelayProfileKind::Simulator,
     90         [RelayEndpoint::new(&url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()],
     91     )
     92     .unwrap();
     93     let config = Config::from_profile(profile)
     94         .with_timeouts(5000, 5000, 500)
     95         .unwrap();
     96     let targets = TargetSet::new(
     97         config
     98             .read_relays()
     99             .map(|relay| relay.to_target().unwrap())
    100             .collect(),
    101     )
    102     .unwrap();
    103     let transport = radroots_transport_nostr_native::create_transport(config);
    104     let deadline = SystemTime::now()
    105         .duration_since(UNIX_EPOCH)
    106         .unwrap()
    107         .as_millis() as u64
    108         + 20000;
    109     let request = FetchRequest::new(
    110         "live-capped-window",
    111         targets,
    112         FetchBounds::new(500, deadline).unwrap(),
    113     )
    114     .unwrap();
    115     tokio::time::timeout(Duration::from_secs(15), async {
    116         let first = transport.fetch(request.clone()).await.unwrap();
    117         assert_eq!(first.events().len(), 500);
    118         assert_eq!(
    119             first.target_outcomes()[0].state(),
    120             FetchTargetState::Partial
    121         );
    122         let NextPage::Cursor(cursor) = first.next_page() else {
    123             panic!("received peers remain")
    124         };
    125         let second = transport
    126             .fetch(request.clone().with_cursor(cursor.clone()))
    127             .await
    128             .unwrap();
    129         assert_eq!(second.events().len(), 500);
    130         assert_eq!(
    131             second.target_outcomes()[0].state(),
    132             FetchTargetState::Partial
    133         );
    134         assert_eq!(calls.load(Ordering::SeqCst), 2);
    135         let received = first
    136             .events()
    137             .iter()
    138             .chain(second.events())
    139             .map(|e| e.event().id_str().to_owned())
    140             .collect::<BTreeSet<_>>();
    141         assert_eq!(received, expected);
    142         let NextPage::Cancelled {
    143             resume_from: Some(older),
    144         } = second.next_page()
    145         else {
    146             panic!("explicit partial window yield")
    147         };
    148         let third = transport
    149             .fetch(request.with_cursor(older.clone()))
    150             .await
    151             .unwrap();
    152         assert_eq!(third.events().len(), 1);
    153         assert_eq!(third.events()[0].event().created_at(), 99);
    154         assert!(matches!(third.next_page(), NextPage::Complete));
    155         assert_eq!(calls.load(Ordering::SeqCst), 3);
    156     })
    157     .await
    158     .unwrap();
    159     server.abort();
    160 }