lib

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

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 }