elura-cli 0.2.10

Project scaffold generator for Elura applications
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

use bytes::Bytes;
use elura_protocol::{
    ELR2_VERSION, Elr2Codec, Elr2Frame, EluraProtocol, EluraRoutes, FrameKind, Identity,
    ReconnectTicketResponse, SessionControl, SessionControlAction, SessionControlCodec,
};
#[cfg(feature = "tokio-codec")]
use tokio_util::codec::{Decoder, Encoder};

#[test]
fn elr2_v2_golden_vector_round_trip() {
    assert_eq!(ELR2_VERSION, 2);
    let request = Elr2Frame::request_with_sequence(100, 7, 11, "hello").unwrap();
    let expected = [
        0x45, 0x4c, 0x52, 0x32, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x05, 0x68, 0x65,
        0x6c, 0x6c, 0x6f,
    ];
    assert_eq!(Elr2Codec::encode(&request).unwrap().as_ref(), expected);
    assert_eq!(Elr2Codec::decode(&expected).unwrap(), request);
}

#[cfg(feature = "tokio-codec")]
#[test]
fn tokio_codec_stream_round_trip() {
    let request = Elr2Frame::request_with_sequence(100, 7, 11, "hello").unwrap();
    let mut encoded = bytes::BytesMut::new();
    Elr2Codec::default()
        .encode(request.clone(), &mut encoded)
        .unwrap();
    let split = encoded.split_off(10);
    let mut decoder = Elr2Codec::default();
    assert!(decoder.decode(&mut encoded).unwrap().is_none());
    encoded.extend_from_slice(&split);
    assert_eq!(decoder.decode(&mut encoded).unwrap(), Some(request));
}

#[test]
fn elura_protocol_payloads_and_session_control_round_trip() {
    let auth = EluraProtocol::authenticate(8, "ticket-value").unwrap();
    assert_eq!(auth.route, EluraRoutes::AUTHENTICATE);
    assert_eq!(
        auth.payload,
        Bytes::from_static(br#"{"ticket":"ticket-value"}"#)
    );

    let response = Elr2Frame::response(
        &auth,
        serde_json::to_vec(&serde_json::json!({
            "session_id": "session-1",
            "identity": {
                "account_id": 1,
                "user_id": 2,
                "region_id": 3,
                "realm_id": 4,
                "generation": 5
            },
            "reconnect": {
                "ticket": "next-ticket",
                "expires_in_seconds": 60
            }
        }))
        .unwrap(),
    )
    .unwrap();
    let authenticated = EluraProtocol::decode_authenticate(&response).unwrap();
    assert_eq!(
        authenticated.identity,
        Identity {
            account_id: 1,
            user_id: 2,
            region_id: 3,
            realm_id: 4,
            generation: 5,
        }
    );
    assert_eq!(
        authenticated.reconnect,
        ReconnectTicketResponse {
            ticket: "next-ticket".into(),
            expires_in_seconds: 60,
        }
    );

    let heartbeat = Elr2Frame::request(EluraRoutes::HEARTBEAT, 9, Bytes::new()).unwrap();
    let reply = EluraProtocol::heartbeat_response(&heartbeat).unwrap();
    assert_eq!(reply.kind, FrameKind::Response);
    assert_eq!(reply.request_id, heartbeat.request_id);

    let control = SessionControl {
        action: SessionControlAction::AccountVersionChanged,
        reason: "credentials rotated".into(),
    };
    let encoded = SessionControlCodec::encode(&control).unwrap();
    assert_eq!(
        encoded.as_ref(),
        [
            0x08, 0x02, 0x12, 0x13, b'c', b'r', b'e', b'd', b'e', b'n', b't', b'i', b'a', b'l',
            b's', b' ', b'r', b'o', b't', b'a', b't', b'e', b'd',
        ]
    );
    assert_eq!(SessionControlCodec::decode(&encoded).unwrap(), control);
}