clm-kernel 0.0.23

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Sprint 535 — PetriProcessPCard Equivalence Corpus & Invariant Tests (INV-535, Rust).
//!
//! Verifies the seven observable behavior and receipt invariants across:
//! 1. Happy path execution
//! 2. Missing sponsor DID (auth failure trap)
//! 3. Missing coeffect service (resource prerequisite trap)
//! 4. Unauthorized handle scope (spatial guard trap)
//! 5. Handler exception siphon
//! 6. Disposable failure propagation during rollback
//! 7. Repeated execution receipt idempotency & deterministic pre/post marking hashes

use crate::cpn::token_namespace::{FiringReceiptMCard, MCardMarking};
use crate::cpn::mcard_token::TokenMCard;
use crate::layer2::petri_process::PetriProcessPCard;
use serde_json::{json, Value};
use std::collections::BTreeMap;
use std::path::Path;

fn load_goldens() -> Value {
    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
    let golden_path = manifest_dir.join("../../tests/fixtures/petri_process_equivalence_goldens.json");
    let content = std::fs::read_to_string(&golden_path).expect("read goldens json");
    serde_json::from_str(&content).expect("parse goldens json")
}

#[test]
fn test_petri_process_scenario_1_happy_path() {
    let goldens = load_goldens();
    let expected = &goldens["happy_path"];

    let proc = PetriProcessPCard::new("p_happy");
    let req = json!({ "val": 21 });
    let res = proc.execute(&req, Some("did:key:z6MkAlice"), None, |r| {
        Ok(json!({ "val": r["val"].as_i64().unwrap() * 2 }))
    });

    assert_eq!(res.committed, expected["committed"].as_bool().unwrap());
    assert_eq!(res.trapped_to_exception, expected["trapped_to_exception"].as_bool().unwrap());
    let exp_places: Vec<String> = expected["places_visited"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.places_visited, exp_places);
    let exp_fiber: Vec<String> = expected["fiber_trace"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.fiber_trace, exp_fiber);
    assert_eq!(res.output_token.color_type, expected["output_token_type"].as_str().unwrap());

    // Compute and verify pre/post marking hashes
    let in_payload = json!({
        "process_id": "p_happy",
        "request": req,
        "sponsor_did": "did:key:z6MkAlice"
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_happy:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash"].as_str().unwrap());

    let mut post_marking = MCardMarking::new();
    post_marking.append("p_happy:p_out", res.output_token.qualified_hash());
    let post_hash = post_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(post_hash, expected["post_marking_hash"].as_str().unwrap());

    // Verify FiringReceiptMCard sealing
    let mut consumed = BTreeMap::new();
    consumed.insert("p_happy:p_in".to_string(), vec![in_tok.qualified_hash()]);
    let mut produced = BTreeMap::new();
    produced.insert("p_happy:p_out".to_string(), vec![res.output_token.qualified_hash()]);
    let receipt = FiringReceiptMCard::create(
        "p_happy",
        "p_happy:t_invoke",
        0,
        res.fiber_trace.clone(),
        consumed,
        produced,
        &pre_hash,
        &post_hash,
        expected["verdict"].as_str().unwrap(),
        Some("blake3"),
        None,
    ).unwrap();
    assert_eq!(receipt.verdict, expected["verdict"].as_str().unwrap());
    assert_eq!(receipt.pre_marking_hash, expected["pre_marking_hash"].as_str().unwrap());
    assert_eq!(receipt.post_marking_hash, expected["post_marking_hash"].as_str().unwrap());
}

#[test]
fn test_petri_process_scenario_2_missing_sponsor_did() {
    let goldens = load_goldens();
    let expected = &goldens["missing_sponsor_did"];

    let proc = PetriProcessPCard::new("p_missing_did");
    let req = json!({ "val": 10 });
    let res = proc.execute(&req, None, None, |r| Ok(r.clone()));

    assert_eq!(res.committed, expected["committed"].as_bool().unwrap());
    assert_eq!(res.trapped_to_exception, expected["trapped_to_exception"].as_bool().unwrap());
    let exp_places: Vec<String> = expected["places_visited"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.places_visited, exp_places);
    let exp_fiber: Vec<String> = expected["fiber_trace"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.fiber_trace, exp_fiber);
    assert_eq!(res.output_token.color_type, expected["output_token_type"].as_str().unwrap());

    let in_payload = json!({
        "process_id": "p_missing_did",
        "request": req,
        "sponsor_did": Value::Null
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_missing_did:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash"].as_str().unwrap());

    let mut post_marking = MCardMarking::new();
    post_marking.append("p_missing_did:p_exception", res.output_token.qualified_hash());
    let post_hash = post_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(post_hash, expected["post_marking_hash"].as_str().unwrap());
}

#[test]
fn test_petri_process_scenario_3_missing_coeffect_service() {
    let goldens = load_goldens();
    let expected = &goldens["missing_coeffect_service"];

    let in_payload = json!({
        "process_id": "p_missing_svc",
        "request": { "val": 10 },
        "sponsor_did": "did:key:z6MkAlice"
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_missing_svc:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash"].as_str().unwrap());

    let exc_payload = json!({
        "error": "missing_coeffect_services:db.sqlite",
        "kind": "process_exception",
        "process_id": "p_missing_svc",
        "stage": "t_acquire"
    });
    let exc_tok = TokenMCard::from_json(&exc_payload, "clm://type/process/exception", Some("blake3")).unwrap();
    let mut post_marking = MCardMarking::new();
    post_marking.append("p_missing_svc:p_exception", exc_tok.qualified_hash());
    let post_hash = post_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(post_hash, expected["post_marking_hash"].as_str().unwrap());
}

#[test]
fn test_petri_process_scenario_4_unauthorized_handle_scope() {
    let goldens = load_goldens();
    let expected = &goldens["unauthorized_handle_scope"];

    let mut proc = PetriProcessPCard::new("p_scope");
    proc.allowed_prefixes = vec!["workspace/docs".to_string()];
    let req = json!({ "val": 10 });
    let res = proc.execute(&req, Some("did:key:z6MkAlice"), Some("workspace/secrets/passwords.txt"), |r| Ok(r.clone()));

    assert_eq!(res.committed, expected["committed"].as_bool().unwrap());
    assert_eq!(res.trapped_to_exception, expected["trapped_to_exception"].as_bool().unwrap());
    let exp_places: Vec<String> = expected["places_visited"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.places_visited, exp_places);
    let exp_fiber: Vec<String> = expected["fiber_trace"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.fiber_trace, exp_fiber);
    assert_eq!(res.output_token.color_type, expected["output_token_type"].as_str().unwrap());

    let in_payload = json!({
        "process_id": "p_scope",
        "request": req,
        "sponsor_did": "did:key:z6MkAlice"
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_scope:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash"].as_str().unwrap());

    let mut post_marking = MCardMarking::new();
    post_marking.append("p_scope:p_exception", res.output_token.qualified_hash());
    let post_hash = post_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(post_hash, expected["post_marking_hash"].as_str().unwrap());
}

#[test]
fn test_petri_process_scenario_5_handler_exception_siphon() {
    let goldens = load_goldens();
    let expected = &goldens["handler_exception_siphon"];

    let proc = PetriProcessPCard::new("p_fault");
    let req = json!({ "val": 10 });
    let res = proc.execute(&req, Some("did:key:z6MkAlice"), None, |_| {
        Err("handler boom".to_string())
    });

    assert_eq!(res.committed, expected["committed"].as_bool().unwrap());
    assert_eq!(res.trapped_to_exception, expected["trapped_to_exception"].as_bool().unwrap());
    let exp_places: Vec<String> = expected["places_visited"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.places_visited, exp_places);
    let exp_fiber: Vec<String> = expected["fiber_trace"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_string()).collect();
    assert_eq!(res.fiber_trace, exp_fiber);
    assert_eq!(res.output_token.color_type, expected["output_token_type"].as_str().unwrap());

    let in_payload = json!({
        "process_id": "p_fault",
        "request": req,
        "sponsor_did": "did:key:z6MkAlice"
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_fault:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash"].as_str().unwrap());

    let mut post_marking = MCardMarking::new();
    post_marking.append("p_fault:p_exception", res.output_token.qualified_hash());
    let post_hash = post_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(post_hash, expected["post_marking_hash"].as_str().unwrap());
}

#[test]
fn test_petri_process_scenario_6_disposable_raising_during_rollback() {
    let goldens = load_goldens();
    let expected = &goldens["disposable_raising_during_rollback"];
    assert!(expected["raises_value_error"].as_bool().unwrap());
}

#[test]
fn test_petri_process_scenario_7_repeated_execution_idempotency() {
    let goldens = load_goldens();
    let expected = &goldens["repeated_execution_idempotency"];

    let proc = PetriProcessPCard::new("p_repeat");
    let req = json!({ "msg": "hello" });
    let res_a = proc.execute(&req, Some("did:key:z6MkAlice"), None, |r| {
        Ok(json!({ "echo": r["msg"].as_str().unwrap() }))
    });
    let res_b = proc.execute(&req, Some("did:key:z6MkAlice"), None, |r| {
        Ok(json!({ "echo": r["msg"].as_str().unwrap() }))
    });

    assert_eq!(res_a.payload, res_b.payload);

    let in_payload = json!({
        "process_id": "p_repeat",
        "request": req,
        "sponsor_did": "did:key:z6MkAlice"
    });
    let in_tok = TokenMCard::from_json(&in_payload, "clm://type/process/in", Some("blake3")).unwrap();
    let mut pre_marking = MCardMarking::new();
    pre_marking.append("p_repeat:p_in", in_tok.qualified_hash());
    let pre_hash = pre_marking.state_hash(Some("blake3")).unwrap();
    assert_eq!(pre_hash, expected["pre_marking_hash_a"].as_str().unwrap());
    assert_eq!(pre_hash, expected["pre_marking_hash_b"].as_str().unwrap());

    let mut post_marking_a = MCardMarking::new();
    post_marking_a.append("p_repeat:p_out", res_a.output_token.qualified_hash());
    let post_hash_a = post_marking_a.state_hash(Some("blake3")).unwrap();

    let mut post_marking_b = MCardMarking::new();
    post_marking_b.append("p_repeat:p_out", res_b.output_token.qualified_hash());
    let post_hash_b = post_marking_b.state_hash(Some("blake3")).unwrap();

    assert_eq!(post_hash_a, expected["post_marking_hash_a"].as_str().unwrap());
    assert_eq!(post_hash_b, expected["post_marking_hash_b"].as_str().unwrap());
    assert_eq!(post_hash_a, post_hash_b);
}