lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

authored_plan_wire.rs (3214B)

      1 #![cfg(feature = "json")]
      2 
      3 use std::{borrow::Cow, fs, path::Path};
      4 
      5 use radroots_event::GenericEventDraft;
      6 use radroots_event_codec::authoring::{AuthoredEventPlan, PlanWireV1};
      7 use serde::Deserialize;
      8 use serde_json::Value;
      9 
     10 const PACKAGED_VECTORS: &str = include_str!("fixtures/authored_plan_wire.v1.json");
     11 const WORKSPACE_VECTOR_PATH: &str =
     12     "../../contracts/conformance/vectors/event/authored_plan_wire.v1.json";
     13 const WORKSPACE_CONTRACT_MARKER_PATH: &str = "../../contracts/manifest.toml";
     14 
     15 #[derive(Debug, Deserialize)]
     16 struct Suite {
     17     suite: String,
     18     contract_version: String,
     19     vectors: Vec<Vector>,
     20 }
     21 
     22 #[derive(Debug, Deserialize)]
     23 struct Vector {
     24     id: String,
     25     kind: String,
     26     input: Input,
     27     expected: Value,
     28 }
     29 
     30 #[derive(Debug, Deserialize)]
     31 #[serde(deny_unknown_fields)]
     32 struct Input {
     33     contract_id: String,
     34     expected_author: String,
     35     created_at: u64,
     36     kind: u32,
     37     tags: Vec<Vec<String>>,
     38     content: String,
     39 }
     40 
     41 #[test]
     42 fn checked_in_plan_wire_vector_executes_and_is_package_self_contained() {
     43     let vectors = conformance_vectors();
     44     let suite: Suite = serde_json::from_str(&vectors).expect("plan wire vectors must parse");
     45     assert_eq!(suite.suite, "authored_plan_wire");
     46     assert_eq!(suite.contract_version, "1.0.0");
     47     assert!(!suite.vectors.is_empty());
     48 
     49     for vector in suite.vectors {
     50         assert_eq!(vector.kind, "authored_plan_wire.v1", "{}", vector.id);
     51         let draft = GenericEventDraft::new(
     52             vector.input.contract_id,
     53             vector.input.kind,
     54             vector.input.created_at,
     55             vector.input.tags,
     56             vector.input.content,
     57             vector.input.expected_author,
     58         )
     59         .unwrap_or_else(|error| panic!("{} draft failed: {error}", vector.id));
     60         let plan = AuthoredEventPlan::from_generic(draft)
     61             .unwrap_or_else(|error| panic!("{} plan failed: {error}", vector.id));
     62         let encoded = PlanWireV1::from_plan(&plan)
     63             .to_json()
     64             .unwrap_or_else(|error| panic!("{} encode failed: {error}", vector.id));
     65         assert_eq!(
     66             serde_json::from_slice::<Value>(&encoded).expect("encoded value"),
     67             vector.expected,
     68             "{}",
     69             vector.id
     70         );
     71         assert_eq!(
     72             PlanWireV1::from_json(&encoded)
     73                 .unwrap_or_else(|error| panic!("{} decode failed: {error}", vector.id))
     74                 .into_plan(),
     75             plan,
     76             "{}",
     77             vector.id
     78         );
     79     }
     80 }
     81 
     82 fn conformance_vectors() -> Cow<'static, str> {
     83     let workspace_path = Path::new(env!("CARGO_MANIFEST_DIR")).join(WORKSPACE_VECTOR_PATH);
     84     match fs::read_to_string(&workspace_path) {
     85         Ok(canonical) => {
     86             assert_eq!(canonical, PACKAGED_VECTORS);
     87             Cow::Owned(canonical)
     88         }
     89         Err(error)
     90             if error.kind() == std::io::ErrorKind::NotFound
     91                 && !Path::new(env!("CARGO_MANIFEST_DIR"))
     92                     .join(WORKSPACE_CONTRACT_MARKER_PATH)
     93                     .is_file() =>
     94         {
     95             Cow::Borrowed(PACKAGED_VECTORS)
     96         }
     97         Err(error) => panic!("failed to read {}: {error}", workspace_path.display()),
     98     }
     99 }