deribit-websocket 0.3.0

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

//! Authentication flow against the mock server.
//!
//! Verifies that `DeribitWebSocketClient::authenticate` sends a
//! `public/auth` JSON-RPC request, that the returned `AuthResponse` is
//! parsed from the server reply, and that the whole round-trip
//! completes without panics.

use std::time::Duration;

use futures_util::{SinkExt, StreamExt};
use serde_json::Value;
use tokio::time::timeout;
use tokio_tungstenite::tungstenite::Message;

use super::helpers::client::mock_client;
use super::helpers::frames::auth_success;
use super::helpers::mock_server::spawn_mock_server;

#[tokio::test]
async fn authenticate_round_trip_against_mock() {
    let server = spawn_mock_server(|mut sink, mut stream| async move {
        // Read the single `public/auth` request and reply with a canned
        // AuthResponse carrying the id the client assigned.
        if let Some(Ok(Message::Text(text))) = stream.next().await {
            let request: Value = serde_json::from_str(&text).expect("auth request parses as JSON");
            assert_eq!(
                request["method"], "public/auth",
                "first frame must be public/auth, got {}",
                request["method"]
            );
            let id = request.get("id").cloned().unwrap_or(Value::Null);
            let _ = sink.send(Message::Text(auth_success(&id).into())).await;
        }
        // Keep the sink alive briefly so the client can read the reply.
        tokio::time::sleep(Duration::from_millis(50)).await;
    })
    .await;

    let client = mock_client(&server);

    timeout(Duration::from_secs(5), async {
        client.connect().await.expect("connect succeeds");

        let auth = client
            .authenticate("mock-id", "mock-secret")
            .await
            .expect("authenticate succeeds");

        assert_eq!(auth.access_token, "mock-access-token");
        assert_eq!(auth.token_type, "bearer");
        assert_eq!(auth.expires_in, 900);
        assert_eq!(auth.refresh_token, "mock-refresh-token");
        assert_eq!(auth.scope, "session:mock");

        client.disconnect().await.expect("disconnect succeeds");
    })
    .await
    .expect("auth flow finishes within 5s");

    // Surface any panic from the server scenario closure.
    server.finish().await;
}