liteguard 0.7.20260603

Feature guards, observability, and security response in a single import. Evaluated locally, zero network overhead per check
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

use liteguard::evaluation::evaluate_guard;
use liteguard::{Guard, PropertyValue, Rule};
use serde::Deserialize;
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;

#[derive(Deserialize)]
struct FixtureBundle {
    version: u32,
    cases: Vec<FixtureCase>,
}

#[derive(Deserialize)]
struct FixtureCase {
    name: String,
    guard: FixtureGuard,
    properties: HashMap<String, PropertyValue>,
    expected: bool,
}

#[derive(Deserialize)]
struct FixtureGuard {
    default_value: bool,
    rules: Vec<FixtureRule>,
}

#[derive(Deserialize)]
struct FixtureRule {
    property_name: String,
    operator: liteguard::Operator,
    values: Vec<PropertyValue>,
    result: bool,
    enabled: bool,
}

fn fixture_path() -> PathBuf {
    if let Ok(repo_root) = std::env::var("LITEGUARD_REPO_ROOT") {
        return PathBuf::from(repo_root)
            .join("tests")
            .join("conformance")
            .join("evaluation_cases.json");
    }

    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("..")
        .join("..")
        .join("tests")
        .join("conformance")
        .join("evaluation_cases.json")
}

fn to_guard(spec: FixtureGuard) -> Guard {
    Guard {
        name: "test.guard".into(),
        rules: spec
            .rules
            .into_iter()
            .map(|rule| Rule {
                property_name: rule.property_name,
                operator: rule.operator,
                values: rule.values,
                result: rule.result,
                enabled: rule.enabled,
            })
            .collect(),
        default_value: spec.default_value,
        adopted: true,
        rate_limit: None,
        dry_run_rate_limit: None,
        disable_measurement: None,
    }
}

#[test]
fn evaluation_matches_shared_conformance_fixtures() {
    let raw = fs::read_to_string(fixture_path()).expect("read conformance fixtures");
    let bundle: FixtureBundle = serde_json::from_str(&raw).expect("parse conformance fixtures");
    assert_eq!(bundle.version, 1);

    for case in bundle.cases {
        assert_eq!(
            evaluate_guard(
                &to_guard(case.guard),
                &liteguard::Properties(case.properties),
            ),
            case.expected,
            "{}",
            case.name
        );
    }
}