iris-chat 0.1.55

Iris Chat command line client and shared encrypted chat core
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

use super::*;

#[test]
fn chunks_are_bounded_additive_camel_case_snapshots() {
    let snapshot = DeviceSyncSnapshot {
        roster_at: 42,
        deleted_chats: Vec::new(),
        chat_mutes: Vec::new(),
        chat_pins: Vec::new(),
        private_contacts_v2: Vec::new(),
        private_device_labels_v2: Vec::new(),
        chats: vec![DeviceSyncChat {
            id: "a".repeat(64),
            updated_at: 41,
            read_state: None,
        }],
        app_keys: vec![DeviceSyncAppKeys {
            owner_pubkey: "a".repeat(64),
            created_at: 42,
            devices: vec![DeviceSyncAppKeyDevice {
                identity_pubkey: "b".repeat(64),
                created_at: 40,
            }],
        }],
        groups: vec![DeviceSyncGroup {
            legacy_message_ttl_seconds: None,
            id: "group".to_string(),
            name: "Group".to_string(),
            description: None,
            picture: None,
            created_by: "b".repeat(64),
            members: vec!["b".repeat(64)],
            admins: vec!["b".repeat(64)],
            protocol: None,
            revision: 0,
            created_at: 1,
            updated_at: 2,
            accepted: Some(true),
        }],
        messages: (0..200)
            .map(|index| DeviceSyncMessage {
                legacy_reactions: None,
                chat_id: "a".repeat(64),
                id: format!("message-{index}"),
                body: "x".repeat(1024),
                author: "b".repeat(64),
                created_at: 43 + index,
                expires_at: None,
            })
            .collect(),
    };
    let packets = encode_device_sync_chunks(snapshot);
    assert!(packets.len() > 1);
    assert!(packets
        .iter()
        .all(|packet| packet.len() <= DEVICE_SYNC_MAX_PACKET_BYTES));
    let json = String::from_utf8(packets[0].clone()).unwrap();
    assert!(json.contains("\"rosterAt\":42"));
    assert!(json.contains("\"appKeys\""));
    assert!(json.contains("\"ownerPubkey\""));
    assert!(json.contains("\"identityPubkey\""));
    assert!(json.contains("\"createdBy\""));
    assert!(json.contains("\"updatedAt\""));
    let app_keys_count = packets
        .iter()
        .map(|packet| serde_json::from_slice::<DeviceSyncPacket>(packet).unwrap())
        .map(|packet| match packet {
            DeviceSyncPacket::Snapshot { app_keys, .. } => app_keys.len(),
            _ => 0,
        })
        .sum::<usize>();
    assert_eq!(app_keys_count, 1);
    let message_count = packets
        .iter()
        .map(|packet| serde_json::from_slice::<DeviceSyncPacket>(packet).unwrap())
        .map(|packet| match packet {
            DeviceSyncPacket::Snapshot { messages, .. } => messages.len(),
            _ => 0,
        })
        .sum::<usize>();
    assert_eq!(message_count, 200);
}

#[test]
fn authorized_siblings_are_enqueued_without_requiring_a_live_fips_peer() {
    let (sender, rx) = DeviceSyncTcpSender::test_channel(4, 1024);
    let identity = fips_core::Identity::generate();
    let sibling = FipsPeerIdentity::from_pubkey_full(identity.pubkey_full());
    let packet = br#"{"type":"snapshot"}"#.to_vec();

    send_device_sync_packets(
        &sender,
        std::slice::from_ref(&sibling),
        std::slice::from_ref(&packet),
    );

    let queued = rx.try_recv().expect("authorized sibling should be queued");
    assert_eq!(queued.peer, sibling);
    assert_eq!(queued.records.into_iter().collect::<Vec<_>>(), vec![packet]);
}