sink.rs (30721B)
1 //! Nostr implementation of the transport event sink. 2 3 use crate::exact_delivery::ExactEvent; 4 use crate::host_time::unix_time_ms; 5 use crate::{NostrTransport, RelayUrl, status}; 6 use core::{fmt, time::Duration}; 7 use futures::{StreamExt, stream}; 8 use radroots_transport::{ 9 BoxFuture, DeliveryReceipt, DeliveryRequest, EventSink, SinkFailure, Target, TargetSet, 10 outcome::DeliveryOutcome, 11 sink::{DeliveryTargetReceipt, SinkStatus}, 12 }; 13 use std::collections::{BTreeMap, BTreeSet}; 14 15 #[derive(Clone, Debug)] 16 pub(crate) struct RelayPublishResult { 17 relay: RelayUrl, 18 attempted: bool, 19 outcome: DeliveryOutcome, 20 } 21 22 /// Sealed, no-I/O result of validating one delivery against this adapter. 23 /// 24 /// The value retains the exact request and signed event bytes. It is 25 /// constructed only by [`NostrTransport::prepare_delivery`] and is consumed by 26 /// [`NostrTransport::execute_prepared_delivery`]. Ordinary `Debug` never 27 /// exposes event bytes, request identities, or relay destinations. 28 #[must_use = "prepared delivery must be durably bound before execution or deliberately discarded"] 29 pub struct PreparedDelivery { 30 request: DeliveryRequest, 31 config: crate::Config, 32 event: ExactEvent, 33 authorized: Vec<(RelayUrl, Target)>, 34 skipped: Vec<DeliveryTargetReceipt>, 35 } 36 37 impl PreparedDelivery { 38 /// Returns the exact validated request retained for persistence binding. 39 #[must_use] 40 pub const fn request(&self) -> &DeliveryRequest { 41 &self.request 42 } 43 } 44 45 impl fmt::Debug for PreparedDelivery { 46 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 47 formatter.write_str("PreparedDelivery([redacted])") 48 } 49 } 50 51 pub(crate) trait RelayClient: Send + Sync { 52 fn publish<'a>( 53 &'a self, 54 relays: Vec<RelayUrl>, 55 event: ExactEvent, 56 max_connections: usize, 57 connect_timeout: Duration, 58 operation_timeout: Duration, 59 ) -> BoxFuture<'a, Vec<RelayPublishResult>>; 60 } 61 62 #[derive(Clone, Debug)] 63 pub(crate) struct LiveRelayClient { 64 client: nostr_sdk::client::Client, 65 writers: crate::socket_write::WriterRegistry, 66 connections: std::sync::Arc<crate::connections::Connections>, 67 } 68 69 impl LiveRelayClient { 70 pub(crate) const fn new( 71 client: nostr_sdk::client::Client, 72 writers: crate::socket_write::WriterRegistry, 73 connections: std::sync::Arc<crate::connections::Connections>, 74 ) -> Self { 75 Self { 76 client, 77 writers, 78 connections, 79 } 80 } 81 82 #[cfg(test)] 83 pub(crate) fn isolated() -> Self { 84 let client = nostr_sdk::client::Client::default(); 85 Self::new( 86 client, 87 crate::socket_write::WriterRegistry::new(std::iter::empty()), 88 std::sync::Arc::new(crate::connections::Connections::new( 89 crate::client::MAX_RELAYS, 90 )), 91 ) 92 } 93 } 94 95 impl RelayClient for LiveRelayClient { 96 // Socket scheduling is exercised by the real loopback suite. Deterministic 97 // coverage owns framing, writer lifecycle and acknowledgement normalization. 98 #[cfg_attr(coverage_nightly, coverage(off))] 99 fn publish<'a>( 100 &'a self, 101 relays: Vec<RelayUrl>, 102 event: ExactEvent, 103 max_connections: usize, 104 connect_timeout: Duration, 105 operation_timeout: Duration, 106 ) -> BoxFuture<'a, Vec<RelayPublishResult>> { 107 Box::pin(async move { 108 let deadline = crate::host_time::Instant::now() + operation_timeout; 109 stream::iter(relays.into_iter().map(|relay| { 110 let event = event.clone(); 111 async move { 112 let url = relay.as_str().to_owned(); 113 let mut attempted = false; 114 let attempt = async { 115 if crate::host_time::Instant::now() >= deadline { 116 return Err("timeout".to_owned()); 117 } 118 attempted = true; 119 self.client 120 .add_relay(url.as_str()) 121 .connect_timeout(connect_timeout) 122 .await 123 .map_err(|error| error.to_string())?; 124 crate::client::connect_tracked( 125 &self.client, 126 &self.connections, 127 url.as_str(), 128 connect_timeout, 129 ) 130 .await 131 .map_err(|error| error.to_string())?; 132 event.publish(&self.client, &self.writers, &url).await 133 }; 134 let outcome = match crate::host_time::timeout_at(deadline, attempt).await { 135 Err(_) => status::delivery_failure("timeout"), 136 Ok(Err(error)) => status::delivery_failure(&error), 137 Ok(Ok(outcome)) => outcome, 138 }; 139 RelayPublishResult { 140 relay, 141 attempted, 142 outcome, 143 } 144 } 145 })) 146 .buffered(max_connections) 147 .collect() 148 .await 149 }) 150 } 151 } 152 153 impl NostrTransport { 154 /// Validates and converts one delivery without reading a clock or performing relay I/O. 155 pub fn prepare_delivery( 156 &self, 157 request: DeliveryRequest, 158 ) -> Result<PreparedDelivery, Box<SinkFailure>> { 159 self.prepare_delivery_inner(request, None) 160 } 161 162 /// Prepares only an exact subset, retaining the complete original request. 163 /// Unselected targets remain explicit unattempted, retryable receipt rows. 164 pub fn prepare_delivery_selected( 165 &self, 166 request: DeliveryRequest, 167 selected: &TargetSet, 168 ) -> Result<PreparedDelivery, Box<SinkFailure>> { 169 request 170 .validate_target_selection(selected) 171 .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?; 172 self.prepare_delivery_inner(request, Some(selected)) 173 } 174 175 fn prepare_delivery_inner( 176 &self, 177 request: DeliveryRequest, 178 selected: Option<&TargetSet>, 179 ) -> Result<PreparedDelivery, Box<SinkFailure>> { 180 let mut authorized = Vec::new(); 181 let mut skipped = Vec::new(); 182 for target in request.target_set().targets() { 183 if selected.is_some_and(|targets| !targets.targets().contains(target)) { 184 skipped.push( 185 DeliveryTargetReceipt::skipped( 186 target.clone(), 187 DeliveryOutcome::unavailable() 188 .with_detail( 189 "target_not_selected", 190 "target is held for a later attempt", 191 ) 192 .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?, 193 ) 194 .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?, 195 ); 196 continue; 197 } 198 match self.config().endpoint_for_target(target) { 199 Some(endpoint) if endpoint.access().can_write() => { 200 authorized.push((endpoint.url().clone(), target.clone())); 201 } 202 None | Some(_) => skipped.push( 203 DeliveryTargetReceipt::skipped( 204 target.clone(), 205 DeliveryOutcome::rejected() 206 .with_detail("target_denied", "target is not configured for this sink") 207 .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?, 208 ) 209 .map_err(|_| Box::new(SinkFailure::invalid_contract(&request)))?, 210 ), 211 } 212 } 213 let event = ExactEvent::from_request(&request) 214 .ok_or_else(|| Box::new(SinkFailure::invalid_contract(&request)))?; 215 Ok(PreparedDelivery { 216 request, 217 config: self.config().clone(), 218 event, 219 authorized, 220 skipped, 221 }) 222 } 223 224 /// Performs relay I/O for one exact prepared delivery and consumes its authority. 225 pub fn execute_prepared_delivery( 226 &self, 227 prepared: PreparedDelivery, 228 ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> { 229 Box::pin(async move { 230 let PreparedDelivery { 231 request, 232 config, 233 event, 234 authorized, 235 mut skipped, 236 } = prepared; 237 let _operation = self.connections.begin().map_err(|error| match error { 238 radroots_transport::Error::TransportClosed => { 239 SinkFailure::transport_closed(&request) 240 } 241 _ => SinkFailure::transport_unavailable(&request), 242 })?; 243 if config != *self.config() { 244 return Err(SinkFailure::invalid_contract(&request)); 245 } 246 let now_unix_ms = unix_time_ms(); 247 let mut requested = Vec::new(); 248 for (relay, target) in authorized { 249 if self.status.may_write(&relay, now_unix_ms) { 250 requested.push((relay, target)); 251 } else { 252 skipped.push( 253 DeliveryTargetReceipt::skipped( 254 target, 255 DeliveryOutcome::unavailable() 256 .with_detail( 257 "reconnect_backoff", 258 "relay reconnect backoff is active", 259 ) 260 .map_err(|_| SinkFailure::invalid_contract(&request))?, 261 ) 262 .map_err(|_| SinkFailure::invalid_contract(&request))?, 263 ); 264 } 265 } 266 let remaining_ms = request.deadline_unix_ms().saturating_sub(now_unix_ms); 267 let operation_timeout_ms = remaining_ms.min(self.config().request_timeout_ms()); 268 if operation_timeout_ms == 0 { 269 for (relay, _) in &requested { 270 self.status.record_write(relay, false, true, now_unix_ms); 271 } 272 let timeout = status::delivery_failure("timeout"); 273 skipped.extend(requested.into_iter().map(|(_, target)| { 274 DeliveryTargetReceipt::skipped(target, timeout.clone()) 275 .expect("normalized timeout cannot satisfy delivery") 276 })); 277 return DeliveryReceipt::for_request(&request, skipped) 278 .map_err(|_| SinkFailure::invalid_contract(&request)); 279 } 280 let expected: BTreeSet<_> = requested.iter().map(|(relay, _)| relay.clone()).collect(); 281 for (relay, _) in &requested { 282 self.status.begin_write(relay, now_unix_ms); 283 } 284 let results = self 285 .client 286 .publish( 287 requested.iter().map(|(relay, _)| relay.clone()).collect(), 288 event, 289 self.config().max_connections(), 290 Duration::from_millis(self.config().connect_timeout_ms()), 291 Duration::from_millis(operation_timeout_ms), 292 ) 293 .await; 294 let mut by_relay = BTreeMap::new(); 295 let observed_at_unix_ms = unix_time_ms().max(now_unix_ms); 296 for result in results { 297 if !expected.contains(&result.relay) 298 || by_relay.contains_key(&result.relay) 299 || (!result.attempted && status::delivery_succeeded(&result.outcome)) 300 { 301 return Err(SinkFailure::invalid_contract(&request)); 302 } 303 let succeeded = status::delivery_succeeded(&result.outcome); 304 self.status.record_write( 305 &result.relay, 306 succeeded, 307 result.outcome.is_retryable(), 308 observed_at_unix_ms, 309 ); 310 by_relay.insert(result.relay, (result.outcome, result.attempted)); 311 } 312 313 let mut receipts = skipped; 314 for (relay, target) in requested { 315 let (outcome, attempted) = by_relay.remove(&relay).unwrap_or_else(|| { 316 self.status 317 .record_write(&relay, false, true, observed_at_unix_ms); 318 ( 319 DeliveryOutcome::unavailable() 320 .with_detail("missing_result", "relay returned no result") 321 .expect("static normalized outcome"), 322 true, 323 ) 324 }); 325 receipts.push(if attempted { 326 DeliveryTargetReceipt::attempted(target, outcome) 327 } else { 328 DeliveryTargetReceipt::skipped(target, outcome) 329 .map_err(|_| SinkFailure::invalid_contract(&request))? 330 }); 331 } 332 DeliveryReceipt::for_request(&request, receipts) 333 .map_err(|_| SinkFailure::invalid_contract(&request)) 334 }) 335 } 336 } 337 338 impl EventSink for NostrTransport { 339 fn status(&self) -> BoxFuture<'_, Result<SinkStatus, radroots_transport::Error>> { 340 Box::pin(async move { 341 self.require_open()?; 342 Ok(status::sink_status(&self.status)) 343 }) 344 } 345 346 fn deliver( 347 &self, 348 request: DeliveryRequest, 349 ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> { 350 Box::pin(async move { 351 let prepared = self.prepare_delivery(request).map_err(|failure| *failure)?; 352 self.execute_prepared_delivery(prepared).await 353 }) 354 } 355 356 fn deliver_selected( 357 &self, 358 request: DeliveryRequest, 359 selected: TargetSet, 360 ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> { 361 Box::pin(async move { 362 let prepared = self 363 .prepare_delivery_selected(request, &selected) 364 .map_err(|failure| *failure)?; 365 self.execute_prepared_delivery(prepared).await 366 }) 367 } 368 } 369 370 #[cfg(test)] 371 mod tests { 372 use super::*; 373 use crate::{Config, RelayUrlPolicy}; 374 use radroots_transport::{ 375 Target, TargetSet, 376 outcome::DeliveryOutcomeKind, 377 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 378 sink::DeliveryPayload, 379 }; 380 use std::sync::{ 381 Arc, 382 atomic::{AtomicUsize, Ordering}, 383 }; 384 385 #[derive(Debug)] 386 struct MockRelayClient { 387 outcomes: BTreeMap<RelayUrl, DeliveryOutcome>, 388 } 389 390 impl RelayClient for MockRelayClient { 391 fn publish<'a>( 392 &'a self, 393 relays: Vec<RelayUrl>, 394 _event: ExactEvent, 395 _max_connections: usize, 396 _connect_timeout: Duration, 397 _operation_timeout: Duration, 398 ) -> BoxFuture<'a, Vec<RelayPublishResult>> { 399 Box::pin(async move { 400 relays 401 .into_iter() 402 .map(|relay| RelayPublishResult { 403 attempted: true, 404 outcome: self 405 .outcomes 406 .get(&relay) 407 .cloned() 408 .unwrap_or_else(DeliveryOutcome::accepted), 409 relay, 410 }) 411 .collect() 412 }) 413 } 414 } 415 416 #[derive(Debug)] 417 struct CountingRelayClient(Arc<AtomicUsize>); 418 419 impl RelayClient for CountingRelayClient { 420 fn publish<'a>( 421 &'a self, 422 _relays: Vec<RelayUrl>, 423 _event: ExactEvent, 424 _max_connections: usize, 425 _connect_timeout: Duration, 426 _operation_timeout: Duration, 427 ) -> BoxFuture<'a, Vec<RelayPublishResult>> { 428 self.0.fetch_add(1, Ordering::SeqCst); 429 Box::pin(async { Vec::new() }) 430 } 431 } 432 433 fn payload() -> DeliveryPayload { 434 let raw = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#; 435 DeliveryPayload::new(radroots_event_codec::decode::signed_event(raw).expect("signed event")) 436 } 437 438 fn request() -> DeliveryRequest { 439 request_with_deadline(1_800_000_000_000) 440 } 441 442 fn request_with_deadline(deadline_unix_ms: u64) -> DeliveryRequest { 443 DeliveryRequest::new( 444 "nostr-delivery", 445 payload(), 446 TargetSet::new(vec![ 447 Target::nostr_relay("wss://one.example").expect("one"), 448 Target::nostr_relay("wss://two.example").expect("two"), 449 ]) 450 .expect("targets"), 451 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 452 deadline_unix_ms, 453 ) 454 .expect("request") 455 } 456 457 #[test] 458 fn sink_returns_normalized_per_relay_partial_success() { 459 let config = Config::from_profile( 460 crate::profile::test_profile( 461 crate::RelayProfileKind::Public, 462 RelayUrlPolicy::Public, 463 ["wss://one.example", "wss://two.example"], 464 ) 465 .expect("profile"), 466 ); 467 let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).expect("two"); 468 let client = MockRelayClient { 469 outcomes: BTreeMap::from([(two, status::delivery_failure("rate limited"))]), 470 }; 471 let transport = NostrTransport::with_client(config, Arc::new(client)); 472 let request = request(); 473 let receipt = futures::executor::block_on(transport.deliver(request.clone())) 474 .expect("delivery receipt"); 475 476 assert_eq!(receipt.target_receipts().len(), 2); 477 assert_eq!( 478 receipt.target_receipts()[0].outcome().kind(), 479 DeliveryOutcomeKind::Accepted 480 ); 481 assert_eq!( 482 receipt.target_receipts()[1].outcome().kind(), 483 DeliveryOutcomeKind::Unavailable 484 ); 485 assert!(!receipt.is_satisfied(&request).expect("satisfaction")); 486 } 487 488 #[test] 489 fn selected_preparation_retains_binding_and_only_authorizes_selected_relays() { 490 let config = Config::from_profile( 491 crate::profile::test_profile( 492 crate::RelayProfileKind::Public, 493 RelayUrlPolicy::Public, 494 ["wss://one.example", "wss://two.example"], 495 ) 496 .unwrap(), 497 ); 498 let transport = NostrTransport::with_client( 499 config, 500 Arc::new(MockRelayClient { 501 outcomes: BTreeMap::new(), 502 }), 503 ); 504 let request = request(); 505 let selected = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap(); 506 let prepared = transport 507 .prepare_delivery_selected(request.clone(), &selected) 508 .unwrap(); 509 assert_eq!(prepared.request(), &request); 510 assert_eq!(prepared.authorized.len(), 1); 511 assert_eq!(&prepared.authorized[0].1, &selected.targets()[0]); 512 let receipt = 513 futures::executor::block_on(transport.execute_prepared_delivery(prepared)).unwrap(); 514 receipt.validate_for_request(&request).unwrap(); 515 assert!(receipt.target_receipts()[0].was_attempted()); 516 assert_eq!( 517 receipt.target_receipts()[0].outcome().kind(), 518 DeliveryOutcomeKind::Accepted 519 ); 520 assert!(!receipt.target_receipts()[1].was_attempted()); 521 assert_eq!( 522 receipt.target_receipts()[1].outcome().code(), 523 Some("target_not_selected") 524 ); 525 assert!(receipt.target_receipts()[1].outcome().is_retryable()); 526 assert!(!receipt.is_satisfied(&request).unwrap()); 527 let foreign = 528 TargetSet::new(vec![Target::nostr_relay("wss://foreign.example").unwrap()]).unwrap(); 529 let failure = transport 530 .prepare_delivery_selected(request.clone(), &foreign) 531 .unwrap_err(); 532 failure.validate_for_request(&request).unwrap(); 533 assert_eq!(failure.code(), "invalid_transport_contract"); 534 let all = futures::executor::block_on( 535 transport.deliver_selected(request.clone(), request.target_set().clone()), 536 ) 537 .unwrap(); 538 assert!(all.is_satisfied(&request).unwrap()); 539 } 540 541 #[test] 542 fn upstream_messages_map_to_stable_outcomes() { 543 let cases = [ 544 ("duplicate: already have", DeliveryOutcomeKind::Unavailable), 545 ("blocked by policy", DeliveryOutcomeKind::Rejected), 546 ("rate limited", DeliveryOutcomeKind::Unavailable), 547 ("auth required", DeliveryOutcomeKind::Failed), 548 ("connection timeout", DeliveryOutcomeKind::Unavailable), 549 ("connection failed", DeliveryOutcomeKind::Unavailable), 550 ]; 551 for (message, expected) in cases { 552 assert_eq!(status::delivery_failure(message).kind(), expected); 553 } 554 } 555 556 #[test] 557 fn dropping_an_unpolled_delivery_performs_no_relay_work() { 558 let calls = Arc::new(AtomicUsize::new(0)); 559 let config = Config::from_profile( 560 crate::profile::test_profile( 561 crate::RelayProfileKind::Public, 562 RelayUrlPolicy::Public, 563 ["wss://one.example", "wss://two.example"], 564 ) 565 .expect("profile"), 566 ); 567 let transport = 568 NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls)))); 569 let delivery = transport.deliver(request()); 570 drop(delivery); 571 assert_eq!(calls.load(Ordering::SeqCst), 0); 572 } 573 574 #[test] 575 fn preparation_is_no_io_redacted_consuming_and_bound_to_exact_config() { 576 let calls = Arc::new(AtomicUsize::new(0)); 577 let profile = crate::profile::test_profile( 578 crate::RelayProfileKind::Public, 579 RelayUrlPolicy::Public, 580 ["wss://one.example", "wss://two.example"], 581 ) 582 .expect("profile"); 583 let config = Config::from_profile(profile.clone()); 584 let transport = 585 NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls)))); 586 let request = request(); 587 588 let prepared = transport 589 .prepare_delivery(request.clone()) 590 .expect("prepared delivery"); 591 assert_eq!(prepared.request(), &request); 592 assert_eq!(format!("{prepared:?}"), "PreparedDelivery([redacted])"); 593 assert_eq!(calls.load(Ordering::SeqCst), 0); 594 595 let receipt = futures::executor::block_on(transport.execute_prepared_delivery(prepared)) 596 .expect("executed delivery"); 597 assert_eq!(receipt.request_id(), request.request_id()); 598 assert_eq!(calls.load(Ordering::SeqCst), 1); 599 600 let mismatch_calls = Arc::new(AtomicUsize::new(0)); 601 let mismatched = NostrTransport::with_client( 602 Config::from_profile(profile) 603 .with_timeouts(5_000, 20_000, 2_000) 604 .expect("different bounded config"), 605 Arc::new(CountingRelayClient(Arc::clone(&mismatch_calls))), 606 ); 607 let prepared = transport 608 .prepare_delivery(request) 609 .expect("second prepared delivery"); 610 assert_eq!( 611 futures::executor::block_on(mismatched.execute_prepared_delivery(prepared)) 612 .expect_err("prepared authority is config-bound") 613 .code(), 614 "invalid_transport_contract" 615 ); 616 assert_eq!(mismatch_calls.load(Ordering::SeqCst), 0); 617 } 618 619 #[test] 620 fn expired_delivery_deadline_performs_no_relay_work() { 621 let calls = Arc::new(AtomicUsize::new(0)); 622 let config = Config::from_profile( 623 crate::profile::test_profile( 624 crate::RelayProfileKind::Public, 625 RelayUrlPolicy::Public, 626 ["wss://one.example", "wss://two.example"], 627 ) 628 .expect("profile"), 629 ); 630 let transport = 631 NostrTransport::with_client(config, Arc::new(CountingRelayClient(Arc::clone(&calls)))); 632 let receipt = futures::executor::block_on(transport.deliver(request_with_deadline(1))) 633 .expect("bounded timeout receipt"); 634 assert_eq!(calls.load(Ordering::SeqCst), 0); 635 assert!( 636 receipt 637 .target_receipts() 638 .iter() 639 .all(|target| !target.was_attempted()) 640 ); 641 } 642 643 #[derive(Debug)] 644 struct ScriptedRelayClient(Vec<RelayPublishResult>); 645 646 impl RelayClient for ScriptedRelayClient { 647 fn publish<'a>( 648 &'a self, 649 _relays: Vec<RelayUrl>, 650 _event: ExactEvent, 651 _max_connections: usize, 652 _connect_timeout: Duration, 653 _operation_timeout: Duration, 654 ) -> BoxFuture<'a, Vec<RelayPublishResult>> { 655 Box::pin(async move { self.0.clone() }) 656 } 657 } 658 659 fn scripted(results: Vec<RelayPublishResult>) -> NostrTransport { 660 let config = Config::from_profile( 661 crate::profile::test_profile( 662 crate::RelayProfileKind::Public, 663 RelayUrlPolicy::Public, 664 ["wss://one.example", "wss://two.example"], 665 ) 666 .expect("profile"), 667 ); 668 NostrTransport::with_client(config, Arc::new(ScriptedRelayClient(results))) 669 } 670 671 #[test] 672 fn sink_handles_missing_duplicate_unexpected_and_denied_targets() { 673 let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("one"); 674 let missing = futures::executor::block_on( 675 scripted(vec![RelayPublishResult { 676 relay: one.clone(), 677 attempted: true, 678 outcome: DeliveryOutcome::accepted(), 679 }]) 680 .deliver(request()), 681 ) 682 .expect("missing result receipt"); 683 assert_eq!(missing.target_receipts().len(), 2); 684 685 let duplicate = scripted(vec![ 686 RelayPublishResult { 687 relay: one.clone(), 688 attempted: true, 689 outcome: DeliveryOutcome::accepted(), 690 }, 691 RelayPublishResult { 692 relay: one, 693 attempted: true, 694 outcome: DeliveryOutcome::accepted(), 695 }, 696 ]); 697 assert_eq!( 698 futures::executor::block_on(duplicate.deliver(request())) 699 .expect_err("duplicate relay evidence") 700 .code(), 701 "invalid_transport_contract" 702 ); 703 704 let other = RelayUrl::parse("wss://other.example", RelayUrlPolicy::Public).expect("other"); 705 let unexpected = scripted(vec![RelayPublishResult { 706 relay: other, 707 attempted: true, 708 outcome: DeliveryOutcome::accepted(), 709 }]); 710 assert_eq!( 711 futures::executor::block_on(unexpected.deliver(request())) 712 .expect_err("unexpected relay evidence") 713 .code(), 714 "invalid_transport_contract" 715 ); 716 717 let denied_request = DeliveryRequest::new( 718 "denied", 719 payload(), 720 TargetSet::new(vec![ 721 Target::nostr_relay("wss://other.example").expect("other"), 722 ]) 723 .expect("targets"), 724 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 725 1_800_000_000_000, 726 ) 727 .expect("request"); 728 let denied = futures::executor::block_on(scripted(vec![]).deliver(denied_request)) 729 .expect("denied receipt"); 730 assert!(!denied.target_receipts()[0].was_attempted()); 731 assert!(futures::executor::block_on(scripted(vec![]).status()).is_ok()); 732 } 733 734 #[test] 735 fn skipped_results_remain_skipped_and_cannot_claim_acceptance() { 736 let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap(); 737 let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).unwrap(); 738 let receipt = futures::executor::block_on( 739 scripted(vec![ 740 RelayPublishResult { 741 relay: one.clone(), 742 attempted: false, 743 outcome: status::delivery_failure("timeout"), 744 }, 745 RelayPublishResult { 746 relay: two, 747 attempted: true, 748 outcome: DeliveryOutcome::accepted(), 749 }, 750 ]) 751 .deliver(request()), 752 ) 753 .unwrap(); 754 assert!(!receipt.target_receipts()[0].was_attempted()); 755 assert_eq!( 756 receipt.target_receipts()[0].outcome().code(), 757 Some("timeout") 758 ); 759 assert!(receipt.target_receipts()[1].was_attempted()); 760 assert_eq!( 761 receipt.target_receipts()[1].outcome(), 762 &DeliveryOutcome::accepted() 763 ); 764 for outcome in [DeliveryOutcome::accepted(), DeliveryOutcome::delivered()] { 765 let transport = scripted(vec![RelayPublishResult { 766 relay: one.clone(), 767 attempted: false, 768 outcome, 769 }]); 770 let failure = futures::executor::block_on(transport.deliver(request())).unwrap_err(); 771 assert_eq!(failure.code(), "invalid_transport_contract"); 772 assert!( 773 transport 774 .relay_status() 775 .relays() 776 .iter() 777 .all(|relay| relay.write().last_success_unix_ms().is_none()) 778 ); 779 } 780 } 781 782 #[test] 783 fn live_relay_client_accepts_an_empty_batch_without_io() { 784 let client = LiveRelayClient::isolated(); 785 let results = futures::executor::block_on(client.publish( 786 vec![], 787 ExactEvent::from_request(&request()).expect("exact event"), 788 1, 789 Duration::from_millis(1), 790 Duration::from_millis(1), 791 )); 792 assert!(results.is_empty()); 793 } 794 }