watasu 0.1.66

Rust SDK for Watasu
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

use watasu::{ConnectionOptions, Sandbox, SnapshotListOptions, Template};

#[tokio::test]
async fn live_snapshot_list_shape() {
    if std::env::var("WATASU_LIVE_API_TESTS").ok().as_deref() != Some("1") {
        eprintln!("set WATASU_LIVE_API_TESTS=1 to run live API smoke tests");
        return;
    }

    let page = Sandbox::list_snapshots_page(SnapshotListOptions {
        limit: Some(2),
        ..SnapshotListOptions::default()
    })
    .await
    .expect("live snapshot list request should succeed");

    assert!(page.snapshots.len() <= 2);
}

#[tokio::test]
async fn live_template_helpers_expose_platform_template_aliases() {
    if std::env::var("WATASU_LIVE_API_TESTS").ok().as_deref() != Some("1") {
        eprintln!("set WATASU_LIVE_API_TESTS=1 to run live API smoke tests");
        return;
    }

    assert!(Template::exists("base", ConnectionOptions::default())
        .await
        .expect("live template alias request should succeed"));
    assert!(
        !Template::exists("watasu-live-missing-template", ConnectionOptions::default())
            .await
            .expect("live missing template alias request should succeed")
    );
    let _tags = Template::get_tags("base", ConnectionOptions::default())
        .await
        .expect("live template tags request should succeed");
}

#[tokio::test]
async fn live_sandbox_template_admin_reads_version_and_logs() {
    if std::env::var("WATASU_LIVE_API_TESTS").ok().as_deref() != Some("1") {
        eprintln!("set WATASU_LIVE_API_TESTS=1 to run live API smoke tests");
        return;
    }

    let templates = Template::list_sandbox_templates(ConnectionOptions::default())
        .await
        .expect("live sandbox template list request should succeed");
    let base = templates
        .iter()
        .find(|template| template.slug == "base")
        .expect("live platform base template should be listed");

    let found = Template::find_sandbox_template_by_slug("base", ConnectionOptions::default())
        .await
        .expect("live sandbox template slug lookup should succeed")
        .expect("live platform base template should be found");
    assert_eq!(found.template_id, base.template_id);

    let versions =
        Template::list_sandbox_template_versions(&base.template_id, ConnectionOptions::default())
            .await
            .expect("live sandbox template versions request should succeed");
    let version = versions
        .first()
        .expect("live platform base template should have at least one version");
    assert!(!version.template_version_id.is_empty());
    assert!(!version.status.is_empty());

    let fetched = Template::get_sandbox_template_version(
        &base.template_id,
        &version.template_version_id,
        ConnectionOptions::default(),
    )
    .await
    .expect("live sandbox template version request should succeed");
    assert_eq!(fetched.template_version_id, version.template_version_id);

    let logs = Template::get_sandbox_template_version_build_logs(
        &base.template_id,
        &version.template_version_id,
        ConnectionOptions::default(),
    )
    .await
    .expect("live sandbox template build logs request should succeed");
    assert_eq!(logs.template_version_id, version.template_version_id);
    assert!(!logs.status.is_empty());
}