Skip to main content

nautilus_kraken/websocket/futures/
handler.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket message handler for Kraken Futures.
17
18use 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/// Commands sent from the outer client to the inner message handler.
45#[derive(Debug)]
46pub enum FuturesHandlerCommand {
47    SetClient(WebSocketClient),
48    Disconnect,
49    Subscribe { payload: SecretString },
50    Unsubscribe { payload: SecretString },
51    RequestChallenge { payload: SecretString },
52}
53
54/// WebSocket message handler for Kraken Futures.
55pub 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    /// Creates a new [`FuturesFeedHandler`] instance.
66    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    /// Processes messages and commands, returning when stopped or stream ends.
92    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    /// A subscribe that reaches the handler before its `SetClient` is dropped with an error
500    /// naming the lost command, rather than vanishing while the client already answered `Ok`.
501    #[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        // The raw stream stays open so `next` cannot return early: the only ready
510        // branch is the command channel, so the queued subscribe is handled first.
511        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}