harn-vm 0.10.163

Async bytecode virtual machine for the Harn programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use super::parse_review_verdict;

fn parse(
    approved: bool,
    disposition: &str,
    outcome: serde_json::Value,
) -> super::ApprovalReviewOutcome {
    parse_review_verdict(crate::stdlib::json_to_vm_value(&serde_json::json!({
        "approved": approved,
        "reviewer_answered": true,
        "rationale": "fixture",
        "evaluation_review": {
            "disposition": disposition,
            "rule": "fixture_rule",
            "outcome": outcome,
        },
    })))
}

#[test]
fn non_answers_cannot_become_grants_or_considered_rejections() {
    let outcomes = [
        serde_json::json!({"kind": "low_confidence", "candidates": {}, "threshold": 0.99, "question_ids": [], "receipt": "low"}),
        serde_json::json!({"kind": "refused", "reason": "provider_refusal", "diagnostic": "fixture", "receipt": "refused"}),
        serde_json::json!({"kind": "unavailable", "reason": "model_unconfigured", "receipt": "unavailable"}),
    ];
    for outcome in outcomes {
        let fallback = parse(false, "needs_review", outcome.clone());
        assert!(!fallback.approved);
        assert!(!fallback.reviewer_answered);
        assert_eq!(
            fallback.unavailable_reason.as_deref(),
            outcome["kind"].as_str()
        );
        assert!(
            fallback.evaluation_review.is_some(),
            "valid non-answers retain their metadata"
        );
        for disposition in ["approved", "denied"] {
            let invalid = parse(disposition == "approved", disposition, outcome.clone());
            assert!(!invalid.approved);
            assert_eq!(
                invalid.unavailable_reason.as_deref(),
                Some("non_answer_cannot_settle_review")
            );
        }
    }
}

#[test]
fn malformed_and_inconsistent_decision_evidence_fail_closed() {
    let missing_receipt = parse(
        true,
        "approved",
        serde_json::json!({"kind": "answered", "value": {}}),
    );
    assert!(!missing_receipt.approved);
    assert_eq!(
        missing_receipt.unavailable_reason.as_deref(),
        Some("invalid_evaluation_outcome")
    );
    let inconsistent = parse(
        true,
        "needs_review",
        serde_json::json!({"kind": "answered", "value": {}, "receipt": "fixture"}),
    );
    assert!(!inconsistent.approved);
    assert_eq!(
        inconsistent.unavailable_reason.as_deref(),
        Some("inconsistent_review_disposition")
    );
}

#[test]
fn completed_decisions_preserve_grants_and_considered_rejections() {
    for approved in [true, false] {
        let review = parse(
            approved,
            if approved { "approved" } else { "denied" },
            serde_json::json!({"kind": "answered", "value": {}, "receipt": "fixture"}),
        );
        assert_eq!(review.approved, approved);
        assert!(review.reviewer_answered);
        assert!(review.unavailable_reason.is_none());
        assert!(review.evaluation_review.is_some());
    }
}