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

use std::time::{Duration, Instant};

use crate::{
    DiagnosticEventKind, GenerationEventKind, RequestEventKind, RuntimeEventIngress, SubmitOutcome,
};

use super::support::{SaturatingIngress, diagnostic_fact, generation_fact, request_fact};

const SATURATED_SUBMISSION_DEADLINE: Duration = Duration::from_millis(50);

fn assert_object_safe(_: &dyn RuntimeEventIngress) {}

#[test]
fn ingress_contract_is_object_safe() {
    // Given
    let (ingress, _receiver) = SaturatingIngress::connected(1);

    // When
    let erased: &dyn RuntimeEventIngress = &ingress;

    // Then
    assert_object_safe(erased);
}

#[test]
fn accepted_submission_reports_accepted() {
    // Given
    let (ingress, _receiver) = SaturatingIngress::connected(1);

    // When
    let outcome = ingress.try_submit(request_fact(RequestEventKind::RequestReceived));

    // Then
    assert_eq!(outcome, SubmitOutcome::Accepted);
}

#[test]
fn saturated_progress_submission_returns_without_a_consumer() {
    // Given
    let (ingress, _receiver) = SaturatingIngress::connected(1);
    assert_eq!(
        ingress.try_submit(request_fact(RequestEventKind::RequestReceived)),
        SubmitOutcome::Accepted
    );

    // When
    let started = Instant::now();
    let outcome = ingress.try_submit(generation_fact(GenerationEventKind::GenerationProgress));
    let elapsed = started.elapsed();

    // Then
    assert_eq!(outcome, SubmitOutcome::DroppedProgress);
    assert!(
        elapsed < SATURATED_SUBMISSION_DEADLINE,
        "elapsed: {elapsed:?}"
    );
}

#[test]
fn saturated_class_outcomes_are_explicit() {
    // Given
    let (ingress, _receiver) = SaturatingIngress::connected(1);
    assert_eq!(
        ingress.try_submit(request_fact(RequestEventKind::RequestReceived)),
        SubmitOutcome::Accepted
    );

    // When
    let outcomes = [
        ingress.try_submit(request_fact(RequestEventKind::RequestQueued)),
        ingress.try_submit(diagnostic_fact(DiagnosticEventKind::WarningRaised)),
        ingress.try_submit(request_fact(RequestEventKind::RequestCompleted)),
    ];

    // Then
    assert_eq!(
        outcomes,
        [
            SubmitOutcome::RejectedCapacity,
            SubmitOutcome::DroppedDiagnostic,
            SubmitOutcome::TerminalDeliveryFailed,
        ]
    );
}

#[test]
fn disconnected_ingress_reports_shutdown() {
    // Given
    let (ingress, receiver) = SaturatingIngress::connected(1);
    drop(receiver);

    // When
    let outcome = ingress.try_submit(request_fact(RequestEventKind::RequestReceived));

    // Then
    assert_eq!(outcome, SubmitOutcome::RejectedShuttingDown);
}