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 }