cesr-rs 0.8.0

CESR + KERI primitives for Rust as a single feature-gated, no_std-capable crate
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

//! Parity-gate harness vs keripy (issue #151).
//!
//! The "missing middle" between primitive byte-diffing (`keripy_diff`) and the
//! event-wire corpus (#145): replays checked-in, keripy-generated codex /
//! formula / validation vectors and asserts cesr agrees. Vectors carrying a
//! `divergence` marker are deliberate non-goals recorded in
//! `docs/keripy-parity/ledger.md`; temporarily-open gaps (#150
//! `TRACKED_SEALS`, #160 `TRACKED` said-codes) live in Rust-side tracked
//! tables next to `#[ignore]`d bug-probe tests that FAIL while the gap
//! exists. #149 (witness semantics)
//! is closed: its probe is deleted, its tables emptied, and its rows assert
//! live in the validation sweep.

use serde::Deserialize;
use serde_json::Value;
use std::string::String;
use std::vec::Vec;

mod codex;
mod formulas;
mod said_codes;
mod validation;

#[derive(Debug, Deserialize)]
struct CodexVector {
    pub kind: String,
    pub family: String,
    pub name: String,
    #[serde(default)]
    pub code: String,
    #[serde(default)]
    pub qb64: String,
    #[serde(default)]
    #[allow(
        dead_code,
        reason = "corpus-carried keripy field list (full row representability); sweeps assert via code/qb64/sample instead"
    )]
    pub fields: Vec<String>,
    pub sample: Option<Value>,
    pub divergence: Option<String>,
}

#[derive(Debug, Deserialize)]
struct FormulaVector {
    pub kind: String,
    pub formula: String,
    pub n: Option<u64>,
    pub weak: Option<bool>,
    pub m: Option<u64>,
    pub sith: Option<Value>,
    #[serde(default)]
    pub indices: Vec<u32>,
    pub satisfies: Option<bool>,
    #[allow(
        dead_code,
        reason = "corpus-carried keripy exception name (full row representability); no sweep asserts it yet"
    )]
    pub error: Option<String>,
    pub divergence: Option<String>,
}

#[derive(Debug, Deserialize)]
struct ValidationVector {
    pub kind: String,
    pub factory: String,
    pub case: String,
    pub params: Value,
    pub raises: Option<String>,
    #[serde(default)]
    pub message: String,
    pub rust_static: Option<String>,
}

// Embedded at compile time (`include_str!`) for the same reason as
// `keripy_diff`: the nix gate builds and runs tests in separate hermetic
// phases, so runtime manifest-relative paths do not survive to nextest.
#[allow(
    clippy::panic,
    reason = "test-only corpus loader: panics on malformed corpus fixtures"
)]
fn parse_lines<T: serde::de::DeserializeOwned>(text: &str) -> Vec<T> {
    text.lines()
        .filter(|l| !l.trim().is_empty())
        .map(|l| serde_json::from_str::<T>(l).unwrap_or_else(|e| panic!("parse `{l}`: {e}")))
        .collect()
}

fn load_codex() -> Vec<CodexVector> {
    parse_lines(include_str!("../../tests/corpus/keripy/parity/codex.jsonl"))
}

fn load_formulas() -> Vec<FormulaVector> {
    parse_lines(include_str!(
        "../../tests/corpus/keripy/parity/formulas.jsonl"
    ))
}

fn load_validation() -> Vec<ValidationVector> {
    parse_lines(include_str!(
        "../../tests/corpus/keripy/parity/validation.jsonl"
    ))
}

#[derive(Debug, Deserialize)]
struct SaidCodeVector {
    pub kind: String,
    pub factory: String,
    pub case: String,
    #[serde(default)]
    pub code: String,
    pub raw_b64: String,
    pub said: String,
    pub pre: String,
}

fn load_said_codes() -> Vec<SaidCodeVector> {
    parse_lines(include_str!(
        "../../tests/corpus/keripy/parity/said_codes.jsonl"
    ))
}

#[cfg(test)]
mod scaffold_tests {
    use super::*;

    #[test]
    fn corpus_families_load_and_are_nonempty() {
        assert!(!load_codex().is_empty(), "codex corpus is empty");
        assert!(!load_formulas().is_empty(), "formulas corpus is empty");
        assert!(!load_validation().is_empty(), "validation corpus is empty");
        assert!(!load_said_codes().is_empty(), "said_codes corpus is empty");
    }

    #[test]
    fn kinds_are_homogeneous() {
        assert!(load_codex().iter().all(|v| v.kind == "codex"));
        assert!(load_formulas().iter().all(|v| v.kind == "formula"));
        assert!(load_validation().iter().all(|v| v.kind == "validation"));
        assert!(load_said_codes().iter().all(|v| v.kind == "said_code"));
    }
}