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());
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());
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);
}