cloud-sdk-testkit 0.29.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
98
99
100
101
102
103
104

use cloud_sdk::Method;
use cloud_sdk::transport::{
    AsyncExecutionError, BlockingRawHttpExecutor, DeliveryPhase, MediaType, RawResponsePolicy,
    RequestTarget, ResponseBuffer, ResponseMediaPolicy, TransportRequest, drive_async_raw,
};
use core::future::Future;
use core::task::{Context, Poll, Waker};

use crate::{RawFault, RawFaultExecutor};

fn policy() -> Option<RawResponsePolicy<'static>> {
    RawResponsePolicy::new(
        1,
        1,
        ResponseMediaPolicy::Optional(&[MediaType::JSON]),
        ResponseMediaPolicy::Optional(&[MediaType::JSON]),
        &[],
        0,
    )
    .ok()
}

#[test]
fn preserves_every_conservative_delivery_phase() {
    let Ok(target) = RequestTarget::new("/fault") else {
        unreachable!("testkit security fixture construction failed");
    };
    let Some(policy) = policy() else {
        unreachable!("testkit security fixture construction failed");
    };
    for (fault, expected) in [
        (RawFault::NotSent, DeliveryPhase::NotSent),
        (RawFault::PossiblySent, DeliveryPhase::PossiblySent),
        (RawFault::ResponseStarted, DeliveryPhase::ResponseStarted),
        (RawFault::Unknown, DeliveryPhase::PossiblySent),
    ] {
        let executor = RawFaultExecutor::new(fault);
        let mut body = [0xa5_u8; 1];
        let mut headers = [0xa5_u8; 32];
        let mut response = ResponseBuffer::new(&mut body, 1, &mut headers);
        let failure = BlockingRawHttpExecutor::execute(
            &executor,
            TransportRequest::new(Method::Get, target),
            policy,
            response.writer(),
        );
        assert!(matches!(failure, Err(error) if error.phase() == expected));
    }
}

#[test]
fn async_unknown_fault_is_immediately_possibly_sent() {
    let Ok(target) = RequestTarget::new("/fault") else {
        unreachable!("testkit security fixture construction failed");
    };
    let Some(policy) = policy() else {
        unreachable!("testkit security fixture construction failed");
    };
    let executor = RawFaultExecutor::new(RawFault::Unknown);
    let mut body = [0xa5_u8; 1];
    let mut headers = [0xa5_u8; 32];
    let mut response = ResponseBuffer::new(&mut body, 1, &mut headers);
    let future = drive_async_raw(
        &executor,
        TransportRequest::new(Method::Get, target),
        policy,
        response.writer(),
    );
    let mut future = core::pin::pin!(future);
    let waker = Waker::noop();
    let mut context = Context::from_waker(waker);
    assert!(matches!(
        Future::poll(future.as_mut(), &mut context),
        Poll::Ready(Err(AsyncExecutionError::Transport(error)))
            if error.phase() == DeliveryPhase::PossiblySent
    ));
}

#[test]
fn send_raw_executor_automatically_satisfies_local_async() {
    let Ok(target) = RequestTarget::new("/fault") else {
        unreachable!("testkit security fixture construction failed");
    };
    let Some(policy) = policy() else {
        unreachable!("testkit security fixture construction failed");
    };
    let executor = RawFaultExecutor::new(RawFault::NotSent);
    let mut body = [0xa5_u8; 1];
    let mut headers = [0xa5_u8; 32];
    let mut response = ResponseBuffer::new(&mut body, 1, &mut headers);
    let future = cloud_sdk::transport::drive_local_raw(
        &executor,
        TransportRequest::new(Method::Get, target),
        policy,
        response.writer(),
    );
    let mut future = core::pin::pin!(future);
    let mut context = Context::from_waker(Waker::noop());
    assert!(matches!(
        Future::poll(future.as_mut(), &mut context),
        Poll::Ready(Err(AsyncExecutionError::Transport(error)))
            if error.phase() == DeliveryPhase::NotSent
    ));
}