cloud-sdk-testkit 0.22.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
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Redacted records of prepared request policy and shape.

use core::fmt;

use cloud_sdk::Method;
use cloud_sdk::operation::{OperationMetadata, PreparedRequest, ProviderService, ResponsePolicy};
use cloud_sdk::transport::HeaderSensitivity;

/// Non-secret record of one prepared request for policy assertions.
#[derive(Clone, Copy, Eq, PartialEq)]
pub struct PreparedRequestRecord<'endpoint> {
    method: Method,
    target_len: usize,
    body_len: usize,
    has_request_content_type: bool,
    header_count: usize,
    sensitive_header_count: usize,
    service: ProviderService<'endpoint>,
    metadata: OperationMetadata,
    response_policy: ResponsePolicy,
}

impl<'endpoint> PreparedRequestRecord<'endpoint> {
    /// Captures request shape and complete policy without copying target or body bytes.
    #[must_use]
    pub fn capture(prepared: PreparedRequest<'endpoint>) -> Self {
        let request = prepared.transport_request();
        Self {
            method: request.method(),
            target_len: request.target().len(),
            body_len: request.body().len(),
            has_request_content_type: request.headers().get("content-type").is_some(),
            header_count: request.headers().as_slice().len(),
            sensitive_header_count: request
                .headers()
                .as_slice()
                .iter()
                .filter(|header| matches!(header.sensitivity(), HeaderSensitivity::Sensitive))
                .count(),
            service: prepared.service(),
            metadata: prepared.metadata(),
            response_policy: prepared.response_policy(),
        }
    }

    /// Returns the HTTP method.
    #[must_use]
    pub const fn method(self) -> Method {
        self.method
    }

    /// Returns the redacted request-target length.
    #[must_use]
    pub const fn target_len(self) -> usize {
        self.target_len
    }

    /// Returns the redacted request-body length.
    #[must_use]
    pub const fn body_len(self) -> usize {
        self.body_len
    }

    /// Reports whether a request content type is configured.
    #[must_use]
    pub const fn has_request_content_type(self) -> bool {
        self.has_request_content_type
    }

    /// Returns the request-header count without exposing values.
    #[must_use]
    pub const fn header_count(self) -> usize {
        self.header_count
    }

    /// Returns the number of headers marked sensitive.
    #[must_use]
    pub const fn sensitive_header_count(self) -> usize {
        self.sensitive_header_count
    }

    /// Returns the bound provider service and endpoint.
    #[must_use]
    pub const fn service(self) -> ProviderService<'endpoint> {
        self.service
    }

    /// Returns complete operation safety and retry metadata.
    #[must_use]
    pub const fn metadata(self) -> OperationMetadata {
        self.metadata
    }

    /// Returns complete checked-response policy.
    #[must_use]
    pub const fn response_policy(self) -> ResponsePolicy {
        self.response_policy
    }
}

impl fmt::Debug for PreparedRequestRecord<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("PreparedRequestRecord")
            .field("method", &self.method)
            .field("target_len", &self.target_len)
            .field("target", &"[redacted]")
            .field("body_len", &self.body_len)
            .field("body", &"[redacted]")
            .field("has_request_content_type", &self.has_request_content_type)
            .field("header_count", &self.header_count)
            .field("sensitive_header_count", &self.sensitive_header_count)
            .field("service", &self.service)
            .field("metadata", &self.metadata)
            .field("response_policy", &self.response_policy)
            .finish()
    }
}