khive-storage 0.12.0

Storage capability contracts and backend-neutral request context.
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

use super::*;

#[test]
fn lifecycle_event_roundtrips_through_json() {
    for kind in [
        LifecycleEvent::ChannelPollStarted,
        LifecycleEvent::ChannelPollSucceeded,
        LifecycleEvent::ChannelPollFailed,
        LifecycleEvent::ChannelBackoffArmed,
        LifecycleEvent::ChannelBackoffReset,
        LifecycleEvent::ChannelHeartbeatPersistFailed,
        LifecycleEvent::ConfigLocked,
        LifecycleEvent::CheckpointOutcomeRecorded,
        LifecycleEvent::PhaseStarted,
        LifecycleEvent::PhaseCompleted,
        LifecycleEvent::PhaseCancelled,
    ] {
        let json = serde_json::to_string(&kind).expect("serialize");
        let parsed: LifecycleEvent = serde_json::from_str(&json).expect("deserialize");
        assert_eq!(parsed, kind);
    }
}

#[test]
fn checkpoint_outcome_recorded_payload_roundtrips() {
    let payload = CheckpointOutcomeRecordedPayload {
        wal_pages: 2500,
        warn_pages: 2000,
        high_water_pages: 6000,
        truncate_high_water_pages: 20_000,
        above_warn: true,
        above_high_water: false,
        above_truncate_high_water: false,
        episode_elevated_ticks: Some(7),
        episode_peak_wal_pages: Some(3100),
    };
    let json = serde_json::to_value(&payload).expect("serialize");
    let parsed: CheckpointOutcomeRecordedPayload =
        serde_json::from_value(json).expect("deserialize");
    assert_eq!(parsed, payload);
}

#[test]
fn checkpoint_outcome_recorded_payload_accepts_legacy_rows_without_episode_summary() {
    let parsed: CheckpointOutcomeRecordedPayload = serde_json::from_value(serde_json::json!({
        "wal_pages": 2500,
        "warn_pages": 2000,
        "high_water_pages": 6000,
        "truncate_high_water_pages": 20000,
        "above_warn": true,
        "above_high_water": false,
        "above_truncate_high_water": false
    }))
    .expect("legacy payload must remain readable");

    assert_eq!(parsed.episode_elevated_ticks, None);
    assert_eq!(parsed.episode_peak_wal_pages, None);
}

#[test]
fn phase_started_payload_roundtrips() {
    let payload = PhaseStartedPayload {
        work_class: "warm".into(),
        phase: "ann_warm".into(),
        corpus_size: Some(553_000),
    };
    let json = serde_json::to_value(&payload).expect("serialize");
    let parsed: PhaseStartedPayload = serde_json::from_value(json).expect("deserialize");
    assert_eq!(parsed, payload);
}

#[test]
fn phase_completed_payload_roundtrips_with_absent_cpu_us() {
    let payload = PhaseCompletedPayload {
        work_class: "warm".into(),
        phase: "ann_warm".into(),
        wall_us: 41_000_000,
        cpu_us: None,
    };
    let json = serde_json::to_value(&payload).expect("serialize");
    let parsed: PhaseCompletedPayload = serde_json::from_value(json).expect("deserialize");
    assert_eq!(parsed, payload);
}

#[test]
fn phase_cancelled_payload_roundtrips() {
    let payload = PhaseCancelledPayload {
        work_class: "warm".into(),
        phase: "ann_warm".into(),
        wall_us: 12_000,
        cpu_us: Some(9_500),
    };
    let json = serde_json::to_value(&payload).expect("serialize");
    let parsed: PhaseCancelledPayload = serde_json::from_value(json).expect("deserialize");
    assert_eq!(parsed, payload);
}