cortexdb-sdk 0.2.0-beta.2

Rust HTTP client SDK for CortexDB
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::*;

#[test]
fn verify_request_fact_builder_outputs_stable_path_and_body() {
    let request = VerifyRequest::fact(
        "project:investments",
        "Solar Plant budget is 1.2B KZT",
        "investment_projects",
    )
    .expect("verify request should build")
    .markdown();

    assert_eq!(request.scope(), "project:investments");
    assert_eq!(request.format(), VerifyOutputFormat::Markdown);
    assert_eq!(
        request.path(),
        "/v1/verify?scope=project%3Ainvestments&format=markdown"
    );
    assert_eq!(
        request.statement(),
        "VERIFY FACT \"Solar Plant budget is 1.2B KZT\" IN BRAIN investment_projects;"
    );
}

#[test]
fn verify_request_formats_are_wire_stable() {
    let json = VerifyRequest::new("project:investments", "VERIFY FACT \"x\" IN BRAIN b;");
    let audit = json.clone().audit();

    assert_eq!(json.format(), VerifyOutputFormat::Json);
    assert_eq!(
        json.path(),
        "/v1/verify?scope=project%3Ainvestments&format=json"
    );
    assert_eq!(
        audit.path(),
        "/v1/verify?scope=project%3Ainvestments&format=audit"
    );
}

#[test]
fn verify_result_maps_current_and_legacy_wire_statuses() {
    assert_eq!(
        VerifyResult::from_wire("supported"),
        VerifyResult::Supported
    );
    assert_eq!(
        VerifyResult::from_wire("insufficient"),
        VerifyResult::Insufficient
    );
    assert_eq!(
        VerifyResult::from_wire("contradicted"),
        VerifyResult::Contradicted
    );
    assert_eq!(
        VerifyResult::from_wire("mixed"),
        VerifyResult::MixedEvidence
    );
    assert_eq!(
        VerifyResult::from_wire("mixed_evidence"),
        VerifyResult::MixedEvidence
    );
    assert_eq!(
        VerifyResult::from_wire("future_status"),
        VerifyResult::Unknown("future_status".to_owned())
    );
}

#[test]
fn verification_report_helpers_surface_result_and_conflicts() {
    let value = serde_json::json!({
        "fact": "Solar Plant budget is 1.2B KZT",
        "status": "mixed",
        "verdict": "mixed_evidence",
        "confidence_q16": 60000,
        "evidence": [],
        "contradicting_evidence": [{
            "cell_id": 7,
            "matched_terms": 3,
            "match_score_q16": 65535,
            "match_kind": "numeric_contradiction",
            "source_trust_q16": 60000,
            "source_trust_category": "official",
            "citation": "ifc:project-7",
            "payload_text": "scope=project:investments\nvalue=1.4B KZT"
        }],
        "guards": [],
        "supporting": [],
        "contradicting": [],
        "numeric_conflicts": [{
            "metric": "budget",
            "left": "1.2B KZT",
            "right": "1.4B KZT"
        }]
    });

    let report: VerificationReportResponse =
        serde_json::from_value(value).expect("verification report should decode");

    assert_eq!(report.result(), VerifyResult::MixedEvidence);
    assert_eq!(report.confidence_q16, 60_000);
    assert!(report.result().is_actionable_conflict());
    assert!(report.has_conflicts());

    let conflicts = report.conflicts();
    assert_eq!(conflicts.len(), 2);
    assert!(matches!(
        &conflicts[0],
        VerifyConflict::ContradictingEvidence(conflict)
            if conflict.cell_id == 7
                && conflict.source_trust_category == "official"
                && conflict.match_kind == "numeric_contradiction"
    ));
    assert!(matches!(
        &conflicts[1],
        VerifyConflict::Numeric(conflict)
            if conflict.metric == "budget" && conflict.left == "1.2B KZT"
    ));
}