session_socket_tests.rs (10877B)
1 use super::*; 2 use futures::{SinkExt, StreamExt}; 3 use radroots_transport::host::websocket::{CloseFrame, Error, IoFuture}; 4 use std::sync::{ 5 Mutex, 6 atomic::{AtomicUsize, Ordering}, 7 }; 8 9 #[test] 10 fn host_policy_and_timeout_keep_their_sdk_class_without_misclassifying_authority_as_auth() { 11 let policy = host_error(Error::Policy); 12 assert_eq!(policy.kind(), nostr_sdk::error::ErrorKind::Policy); 13 assert_eq!( 14 crate::status::delivery_failure(&policy.to_string()), 15 crate::status::delivery_failure("rejected") 16 ); 17 let timeout = host_error(Error::Timeout); 18 assert_eq!(timeout.kind(), nostr_sdk::error::ErrorKind::Timeout); 19 assert_eq!( 20 crate::status::delivery_failure(&timeout.to_string()), 21 crate::status::delivery_failure("timeout") 22 ); 23 for error in [ 24 Error::Unavailable, 25 Error::Closed, 26 Error::Protocol, 27 Error::Unsupported, 28 ] { 29 let mapped = host_error(error); 30 assert_eq!(mapped.kind(), nostr_sdk::error::ErrorKind::Transport); 31 assert!(mapped.to_string().len() < 128); 32 } 33 } 34 35 #[test] 36 fn original_text_identifiers_are_exact_and_binary_is_never_promoted_or_reencoded() { 37 use serde_json::json; 38 let event = json!({"id": "ab".repeat(32), "pubkey": "cd".repeat(32), 39 "sig": "ef".repeat(64), "extension": true}); 40 let check = |text: String, valid| { 41 for frame in [ 42 Frame::Text(text.clone()), 43 Frame::Binary(text.clone().into_bytes()), 44 ] { 45 let result = from_host_frame(frame.clone()); 46 let accepted = valid || matches!(frame, Frame::Binary(_)); 47 assert_eq!(result.is_ok(), accepted); 48 if accepted { 49 assert_eq!(to_host_frame(result.unwrap().unwrap()), frame); 50 } 51 } 52 }; 53 check( 54 format!(" \n{} \t", json!(["EVENT", "bounded", event])), 55 true, 56 ); 57 for field in ["id", "pubkey", "sig"] { 58 let original = event[field].as_str().unwrap(); 59 for invalid in [ 60 json!(format!("{original}00")), 61 json!(&original[2..]), 62 json!(original.to_ascii_uppercase()), 63 json!(format!("g{}", &original[1..])), 64 json!(null), 65 json!(32), 66 ] { 67 let mut malformed = event.clone(); 68 malformed[field] = invalid; 69 check(json!(["EVENT", "bounded", malformed]).to_string(), false); 70 } 71 } 72 for id in [json!("aa".repeat(33)), json!("AA".repeat(32)), json!(null)] { 73 check(json!(["OK", id, true, ""]).to_string(), false); 74 } 75 for text in [ 76 "not-json".to_owned(), 77 "[]".to_owned(), 78 "[\"EVENT\"]".to_owned(), 79 "[\"NOTICE\",\"retained\"]".to_owned(), 80 json!(["OK", "aa".repeat(32), true, ""]).to_string(), 81 ] { 82 let valid = text != "[\"EVENT\"]"; 83 check(text, valid); 84 } 85 for frame in [ 86 Frame::Text("x".repeat(MAX_WIRE_MESSAGE_BYTES + 1)), 87 Frame::Binary(vec![0; MAX_WIRE_MESSAGE_BYTES + 1]), 88 ] { 89 assert!(from_host_frame(frame).is_err()); 90 } 91 let non_utf8 = Frame::Binary(vec![0xff, 0]); 92 assert_eq!( 93 to_host_frame(from_host_frame(non_utf8.clone()).unwrap().unwrap()), 94 non_utf8 95 ); 96 } 97 98 #[test] 99 fn owned_data_control_and_close_information_round_trip_at_the_shared_sdk_boundary() { 100 for frame in [ 101 Frame::Text("text".into()), 102 Frame::Binary(vec![0, 255]), 103 Frame::Ping(vec![1, 2]), 104 Frame::Pong(vec![3]), 105 Frame::Close(None), 106 Frame::Close(Some(CloseFrame { 107 code: 1000, 108 reason: "finished".into(), 109 })), 110 ] { 111 assert_eq!( 112 to_host_frame(from_host_frame(frame.clone()).unwrap().unwrap()), 113 frame 114 ); 115 } 116 } 117 118 #[derive(Default)] 119 struct FakeSocket { 120 sent: Mutex<Vec<Frame>>, 121 received: Mutex<std::collections::VecDeque<Result<Option<Frame>, Error>>>, 122 closes: AtomicUsize, 123 } 124 impl Socket for FakeSocket { 125 fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> { 126 Box::pin(async move { 127 self.sent.lock().unwrap().push(frame); 128 Ok(()) 129 }) 130 } 131 fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> { 132 Box::pin(async move { 133 self.received 134 .lock() 135 .unwrap() 136 .pop_front() 137 .unwrap_or(Ok(None)) 138 }) 139 } 140 fn close(&self) -> IoFuture<'_, Result<(), Error>> { 141 Box::pin(async move { 142 self.closes.fetch_add(1, Ordering::SeqCst); 143 Ok(()) 144 }) 145 } 146 } 147 148 #[derive(Debug, Default)] 149 struct Calls(AtomicUsize); 150 #[derive(Default)] 151 struct Host { 152 calls: Arc<Calls>, 153 socket: Arc<FakeSocket>, 154 } 155 impl fmt::Debug for Host { 156 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 157 f.write_str("Host") 158 } 159 } 160 impl Connector for Host { 161 fn supports_ping(&self) -> bool { 162 false 163 } 164 fn connect<'a>( 165 &'a self, 166 _: &'a str, 167 _: Duration, 168 _: NonZeroUsize, 169 _: Arc<dyn Admission>, 170 ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> { 171 Box::pin(async move { 172 self.calls.0.fetch_add(1, Ordering::SeqCst); 173 Ok(self.socket.clone() as Arc<dyn Socket>) 174 }) 175 } 176 } 177 178 #[tokio::test] 179 async fn exact_writer_and_sdk_messages_use_one_host_socket_and_close_it_once() { 180 let host = Arc::new(Host::default()); 181 host.socket.received.lock().unwrap().extend([ 182 Ok(Some(Frame::Text("[\"NOTICE\",\"first\"]".into()))), 183 Err(Error::Closed), 184 ]); 185 let endpoint = crate::RelayEndpoint::new( 186 "ws://127.0.0.1:1234", 187 RelayUrlPolicy::Local, 188 crate::RelayAccess::ReadWrite, 189 ) 190 .unwrap(); 191 let bridge = SessionWebsocketTransport::new(&[endpoint], Duration::from_secs(1), host.clone()); 192 assert!(!bridge.support_ping()); 193 let url = Url::parse("ws://127.0.0.1:1234").unwrap(); 194 let pending = bridge.connect(&url, None); 195 drop(pending); 196 assert_eq!(host.calls.0.load(Ordering::SeqCst), 0); 197 let (mut sink, mut receiver) = bridge.connect(&url, None).await.unwrap(); 198 let writer = bridge.writers.get("ws://127.0.0.1:1234").unwrap(); 199 let original = " \n[\"EVENT\", { \"z\":1, \"a\":2 }] \t"; 200 writer.send(Message::Text(original.into())).await.unwrap(); 201 sink.send(Message::Text("[\"REQ\",\"read\",{}]".into())) 202 .await 203 .unwrap(); 204 assert_eq!( 205 *host.socket.sent.lock().unwrap(), 206 vec![ 207 Frame::Text(original.into()), 208 Frame::Text("[\"REQ\",\"read\",{}]".into()) 209 ] 210 ); 211 assert_eq!( 212 receiver.next().await.unwrap().unwrap(), 213 Message::Text("[\"NOTICE\",\"first\"]".into()) 214 ); 215 assert!(receiver.next().await.unwrap().is_err()); 216 assert!(receiver.next().await.is_none()); 217 sink.close().await.unwrap(); 218 sink.close().await.unwrap(); 219 assert_eq!(host.socket.closes.load(Ordering::SeqCst), 1); 220 assert!(writer.send(Message::Text("denied".into())).await.is_err()); 221 assert_eq!(host.calls.0.load(Ordering::SeqCst), 1); 222 } 223 224 #[test] 225 fn host_sink_enforces_pending_ready_and_closed_states_without_discarding_close() { 226 let socket = Arc::new(FakeSocket::default()); 227 let mut sink = HostSink::new(socket.clone()); 228 let mut context = Context::from_waker(futures::task::noop_waker_ref()); 229 Pin::new(&mut sink) 230 .start_send(Message::Text("first".into())) 231 .unwrap(); 232 assert!( 233 Pin::new(&mut sink) 234 .start_send(Message::Text("second".into())) 235 .is_err() 236 ); 237 assert!(matches!( 238 Pin::new(&mut sink).poll_ready(&mut context), 239 Poll::Ready(Ok(())) 240 )); 241 assert!(matches!( 242 Pin::new(&mut sink).poll_close(&mut context), 243 Poll::Ready(Ok(())) 244 )); 245 assert!(matches!( 246 Pin::new(&mut sink).poll_ready(&mut context), 247 Poll::Ready(Err(_)) 248 )); 249 assert!( 250 Pin::new(&mut sink) 251 .start_send(Message::Text("denied".into())) 252 .is_err() 253 ); 254 assert!(matches!( 255 Pin::new(&mut sink).poll_close(&mut context), 256 Poll::Ready(Ok(())) 257 )); 258 assert_eq!(socket.closes.load(Ordering::SeqCst), 1); 259 assert_eq!( 260 *socket.sent.lock().unwrap(), 261 vec![Frame::Text("first".into())] 262 ); 263 } 264 265 #[tokio::test] 266 async fn proxy_or_unconfigured_endpoint_never_calls_the_host() { 267 let host = Arc::new(Host::default()); 268 let endpoint = crate::RelayEndpoint::new( 269 "ws://127.0.0.1:1234", 270 RelayUrlPolicy::Local, 271 crate::RelayAccess::ReadOnly, 272 ) 273 .unwrap(); 274 let bridge = SessionWebsocketTransport::new(&[endpoint], Duration::from_secs(1), host.clone()); 275 let url = Url::parse("ws://127.0.0.1:1234").unwrap(); 276 assert!( 277 bridge 278 .connect(&url, Some("127.0.0.1:9000".parse().unwrap())) 279 .await 280 .is_err() 281 ); 282 assert!( 283 bridge 284 .connect(&Url::parse("ws://127.0.0.1:1235").unwrap(), None) 285 .await 286 .is_err() 287 ); 288 assert_eq!(host.calls.0.load(Ordering::SeqCst), 0); 289 for (url, expected) in [ 290 ("wss://relay.example/", "wss://relay.example"), 291 ("wss://relay.example/path/", "wss://relay.example/path/"), 292 ( 293 "wss://relay.example/?scope=write", 294 "wss://relay.example/?scope=write", 295 ), 296 ("wss://relay.example/#status", "wss://relay.example/#status"), 297 ] { 298 assert_eq!(configured_policy_key(&Url::parse(url).unwrap()), expected); 299 } 300 } 301 302 #[test] 303 fn connection_admission_preserves_policy_original_budget_and_generation() { 304 let key = "ws://127.0.0.1:1234"; 305 let registry = crate::source_ingress::IngressRegistry::new([key.to_owned()].into_iter()); 306 let budget = Arc::new(crate::source::budget::FetchBudget::default()); 307 let registration = registry 308 .register([key.to_owned()].into_iter(), budget.clone()) 309 .unwrap(); 310 let admission = ConnectionAdmission { 311 policy: RelayUrlPolicy::Local, 312 ingress: registry.connection(key).unwrap(), 313 }; 314 assert!(admission.permits_address("127.0.0.1".parse().unwrap())); 315 assert!(!admission.permits_address("8.8.8.8".parse().unwrap())); 316 let context = Context::from_waker(futures::task::noop_waker_ref()); 317 assert!(admission.admitted_read(&context) && admission.admitted_write(&context)); 318 assert!(admission.charge(crate::source::budget::MAX_FETCH_BYTES, 0, 0)); 319 assert!(!admission.charge(1, 0, 0)); 320 assert!(budget.exhausted()); 321 assert!(!admission.admitted_read(&context)); 322 drop(registration); 323 assert!(!admission.admitted_write(&context)); 324 assert!(!admission.charge(0, 0, 0)); 325 assert_eq!(format!("{admission:?}"), "ConnectionAdmission([redacted])"); 326 }