210 210 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
211 211 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
212 212 | })?;
|
213 213 | cfg.interceptor_state()
|
214 214 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
215 215 | ::std::result::Result::Ok(())
|
216 216 | }
|
217 217 | }
|
218 218 | #[allow(unreachable_code, unused_variables)]
|
219 219 | #[cfg(test)]
|
220 - | mod json_unions_request_test {
|
220 + | mod json_unions_test {
|
221 + |
|
221 222 | /// Serializes a string union value
|
222 223 | /// Test ID: AwsJson10SerializeStringUnionValue
|
223 224 | #[::tokio::test]
|
224 - | #[allow(unused_mut)]
|
225 + | #[::tracing_test::traced_test]
|
225 226 | async fn aws_json10_serialize_string_union_value_request() {
|
226 227 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
227 228 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
228 229 |
|
229 230 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
230 231 | let result = client
|
231 232 | .json_unions()
|
232 233 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
|
233 234 | .send()
|
234 235 | .await;
|
235 236 | let _ = dbg!(result);
|
236 237 | let http_request = request_receiver.expect_request();
|
237 238 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
238 239 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
239 240 | let body = http_request.body().bytes().expect("body should be strict");
|
240 241 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
241 242 | body,
|
242 243 | "{\n \"contents\": {\n \"stringValue\": \"foo\"\n }\n}",
|
243 244 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
244 245 | ));
|
245 246 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
246 247 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
247 248 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
248 249 | }
|
249 250 | /// Serializes a boolean union value
|
250 251 | /// Test ID: AwsJson10SerializeBooleanUnionValue
|
251 252 | #[::tokio::test]
|
252 - | #[allow(unused_mut)]
|
253 + | #[::tracing_test::traced_test]
|
253 254 | async fn aws_json10_serialize_boolean_union_value_request() {
|
254 255 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
255 256 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
256 257 |
|
257 258 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
258 259 | let result = client
|
259 260 | .json_unions()
|
260 261 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
|
261 262 | .send()
|
262 263 | .await;
|
263 264 | let _ = dbg!(result);
|
264 265 | let http_request = request_receiver.expect_request();
|
265 266 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
266 267 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
267 268 | let body = http_request.body().bytes().expect("body should be strict");
|
268 269 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
269 270 | body,
|
270 271 | "{\n \"contents\": {\n \"booleanValue\": true\n }\n}",
|
271 272 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
272 273 | ));
|
273 274 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
274 275 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
275 276 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
276 277 | }
|
277 278 | /// Serializes a number union value
|
278 279 | /// Test ID: AwsJson10SerializeNumberUnionValue
|
279 280 | #[::tokio::test]
|
280 - | #[allow(unused_mut)]
|
281 + | #[::tracing_test::traced_test]
|
281 282 | async fn aws_json10_serialize_number_union_value_request() {
|
282 283 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
283 284 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
284 285 |
|
285 286 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
286 287 | let result = client
|
287 288 | .json_unions()
|
288 289 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
|
289 290 | .send()
|
290 291 | .await;
|
291 292 | let _ = dbg!(result);
|
292 293 | let http_request = request_receiver.expect_request();
|
293 294 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
294 295 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
295 296 | let body = http_request.body().bytes().expect("body should be strict");
|
296 297 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
297 298 | body,
|
298 299 | "{\n \"contents\": {\n \"numberValue\": 1\n }\n}",
|
299 300 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
300 301 | ));
|
301 302 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
302 303 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
303 304 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
304 305 | }
|
305 306 | /// Serializes a blob union value
|
306 307 | /// Test ID: AwsJson10SerializeBlobUnionValue
|
307 308 | #[::tokio::test]
|
308 - | #[allow(unused_mut)]
|
309 + | #[::tracing_test::traced_test]
|
309 310 | async fn aws_json10_serialize_blob_union_value_request() {
|
310 311 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
311 312 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
312 313 |
|
313 314 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
314 315 | let result = client
|
315 316 | .json_unions()
|
316 317 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
|
317 318 | ::aws_smithy_types::Blob::new("foo"),
|
318 319 | )))
|
319 320 | .send()
|
320 321 | .await;
|
321 322 | let _ = dbg!(result);
|
322 323 | let http_request = request_receiver.expect_request();
|
323 324 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
324 325 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
325 326 | let body = http_request.body().bytes().expect("body should be strict");
|
326 327 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
327 328 | body,
|
328 329 | "{\n \"contents\": {\n \"blobValue\": \"Zm9v\"\n }\n}",
|
329 330 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
330 331 | ));
|
331 332 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
332 333 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
333 334 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
334 335 | }
|
335 336 | /// Serializes a timestamp union value
|
336 337 | /// Test ID: AwsJson10SerializeTimestampUnionValue
|
337 338 | #[::tokio::test]
|
338 - | #[allow(unused_mut)]
|
339 + | #[::tracing_test::traced_test]
|
339 340 | async fn aws_json10_serialize_timestamp_union_value_request() {
|
340 341 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
341 342 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
342 343 |
|
343 344 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
344 345 | let result = client
|
345 346 | .json_unions()
|
346 347 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
|
347 348 | ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
|
348 349 | )))
|
349 350 | .send()
|
350 351 | .await;
|
351 352 | let _ = dbg!(result);
|
352 353 | let http_request = request_receiver.expect_request();
|
353 354 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
354 355 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
355 356 | let body = http_request.body().bytes().expect("body should be strict");
|
356 357 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
357 358 | body,
|
358 359 | "{\n \"contents\": {\n \"timestampValue\": 1398796238\n }\n}",
|
359 360 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
360 361 | ));
|
361 362 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
362 363 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
363 364 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
364 365 | }
|
365 366 | /// Serializes an enum union value
|
366 367 | /// Test ID: AwsJson10SerializeEnumUnionValue
|
367 368 | #[::tokio::test]
|
368 - | #[allow(unused_mut)]
|
369 + | #[::tracing_test::traced_test]
|
369 370 | async fn aws_json10_serialize_enum_union_value_request() {
|
370 371 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
371 372 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
372 373 |
|
373 374 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
374 375 | let result = client
|
375 376 | .json_unions()
|
376 377 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
|
377 378 | "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
|
378 379 | )))
|
379 380 | .send()
|
380 381 | .await;
|
381 382 | let _ = dbg!(result);
|
382 383 | let http_request = request_receiver.expect_request();
|
383 384 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
384 385 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
385 386 | let body = http_request.body().bytes().expect("body should be strict");
|
386 387 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
387 388 | body,
|
388 389 | "{\n \"contents\": {\n \"enumValue\": \"Foo\"\n }\n}",
|
389 390 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
390 391 | ));
|
391 392 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
392 393 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
393 394 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
394 395 | }
|
395 396 | /// Serializes an intEnum union value
|
396 397 | /// Test ID: AwsJson10SerializeIntEnumUnionValue
|
397 398 | #[::tokio::test]
|
398 - | #[allow(unused_mut)]
|
399 + | #[::tracing_test::traced_test]
|
399 400 | async fn aws_json10_serialize_int_enum_union_value_request() {
|
400 401 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
401 402 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
402 403 |
|
403 404 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
404 405 | let result = client
|
405 406 | .json_unions()
|
406 407 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::IntEnumValue(1)))
|
407 408 | .send()
|
408 409 | .await;
|
409 410 | let _ = dbg!(result);
|
410 411 | let http_request = request_receiver.expect_request();
|
411 412 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
412 413 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
413 414 | let body = http_request.body().bytes().expect("body should be strict");
|
414 415 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
415 416 | body,
|
416 417 | "{\n \"contents\": {\n \"intEnumValue\": 1\n }\n}",
|
417 418 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
418 419 | ));
|
419 420 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
420 421 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
421 422 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
422 423 | }
|
423 424 | /// Serializes a list union value
|
424 425 | /// Test ID: AwsJson10SerializeListUnionValue
|
425 426 | #[::tokio::test]
|
426 - | #[allow(unused_mut)]
|
427 + | #[::tracing_test::traced_test]
|
427 428 | async fn aws_json10_serialize_list_union_value_request() {
|
428 429 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
429 430 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
430 431 |
|
431 432 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
432 433 | let result = client
|
433 434 | .json_unions()
|
434 435 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
|
435 436 | "foo".to_owned(),
|
436 437 | "bar".to_owned(),
|
437 438 | ])))
|
438 439 | .send()
|
439 440 | .await;
|
440 441 | let _ = dbg!(result);
|
441 442 | let http_request = request_receiver.expect_request();
|
442 443 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
443 444 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
444 445 | let body = http_request.body().bytes().expect("body should be strict");
|
445 446 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
446 447 | body,
|
447 448 | "{\n \"contents\": {\n \"listValue\": [\"foo\", \"bar\"]\n }\n}",
|
448 449 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
449 450 | ));
|
450 451 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
451 452 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
452 453 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
453 454 | }
|
454 455 | /// Serializes a map union value
|
455 456 | /// Test ID: AwsJson10SerializeMapUnionValue
|
456 457 | #[::tokio::test]
|
457 - | #[allow(unused_mut)]
|
458 + | #[::tracing_test::traced_test]
|
458 459 | async fn aws_json10_serialize_map_union_value_request() {
|
459 460 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
460 461 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
461 462 |
|
462 463 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
463 464 | let result = client
|
464 465 | .json_unions()
|
465 466 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
|
466 467 | let mut ret = ::std::collections::HashMap::new();
|
467 468 | ret.insert("foo".to_owned(), "bar".to_owned());
|
468 469 | ret.insert("spam".to_owned(), "eggs".to_owned());
|
469 470 | ret
|
470 471 | })))
|
471 472 | .send()
|
472 473 | .await;
|
473 474 | let _ = dbg!(result);
|
474 475 | let http_request = request_receiver.expect_request();
|
475 476 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
476 477 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
477 478 | let body = http_request.body().bytes().expect("body should be strict");
|
478 479 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
479 480 | body,
|
480 481 | "{\n \"contents\": {\n \"mapValue\": {\n \"foo\": \"bar\",\n \"spam\": \"eggs\"\n }\n }\n}",
|
481 482 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
482 483 | ));
|
483 484 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
484 485 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
485 486 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
486 487 | }
|
487 488 | /// Serializes a structure union value
|
488 489 | /// Test ID: AwsJson10SerializeStructureUnionValue
|
489 490 | #[::tokio::test]
|
490 - | #[allow(unused_mut)]
|
491 + | #[::tracing_test::traced_test]
|
491 492 | async fn aws_json10_serialize_structure_union_value_request() {
|
492 493 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
493 494 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
494 495 |
|
495 496 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
496 497 | let result = client
|
497 498 | .json_unions()
|
498 499 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
|
499 500 | crate::types::GreetingStruct::builder()
|
500 501 | .set_hi(::std::option::Option::Some("hello".to_owned()))
|
501 502 | .build(),
|
502 503 | )))
|
503 504 | .send()
|
504 505 | .await;
|
505 506 | let _ = dbg!(result);
|
506 507 | let http_request = request_receiver.expect_request();
|
507 508 | let expected_headers = [("Content-Type", "application/x-amz-json-1.0"), ("X-Amz-Target", "JsonRpc10.JsonUnions")];
|
508 509 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
509 510 | let body = http_request.body().bytes().expect("body should be strict");
|
510 511 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
511 512 | body,
|
512 513 | "{\n \"contents\": {\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}",
|
513 514 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
514 515 | ));
|
515 516 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
516 517 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
517 518 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
518 519 | }
|
519 520 | /// Deserializes a string union value
|
520 521 | /// Test ID: AwsJson10DeserializeStringUnionValue
|
521 522 | #[::tokio::test]
|
522 - | #[allow(unused_mut)]
|
523 + | #[::tracing_test::traced_test]
|
523 524 | async fn aws_json10_deserialize_string_union_value_response() {
|
524 525 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
525 526 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StringValue("foo".to_owned())))
|
526 527 | .build();
|
527 528 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
528 529 | ::http::response::Builder::new()
|
529 530 | .header("Content-Type", "application/x-amz-json-1.0")
|
530 531 | .status(200)
|
531 532 | .body(::aws_smithy_types::body::SdkBody::from(
|
532 533 | "{\n \"contents\": {\n \"stringValue\": \"foo\"\n }\n}",
|
533 534 | ))
|
534 535 | .unwrap(),
|
535 536 | )
|
536 537 | .unwrap();
|
537 538 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
538 539 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
539 540 |
|
540 541 | let op = crate::operation::json_unions::JsonUnions::new();
|
541 542 | let config = op.config().expect("the operation has config");
|
542 543 | let de = config
|
543 544 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
544 545 | .expect("the config must have a deserializer");
|
545 546 |
|
546 547 | let parsed = de.deserialize_streaming(&mut http_response);
|
547 548 | let parsed = parsed.unwrap_or_else(|| {
|
548 549 | let http_response =
|
549 550 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
550 551 | de.deserialize_nonstreaming(&http_response)
|
551 552 | });
|
552 553 | let parsed = parsed
|
553 554 | .expect("should be successful response")
|
554 555 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
555 556 | .unwrap();
|
556 557 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
557 558 | }
|
558 559 | /// Deserializes a boolean union value
|
559 560 | /// Test ID: AwsJson10DeserializeBooleanUnionValue
|
560 561 | #[::tokio::test]
|
561 - | #[allow(unused_mut)]
|
562 + | #[::tracing_test::traced_test]
|
562 563 | async fn aws_json10_deserialize_boolean_union_value_response() {
|
563 564 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
564 565 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::BooleanValue(true)))
|
565 566 | .build();
|
566 567 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
567 568 | ::http::response::Builder::new()
|
568 569 | .header("Content-Type", "application/x-amz-json-1.0")
|
569 570 | .status(200)
|
570 571 | .body(::aws_smithy_types::body::SdkBody::from(
|
571 572 | "{\n \"contents\": {\n \"booleanValue\": true\n }\n}",
|
572 573 | ))
|
573 574 | .unwrap(),
|
574 575 | )
|
575 576 | .unwrap();
|
576 577 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
577 578 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
578 579 |
|
579 580 | let op = crate::operation::json_unions::JsonUnions::new();
|
580 581 | let config = op.config().expect("the operation has config");
|
581 582 | let de = config
|
582 583 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
583 584 | .expect("the config must have a deserializer");
|
584 585 |
|
585 586 | let parsed = de.deserialize_streaming(&mut http_response);
|
586 587 | let parsed = parsed.unwrap_or_else(|| {
|
587 588 | let http_response =
|
588 589 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
589 590 | de.deserialize_nonstreaming(&http_response)
|
590 591 | });
|
591 592 | let parsed = parsed
|
592 593 | .expect("should be successful response")
|
593 594 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
594 595 | .unwrap();
|
595 596 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
596 597 | }
|
597 598 | /// Deserializes a number union value
|
598 599 | /// Test ID: AwsJson10DeserializeNumberUnionValue
|
599 600 | #[::tokio::test]
|
600 - | #[allow(unused_mut)]
|
601 + | #[::tracing_test::traced_test]
|
601 602 | async fn aws_json10_deserialize_number_union_value_response() {
|
602 603 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
603 604 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::NumberValue(1)))
|
604 605 | .build();
|
605 606 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
606 607 | ::http::response::Builder::new()
|
607 608 | .header("Content-Type", "application/x-amz-json-1.0")
|
608 609 | .status(200)
|
609 610 | .body(::aws_smithy_types::body::SdkBody::from(
|
610 611 | "{\n \"contents\": {\n \"numberValue\": 1\n }\n}",
|
611 612 | ))
|
612 613 | .unwrap(),
|
613 614 | )
|
614 615 | .unwrap();
|
615 616 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
616 617 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
617 618 |
|
618 619 | let op = crate::operation::json_unions::JsonUnions::new();
|
619 620 | let config = op.config().expect("the operation has config");
|
620 621 | let de = config
|
621 622 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
622 623 | .expect("the config must have a deserializer");
|
623 624 |
|
624 625 | let parsed = de.deserialize_streaming(&mut http_response);
|
625 626 | let parsed = parsed.unwrap_or_else(|| {
|
626 627 | let http_response =
|
627 628 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
628 629 | de.deserialize_nonstreaming(&http_response)
|
629 630 | });
|
630 631 | let parsed = parsed
|
631 632 | .expect("should be successful response")
|
632 633 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
633 634 | .unwrap();
|
634 635 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
635 636 | }
|
636 637 | /// Deserializes a blob union value
|
637 638 | /// Test ID: AwsJson10DeserializeBlobUnionValue
|
638 639 | #[::tokio::test]
|
639 - | #[allow(unused_mut)]
|
640 + | #[::tracing_test::traced_test]
|
640 641 | async fn aws_json10_deserialize_blob_union_value_response() {
|
641 642 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
642 643 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::BlobValue(
|
643 644 | ::aws_smithy_types::Blob::new("foo"),
|
644 645 | )))
|
645 646 | .build();
|
646 647 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
647 648 | ::http::response::Builder::new()
|
648 649 | .header("Content-Type", "application/x-amz-json-1.0")
|
649 650 | .status(200)
|
650 651 | .body(::aws_smithy_types::body::SdkBody::from(
|
651 652 | "{\n \"contents\": {\n \"blobValue\": \"Zm9v\"\n }\n}",
|
652 653 | ))
|
653 654 | .unwrap(),
|
654 655 | )
|
655 656 | .unwrap();
|
656 657 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
657 658 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
658 659 |
|
659 660 | let op = crate::operation::json_unions::JsonUnions::new();
|
660 661 | let config = op.config().expect("the operation has config");
|
661 662 | let de = config
|
662 663 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
663 664 | .expect("the config must have a deserializer");
|
664 665 |
|
665 666 | let parsed = de.deserialize_streaming(&mut http_response);
|
666 667 | let parsed = parsed.unwrap_or_else(|| {
|
667 668 | let http_response =
|
668 669 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
669 670 | de.deserialize_nonstreaming(&http_response)
|
670 671 | });
|
671 672 | let parsed = parsed
|
672 673 | .expect("should be successful response")
|
673 674 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
674 675 | .unwrap();
|
675 676 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
676 677 | }
|
677 678 | /// Deserializes a timestamp union value
|
678 679 | /// Test ID: AwsJson10DeserializeTimestampUnionValue
|
679 680 | #[::tokio::test]
|
680 - | #[allow(unused_mut)]
|
681 + | #[::tracing_test::traced_test]
|
681 682 | async fn aws_json10_deserialize_timestamp_union_value_response() {
|
682 683 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
683 684 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::TimestampValue(
|
684 685 | ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
|
685 686 | )))
|
686 687 | .build();
|
687 688 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
688 689 | ::http::response::Builder::new()
|
689 690 | .header("Content-Type", "application/x-amz-json-1.0")
|
690 691 | .status(200)
|
691 692 | .body(::aws_smithy_types::body::SdkBody::from(
|
692 693 | "{\n \"contents\": {\n \"timestampValue\": 1398796238\n }\n}",
|
693 694 | ))
|
694 695 | .unwrap(),
|
695 696 | )
|
696 697 | .unwrap();
|
697 698 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
698 699 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
699 700 |
|
700 701 | let op = crate::operation::json_unions::JsonUnions::new();
|
701 702 | let config = op.config().expect("the operation has config");
|
702 703 | let de = config
|
703 704 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
704 705 | .expect("the config must have a deserializer");
|
705 706 |
|
706 707 | let parsed = de.deserialize_streaming(&mut http_response);
|
707 708 | let parsed = parsed.unwrap_or_else(|| {
|
708 709 | let http_response =
|
709 710 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
710 711 | de.deserialize_nonstreaming(&http_response)
|
711 712 | });
|
712 713 | let parsed = parsed
|
713 714 | .expect("should be successful response")
|
714 715 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
715 716 | .unwrap();
|
716 717 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
717 718 | }
|
718 719 | /// Deserializes an enum union value
|
719 720 | /// Test ID: AwsJson10DeserializeEnumUnionValue
|
720 721 | #[::tokio::test]
|
721 - | #[allow(unused_mut)]
|
722 + | #[::tracing_test::traced_test]
|
722 723 | async fn aws_json10_deserialize_enum_union_value_response() {
|
723 724 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
724 725 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::EnumValue(
|
725 726 | "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
|
726 727 | )))
|
727 728 | .build();
|
728 729 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
729 730 | ::http::response::Builder::new()
|
730 731 | .header("Content-Type", "application/x-amz-json-1.0")
|
731 732 | .status(200)
|
732 733 | .body(::aws_smithy_types::body::SdkBody::from(
|
733 734 | "{\n \"contents\": {\n \"enumValue\": \"Foo\"\n }\n}",
|
734 735 | ))
|
735 736 | .unwrap(),
|
736 737 | )
|
737 738 | .unwrap();
|
738 739 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
739 740 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
740 741 |
|
741 742 | let op = crate::operation::json_unions::JsonUnions::new();
|
742 743 | let config = op.config().expect("the operation has config");
|
743 744 | let de = config
|
744 745 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
745 746 | .expect("the config must have a deserializer");
|
746 747 |
|
747 748 | let parsed = de.deserialize_streaming(&mut http_response);
|
748 749 | let parsed = parsed.unwrap_or_else(|| {
|
749 750 | let http_response =
|
750 751 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
751 752 | de.deserialize_nonstreaming(&http_response)
|
752 753 | });
|
753 754 | let parsed = parsed
|
754 755 | .expect("should be successful response")
|
755 756 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
756 757 | .unwrap();
|
757 758 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
758 759 | }
|
759 760 | /// Deserializes an intEnum union value
|
760 761 | /// Test ID: AwsJson10DeserializeIntEnumUnionValue
|
761 762 | #[::tokio::test]
|
762 - | #[allow(unused_mut)]
|
763 + | #[::tracing_test::traced_test]
|
763 764 | async fn aws_json10_deserialize_int_enum_union_value_response() {
|
764 765 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
765 766 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::IntEnumValue(1)))
|
766 767 | .build();
|
767 768 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
768 769 | ::http::response::Builder::new()
|
769 770 | .header("Content-Type", "application/x-amz-json-1.0")
|
770 771 | .status(200)
|
771 772 | .body(::aws_smithy_types::body::SdkBody::from(
|
772 773 | "{\n \"contents\": {\n \"intEnumValue\": 1\n }\n}",
|
773 774 | ))
|
774 775 | .unwrap(),
|
775 776 | )
|
776 777 | .unwrap();
|
777 778 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
778 779 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
779 780 |
|
780 781 | let op = crate::operation::json_unions::JsonUnions::new();
|
781 782 | let config = op.config().expect("the operation has config");
|
782 783 | let de = config
|
783 784 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
784 785 | .expect("the config must have a deserializer");
|
785 786 |
|
786 787 | let parsed = de.deserialize_streaming(&mut http_response);
|
787 788 | let parsed = parsed.unwrap_or_else(|| {
|
788 789 | let http_response =
|
789 790 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
790 791 | de.deserialize_nonstreaming(&http_response)
|
791 792 | });
|
792 793 | let parsed = parsed
|
793 794 | .expect("should be successful response")
|
794 795 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
795 796 | .unwrap();
|
796 797 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
797 798 | }
|
798 799 | /// Deserializes a list union value
|
799 800 | /// Test ID: AwsJson10DeserializeListUnionValue
|
800 801 | #[::tokio::test]
|
801 - | #[allow(unused_mut)]
|
802 + | #[::tracing_test::traced_test]
|
802 803 | async fn aws_json10_deserialize_list_union_value_response() {
|
803 804 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
804 805 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::ListValue(vec![
|
805 806 | "foo".to_owned(),
|
806 807 | "bar".to_owned(),
|
807 808 | ])))
|
808 809 | .build();
|
809 810 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
810 811 | ::http::response::Builder::new()
|
811 812 | .header("Content-Type", "application/x-amz-json-1.0")
|
812 813 | .status(200)
|
813 814 | .body(::aws_smithy_types::body::SdkBody::from(
|
814 815 | "{\n \"contents\": {\n \"listValue\": [\"foo\", \"bar\"]\n }\n}",
|
815 816 | ))
|
816 817 | .unwrap(),
|
817 818 | )
|
818 819 | .unwrap();
|
819 820 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
820 821 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
821 822 |
|
822 823 | let op = crate::operation::json_unions::JsonUnions::new();
|
823 824 | let config = op.config().expect("the operation has config");
|
824 825 | let de = config
|
825 826 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
826 827 | .expect("the config must have a deserializer");
|
827 828 |
|
828 829 | let parsed = de.deserialize_streaming(&mut http_response);
|
829 830 | let parsed = parsed.unwrap_or_else(|| {
|
830 831 | let http_response =
|
831 832 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
832 833 | de.deserialize_nonstreaming(&http_response)
|
833 834 | });
|
834 835 | let parsed = parsed
|
835 836 | .expect("should be successful response")
|
836 837 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
837 838 | .unwrap();
|
838 839 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
839 840 | }
|
840 841 | /// Deserializes a map union value
|
841 842 | /// Test ID: AwsJson10DeserializeMapUnionValue
|
842 843 | #[::tokio::test]
|
843 - | #[allow(unused_mut)]
|
844 + | #[::tracing_test::traced_test]
|
844 845 | async fn aws_json10_deserialize_map_union_value_response() {
|
845 846 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
846 847 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::MapValue({
|
847 848 | let mut ret = ::std::collections::HashMap::new();
|
848 849 | ret.insert("foo".to_owned(), "bar".to_owned());
|
849 850 | ret.insert("spam".to_owned(), "eggs".to_owned());
|
850 851 | ret
|
851 852 | })))
|
852 853 | .build();
|
853 854 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
854 855 | .header("Content-Type", "application/x-amz-json-1.0")
|
855 856 | .status(200)
|
856 857 | .body(::aws_smithy_types::body::SdkBody::from("{\n \"contents\": {\n \"mapValue\": {\n \"foo\": \"bar\",\n \"spam\": \"eggs\"\n }\n }\n}"))
|
857 858 | .unwrap()
|
858 859 | ).unwrap();
|
859 860 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
860 861 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
861 862 |
|
862 863 | let op = crate::operation::json_unions::JsonUnions::new();
|
863 864 | let config = op.config().expect("the operation has config");
|
864 865 | let de = config
|
865 866 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
866 867 | .expect("the config must have a deserializer");
|
867 868 |
|
868 869 | let parsed = de.deserialize_streaming(&mut http_response);
|
869 870 | let parsed = parsed.unwrap_or_else(|| {
|
870 871 | let http_response =
|
871 872 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
872 873 | de.deserialize_nonstreaming(&http_response)
|
873 874 | });
|
874 875 | let parsed = parsed
|
875 876 | .expect("should be successful response")
|
876 877 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
877 878 | .unwrap();
|
878 879 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
879 880 | }
|
880 881 | /// Deserializes a structure union value
|
881 882 | /// Test ID: AwsJson10DeserializeStructureUnionValue
|
882 883 | #[::tokio::test]
|
883 - | #[allow(unused_mut)]
|
884 + | #[::tracing_test::traced_test]
|
884 885 | async fn aws_json10_deserialize_structure_union_value_response() {
|
885 886 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
886 887 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
|
887 888 | crate::types::GreetingStruct::builder()
|
888 889 | .set_hi(::std::option::Option::Some("hello".to_owned()))
|
889 890 | .build(),
|
890 891 | )))
|
891 892 | .build();
|
892 893 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
893 894 | ::http::response::Builder::new()
|
894 895 | .header("Content-Type", "application/x-amz-json-1.0")
|
895 896 | .status(200)
|
896 897 | .body(::aws_smithy_types::body::SdkBody::from(
|
897 898 | "{\n \"contents\": {\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}",
|
898 899 | ))
|
899 900 | .unwrap(),
|
900 901 | )
|
901 902 | .unwrap();
|
902 903 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
903 904 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
904 905 |
|
905 906 | let op = crate::operation::json_unions::JsonUnions::new();
|
906 907 | let config = op.config().expect("the operation has config");
|
907 908 | let de = config
|
908 909 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
909 910 | .expect("the config must have a deserializer");
|
910 911 |
|
911 912 | let parsed = de.deserialize_streaming(&mut http_response);
|
912 913 | let parsed = parsed.unwrap_or_else(|| {
|
913 914 | let http_response =
|
914 915 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
915 916 | de.deserialize_nonstreaming(&http_response)
|
916 917 | });
|
917 918 | let parsed = parsed
|
918 919 | .expect("should be successful response")
|
919 920 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
920 921 | .unwrap();
|
921 922 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
922 923 | }
|
923 924 | /// Ignores an unrecognized __type property
|
924 925 | /// Test ID: AwsJson10DeserializeIgnoreType
|
925 926 | #[::tokio::test]
|
926 - | #[allow(unused_mut)]
|
927 + | #[::tracing_test::traced_test]
|
927 928 | async fn aws_json10_deserialize_ignore_type_response() {
|
928 929 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
929 930 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
|
930 931 | crate::types::GreetingStruct::builder()
|
931 932 | .set_hi(::std::option::Option::Some("hello".to_owned()))
|
932 933 | .build(),
|
933 934 | )))
|
934 935 | .build();
|
935 936 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
936 937 | .header("Content-Type", "application/x-amz-json-1.0")
|
937 938 | .status(200)
|
938 939 | .body(::aws_smithy_types::body::SdkBody::from("{\n \"contents\": {\n \"__type\": \"aws.protocoltests.json10#MyUnion\",\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}"))
|
939 940 | .unwrap()
|
940 941 | ).unwrap();
|
941 942 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
942 943 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
943 944 |
|
944 945 | let op = crate::operation::json_unions::JsonUnions::new();
|
945 946 | let config = op.config().expect("the operation has config");
|
946 947 | let de = config
|
947 948 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
948 949 | .expect("the config must have a deserializer");
|
949 950 |
|
950 951 | let parsed = de.deserialize_streaming(&mut http_response);
|
951 952 | let parsed = parsed.unwrap_or_else(|| {
|
952 953 | let http_response =
|
953 954 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
954 955 | de.deserialize_nonstreaming(&http_response)
|
955 956 | });
|
956 957 | let parsed = parsed
|
957 958 | .expect("should be successful response")
|
958 959 | .downcast::<crate::operation::json_unions::JsonUnionsOutput>()
|
959 960 | .unwrap();
|
960 961 | ::pretty_assertions::assert_eq!(parsed.contents, expected_output.contents, "Unexpected value for `contents`");
|
961 962 | }
|
962 963 | /// Allows for `: null` to be set for all unset fields
|
963 964 | /// Test ID: AwsJson10DeserializeAllowNulls
|
964 965 | #[::tokio::test]
|
965 - | #[allow(unused_mut)]
|
966 + | #[::tracing_test::traced_test]
|
966 967 | async fn aws_json10_deserialize_allow_nulls_response() {
|
967 968 | let expected_output = crate::operation::json_unions::JsonUnionsOutput::builder()
|
968 969 | .set_contents(::std::option::Option::Some(crate::types::MyUnion::StructureValue(
|
969 970 | crate::types::GreetingStruct::builder()
|
970 971 | .set_hi(::std::option::Option::Some("hello".to_owned()))
|
971 972 | .build(),
|
972 973 | )))
|
973 974 | .build();
|
974 975 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
975 976 | .header("Content-Type", "application/x-amz-json-1.0")
|