mesh-llm-runtime-event-contracts 0.78.1

Dependency-leaf producer contracts for mesh-llm runtime events
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

use std::collections::BTreeSet;

use crate::{
    DeliveryClass, DiagnosticEventKind, DiagnosticFact, GenerationEventKind, GenerationFact,
    ModelAvailabilityEventKind, ModelAvailabilityFact, ModelPreparationEventKind,
    ModelPreparationFact, RuntimeFact,
};

#[test]
fn delivery_class_is_derived_only_from_fact_kind() {
    // Given
    let cases = [
        (
            RuntimeFact::ModelPreparation(ModelPreparationFact::new(
                ModelPreparationEventKind::ModelPreparationCompleted,
            )),
            DeliveryClass::Terminal,
        ),
        (
            RuntimeFact::Generation(GenerationFact::new(GenerationEventKind::GenerationProgress)),
            DeliveryClass::Progress,
        ),
        (
            RuntimeFact::Diagnostic(DiagnosticFact::new(DiagnosticEventKind::WarningRaised)),
            DeliveryClass::Diagnostic,
        ),
        (
            RuntimeFact::ModelAvailability(ModelAvailabilityFact::new(
                ModelAvailabilityEventKind::ModelCapacityChanged,
            )),
            DeliveryClass::StateTransition,
        ),
    ];

    // When / Then
    for (fact, expected) in cases {
        assert_eq!(fact.delivery_class(), expected);
    }
}

#[test]
fn all_fifteen_typed_family_facts_have_one_runtime_sum_variant() {
    // Given / When
    let facts = crate::tests::support::one_fact_per_family();

    // Then
    assert_eq!(facts.len(), 15);
    assert_eq!(facts[0].kind_id(), "runtime_resolution_started");
    assert_eq!(facts[14].kind_id(), "ingress_queue_pressure");
}

#[test]
fn every_inventory_kind_has_its_exact_derived_delivery_class() {
    // Given
    let inventory_text = std::fs::read_to_string(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/inventory/runtime_events.toml"
    ))
    .expect("inventory should be readable");
    let inventory = toml::from_str::<toml::Value>(&inventory_text).expect("inventory should parse");
    let terminal_ids = catalog_ids(&inventory, "terminal_event_ids");
    let progress_ids = catalog_ids(&inventory, "progress_event_ids");
    let diagnostic_ids = DiagnosticEventKind::ALL
        .iter()
        .map(|kind| kind.as_str())
        .filter(|id| !terminal_ids.contains(id))
        .collect::<BTreeSet<_>>();

    // When
    let classified = crate::tests::support::all_facts()
        .into_iter()
        .map(|fact| (fact.kind_id(), fact.delivery_class()))
        .collect::<Vec<_>>();

    // Then
    assert_eq!(classified.len(), 184);
    assert_eq!(
        classified
            .iter()
            .map(|(id, _)| id)
            .collect::<BTreeSet<_>>()
            .len(),
        184
    );
    for (id, actual) in classified {
        let expected = if terminal_ids.contains(id) {
            DeliveryClass::Terminal
        } else if progress_ids.contains(id) {
            DeliveryClass::Progress
        } else if diagnostic_ids.contains(id) {
            DeliveryClass::Diagnostic
        } else {
            DeliveryClass::StateTransition
        };
        assert_eq!(actual, expected, "delivery mismatch for {id}");
    }
}

fn catalog_ids<'a>(inventory: &'a toml::Value, key: &str) -> BTreeSet<&'a str> {
    inventory["catalog"][key]
        .as_array()
        .expect("catalog list")
        .iter()
        .map(|value| value.as_str().expect("event id"))
        .collect()
}