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 }