lib

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

state_tests.rs (8502B)


      1 use super::*;
      2 use std::{
      3     net::IpAddr,
      4     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
      5     task::Context,
      6 };
      7 
      8 pub(crate) struct AdmissionCounter {
      9     allow: AtomicBool,
     10     bytes: AtomicUsize,
     11     frames: AtomicUsize,
     12     cancelling: Mutex<Option<std::sync::Weak<Shared>>>,
     13 }
     14 impl AdmissionCounter {
     15     pub(crate) fn new(allow: bool) -> Arc<Self> {
     16         Arc::new(Self {
     17             allow: AtomicBool::new(allow),
     18             bytes: AtomicUsize::new(0),
     19             frames: AtomicUsize::new(0),
     20             cancelling: Mutex::new(None),
     21         })
     22     }
     23 }
     24 impl Admission for AdmissionCounter {
     25     fn permits_address(&self, _: IpAddr) -> bool {
     26         self.allow.load(Ordering::SeqCst)
     27     }
     28     fn admitted_read(&self, _: &Context<'_>) -> bool {
     29         self.allow.load(Ordering::SeqCst)
     30     }
     31     fn admitted_write(&self, _: &Context<'_>) -> bool {
     32         self.allow.load(Ordering::SeqCst)
     33     }
     34     fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
     35         assert_eq!(frames, data);
     36         self.bytes.fetch_add(bytes, Ordering::SeqCst);
     37         self.frames.fetch_add(frames, Ordering::SeqCst);
     38         let cancelling = self.cancelling.lock().unwrap().clone();
     39         if let Some(shared) = cancelling.and_then(|weak| weak.upgrade()) {
     40             // Fail promptly rather than deadlocking the regression if a host
     41             // calls the admission callback while holding its own state lock.
     42             if shared.state.try_lock().is_err() {
     43                 return false;
     44             }
     45             shared.stop();
     46         }
     47         self.allow.load(Ordering::SeqCst)
     48     }
     49 }
     50 fn shared(limit: usize) -> (Shared, Arc<AdmissionCounter>) {
     51     let admission = AdmissionCounter::new(true);
     52     (Shared::new(admission.clone(), limit), admission)
     53 }
     54 fn open(limit: usize) -> (Shared, Arc<AdmissionCounter>) {
     55     let result = shared(limit);
     56     result.0.lock().unwrap().status = Status::Open;
     57     result
     58 }
     59 
     60 #[test]
     61 fn original_binary_and_text_are_charged_once_and_dequeue_releases_bytes() {
     62     let (shared, admission) = open(64);
     63     assert_eq!(shared.pop(), Ok(None));
     64     let frames = [
     65         Frame::Text(" [\"raw\",  3] ".into()),
     66         Frame::Binary(vec![0, 255, 12]),
     67     ];
     68     for frame in &frames {
     69         shared.push(frame.clone()).unwrap();
     70     }
     71     assert_eq!(admission.bytes.load(Ordering::SeqCst), 16);
     72     assert_eq!(admission.frames.load(Ordering::SeqCst), 2);
     73     for frame in frames {
     74         assert_eq!(shared.pop(), Ok(Some(frame)));
     75     }
     76     assert_eq!(shared.lock().unwrap().bytes, 0);
     77 }
     78 
     79 #[test]
     80 fn item_limit_counts_empty_messages_and_never_charges_rejected_queue_work() {
     81     let (shared, admission) = open(1);
     82     for _ in 0..MAX_QUEUE_MESSAGES {
     83         shared.push(Frame::Text(String::new())).unwrap();
     84     }
     85     assert_eq!(shared.push(Frame::Binary(vec![])), Err(Error::Policy));
     86     assert_eq!(admission.frames.load(Ordering::SeqCst), MAX_QUEUE_MESSAGES);
     87     assert_eq!(shared.pop(), Ok(Some(Frame::Text(String::new()))));
     88     shared.push(Frame::Binary(vec![])).unwrap();
     89 }
     90 
     91 #[test]
     92 fn byte_limit_is_exact_and_newly_freed_credit_is_reusable() {
     93     let (shared, _) = open(MAX_MESSAGE);
     94     for _ in 0..8 {
     95         shared.push(Frame::Binary(vec![7; MAX_MESSAGE])).unwrap();
     96     }
     97     assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES);
     98     assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Policy));
     99     shared.pop().unwrap();
    100     shared.push(Frame::Binary(vec![9; MAX_MESSAGE])).unwrap();
    101     assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES);
    102 }
    103 
    104 #[test]
    105 fn message_limit_and_control_frames_refuse_before_charging() {
    106     let (shared, admission) = open(2);
    107     assert_eq!(shared.push(Frame::Text("abc".into())), Err(Error::Policy));
    108     assert_eq!(shared.push(Frame::Ping(vec![])), Err(Error::Unsupported));
    109     assert_eq!(shared.push(Frame::Pong(vec![])), Err(Error::Unsupported));
    110     assert_eq!(shared.push(Frame::Close(None)), Err(Error::Unsupported));
    111     assert_eq!(admission.frames.load(Ordering::SeqCst), 0);
    112     shared.push(Frame::Text("é".into())).unwrap();
    113     assert_eq!(admission.bytes.load(Ordering::SeqCst), 2);
    114     assert_eq!(Shared::new(admission, usize::MAX).limit, MAX_MESSAGE);
    115 }
    116 
    117 #[test]
    118 fn admission_refusal_never_exposes_the_original_payload() {
    119     let (shared, admission) = open(4);
    120     admission.allow.store(false, Ordering::SeqCst);
    121     assert_eq!(shared.push(Frame::Text("deny".into())), Err(Error::Policy));
    122     assert_eq!(shared.pop(), Ok(None));
    123     assert_eq!(admission.bytes.load(Ordering::SeqCst), 4);
    124 }
    125 
    126 #[test]
    127 fn first_failure_survives_subsequent_failure_close_and_finish() {
    128     let (shared, _) = open(4);
    129     shared.push(Frame::Text("live".into())).unwrap();
    130     shared.fail(Error::Policy);
    131     shared.fail(Error::Unavailable);
    132     shared.stop();
    133     shared.finish();
    134     shared.finish();
    135     assert_eq!(shared.pop(), Err(Error::Policy));
    136     let state = shared.lock().unwrap();
    137     assert_eq!(state.status, Status::Failed(Error::Policy));
    138     assert!(state.finished && state.stopping);
    139     assert_eq!(state.bytes, 0);
    140 }
    141 
    142 #[test]
    143 fn graceful_finish_preserves_original_queued_frames_and_fails_pending_send() {
    144     let (shared, _) = open(8);
    145     shared.push(Frame::Binary(vec![1, 2, 3])).unwrap();
    146     let (sender, receiver) = oneshot::channel();
    147     shared.lock().unwrap().outgoing = Some(SendRequest {
    148         frame: Frame::Text("send".into()),
    149         result: sender,
    150     });
    151     assert_eq!(
    152         shared.lock().unwrap().outgoing.as_ref().unwrap().frame,
    153         Frame::Text("send".into())
    154     );
    155     shared.finish();
    156     assert_eq!(
    157         futures::executor::block_on(receiver),
    158         Ok(Err(Error::Closed))
    159     );
    160     assert_eq!(shared.pop(), Ok(Some(Frame::Binary(vec![1, 2, 3]))));
    161     assert_eq!(shared.pop(), Ok(None));
    162     assert_eq!(shared.lock().unwrap().status, Status::Ended);
    163 }
    164 
    165 #[test]
    166 fn connecting_stopping_ended_and_failed_refuse_new_payloads() {
    167     let (shared, _) = shared(4);
    168     assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
    169     for status in [Status::Ended, Status::Failed(Error::Policy)] {
    170         shared.lock().unwrap().status = status;
    171         assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
    172     }
    173     shared.lock().unwrap().status = Status::Open;
    174     shared.stop();
    175     assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
    176 }
    177 
    178 #[test]
    179 fn poisoned_state_refuses_and_cleanup_does_not_panic() {
    180     let (shared, _) = shared(1);
    181     let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
    182         let _guard = shared.state.lock().unwrap();
    183         panic!("deliberate test poison");
    184     }));
    185     assert!(matches!(shared.lock(), Err(Error::Closed)));
    186     assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
    187     assert_eq!(shared.pop(), Err(Error::Closed));
    188     shared.fail(Error::Policy);
    189     shared.stop();
    190     shared.finish();
    191 }
    192 
    193 #[test]
    194 fn admission_callback_can_cancel_before_a_frame_is_exposed() {
    195     let admission = AdmissionCounter::new(true);
    196     let shared = Arc::new(Shared::new(admission.clone(), 8));
    197     *admission.cancelling.lock().unwrap() = Some(Arc::downgrade(&shared));
    198     shared.lock().unwrap().status = Status::Open;
    199     assert_eq!(
    200         shared.push(Frame::Text("original".into())),
    201         Err(Error::Closed)
    202     );
    203     assert_eq!(shared.pop(), Ok(None));
    204 }
    205 
    206 #[test]
    207 fn send_completion_wakes_its_observer_after_releasing_the_host_lock() {
    208     use std::{future::Future, pin::Pin};
    209     struct Observer {
    210         shared: Arc<Shared>,
    211         locked: AtomicBool,
    212     }
    213     impl futures::task::ArcWake for Observer {
    214         fn wake_by_ref(this: &Arc<Self>) {
    215             if this.shared.state.try_lock().is_err() {
    216                 this.locked.store(true, Ordering::SeqCst);
    217             }
    218         }
    219     }
    220     let (shared, _) = open(8);
    221     let shared = Arc::new(shared);
    222     let observer = Arc::new(Observer {
    223         shared: shared.clone(),
    224         locked: AtomicBool::new(false),
    225     });
    226     let waker = futures::task::waker(observer.clone());
    227     let mut context = Context::from_waker(&waker);
    228     let (sender, mut receiver) = oneshot::channel();
    229     assert!(Pin::new(&mut receiver).poll(&mut context).is_pending());
    230     shared.lock().unwrap().outgoing = Some(SendRequest {
    231         frame: Frame::Text("original".into()),
    232         result: sender,
    233     });
    234     shared.finish();
    235     assert!(!observer.locked.load(Ordering::SeqCst));
    236     assert_eq!(
    237         futures::executor::block_on(receiver),
    238         Ok(Err(Error::Closed))
    239     );
    240 }