sipp-rs 0.1.2

Unified Rust library for extensible Sipp inference
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
107
108
109
110
111
112
113
114
115
116
117

//! Unit tests for the native remote acquisition executor.
//!
//! Covers timeout handling for deterministic local HTTP fixtures without live
//! network access or model loading.

use std::{collections::BTreeMap, time::Duration};

use wiremock::{
    matchers::{method, path},
    Mock, MockServer, ResponseTemplate,
};

use crate::lifecycle::test_support::TempDir;
use crate::lifecycle::{AssetStore, RegistryManifest};

use super::*;

fn short_timeouts() -> NativeHttpTimeouts {
    NativeHttpTimeouts {
        connect: Duration::from_secs(1),
        read: Duration::from_millis(50),
        metadata_request: Duration::from_millis(50),
    }
}

#[tokio::test]
async fn metadata_request_timeout_reports_transport_failure() {
    let server = MockServer::start().await;
    Mock::given(method("HEAD"))
        .and(path("/model.gguf"))
        .respond_with(ResponseTemplate::new(200).set_delay(Duration::from_secs(5)))
        .mount(&server)
        .await;

    let root = TempDir::new("native-acquisition", "metadata-timeout");
    let assets = AssetStore::local(root.path.clone());
    let journal = assets.acquisition_journal("lease-metadata-timeout");
    let executor =
        NativeRemoteExecutor::with_timeouts(assets, journal, short_timeouts()).expect("executor");
    let mut downloaded = BTreeMap::new();
    let event = tokio::time::timeout(
        Duration::from_secs(1),
        executor.execute(
            RemoteAction::FetchMetadata {
                acquisition_id: "lease-metadata-timeout".to_string(),
                member_id: 0,
                attempt: 1,
                url: format!("{}/model.gguf", server.uri()),
            },
            &RegistryManifest::default(),
            &mut downloaded,
        ),
    )
    .await
    .expect("metadata request should return through its configured timeout");

    assert_transport_failure(event, RemoteFailurePhase::Metadata);
}

#[tokio::test]
async fn download_read_timeout_reports_transport_failure() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/model.gguf"))
        .respond_with(ResponseTemplate::new(200).set_delay(Duration::from_secs(5)))
        .mount(&server)
        .await;

    let root = TempDir::new("native-acquisition", "download-timeout");
    let assets = AssetStore::local(root.path.clone());
    let journal = assets.acquisition_journal("lease-download-timeout");
    let executor =
        NativeRemoteExecutor::with_timeouts(assets, journal, short_timeouts()).expect("executor");
    let mut downloaded = BTreeMap::new();
    let event = tokio::time::timeout(
        Duration::from_secs(1),
        executor.execute(
            RemoteAction::Download {
                acquisition_id: "lease-download-timeout".to_string(),
                member_id: 0,
                attempt: 1,
                metadata: super::super::RemoteMetadata {
                    url: format!("{}/model.gguf", server.uri()),
                    name: "model.gguf".to_string(),
                    bytes: 1,
                    etag: None,
                    last_modified: None,
                },
            },
            &RegistryManifest::default(),
            &mut downloaded,
        ),
    )
    .await
    .expect("download request should return through its configured timeout");

    assert_transport_failure(event, RemoteFailurePhase::Download);
}

fn assert_transport_failure(event: RemoteAcquisitionEvent, phase: RemoteFailurePhase) {
    assert!(
        matches!(
            event,
            RemoteAcquisitionEvent::OperationFailed {
                failure: RemoteFailure {
                    phase: actual_phase,
                    kind: RemoteFailureKind::Transport,
                    status: None,
                    ..
                },
                ref created_asset_ids,
                ..
            } if actual_phase == phase && created_asset_ids.is_empty()
        ),
        "expected {phase:?} transport failure, got {event:?}"
    );
}