cloud-sdk-testkit 0.27.0

Provider-neutral mock transport and fixture boundary for cloud-sdk.
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 core::future::Future;
use core::task::{Context, Poll, Waker};

use cloud_sdk::Method;
use cloud_sdk::transport::{RequestTarget, ResponseBuffer, TransportRequest, drive_local};

use crate::{ExpectedRequest, FixtureBody, LocalMockTransport, MockExchange, ResponseFixture};

#[test]
fn local_async_mock_supports_cooperatively_outstanding_requests() {
    let Ok(target) = RequestTarget::new("/local") else {
        return;
    };
    let Ok(body) = FixtureBody::new(b"ok") else {
        return;
    };
    let exchanges = [
        MockExchange::new(
            ExpectedRequest::new(Method::Get, target),
            ResponseFixture::success(body),
        ),
        MockExchange::new(
            ExpectedRequest::new(Method::Get, target),
            ResponseFixture::success(body),
        ),
    ];
    let transport = LocalMockTransport::new(&exchanges);
    let mut first_body = [0_u8; 2];
    let mut first_headers = [0_u8; 64];
    let mut first_response = ResponseBuffer::new(&mut first_body, 2, &mut first_headers);
    let mut second_body = [0_u8; 2];
    let mut second_headers = [0_u8; 64];
    let mut second_response = ResponseBuffer::new(&mut second_body, 2, &mut second_headers);
    {
        let first = drive_local(
            &transport,
            TransportRequest::new(Method::Get, target),
            first_response.writer(),
        );
        let second = drive_local(
            &transport,
            TransportRequest::new(Method::Get, target),
            second_response.writer(),
        );
        let mut first = core::pin::pin!(first);
        let mut second = core::pin::pin!(second);
        let mut context = Context::from_waker(Waker::noop());
        assert!(matches!(
            Future::poll(first.as_mut(), &mut context),
            Poll::Ready(Ok(()))
        ));
        assert!(matches!(
            Future::poll(second.as_mut(), &mut context),
            Poll::Ready(Ok(()))
        ));
    }
    assert!(transport.is_complete());
    assert!(
        first_response
            .with_response(|response| response.body() == b"ok")
            .is_ok_and(core::convert::identity)
    );
    assert!(
        second_response
            .with_response(|response| response.body() == b"ok")
            .is_ok_and(core::convert::identity)
    );
}

#[test]
fn dropping_unpolled_local_mock_future_preserves_the_exchange() {
    let Ok(target) = RequestTarget::new("/local-drop") else {
        return;
    };
    let Ok(body) = FixtureBody::new(b"ok") else {
        return;
    };
    let exchanges = [MockExchange::new(
        ExpectedRequest::new(Method::Get, target),
        ResponseFixture::success(body),
    )];
    let transport = LocalMockTransport::new(&exchanges);
    let mut output = [0xa5_u8; 2];
    let mut headers = [0xa5_u8; 64];
    {
        let mut response = ResponseBuffer::new(&mut output, 2, &mut headers);
        let future = drive_local(
            &transport,
            TransportRequest::new(Method::Get, target),
            response.writer(),
        );
        drop(future);
    }
    assert_eq!(output, [0_u8; 2]);
    assert_eq!(headers, [0_u8; 64]);
    assert_eq!(transport.remaining(), 1);
}