structured-cms 0.13.0

Borrowed CMS signatures, digital envelopes and timestamps with explicit providers and resource accounting
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

//! Freshness facts cannot turn absent accuracy into zero or hide failed checks.

use structured_cms::timestamp::{
    Accuracy, BoundUncertainty, RequestWindow, Timeliness, timeliness,
};
use structured_pkix::temporal::{Instant, LeapTable, Reading};

fn at(seconds: i64) -> Instant {
    Instant::new(seconds, 0).unwrap()
}

#[test]
fn nonce_does_not_override_performed_future_or_window_failure() {
    // Independently matching nonce never erases a completed negative temporal
    // comparison, including when only one accuracy endpoint crosses the window.
    let utc = LeapTable::new(0, 100, &[]).unwrap();
    let window = RequestWindow::for_unique_imprint(at(45), at(55)).unwrap();
    let reading = Reading::from(at(50));
    assert_eq!(
        timeliness(
            reading,
            Some(Accuracy::new(1, 0, 0)),
            &utc,
            Some(at(48)),
            true,
            Some(true),
            Some(window)
        ),
        Timeliness::Future
    );
    assert_eq!(
        timeliness(
            reading,
            Some(Accuracy::new(6, 0, 0)),
            &utc,
            Some(at(90)),
            true,
            Some(true),
            Some(window)
        ),
        Timeliness::OutsideWindow
    );
    assert_eq!(
        timeliness(
            reading,
            Some(Accuracy::new(5, 0, 0)),
            &utc,
            Some(at(90)),
            true,
            Some(true),
            Some(window)
        ),
        Timeliness::LocalWindow
    );
}

#[test]
fn unstated_accuracy_nonce_fallback_and_archived_evidence_stay_distinct() {
    // Missing accuracy never yields a zero interval. Nonce can independently
    // establish live-response freshness, but archived facts claim no live request.
    let utc = LeapTable::new(0, 100, &[]).unwrap();
    let reading = Reading::from(at(50));
    let window = RequestWindow::for_unique_imprint(at(45), at(55)).unwrap();
    assert_eq!(
        timeliness(
            reading,
            None,
            &utc,
            Some(at(90)),
            true,
            Some(true),
            Some(window)
        ),
        Timeliness::RequestNonce
    );
    assert_eq!(
        timeliness(
            reading,
            None,
            &utc,
            Some(at(90)),
            true,
            Some(false),
            Some(window)
        ),
        Timeliness::Uncertain(BoundUncertainty::AccuracyUnstated)
    );
    assert_eq!(
        timeliness(
            reading,
            Some(Accuracy::new(0, 0, 0)),
            &utc,
            Some(at(90)),
            false,
            None,
            None
        ),
        Timeliness::NotRequested
    );
    assert_eq!(
        timeliness(reading, None, &utc, None, true, Some(false), None),
        Timeliness::Unverified
    );
    assert!(RequestWindow::for_unique_imprint(at(55), at(45)).is_none());
}