lib

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

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 }