nautilus_kraken/websocket/futures/
handler.rs1use std::{
19 collections::VecDeque,
20 sync::{
21 Arc,
22 atomic::{AtomicBool, Ordering},
23 },
24};
25
26use nautilus_core::string::secret::SecretString;
27use nautilus_network::{
28 RECONNECTED,
29 websocket::{SubscriptionState, WebSocketClient},
30};
31use serde::Deserialize;
32use serde_json::Value;
33use tokio_tungstenite::tungstenite::Message;
34use ustr::Ustr;
35
36use super::messages::{
37 KrakenFuturesBookDelta, KrakenFuturesBookSnapshot, KrakenFuturesChannel,
38 KrakenFuturesFillsDelta, KrakenFuturesMessageType, KrakenFuturesOpenOrdersCancel,
39 KrakenFuturesOpenOrdersDelta, KrakenFuturesTickerData, KrakenFuturesTradeData,
40 KrakenFuturesWsMessage, classify_futures_message,
41};
42use crate::common::consts::KRAKEN_RATE_LIMIT_KEY_SUBSCRIPTION;
43
44#[derive(Debug)]
46pub enum FuturesHandlerCommand {
47 SetClient(WebSocketClient),
48 Disconnect,
49 Subscribe { payload: SecretString },
50 Unsubscribe { payload: SecretString },
51 RequestChallenge { payload: SecretString },
52}
53
54pub struct FuturesFeedHandler {
56 signal: Arc<AtomicBool>,
57 inner: Option<WebSocketClient>,
58 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<FuturesHandlerCommand>,
59 raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
60 subscriptions: SubscriptionState,
61 pending_messages: VecDeque<KrakenFuturesWsMessage>,
62}
63
64impl FuturesFeedHandler {
65 pub fn new(
67 signal: Arc<AtomicBool>,
68 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<FuturesHandlerCommand>,
69 raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
70 subscriptions: SubscriptionState,
71 ) -> Self {
72 Self {
73 signal,
74 inner: None,
75 cmd_rx,
76 raw_rx,
77 subscriptions,
78 pending_messages: VecDeque::new(),
79 }
80 }
81
82 pub fn is_stopped(&self) -> bool {
83 self.signal.load(Ordering::Relaxed)
84 }
85
86 fn is_subscribed(&self, channel: KrakenFuturesChannel, symbol: &Ustr) -> bool {
87 let channel_ustr = Ustr::from(channel.as_ref());
88 self.subscriptions.is_subscribed(&channel_ustr, symbol)
89 }
90
91 pub async fn next(&mut self) -> Option<KrakenFuturesWsMessage> {
93 if let Some(msg) = self.pending_messages.pop_front() {
94 return Some(msg);
95 }
96
97 loop {
98 tokio::select! {
99 Some(cmd) = self.cmd_rx.recv() => {
100 match cmd {
101 FuturesHandlerCommand::SetClient(client) => {
102 log::debug!("WebSocketClient received by futures handler");
103 self.inner = Some(client);
104 }
105 FuturesHandlerCommand::Disconnect => {
106 log::debug!("Disconnect command received");
107
108 if let Some(client) = self.inner.take() {
109 client.disconnect().await;
110 }
111 return None;
112 }
113 FuturesHandlerCommand::Subscribe { payload }
114 | FuturesHandlerCommand::Unsubscribe { payload } => {
115 if let Some(client) = &self.inner {
116 if let Err(e) = client
117 .send_text(
118 payload.expose_secret().to_owned(),
119 Some(KRAKEN_RATE_LIMIT_KEY_SUBSCRIPTION.as_slice()),
120 )
121 .await
122 {
123 log::error!("Failed to send text: {e}");
124 }
125 } else {
126 log::error!(
127 "Kraken Futures WS subscribe or unsubscribe dropped, no active client"
128 );
129 }
130 }
131 FuturesHandlerCommand::RequestChallenge { payload } => {
132 if let Some(ref client) = self.inner
133 && let Err(e) = client.send_text(payload.expose_secret().to_owned(), None).await
134 {
135 log::error!("Failed to send text: {e}");
136 }
137 }
138 }
139 }
140
141 msg = self.raw_rx.recv() => {
142 let msg = match msg {
143 Some(msg) => msg,
144 None => {
145 log::debug!("WebSocket stream closed");
146 return None;
147 }
148 };
149
150 if self.signal.load(Ordering::Relaxed) {
151 log::debug!("Stop signal received");
152 return None;
153 }
154
155 match &msg {
156 Message::Ping(data) => {
157 let len = data.len();
158 log::trace!("Received ping frame with {len} bytes");
159
160 if let Some(client) = &self.inner
161 && let Err(e) = client.send_pong(data.to_vec()).await
162 {
163 log::warn!("Failed to send pong frame: {e}");
164 }
165 continue;
166 }
167 Message::Pong(_) => {
168 log::debug!("Received pong from server");
169 continue;
170 }
171 Message::Close(_) => {
172 log::debug!("WebSocket connection closed");
173 return None;
174 }
175 Message::Frame(_) => {
176 log::trace!("Received raw frame");
177 continue;
178 }
179 _ => {}
180 }
181
182 let text: &str = match &msg {
183 Message::Text(text) => text,
184 Message::Binary(data) => match std::str::from_utf8(data) {
185 Ok(s) => s,
186 Err(_) => continue,
187 },
188 _ => continue,
189 };
190
191 if text == RECONNECTED {
192 log::debug!("Received WebSocket reconnected signal");
193 return Some(KrakenFuturesWsMessage::Reconnected);
194 }
195
196 self.parse_message(text);
197
198 if let Some(msg) = self.pending_messages.pop_front() {
199 return Some(msg);
200 }
201 }
202 }
203 }
204 }
205
206 fn parse_message(&mut self, text: &str) {
207 let value: Value = match serde_json::from_str(text) {
208 Ok(v) => v,
209 Err(e) => {
210 log::debug!("Failed to parse message as JSON: {e}");
211 return;
212 }
213 };
214
215 match classify_futures_message(&value) {
216 KrakenFuturesMessageType::OpenOrdersSnapshot => {
217 log::debug!(
218 "Skipping open_orders_snapshot (REST reconciliation handles initial state)"
219 );
220 }
221 KrakenFuturesMessageType::OpenOrdersCancel => {
222 self.handle_open_orders_cancel_text(text);
223 }
224 KrakenFuturesMessageType::OpenOrdersDelta => {
225 self.handle_open_orders_delta_text(text);
226 }
227 KrakenFuturesMessageType::FillsSnapshot => {
228 log::debug!("Skipping fills_snapshot (REST reconciliation handles initial state)");
229 }
230 KrakenFuturesMessageType::FillsDelta => {
231 self.handle_fills_delta_text(text);
232 }
233 KrakenFuturesMessageType::Ticker => {
234 self.handle_ticker_message_text(text);
235 }
236 KrakenFuturesMessageType::TradeSnapshot => {
237 log::debug!("Skipping trade_snapshot (only streaming live trades)");
238 }
239 KrakenFuturesMessageType::Trade => {
240 self.handle_trade_message_text(text);
241 }
242 KrakenFuturesMessageType::BookSnapshot => {
243 self.handle_book_snapshot_text(text);
244 }
245 KrakenFuturesMessageType::BookDelta => {
246 self.handle_book_delta_text(text);
247 }
248 KrakenFuturesMessageType::Info => {
249 log::debug!("Received info message: {text}");
250 }
251 KrakenFuturesMessageType::Pong => {
252 log::debug!("Received text pong response");
253 }
254 KrakenFuturesMessageType::Subscribed => {
255 log::debug!("Subscription confirmed: {text}");
256 }
257 KrakenFuturesMessageType::Unsubscribed => {
258 log::debug!("Unsubscription confirmed: {text}");
259 }
260 KrakenFuturesMessageType::Challenge => {
261 self.handle_challenge_response_text(text);
262 }
263 KrakenFuturesMessageType::Heartbeat => {
264 log::trace!("Heartbeat received");
265 }
266 KrakenFuturesMessageType::Error => {
267 let message = value
268 .get("message")
269 .and_then(|v| v.as_str())
270 .unwrap_or("Unknown error");
271 log::warn!("Kraken Futures WebSocket error: {message}");
272 }
273 KrakenFuturesMessageType::Alert => {
274 let message = value
275 .get("message")
276 .and_then(|v| v.as_str())
277 .unwrap_or("Unknown alert");
278 log::warn!("Kraken Futures WebSocket alert: {message}");
279 }
280 KrakenFuturesMessageType::Unknown => {
281 log::warn!("Unhandled futures message: {text}");
282 }
283 }
284 }
285
286 fn handle_challenge_response_text(&mut self, text: &str) {
287 #[derive(Deserialize)]
288 struct ChallengeResponse {
289 message: String,
290 }
291
292 match serde_json::from_str::<ChallengeResponse>(text) {
293 Ok(response) => {
294 let len = response.message.len();
295 log::debug!("Challenge received, length: {len}");
296
297 self.pending_messages
298 .push_back(KrakenFuturesWsMessage::Challenge(response.message));
299 }
300 Err(e) => {
301 log::error!("Failed to parse challenge response: {e}");
302 }
303 }
304 }
305
306 fn handle_ticker_message_text(&mut self, text: &str) {
307 let ticker = match serde_json::from_str::<KrakenFuturesTickerData>(text) {
308 Ok(t) => t,
309 Err(e) => {
310 log::debug!("Failed to parse ticker: {e}");
311 return;
312 }
313 };
314
315 self.pending_messages
316 .push_back(KrakenFuturesWsMessage::Ticker(ticker));
317 }
318
319 fn handle_trade_message_text(&mut self, text: &str) {
320 let trade = match serde_json::from_str::<KrakenFuturesTradeData>(text) {
321 Ok(t) => t,
322 Err(e) => {
323 log::warn!("Failed to parse trade: {e}");
324 return;
325 }
326 };
327
328 if !self.is_subscribed(KrakenFuturesChannel::Trades, &trade.product_id) {
329 log::debug!(
330 "Received trade for unsubscribed product: {}",
331 trade.product_id
332 );
333 return;
334 }
335
336 self.pending_messages
337 .push_back(KrakenFuturesWsMessage::Trade(trade));
338 }
339
340 fn handle_book_snapshot_text(&mut self, text: &str) {
341 let snapshot = match serde_json::from_str::<KrakenFuturesBookSnapshot>(text) {
342 Ok(s) => s,
343 Err(e) => {
344 log::warn!("Failed to parse book snapshot: {e}");
345 return;
346 }
347 };
348
349 let has_book = self.is_subscribed(KrakenFuturesChannel::Book, &snapshot.product_id);
350 let has_quotes = self.is_subscribed(KrakenFuturesChannel::Quotes, &snapshot.product_id);
351
352 if !has_book && !has_quotes {
353 log::debug!(
354 "Received book snapshot for unsubscribed product: {}",
355 snapshot.product_id
356 );
357 return;
358 }
359
360 self.pending_messages
361 .push_back(KrakenFuturesWsMessage::BookSnapshot(snapshot));
362 }
363
364 fn handle_book_delta_text(&mut self, text: &str) {
365 let delta = match serde_json::from_str::<KrakenFuturesBookDelta>(text) {
366 Ok(d) => d,
367 Err(e) => {
368 log::warn!("Failed to parse book delta: {e}");
369 return;
370 }
371 };
372
373 let has_book = self.is_subscribed(KrakenFuturesChannel::Book, &delta.product_id);
374 let has_quotes = self.is_subscribed(KrakenFuturesChannel::Quotes, &delta.product_id);
375
376 if !has_book && !has_quotes {
377 log::debug!(
378 "Received book delta for unsubscribed product: {}",
379 delta.product_id
380 );
381 return;
382 }
383
384 self.pending_messages
385 .push_back(KrakenFuturesWsMessage::BookDelta(delta));
386 }
387
388 fn handle_open_orders_delta_text(&mut self, text: &str) {
389 let delta = match serde_json::from_str::<KrakenFuturesOpenOrdersDelta>(text) {
390 Ok(d) => d,
391 Err(e) => {
392 log::error!("Failed to parse open_orders delta: {e}");
393 return;
394 }
395 };
396
397 log::debug!(
398 "Received open_orders delta: order_id={}, is_cancel={}, reason={:?}",
399 delta.order.order_id,
400 delta.is_cancel,
401 delta.reason
402 );
403
404 self.pending_messages
405 .push_back(KrakenFuturesWsMessage::OpenOrdersDelta(delta));
406 }
407
408 fn handle_open_orders_cancel_text(&mut self, text: &str) {
409 let cancel = match serde_json::from_str::<KrakenFuturesOpenOrdersCancel>(text) {
410 Ok(c) => c,
411 Err(e) => {
412 log::error!("Failed to parse open_orders cancel: {e}");
413 return;
414 }
415 };
416
417 log::debug!(
418 "Received open_orders cancel: order_id={}, cli_ord_id={:?}, reason={:?}",
419 cancel.order_id,
420 cancel.cli_ord_id,
421 cancel.reason
422 );
423
424 self.pending_messages
425 .push_back(KrakenFuturesWsMessage::OpenOrdersCancel(cancel));
426 }
427
428 fn handle_fills_delta_text(&mut self, text: &str) {
429 let delta = match serde_json::from_str::<KrakenFuturesFillsDelta>(text) {
430 Ok(d) => d,
431 Err(e) => {
432 log::error!("Failed to parse fills delta: {e}");
433 return;
434 }
435 };
436
437 log::debug!("Received fills delta: fill_count={}", delta.fills.len());
438
439 self.pending_messages
440 .push_back(KrakenFuturesWsMessage::FillsDelta(delta));
441 }
442}
443
444#[cfg(test)]
445mod tests {
446 use std::time::Duration;
447
448 use nautilus_core::string::secret::REDACTED;
449 use parking_lot::Mutex;
450 use rstest::rstest;
451 use rust_decimal_macros::dec;
452
453 use super::*;
454
455 fn create_test_handler() -> FuturesFeedHandler {
456 let signal = Arc::new(AtomicBool::new(false));
457 let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
458 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
459 let subscriptions = SubscriptionState::new(':');
460
461 FuturesFeedHandler::new(signal, cmd_rx, raw_rx, subscriptions)
462 }
463
464 #[rstest]
465 fn test_command_debug_redacts_payload() {
466 let command = FuturesHandlerCommand::RequestChallenge {
467 payload: SecretString::from("private-challenge-payload"),
468 };
469
470 assert_eq!(
471 format!("{command:?}"),
472 format!("RequestChallenge {{ payload: {REDACTED} }}")
473 );
474 }
475
476 struct DroppedCommandLogCapture {
477 messages: Mutex<Vec<String>>,
478 }
479
480 static DROPPED_COMMAND_LOG_CAPTURE: DroppedCommandLogCapture = DroppedCommandLogCapture {
481 messages: Mutex::new(Vec::new()),
482 };
483
484 impl log::Log for DroppedCommandLogCapture {
485 fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
486 metadata.level() == log::Level::Error
487 && metadata.target() == "nautilus_kraken::websocket::futures::handler"
488 }
489
490 fn log(&self, record: &log::Record<'_>) {
491 if self.enabled(record.metadata()) {
492 self.messages.lock().push(record.args().to_string());
493 }
494 }
495
496 fn flush(&self) {}
497 }
498
499 #[rstest]
502 #[tokio::test]
503 async fn test_subscribe_without_active_client_logs_dropped_command() {
504 log::set_logger(&DROPPED_COMMAND_LOG_CAPTURE).expect("test logger already installed");
505 log::set_max_level(log::LevelFilter::Error);
506
507 let signal = Arc::new(AtomicBool::new(false));
508 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
509 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel::<Message>();
512 let subscriptions = SubscriptionState::new(':');
513
514 let mut handler = FuturesFeedHandler::new(signal, cmd_rx, raw_rx, subscriptions);
515
516 cmd_tx
517 .send(FuturesHandlerCommand::Subscribe {
518 payload: SecretString::from(
519 r#"{"event":"subscribe","feed":"trade","token":"SUBSCRIBE_SECRET_MARKER"}"#
520 .to_string(),
521 ),
522 })
523 .unwrap();
524
525 drop(cmd_tx);
526
527 let mut next = std::pin::pin!(handler.next());
528 let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
529
530 while DROPPED_COMMAND_LOG_CAPTURE.messages.lock().is_empty() {
531 assert!(
532 tokio::time::Instant::now() < deadline,
533 "handler never processed the queued subscribe"
534 );
535 let _ = tokio::time::timeout(Duration::from_millis(10), next.as_mut()).await;
536 }
537
538 let messages = DROPPED_COMMAND_LOG_CAPTURE.messages.lock().clone();
539 assert_eq!(
540 messages,
541 vec![
542 "Kraken Futures WS subscribe or unsubscribe dropped, no active client".to_string()
543 ],
544 "a subscribe without an active client must log the dropped command"
545 );
546 assert!(
547 !messages.join("\n").contains("SUBSCRIBE_SECRET_MARKER"),
548 "dropped-command log must not leak the payload"
549 );
550 }
551
552 #[rstest]
553 fn test_parse_ticker_emits_ticker_message() {
554 let mut handler = create_test_handler();
555 let json = include_str!("../../../test_data/ws_futures_ticker.json");
556
557 handler.parse_message(json);
558
559 assert_eq!(handler.pending_messages.len(), 1);
560 let msg = handler.pending_messages.pop_front().unwrap();
561 let KrakenFuturesWsMessage::Ticker(ticker) = msg else {
562 panic!("Expected Ticker message, was {msg:?}");
563 };
564 assert_eq!(ticker.product_id, Ustr::from("PI_XBTUSD"));
565 assert_eq!(ticker.bid, Some(dec!(21978.5)));
566 assert_eq!(ticker.ask, Some(dec!(21987)));
567 }
568
569 #[rstest]
570 fn test_parse_trade_emits_trade_message() {
571 let mut handler = create_test_handler();
572 handler.subscriptions.mark_subscribe("trades:PI_XBTUSD");
573 handler.subscriptions.confirm_subscribe("trades:PI_XBTUSD");
574
575 let json = include_str!("../../../test_data/ws_futures_trade.json");
576
577 handler.parse_message(json);
578
579 assert_eq!(handler.pending_messages.len(), 1);
580 let msg = handler.pending_messages.pop_front().unwrap();
581 let KrakenFuturesWsMessage::Trade(trade) = msg else {
582 panic!("Expected Trade message, was {msg:?}");
583 };
584 assert_eq!(trade.product_id, Ustr::from("PI_XBTUSD"));
585 assert_eq!(trade.price, dec!(34969.5));
586 assert_eq!(trade.qty, dec!(15000));
587 }
588
589 #[rstest]
590 fn test_parse_trade_filters_unsubscribed() {
591 let mut handler = create_test_handler();
592 let json = include_str!("../../../test_data/ws_futures_trade.json");
593
594 handler.parse_message(json);
595
596 assert!(
597 handler.pending_messages.is_empty(),
598 "Trade for unsubscribed product should be filtered"
599 );
600 }
601
602 #[rstest]
603 fn test_parse_book_snapshot_emits_book_snapshot() {
604 let mut handler = create_test_handler();
605 handler.subscriptions.mark_subscribe("book:PI_XBTUSD");
606 handler.subscriptions.confirm_subscribe("book:PI_XBTUSD");
607
608 let json = include_str!("../../../test_data/ws_futures_book_snapshot.json");
609
610 handler.parse_message(json);
611
612 assert_eq!(handler.pending_messages.len(), 1);
613 let msg = handler.pending_messages.pop_front().unwrap();
614 let KrakenFuturesWsMessage::BookSnapshot(snapshot) = msg else {
615 panic!("Expected BookSnapshot message, was {msg:?}");
616 };
617 assert_eq!(snapshot.product_id, Ustr::from("PI_XBTUSD"));
618 assert_eq!(snapshot.bids.len(), 2);
619 assert_eq!(snapshot.asks.len(), 2);
620 }
621
622 #[rstest]
623 fn test_parse_book_snapshot_filters_unsubscribed() {
624 let mut handler = create_test_handler();
625 let json = include_str!("../../../test_data/ws_futures_book_snapshot.json");
626
627 handler.parse_message(json);
628
629 assert!(
630 handler.pending_messages.is_empty(),
631 "Book snapshot for unsubscribed product should be filtered"
632 );
633 }
634
635 #[rstest]
636 fn test_parse_book_delta_emits_book_delta() {
637 let mut handler = create_test_handler();
638 handler.subscriptions.mark_subscribe("book:PI_XBTUSD");
639 handler.subscriptions.confirm_subscribe("book:PI_XBTUSD");
640
641 let json = include_str!("../../../test_data/ws_futures_book_delta.json");
642
643 handler.parse_message(json);
644
645 assert_eq!(handler.pending_messages.len(), 1);
646 let msg = handler.pending_messages.pop_front().unwrap();
647 let KrakenFuturesWsMessage::BookDelta(delta) = msg else {
648 panic!("Expected BookDelta message, was {msg:?}");
649 };
650 assert_eq!(delta.product_id, Ustr::from("PI_XBTUSD"));
651 assert_eq!(delta.price, dec!(34981));
652 }
653
654 #[rstest]
655 fn test_parse_book_delta_preserves_decimal_precision() {
656 let mut handler = create_test_handler();
657 handler.subscriptions.mark_subscribe("book:PI_XBTUSD");
658 handler.subscriptions.confirm_subscribe("book:PI_XBTUSD");
659 let json = include_str!("../../../test_data/ws_futures_book_precision.json");
660
661 handler.parse_message(json);
662
663 let message = handler.pending_messages.pop_front().unwrap();
664 let KrakenFuturesWsMessage::BookDelta(delta) = message else {
665 panic!("Expected BookDelta message, was {message:?}");
666 };
667 assert_eq!(delta.price, dec!(123456789.123456789));
668 assert_eq!(delta.qty, dec!(0.1234567890123456789012345678));
669 }
670
671 #[rstest]
672 fn test_parse_book_delta_filters_unsubscribed() {
673 let mut handler = create_test_handler();
674 let json = include_str!("../../../test_data/ws_futures_book_delta.json");
675
676 handler.parse_message(json);
677
678 assert!(
679 handler.pending_messages.is_empty(),
680 "Book delta for unsubscribed product should be filtered"
681 );
682 }
683
684 #[rstest]
685 fn test_parse_open_orders_cancel_emits_cancel() {
686 let mut handler = create_test_handler();
687 let json = include_str!("../../../test_data/ws_futures_open_orders_cancel.json");
688
689 handler.parse_message(json);
690
691 assert_eq!(handler.pending_messages.len(), 1);
692 let msg = handler.pending_messages.pop_front().unwrap();
693 let KrakenFuturesWsMessage::OpenOrdersCancel(cancel) = msg else {
694 panic!("Expected OpenOrdersCancel message, was {msg:?}");
695 };
696 assert_eq!(cancel.order_id, "660c6b23-8007-48c1-a7c9-4893f4572e8c");
697 assert!(cancel.is_cancel);
698 }
699
700 #[rstest]
701 fn test_parse_open_orders_delta_emits_delta() {
702 let mut handler = create_test_handler();
703 let json = include_str!("../../../test_data/ws_futures_open_orders_delta.json");
704
705 handler.parse_message(json);
706
707 assert_eq!(handler.pending_messages.len(), 1);
708 let msg = handler.pending_messages.pop_front().unwrap();
709 let KrakenFuturesWsMessage::OpenOrdersDelta(delta) = msg else {
710 panic!("Expected OpenOrdersDelta message, was {msg:?}");
711 };
712 assert_eq!(delta.order.instrument, Ustr::from("PI_XBTUSD"));
713 assert!(!delta.is_cancel);
714 }
715
716 #[rstest]
717 fn test_parse_fills_delta_emits_fills() {
718 let mut handler = create_test_handler();
719 let json = include_str!("../../../test_data/ws_futures_fills_delta.json");
720
721 handler.parse_message(json);
722
723 assert_eq!(handler.pending_messages.len(), 1);
724 let msg = handler.pending_messages.pop_front().unwrap();
725 let KrakenFuturesWsMessage::FillsDelta(fills) = msg else {
726 panic!("Expected FillsDelta message, was {msg:?}");
727 };
728 assert_eq!(fills.fills.len(), 1);
729 assert_eq!(
730 fills.fills[0].fill_id,
731 "6a22a3fb-e18e-4e76-b841-8689735c9158"
732 );
733 }
734
735 #[rstest]
736 fn test_parse_challenge_emits_challenge_message() {
737 let mut handler = create_test_handler();
738 let json = r#"{"event":"challenge","message":"server-challenge-abc"}"#;
739
740 handler.parse_message(json);
741
742 assert_eq!(handler.pending_messages.len(), 1);
743 let msg = handler.pending_messages.pop_front().unwrap();
744 let KrakenFuturesWsMessage::Challenge(challenge) = msg else {
745 panic!("Expected Challenge message, was {msg:?}");
746 };
747 assert_eq!(challenge, "server-challenge-abc");
748 }
749
750 #[rstest]
751 fn test_heartbeat_produces_no_message() {
752 let mut handler = create_test_handler();
753 let json = r#"{"feed":"heartbeat","time":1700000000000}"#;
754
755 handler.parse_message(json);
756
757 assert!(handler.pending_messages.is_empty());
758 }
759
760 #[rstest]
761 fn test_info_event_produces_no_message() {
762 let mut handler = create_test_handler();
763 let json = r#"{"event":"info","version":1}"#;
764
765 handler.parse_message(json);
766
767 assert!(handler.pending_messages.is_empty());
768 }
769}