219 219 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
220 220 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
221 221 | })?;
|
222 222 | cfg.interceptor_state()
|
223 223 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
224 224 | ::std::result::Result::Ok(())
|
225 225 | }
|
226 226 | }
|
227 227 | #[allow(unreachable_code, unused_variables)]
|
228 228 | #[cfg(test)]
|
229 - | mod escaped_string_values_request_test {
|
229 + | mod escaped_string_values_test {
|
230 + |
|
230 231 | /// Test ID: EscapedStringValuesRequest
|
231 232 | #[::tokio::test]
|
232 - | #[allow(unused_mut)]
|
233 + | #[::tracing_test::traced_test]
|
233 234 | async fn escaped_string_values_request_request() {
|
234 235 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
235 236 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
236 237 |
|
237 238 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
238 239 | let result = client
|
239 240 | .escaped_string_values()
|
240 241 | .set_enum(::std::option::Option::Some(
|
241 242 | "has\"quotes"
|
242 243 | .parse::<crate::types::EnumWithEscapedChars>()
|
243 244 | .expect("static value validated to member"),
|
244 245 | ))
|
245 246 | .set_some_string(::std::option::Option::Some("test".to_owned()))
|
246 247 | .send()
|
247 248 | .await;
|
248 249 | let _ = dbg!(result);
|
249 250 | let http_request = request_receiver.expect_request();
|
250 251 | let expected_headers = [("Content-Type", "application/json")];
|
251 252 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
252 253 | let body = http_request.body().bytes().expect("body should be strict");
|
253 254 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
254 255 | body,
|
255 256 | "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
|
256 257 | ::aws_smithy_protocol_test::MediaType::from("unknown"),
|
257 258 | ));
|
258 259 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
259 260 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
260 261 | ::pretty_assertions::assert_eq!(uri.path(), "/escaped-string-values", "path was incorrect");
|
261 262 | }
|
262 263 | /// Test ID: EscapedStringValuesResponse
|
263 264 | #[::tokio::test]
|
264 - | #[allow(unused_mut)]
|
265 + | #[::tracing_test::traced_test]
|
265 266 | async fn escaped_string_values_response_response() {
|
266 267 | let expected_output = crate::operation::escaped_string_values::EscapedStringValuesOutput::builder()
|
267 268 | .set_enum(::std::option::Option::Some(
|
268 269 | "has\"quotes"
|
269 270 | .parse::<crate::types::EnumWithEscapedChars>()
|
270 271 | .expect("static value validated to member"),
|
271 272 | ))
|
272 273 | .set_some_string(::std::option::Option::Some("test".to_owned()))
|
273 274 | .build();
|
274 275 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
275 276 | ::http::response::Builder::new()
|
276 277 | .status(200)
|
277 278 | .body(::aws_smithy_types::body::SdkBody::from(
|
278 279 | "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
|
279 280 | ))
|
280 281 | .unwrap(),
|
281 282 | )
|
282 283 | .unwrap();
|
283 284 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
284 285 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
285 286 |
|
286 287 | let op = crate::operation::escaped_string_values::EscapedStringValues::new();
|
287 288 | let config = op.config().expect("the operation has config");
|
288 289 | let de = config
|
289 290 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
290 291 | .expect("the config must have a deserializer");
|
291 292 |
|
292 293 | let parsed = de.deserialize_streaming(&mut http_response);
|
293 294 | let parsed = parsed.unwrap_or_else(|| {
|
294 295 | let http_response =
|
295 296 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
296 297 | de.deserialize_nonstreaming(&http_response)
|
297 298 | });
|
298 299 | let parsed = parsed
|
299 300 | .expect("should be successful response")
|
300 301 | .downcast::<crate::operation::escaped_string_values::EscapedStringValuesOutput>()
|
301 302 | .unwrap();
|
302 303 | ::pretty_assertions::assert_eq!(parsed.r#enum, expected_output.r#enum, "Unexpected value for `r#enum`");
|
303 304 | ::pretty_assertions::assert_eq!(parsed.some_string, expected_output.some_string, "Unexpected value for `some_string`");
|
304 305 | }
|
305 306 | /// Upper case error modeled lower case
|
306 307 | /// Test ID: ServiceLevelErrorClient
|
307 308 | #[::tokio::test]
|
308 - | #[allow(unused_mut)]
|
309 + | #[::tracing_test::traced_test]
|
309 310 | async fn service_level_error_client_response() {
|
310 311 | let expected_output = crate::types::error::ExtraError::builder().build();
|
311 312 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
312 313 | ::http::response::Builder::new()
|
313 314 | .header("X-Amzn-Errortype", "ExtraError")
|
314 315 | .status(500)
|
315 316 | .body(::aws_smithy_types::body::SdkBody::from(""))
|
316 317 | .unwrap(),
|
317 318 | )
|
318 319 | .unwrap();
|
319 320 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
320 321 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
321 322 |
|
322 323 | let op = crate::operation::escaped_string_values::EscapedStringValues::new();
|
323 324 | let config = op.config().expect("the operation has config");
|
324 325 | let de = config
|
325 326 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
326 327 | .expect("the config must have a deserializer");
|
327 328 |
|
328 329 | let parsed = de.deserialize_streaming(&mut http_response);
|
329 330 | let parsed = parsed.unwrap_or_else(|| {
|
330 331 | let http_response =
|
331 332 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
332 333 | de.deserialize_nonstreaming(&http_response)
|
333 334 | });
|
334 335 | let parsed = parsed.expect_err("should be error response");
|
335 336 | let parsed: &crate::operation::escaped_string_values::EscapedStringValuesError =
|
336 337 | parsed.as_operation_error().expect("operation error").downcast_ref().unwrap();
|
337 338 | if let crate::operation::escaped_string_values::EscapedStringValuesError::ExtraError(parsed) = parsed {
|
338 339 | ::pretty_assertions::assert_eq!(parsed.message, expected_output.message, "Unexpected value for `message`");
|