opentalk-roomserver-types-e2ee 0.0.32

Opentalk RoomServer E2EE Types
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

// SPDX-License-Identifier: EUPL-1.2
// SPDX-FileCopyrightText: OpenTalk Team <mail@opentalk.eu>

use opentalk_roomserver_signaling::signaling_module::CreateReplica;
use opentalk_roomserver_types::connection_id::ConnectionId;
use serde::{Deserialize, Serialize};

use crate::{E2eeEvent, MlsMessages, WelcomeMessage};

#[derive(Deserialize, Serialize, PartialEq, Debug)]
#[serde(tag = "action", rename_all = "snake_case")]
pub enum E2eeCommand {
    Invite {
        invitee: ConnectionId,
        welcome_message: WelcomeMessage,
        /// Proposal and commit sent to the existing members of the group
        mls_messages: MlsMessages,
    },
    Message(MlsMessages),
}

impl CreateReplica<E2eeEvent> for E2eeCommand {
    fn replicate(&self) -> Option<E2eeEvent> {
        // Replication is handled by the module.
        None
    }
}

#[cfg(test)]
mod tests {

    use std::str::FromStr;

    use bytes::Bytes;
    use opentalk_roomserver_types::connection_id::ConnectionId;
    use pretty_assertions::assert_eq;
    use serde_json::json;

    use super::*;
    use crate::WelcomeMessage;

    const SAMPLE_UUID: &str = "6650b3e2-5f1c-4073-951e-cc4bcd6ddfef";

    fn sample_invite_command() -> E2eeCommand {
        E2eeCommand::Invite {
            invitee: ConnectionId::from_str(SAMPLE_UUID).expect("SAMPLE_UUID must be a valid UUID"),
            welcome_message: WelcomeMessage {
                welcome: Bytes::from_static(b"welcome-bytes"),
                ratchet_tree: Bytes::from_static(b"ratchet-tree-bytes"),
            },
            mls_messages: MlsMessages {
                payload: vec![Bytes::from_static(b"mls1"), Bytes::from_static(b"mls2")],
            },
        }
    }

    fn sample_mls_messages() -> MlsMessages {
        MlsMessages {
            payload: vec![Bytes::from_static(b"mls1"), Bytes::from_static(b"mls2")],
        }
    }

    #[test]
    fn serialize_invite_command() {
        let cmd = sample_invite_command();
        let serialized = serde_json::to_value(&cmd).unwrap();

        let expected = json!({
            "action": "invite",
            "invitee": SAMPLE_UUID,
            "welcome_message": {
                "welcome": b"welcome-bytes",
                "ratchet_tree": b"ratchet-tree-bytes",
            },
            "mls_messages": {
                "payload": [
                    b"mls1",
                    b"mls2",
                ]
            }
        });

        assert_eq!(
            serialized, expected,
            "Invite serialization mismatch.\nExpected: {expected:?}\nGot: {serialized:?}"
        );
    }

    #[test]
    fn serialize_message_command() {
        let mls_messages = sample_mls_messages();
        let cmd = E2eeCommand::Message(mls_messages.clone());
        let serialized = serde_json::to_value(&cmd).unwrap();

        let expected = json!({
            "action": "message",
            "payload": [
                b"mls1",
                b"mls2",
            ]
        });

        assert_eq!(
            serialized, expected,
            "Message serialization mismatch.\nExpected: {expected:?}\nGot: {serialized:?}"
        );
    }

    #[test]
    fn deserialize_invite_command() {
        let expected = sample_invite_command();
        let value = json!({
            "action": "invite",
            "invitee": SAMPLE_UUID,
            "welcome_message": {
                "welcome": b"welcome-bytes",
                "ratchet_tree": b"ratchet-tree-bytes",
            },
            "mls_messages": {
                "payload": [
                    b"mls1",
                    b"mls2",
                ]
            }
        });

        let cmd: E2eeCommand = serde_json::from_value(value).unwrap();
        assert_eq!(cmd, expected);
    }

    #[test]
    fn deserialize_message_command() {
        let mls_messages = sample_mls_messages();
        let value = json!({
            "action": "message",
            "payload": [
                b"mls1",
                b"mls2",
            ]
        });

        let cmd: E2eeCommand = serde_json::from_value(value).unwrap();
        assert_eq!(cmd, E2eeCommand::Message(mls_messages.clone()),);
    }

    #[test]
    fn replicate_message() {
        let mls_messages = sample_mls_messages();
        let cmd = E2eeCommand::Message(mls_messages.clone());
        let event = cmd.replicate();
        assert_eq!(event, None);
    }
}