cesr-rs 0.6.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

//! Differential-testing harness vs keripy (P0.3, issue #27).
//!
//! Replays a checked-in, keripy-generated JSONL corpus and asserts cesr
//! agrees with keripy byte-for-byte on both encode and decode. Test-only and
//! `serder`-gated so every codec path (incl. Matter encode via
//! `serder::primitives::to_qb64_string`) is in scope.

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

mod counter;
mod indexer;
mod matter;
mod stream;

#[derive(Debug, Deserialize)]
struct DiffVector {
    pub kind: String,
    #[serde(default)]
    pub code: String,
    #[serde(default)]
    pub raw: String,
    #[serde(default)]
    pub soft: String,
    pub index: Option<u32>,
    pub ondex: Option<u32>,
    pub count: Option<u32>,
    #[serde(default)]
    pub qb64: String,
    #[serde(default)]
    pub qb2: String,
    #[serde(default)]
    pub elements: Vec<Self>,
}

fn from_hex(s: &str) -> Vec<u8> {
    assert!(s.len().is_multiple_of(2), "odd-length hex: {s}");
    (0..s.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&s[i..i + 2], 16).expect("valid hex byte"))
        .collect()
}

// The corpus is embedded at compile time via `include_str!` rather than read at
// runtime: the gate builds and runs tests in separate hermetic nix phases, so a
// runtime `CARGO_MANIFEST_DIR` path points at a build sandbox that no longer
// exists when nextest runs. Baking the bytes in keeps the harness hermetic.
#[allow(
    clippy::panic,
    reason = "test-only corpus loader: panics on malformed corpus fixtures per task spec"
)]
fn load(kind: &str) -> Vec<DiffVector> {
    let text = match kind {
        "matter" => include_str!("../../tests/corpus/keripy/matter.jsonl"),
        "counter_v1" => include_str!("../../tests/corpus/keripy/counter_v1.jsonl"),
        "counter_v2" => include_str!("../../tests/corpus/keripy/counter_v2.jsonl"),
        "indexer" => include_str!("../../tests/corpus/keripy/indexer.jsonl"),
        "stream" => include_str!("../../tests/corpus/keripy/stream.jsonl"),
        other => panic!("unknown corpus kind {other:?}"),
    };
    text.lines()
        .filter(|l| !l.trim().is_empty())
        .map(|l| {
            serde_json::from_str::<DiffVector>(l).unwrap_or_else(|e| panic!("parse `{l}`: {e}"))
        })
        .collect()
}

#[cfg(test)]
mod scaffold_tests {
    use super::{DiffVector, from_hex};
    use std::vec;

    #[test]
    fn parses_one_line_and_decodes_hex() {
        let line = r#"{"kind":"matter","code":"D","raw":"deadbeef","qb64":"Dxx","qb2":"0102"}"#;
        let v: DiffVector = serde_json::from_str(line).unwrap();
        assert_eq!(v.kind, "matter");
        assert_eq!(v.code, "D");
        assert_eq!(from_hex(&v.raw), vec![0xde, 0xad, 0xbe, 0xef]);
        assert_eq!(from_hex(&v.qb2), vec![0x01, 0x02]);
        assert_eq!(v.soft, "");
        assert!(v.index.is_none());
    }
}