openstack_sdk_identity/v3/endpoint/
set.rs1use derive_builder::Builder;
24use http::{HeaderMap, HeaderName, HeaderValue};
25
26use openstack_sdk_core::api::rest_endpoint_prelude::*;
27
28use serde::Deserialize;
29use serde::Serialize;
30use serde_json::Value;
31use std::borrow::Cow;
32use std::collections::BTreeMap;
33
34#[derive(Debug, Deserialize, Clone, Serialize)]
35pub enum Interface {
36 #[serde(rename = "admin")]
37 Admin,
38 #[serde(rename = "internal")]
39 Internal,
40 #[serde(rename = "public")]
41 Public,
42}
43
44#[derive(Builder, Debug, Deserialize, Clone, Serialize)]
46#[builder(setter(strip_option))]
47pub struct Endpoint<'a> {
48 #[serde(skip_serializing_if = "Option::is_none")]
50 #[builder(default, setter(into))]
51 pub(crate) description: Option<Option<Cow<'a, str>>>,
52
53 #[serde(skip_serializing_if = "Option::is_none")]
57 #[builder(default, setter(into))]
58 pub(crate) enabled: Option<bool>,
59
60 #[serde(skip_serializing_if = "Option::is_none")]
66 #[builder(default)]
67 pub(crate) interface: Option<Interface>,
68
69 #[serde(skip_serializing_if = "Option::is_none")]
76 #[builder(default, setter(into))]
77 pub(crate) name: Option<Cow<'a, str>>,
78
79 #[serde(skip_serializing_if = "Option::is_none")]
81 #[builder(default, setter(into))]
82 pub(crate) region: Option<Option<Cow<'a, str>>>,
83
84 #[serde(skip_serializing_if = "Option::is_none")]
86 #[builder(default, setter(into))]
87 pub(crate) region_id: Option<Option<Cow<'a, str>>>,
88
89 #[serde(skip_serializing_if = "Option::is_none")]
91 #[builder(default, setter(into))]
92 pub(crate) service_id: Option<Cow<'a, str>>,
93
94 #[serde(skip_serializing_if = "Option::is_none")]
96 #[builder(default, setter(into))]
97 pub(crate) url: Option<Cow<'a, str>>,
98
99 #[builder(setter(name = "_properties"), default, private)]
100 #[serde(flatten)]
101 _properties: BTreeMap<Cow<'a, str>, Value>,
102}
103
104impl<'a> EndpointBuilder<'a> {
105 pub fn properties<I, K, V>(&mut self, iter: I) -> &mut Self
106 where
107 I: Iterator<Item = (K, V)>,
108 K: Into<Cow<'a, str>>,
109 V: Into<Value>,
110 {
111 self._properties
112 .get_or_insert_with(BTreeMap::new)
113 .extend(iter.map(|(k, v)| (k.into(), v.into())));
114 self
115 }
116}
117
118#[derive(Builder, Debug, Clone)]
119#[builder(setter(strip_option))]
120pub struct Request<'a> {
121 #[builder(setter(into))]
123 pub(crate) endpoint: Endpoint<'a>,
124
125 #[builder(default, setter(into))]
127 id: Cow<'a, str>,
128
129 #[builder(setter(name = "_headers"), default, private)]
130 _headers: Option<HeaderMap>,
131}
132impl<'a> Request<'a> {
133 pub fn builder() -> RequestBuilder<'a> {
135 RequestBuilder::default()
136 }
137}
138
139impl<'a> RequestBuilder<'a> {
140 pub fn header<K, V>(&mut self, header_name: K, header_value: V) -> &mut Self
142 where
143 K: Into<HeaderName>,
144 V: Into<HeaderValue>,
145 {
146 self._headers
147 .get_or_insert(None)
148 .get_or_insert_with(HeaderMap::new)
149 .insert(header_name.into(), header_value.into());
150 self
151 }
152
153 pub fn headers<I, T>(&mut self, iter: I) -> &mut Self
155 where
156 I: Iterator<Item = T>,
157 T: Into<(Option<HeaderName>, HeaderValue)>,
158 {
159 self._headers
160 .get_or_insert(None)
161 .get_or_insert_with(HeaderMap::new)
162 .extend(iter.map(Into::into));
163 self
164 }
165}
166
167impl RestEndpoint for Request<'_> {
168 fn method(&self) -> http::Method {
169 http::Method::PATCH
170 }
171
172 fn endpoint(&self) -> Cow<'static, str> {
173 format!("endpoints/{id}", id = self.id.as_ref(),).into()
174 }
175
176 fn parameters(&self) -> QueryParams<'_> {
177 QueryParams::default()
178 }
179
180 fn body(&self) -> Result<Option<(&'static str, Vec<u8>)>, BodyError> {
181 let mut params = JsonBodyParams::default();
182
183 params.push("endpoint", serde_json::to_value(&self.endpoint)?);
184
185 params.into_body()
186 }
187
188 fn service_type(&self) -> ServiceType {
189 ServiceType::Identity
190 }
191
192 fn response_key(&self) -> Option<Cow<'static, str>> {
193 Some("endpoint".into())
194 }
195
196 fn request_headers(&self) -> Option<&HeaderMap> {
198 self._headers.as_ref()
199 }
200
201 fn api_version(&self) -> Option<ApiVersion> {
203 Some(ApiVersion::new(3, 0))
204 }
205}
206
207#[cfg(test)]
208mod tests {
209 use super::*;
210 use http::{HeaderName, HeaderValue};
211 use httpmock::MockServer;
212 #[cfg(feature = "sync")]
213 use openstack_sdk_core::api::Query;
214 use openstack_sdk_core::test::client::FakeOpenStackClient;
215 use openstack_sdk_core::types::ServiceType;
216 use serde_json::json;
217
218 #[test]
219 fn test_service_type() {
220 assert_eq!(
221 Request::builder()
222 .endpoint(EndpointBuilder::default().build().unwrap())
223 .build()
224 .unwrap()
225 .service_type(),
226 ServiceType::Identity
227 );
228 }
229
230 #[test]
231 fn test_response_key() {
232 assert_eq!(
233 Request::builder()
234 .endpoint(EndpointBuilder::default().build().unwrap())
235 .build()
236 .unwrap()
237 .response_key()
238 .unwrap(),
239 "endpoint"
240 );
241 }
242
243 #[cfg(feature = "sync")]
244 #[test]
245 fn endpoint() {
246 let server = MockServer::start();
247 let client = FakeOpenStackClient::new(server.base_url());
248 let mock = server.mock(|when, then| {
249 when.method(httpmock::Method::PATCH)
250 .path(format!("/endpoints/{id}", id = "id",));
251
252 then.status(200)
253 .header("content-type", "application/json")
254 .json_body(json!({ "endpoint": {} }));
255 });
256
257 let endpoint = Request::builder()
258 .id("id")
259 .endpoint(EndpointBuilder::default().build().unwrap())
260 .build()
261 .unwrap();
262 let _: serde_json::Value = endpoint.query(&client).unwrap();
263 mock.assert();
264 }
265
266 #[cfg(feature = "sync")]
267 #[test]
268 fn endpoint_headers() {
269 let server = MockServer::start();
270 let client = FakeOpenStackClient::new(server.base_url());
271 let mock = server.mock(|when, then| {
272 when.method(httpmock::Method::PATCH)
273 .path(format!("/endpoints/{id}", id = "id",))
274 .header("foo", "bar")
275 .header("not_foo", "not_bar");
276 then.status(200)
277 .header("content-type", "application/json")
278 .json_body(json!({ "endpoint": {} }));
279 });
280
281 let endpoint = Request::builder()
282 .id("id")
283 .endpoint(EndpointBuilder::default().build().unwrap())
284 .headers(
285 [(
286 Some(HeaderName::from_static("foo")),
287 HeaderValue::from_static("bar"),
288 )]
289 .into_iter(),
290 )
291 .header(
292 HeaderName::from_static("not_foo"),
293 HeaderValue::from_static("not_bar"),
294 )
295 .build()
296 .unwrap();
297 let _: serde_json::Value = endpoint.query(&client).unwrap();
298 mock.assert();
299 }
300}