apcore-toolkit 0.7.0

Shared scanner, schema extraction, and output toolkit for apcore framework adapters
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

// Cross-language conformance harness for `format_csv` and `format_jsonl`.
//
// Reads the shared corpus at `apcore-toolkit/conformance/fixtures/` (used by
// Python and TypeScript SDKs as well) and asserts byte-identical output.

use std::path::PathBuf;

use apcore_toolkit::{format_csv, format_jsonl};
use serde_json::{Map, Value};

fn conformance_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .expect("toolkit-rust dir must have a parent")
        .join("apcore-toolkit")
        .join("conformance")
        .join("fixtures")
}

fn load_fixture(name: &str) -> Vec<Value> {
    let path = conformance_dir().join(name);
    let content = match std::fs::read_to_string(&path) {
        Ok(s) => s,
        Err(_) => return Vec::new(),
    };
    let doc: Value = serde_json::from_str(&content).expect("fixture must be valid JSON");
    doc["test_cases"].as_array().cloned().unwrap_or_default()
}

fn rows_from_value(v: &Value) -> Vec<Map<String, Value>> {
    v.as_array()
        .expect("rows must be a JSON array")
        .iter()
        .map(|row| row.as_object().expect("each row must be an object").clone())
        .collect()
}

#[test]
fn format_csv_matches_shared_conformance_fixture() {
    let cases = load_fixture("format_csv.json");
    if cases.is_empty() {
        eprintln!("WARN: conformance fixture not found; skipping");
        return;
    }
    for case in cases {
        let id = case["id"].as_str().unwrap_or("(no-id)");
        let rows = rows_from_value(&case["input"]["rows"]);
        let bom = case["input"]["bom"].as_bool().unwrap_or(false);
        let expected = case["expected"].as_str().expect("expected must be string");
        let actual = format_csv(&rows, bom);
        assert_eq!(
            actual, expected,
            "{}: byte mismatch\nexpected: {:?}\nactual:   {:?}",
            id, expected, actual
        );
    }
}

#[test]
fn format_jsonl_matches_shared_conformance_fixture() {
    let cases = load_fixture("format_jsonl.json");
    if cases.is_empty() {
        eprintln!("WARN: conformance fixture not found; skipping");
        return;
    }
    for case in cases {
        let id = case["id"].as_str().unwrap_or("(no-id)");
        let rows = rows_from_value(&case["input"]["rows"]);
        let expected = case["expected"].as_str().expect("expected must be string");
        let actual = format_jsonl(&rows);
        assert_eq!(
            actual, expected,
            "{}: byte mismatch\nexpected: {:?}\nactual:   {:?}",
            id, expected, actual
        );
    }
}