iris-chat 0.1.58

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

use super::*;
use futures_util::FutureExt;

#[test]
fn discovery_diagnostics_scope_reconfiguration_preserves_accounting() {
    let counters = Counters::default();
    let mut scope = Scope::with_counters(&counters);
    assert_eq!(counters.snapshot().active_scopes, 1);
    assert_eq!(counters.snapshot().initial_sweeps_pending, 0);
    scope.configured();
    assert_eq!(counters.snapshot().initial_sweeps_pending, 1);
    scope.configured();
    let changed = counters.snapshot();
    assert_eq!(changed.initial_sweeps_cancelled, 1);
    assert_eq!(changed.initial_sweeps_pending, 1);
    assert_eq!(changed.config_resets, 1);
    scope.sweep_completed();
    scope.sweep_completed();
    let completed = counters.snapshot();
    assert_eq!(completed.initial_sweeps_pending, 0);
    assert_eq!(completed.initial_sweeps_completed, 1);
    assert_eq!(completed.repeat_sweeps, 1);
    scope.configured();
    drop(scope);
    let stopped = counters.snapshot();
    assert_eq!(stopped.active_scopes, 0);
    assert_eq!(stopped.initial_sweeps_pending, 0);
    assert_eq!(stopped.initial_sweeps_completed, 1);
    assert_eq!(stopped.initial_sweeps_cancelled, 2);
    assert_eq!(stopped.config_resets, 2);
}

#[test]
fn discovery_diagnostics_cancelled_futures_release_scope_and_open_accounting() {
    let counters = Counters::default();
    let scope = Scope::with_counters(&counters);
    let unpolled = async move {
        let _scope = scope;
        std::future::pending::<()>().await;
    };
    drop(unpolled);
    assert_eq!(counters.snapshot(), Snapshot::default());

    let scope = Scope::with_counters(&counters);
    let mut pending = Box::pin(async {
        let mut scope = scope;
        scope.configured();
        let _opening = OpenAttempt::with_counters(&counters, true);
        std::future::pending::<()>().await;
    });
    assert!(pending.as_mut().now_or_never().is_none());
    assert_eq!(counters.snapshot().initial_sweeps_pending, 1);
    assert_eq!(counters.snapshot().failed_opens, 0);
    drop(pending);
    let cancelled = counters.snapshot();
    assert_eq!(cancelled.active_scopes, 0);
    assert_eq!(cancelled.initial_sweeps_pending, 0);
    assert_eq!(cancelled.initial_sweeps_cancelled, 1);
    assert_eq!(cancelled.initial_sweeps_completed, 0);
    assert_eq!(cancelled.failed_opens, 1);
}

#[test]
fn discovery_diagnostics_open_results_count_once_and_serialize_only_counts() {
    let counters = Counters::default();
    OpenAttempt::with_counters(&counters, true).completed(Some(rustls::HandshakeKind::Full));
    OpenAttempt::with_counters(&counters, false)
        .completed(Some(rustls::HandshakeKind::FullWithHelloRetryRequest));
    OpenAttempt::with_counters(&counters, false).completed(Some(rustls::HandshakeKind::Resumed));
    OpenAttempt::with_counters(&counters, true).completed(None);
    fn failed(counters: &Counters) -> Result<(), ()> {
        let _opening = OpenAttempt::with_counters(counters, false);
        Err(())
    }
    assert!(failed(&counters).is_err());
    let snapshot = counters.snapshot();
    assert_eq!(snapshot.retained_opens, 2);
    assert_eq!(snapshot.disposable_opens, 2);
    assert_eq!(snapshot.failed_opens, 1);
    assert_eq!(snapshot.tls_full, 2);
    assert_eq!(snapshot.tls_resumed, 1);
    let json = serde_json::to_value(snapshot).unwrap();
    let fields = json.as_object().unwrap();
    assert_eq!(fields.len(), 13);
    assert!(fields.values().all(|value| value.as_u64().is_some()));
}