source_original_tests.rs (10385B)
1 use super::*; 2 use crate::RelayUrlPolicy; 3 use futures::SinkExt; 4 use radroots_transport::{ 5 EventSubscriber, FetchRequest, SubscriptionNext, SubscriptionRequest, Target, TargetSet, 6 source::{FetchBounds, FetchSelector, SubscriptionBounds}, 7 }; 8 use tokio_tungstenite::{accept_async, tungstenite::Message}; 9 10 async fn observed_wire(original: String, live: bool) -> String { 11 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 12 let url = format!("ws://{}", listener.local_addr().unwrap()); 13 let endpoint = 14 crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly) 15 .unwrap(); 16 let profile = 17 crate::RelayProfile::explicit(crate::RelayProfileKind::Simulator, [endpoint]).unwrap(); 18 let transport = crate::test_host::transport(crate::Config::from_profile(profile)); 19 let server = tokio::spawn(async move { 20 let (tcp, _) = listener.accept().await.unwrap(); 21 let mut socket = accept_async(tcp).await.unwrap(); 22 while let Some(Ok(frame)) = socket.next().await { 23 match frame { 24 Message::Text(text) => { 25 let value: serde_json::Value = serde_json::from_str(&text).unwrap(); 26 if value[0] == "REQ" { 27 socket 28 .send(Message::Text( 29 format!("[\"EVENT\",{},{}]", value[1], original).into(), 30 )) 31 .await 32 .unwrap(); 33 socket 34 .send(Message::Text( 35 serde_json::json!(["EOSE", value[1]]).to_string().into(), 36 )) 37 .await 38 .unwrap(); 39 } 40 } 41 Message::Close(_) => break, 42 _ => { 43 if socket.flush().await.is_err() { 44 break; 45 } 46 } 47 } 48 } 49 }); 50 let targets = TargetSet::new(vec![Target::nostr_relay(&url).unwrap()]).unwrap(); 51 let obtained = if live { 52 let request = SubscriptionRequest::new( 53 "original-protected-live", 54 targets, 55 SubscriptionBounds::new(10, crate::host_time::unix_time_ms() + 5000).unwrap(), 56 ) 57 .unwrap(); 58 let mut subscription = transport.subscribe(request).await.unwrap(); 59 let SubscriptionNext::Event(observed) = subscription.next().await.unwrap() else { 60 panic!("Expected original live event"); 61 }; 62 let original = observed.observed().event().raw_json().to_owned(); 63 subscription.cancel().await.unwrap(); 64 original 65 } else { 66 let request = FetchRequest::new( 67 "original-protected-caller", 68 targets, 69 FetchBounds::new(10, crate::host_time::unix_time_ms() + 5000).unwrap(), 70 ) 71 .unwrap(); 72 let page = transport.fetch(request).await.unwrap(); 73 assert_eq!(page.events().len(), 1); 74 page.events()[0].event().raw_json().to_owned() 75 }; 76 transport.shutdown().await; 77 server.await.unwrap(); 78 obtained 79 } 80 81 #[tokio::test] 82 async fn ordinary_source_preserves_originals_through_protected_commerce_admission() { 83 use radroots_nostr::{ 84 commerce::{self, RecordOpening}, 85 key::SecretKey, 86 private_ingress::OpeningError, 87 signing::LocalSigner, 88 }; 89 use radroots_signing::provider::ProviderCall; 90 tokio::time::timeout(Duration::from_secs(15), async { 91 let fixture: serde_json::Value = 92 serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json")) 93 .unwrap(); 94 let base: serde_json::Value = 95 serde_json::from_str(fixture["raw_wrap"].as_str().unwrap()).unwrap(); 96 let scalar = fixture["recipient_scalar"].as_u64().unwrap(); 97 let signer = 98 LocalSigner::with_clock(SecretKey::parse(&format!("{scalar:064x}")).unwrap(), || { 99 Ok(1000) 100 }) 101 .unwrap(); 102 for (live, extension) in [(false, false), (false, true), (true, false), (true, true)] { 103 let mut body = base.clone(); 104 if extension { 105 body["future_transport_extension"] = serde_json::json!(true); 106 } 107 let original = serde_json::to_string_pretty(&body).unwrap(); 108 let obtained = observed_wire(original.clone(), live).await; 109 assert!( 110 obtained == original, 111 "Ordinary observed SignedEvent must retain exact original object bytes" 112 ); 113 let call = ProviderCall::new( 114 signer.public_key(), 115 core::num::NonZeroU64::new(2000).unwrap(), 116 radroots_signing::request::CancellationSignal::new(), 117 ); 118 let result = commerce::open(&signer, call, &obtained).await; 119 if extension { 120 assert_eq!(result.unwrap_err(), OpeningError::InvalidInput); 121 } else { 122 assert!(matches!(result.unwrap(), RecordOpening::Known(_))); 123 } 124 } 125 }) 126 .await 127 .unwrap(); 128 } 129 130 #[tokio::test] 131 async fn ordinary_source_delivers_large_original_profiles_to_authenticated_public_heads() { 132 use radroots_nostr::public_ingress::{Interpretation, ObservedHead}; 133 use radroots_protocol::advertisement::UnixSeconds; 134 tokio::time::timeout(Duration::from_secs(15), async { 135 let fixture: serde_json::Value = 136 serde_json::from_str(include_str!("../tests/fixtures/public_large.v1.json")).unwrap(); 137 let raw = fixture["raw"].as_str().unwrap(); 138 assert_eq!(raw.len(), 65536); 139 for live in [false, true] { 140 let obtained = observed_wire(raw.into(), live).await; 141 assert!( 142 obtained == raw, 143 "Original large profile must survive ordinary transport observation" 144 ); 145 let mut head = ObservedHead::listing( 146 fixture["author"].as_str().unwrap().parse().unwrap(), 147 fixture["d"].as_str().unwrap(), 148 ) 149 .unwrap(); 150 head.observe(&obtained).unwrap(); 151 let Some(Interpretation::Listing(value)) = 152 head.interpret(UnixSeconds::new(150).unwrap()) 153 else { 154 panic!("Expected complete authenticated observed listing"); 155 }; 156 let terms = serde_json::to_value(value.listing().terms()).unwrap(); 157 assert_eq!( 158 terms["product"]["description"].as_str().unwrap().len(), 159 4000 160 ); 161 assert_eq!(head.raw_json(), Some(raw)); 162 } 163 }) 164 .await 165 .unwrap(); 166 } 167 168 #[tokio::test] 169 async fn live_fetch_retains_original_signed_outer_object_bytes() { 170 tokio::time::timeout(Duration::from_secs(10), async { 171 let fixture: serde_json::Value = 172 serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json")) 173 .unwrap(); 174 let value: serde_json::Value = 175 serde_json::from_str(fixture["raw_wrap"].as_str().unwrap()).unwrap(); 176 let original = serde_json::to_string_pretty(&value).unwrap(); 177 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 178 let url = format!("ws://{}", listener.local_addr().unwrap()); 179 let endpoint = 180 crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly) 181 .unwrap(); 182 let connector = crate::session_socket::SessionWebsocketTransport::new( 183 &[endpoint], 184 Duration::from_secs(1), 185 Arc::new(crate::test_host::LoopbackConnector), 186 ); 187 let ingress = connector.ingress.clone(); 188 let client = nostr_sdk::client::Client::builder() 189 .websocket_transport(connector) 190 .build(); 191 let server_original = original.clone(); 192 let server = tokio::spawn(async move { 193 let (tcp, _) = listener.accept().await.unwrap(); 194 let mut socket = accept_async(tcp).await.unwrap(); 195 while let Some(frame) = socket.next().await { 196 let Ok(frame) = frame else { break }; 197 match frame { 198 Message::Text(text) => { 199 let value: serde_json::Value = serde_json::from_str(&text).unwrap(); 200 if value[0] == "REQ" { 201 let frame = format!("[\"EVENT\",{},{}]", value[1], server_original); 202 socket.send(Message::Text(frame.into())).await.unwrap(); 203 socket 204 .send(Message::Text( 205 serde_json::json!(["EOSE", value[1]]).to_string().into(), 206 )) 207 .await 208 .unwrap(); 209 } 210 } 211 Message::Close(_) => break, 212 _ => { 213 socket.flush().await.unwrap(); 214 } 215 } 216 } 217 }); 218 let source = LiveRelaySourceClient::new( 219 client.clone(), 220 ingress, 221 Arc::new(crate::connections::Connections::new(1)), 222 ); 223 let batches = source 224 .fetch(SourceQuery { 225 relays: vec![RelayUrl::parse(&url, RelayUrlPolicy::Local).unwrap()], 226 selector: FetchSelector::all(), 227 until_unix_seconds: None, 228 connect_timeout: Duration::from_secs(1), 229 deadline: crate::host_time::Instant::now() + Duration::from_secs(5), 230 max_connections: 1, 231 }) 232 .await; 233 client.shutdown().await; 234 server.await.unwrap(); 235 assert_eq!(batches.len(), 1); 236 let RelayFetchResult::Complete(events) = &batches[0].result else { 237 panic!("{:?}", batches[0].result) 238 }; 239 assert_eq!(events.len(), 1); 240 assert!( 241 events[0] == original, 242 "The actual source must retain original event bytes before SDK reserialization" 243 ); 244 }) 245 .await 246 .unwrap(); 247 }