updatehub-sdk 2.1.0

UpdateHub SDK used to interact with a running instance of the UpdateHub Agent
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// Copyright (C) 2019 O.S. Systems Sofware LTDA
//
// SPDX-License-Identifier: Apache-2.0

use testcontainers::{
    clients::Cli,
    images::generic::{GenericImage, WaitFor},
    Container, Docker, Image,
};
use updatehub_sdk as sdk;

struct MockServer {
    docker: Cli,
}

impl MockServer {
    fn new() -> Self {
        MockServer { docker: Cli::default() }
    }

    fn start(&self) -> (String, Container<Cli, GenericImage>) {
        let apisprout = GenericImage::new("danielgtaylor/apisprout:latest")
            .with_wait_for(WaitFor::message_on_stdout(
                "Sprouting UpdateHub Agent local HTTP API routes on port",
            ))
            .with_args(vec!["/api.yaml".to_string(), "--validate-request".to_string()])
            .with_volume(
                &format!("{}/../doc/agent-http.yaml", env!("CARGO_MANIFEST_DIR")),
                "/api.yaml",
            );
        let container = self.docker.run(apisprout);
        let address = format!("localhost:{}", container.get_host_port(8000).unwrap());
        (address, container)
    }
}

#[tokio::test]
async fn info() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.info().await;
    assert!(dbg!(response).is_ok());
}

#[tokio::test]
async fn probe_default() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.probe(None).await;
    match dbg!(response) {
        Ok(_) => {}
        Err(sdk::Error::AgentIsBusy(_)) => {}
        Err(e) => panic!("Unexpected Error response: {}", e),
    }
}

#[tokio::test]
async fn probe_custom() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.probe(Some(String::from("http://foo.bar"))).await;
    match dbg!(response) {
        Ok(_) => {}
        Err(sdk::Error::AgentIsBusy(_)) => {}
        Err(e) => panic!("Unexpected Error response: {}", e),
    }
}

#[tokio::test]
async fn local_install() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let file = tempfile::NamedTempFile::new().unwrap();
    let response = client.local_install(file.path()).await;

    match dbg!(response) {
        Ok(_) => {}
        Err(sdk::Error::AgentIsBusy(_)) => {}
        Err(e) => panic!("Unexpected Error response: {}", e),
    }
}

#[tokio::test]
async fn remote_install() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.remote_install("http://foo.bar").await;
    match dbg!(response) {
        Ok(_) => {}
        Err(sdk::Error::AgentIsBusy(_)) => {}
        Err(e) => panic!("Unexpected Error response: {}", e),
    }
}

#[tokio::test]
async fn abort_download() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.abort_download().await;
    match dbg!(response) {
        Ok(_) => {}
        Err(sdk::Error::AbortDownloadRefused(_)) => {}
        Err(e) => panic!("Unexpected Error response: {}", e),
    }
}

#[tokio::test]
async fn log() {
    let mock = MockServer::new();
    let (addr, _guard) = &mock.start();
    let client = sdk::Client::new(addr);
    let response = client.log().await;
    assert!(dbg!(response).is_ok());
}