app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

main.rs (6349B)


      1 // SPDX-License-Identifier: GPL-3.0-only
      2 // Actual immutable public Lib189 Message codec, not an application crypto stack.
      3 #![forbid(unsafe_code)]
      4 use radroots_blossom::Sha256;
      5 use radroots_event::social::message::Message;
      6 use radroots_event_codec::decode::message::message_from_tags;
      7 use radroots_event_codec::encode::message::{message_build_tags, to_wire_parts};
      8 use serde_json::{Value, json};
      9 use std::{collections::BTreeSet, env, fs, path::Path};
     10 const REVISION: &str = "189c49b74b4bafc142b00b76b296477931139e72";
     11 const PROFILE: &str = include_str!("../../source_profile.v1.json");
     12 fn expanded(value: &Value) -> Value {
     13     match value {
     14         Value::Object(fields)
     15             if fields.len() == 2
     16                 && fields.contains_key("repeat")
     17                 && fields.contains_key("count") =>
     18         {
     19             let text = fields["repeat"].as_str().unwrap();
     20             let count = usize::try_from(fields["count"].as_u64().unwrap()).unwrap();
     21             assert_eq!(text.chars().count(), 1);
     22             assert!(count <= 8192);
     23             json!(text.repeat(count))
     24         }
     25         Value::Object(fields) => Value::Object(
     26             fields
     27                 .iter()
     28                 .map(|(key, value)| (key.clone(), expanded(value)))
     29                 .collect(),
     30         ),
     31         Value::Array(values) => Value::Array(values.iter().map(expanded).collect()),
     32         _ => value.clone(),
     33     }
     34 }
     35 fn actual(mode: &str, input: &Value) -> Value {
     36     if mode == "write" {
     37         let message: Message = serde_json::from_value(input.clone()).unwrap();
     38         match to_wire_parts(&message) {
     39             Ok(parts) => {
     40                 assert_eq!(parts.tags, message_build_tags(&message).unwrap());
     41                 let decoded = message_from_tags(parts.kind, &parts.tags, &parts.content).unwrap();
     42                 json!({"status":"supported","wire_parts":{"kind":parts.kind,"tags":parts.tags,"content":parts.content},"message":decoded})
     43             }
     44             Err(error) => json!({"status":"unsupported","error":error.to_string()}),
     45         }
     46     } else {
     47         assert_eq!(mode, "read");
     48         let kind = u32::try_from(input["kind"].as_u64().unwrap()).unwrap();
     49         let tags: Vec<Vec<String>> = serde_json::from_value(input["tags"].clone()).unwrap();
     50         match message_from_tags(kind, &tags, input["content"].as_str().unwrap()) {
     51             Ok(message) => json!({"status":"supported","message":message}),
     52             Err(error) => json!({"status":"unsupported","error":error.to_string()}),
     53         }
     54     }
     55 }
     56 fn corpus() -> Value {
     57     let source: Value = serde_json::from_str(PROFILE).unwrap();
     58     assert_eq!(source["revision"], REVISION);
     59     let vectors = source["vectors"].as_array().unwrap();
     60     assert!(vectors.len() > 20 && vectors.len() <= 100);
     61     let mut ids = BTreeSet::new();
     62     let rows: Vec<_> = vectors
     63         .iter()
     64         .map(|recipe| {
     65             let mut row = recipe.clone();
     66             let id = row["id"].as_str().unwrap();
     67             assert!(ids.insert(id.to_owned()));
     68             let input = expanded(&row["input"]);
     69             let result = actual(row["mode"].as_str().unwrap(), &input);
     70             row["input"] = input;
     71             row["expected"] = result;
     72             row
     73         })
     74         .collect();
     75     json!({"revision":REVISION,"source_sha256":Sha256::digest(PROFILE.as_bytes()).to_hex(),"vectors":rows})
     76 }
     77 fn text(value: &Value) -> String {
     78     serde_json::to_string_pretty(value).unwrap() + "\n"
     79 }
     80 fn consume(path: &str) -> Value {
     81     let info = fs::symlink_metadata(path).unwrap();
     82     assert!(info.is_file() && !info.file_type().is_symlink() && info.len() <= 1024 * 1024);
     83     let input: Value = serde_json::from_slice(&fs::read(path).unwrap()).unwrap();
     84     let rows = input.as_array().unwrap();
     85     assert!(!rows.is_empty() && rows.len() <= 100);
     86     let mut ids = BTreeSet::new();
     87     let results: Vec<_> = rows
     88         .iter()
     89         .map(|row| {
     90             let id = row["id"].as_str().unwrap();
     91             assert!(ids.insert(id.to_owned()));
     92             let result = actual("read", &row["wire_parts"]);
     93             assert_eq!(result["status"], "supported");
     94             assert_eq!(result["message"], row["expected"]);
     95             json!({"id":id,"message":result["message"]})
     96         })
     97         .collect();
     98     json!({"revision":REVISION,"consumed":results})
     99 }
    100 fn main() {
    101     let args: Vec<String> = env::args().skip(1).collect();
    102     match args.as_slice() {
    103         [arg] if arg == "--emit" => print!("{}", text(&corpus())),
    104         [arg] if arg == "--check" => {
    105             let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../corpus.v1.json");
    106             let info = fs::symlink_metadata(&path).unwrap();
    107             assert!(info.is_file() && !info.file_type().is_symlink() && info.len() <= 1024 * 1024);
    108             assert_eq!(fs::read_to_string(path).unwrap(), text(&corpus()));
    109             println!("PASS actual pinned Message corpus freshness");
    110         }
    111         [arg, path] if arg == "--consume" => print!("{}", text(&consume(path))),
    112         _ => panic!("expected --emit, --check or --consume <bounded fixture>"),
    113     }
    114 }
    115 #[cfg(test)]
    116 mod tests {
    117     use super::*;
    118     #[test]
    119     fn real_message_vectors_round_trip() {
    120         let value = corpus();
    121         let rows = value["vectors"].as_array().unwrap();
    122         assert!(
    123             rows.iter()
    124                 .any(|v| v["id"] == "first_enquiry"
    125                     && v["expected"]["message"]["reply_to"].is_null())
    126         );
    127         assert!(
    128             rows.iter()
    129                 .any(|v| v["expected"]["status"] == "unsupported")
    130         );
    131         assert!(rows.iter().any(
    132             |v| v.get("policy_difference").is_some() && v["expected"]["status"] == "supported"
    133         ));
    134     }
    135     #[test]
    136     fn native_canonical_tags_are_plain_unsigned_message_parts() {
    137         let value = corpus();
    138         let first = value["vectors"]
    139             .as_array()
    140             .unwrap()
    141             .iter()
    142             .find(|v| v["id"] == "first_enquiry")
    143             .unwrap();
    144         assert_eq!(first["expected"]["wire_parts"]["kind"], 14);
    145         assert_eq!(
    146             first["expected"]["wire_parts"]["tags"]
    147                 .as_array()
    148                 .unwrap()
    149                 .len(),
    150             1
    151         );
    152         assert!(first["expected"]["wire_parts"].get("sig").is_none());
    153     }
    154 }