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 }