deribit-websocket 0.3.1

WebSocket client for Deribit trading platform real-time data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Unit tests for callback module

use deribit_websocket::callback::{MessageHandler, MessageHandlerBuilder};
use deribit_websocket::error::WebSocketError;
use std::sync::{Arc, Mutex};

#[test]
fn test_message_handler_creation() {
    let handler = MessageHandler::new(|_message| Ok(()), |_message, _error| {});

    // handle_message returns () not Option, so we just test it doesn't panic
    handler.handle_message("test");
}

#[test]
fn test_message_handler_success() {
    let processed = Arc::new(Mutex::new(false));
    let processed_clone = processed.clone();

    let handler = MessageHandler::new(
        move |_message| {
            *processed_clone.lock().unwrap() = true;
            Ok(())
        },
        |_message, _error| {},
    );

    handler.handle_message("test message");
    assert!(*processed.lock().unwrap());
}

#[test]
fn test_message_handler_error() {
    let error_called = Arc::new(Mutex::new(false));
    let error_clone = error_called.clone();

    let handler = MessageHandler::new(
        |_message| Err(WebSocketError::InvalidMessage("test error".to_string())),
        move |_message, _error| {
            *error_clone.lock().unwrap() = true;
        },
    );

    handler.handle_message("test message");
    assert!(*error_called.lock().unwrap());
}

#[test]
fn test_message_handler_builder() {
    let processed = Arc::new(Mutex::new(0u32));
    let processed_clone = processed.clone();

    let handler = MessageHandlerBuilder::new()
        .with_message_callback(move |_message| {
            *processed_clone.lock().unwrap() += 1;
            Ok(())
        })
        .with_error_callback(|_message, _error| {})
        .build()
        .expect("Failed to build handler");

    handler.handle_message("message 1");
    handler.handle_message("message 2");

    assert_eq!(*processed.lock().unwrap(), 2);
}

#[test]
fn test_message_handler_builder_missing_callback() {
    let result = MessageHandlerBuilder::new()
        .with_error_callback(|_message, _error| {})
        .build();

    assert!(result.is_err());
}

#[test]
fn test_message_handler_builder_missing_error_callback() {
    let result = MessageHandlerBuilder::new()
        .with_message_callback(|_message| Ok(()))
        .build();

    assert!(result.is_err());
}

#[test]
fn test_message_handler_with_complex_processing() {
    let messages = Arc::new(Mutex::new(Vec::new()));
    let messages_clone = messages.clone();
    let errors = Arc::new(Mutex::new(Vec::new()));
    let errors_clone = errors.clone();

    let handler = MessageHandler::new(
        move |message: &str| {
            messages_clone.lock().unwrap().push(message.to_string());
            if message.contains("error") {
                Err(WebSocketError::InvalidMessage(
                    "Simulated error".to_string(),
                ))
            } else {
                Ok(())
            }
        },
        move |message: &str, error: &WebSocketError| {
            errors_clone
                .lock()
                .unwrap()
                .push((message.to_string(), error.to_string()));
        },
    );

    handler.handle_message("normal message");
    handler.handle_message("error message");
    handler.handle_message("another normal message");

    let messages = messages.lock().unwrap();
    let errors = errors.lock().unwrap();

    assert_eq!(messages.len(), 3);
    assert_eq!(errors.len(), 1);
    assert!(errors[0].0.contains("error message"));
}