218 218 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
219 219 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
220 220 | })?;
|
221 221 | cfg.interceptor_state()
|
222 222 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
223 223 | ::std::result::Result::Ok(())
|
224 224 | }
|
225 225 | }
|
226 226 | #[allow(unreachable_code, unused_variables)]
|
227 227 | #[cfg(test)]
|
228 - | mod kitchen_sink_operation_request_test {
|
228 + | mod kitchen_sink_operation_test {
|
229 229 | use ::aws_smithy_protocol_test::FloatEquals;
|
230 + |
|
230 231 | /// Serializes string shapes
|
231 232 | /// Test ID: serializes_string_shapes
|
232 233 | #[::tokio::test]
|
233 - | #[allow(unused_mut)]
|
234 + | #[::tracing_test::traced_test]
|
234 235 | async fn serializes_string_shapes_request() {
|
235 236 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
236 237 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
237 238 |
|
238 239 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
239 240 | let result = client
|
240 241 | .kitchen_sink_operation()
|
241 242 | .set_string(::std::option::Option::Some("abc xyz".to_owned()))
|
242 243 | .send()
|
243 244 | .await;
|
244 245 | let _ = dbg!(result);
|
245 246 | let http_request = request_receiver.expect_request();
|
246 247 | let expected_headers = [
|
247 248 | ("Content-Type", "application/x-amz-json-1.1"),
|
248 249 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
249 250 | ];
|
250 251 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
251 252 | let required_headers = &["Content-Length"];
|
252 253 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
253 254 | let body = http_request.body().bytes().expect("body should be strict");
|
254 255 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
255 256 | body,
|
256 257 | "{\"String\":\"abc xyz\"}",
|
257 258 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
258 259 | ));
|
259 260 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
260 261 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
261 262 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
262 263 | }
|
263 264 | /// Serializes string shapes with jsonvalue trait
|
264 265 | /// Test ID: serializes_string_shapes_with_jsonvalue_trait
|
265 266 | #[::tokio::test]
|
266 - | #[allow(unused_mut)]
|
267 + | #[::tracing_test::traced_test]
|
267 268 | async fn serializes_string_shapes_with_jsonvalue_trait_request() {
|
268 269 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
269 270 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
270 271 |
|
271 272 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
272 273 | let result = client.kitchen_sink_operation()
|
273 274 | .set_json_value(
|
274 275 | ::std::option::Option::Some(
|
275 276 | "{\"string\":\"value\",\"number\":1234.5,\"boolTrue\":true,\"boolFalse\":false,\"array\":[1,2,3,4],\"object\":{\"key\":\"value\"},\"null\":null}".to_owned()
|
276 277 | )
|
277 278 | )
|
278 279 | .send().await;
|
279 280 | let _ = dbg!(result);
|
280 281 | let http_request = request_receiver.expect_request();
|
281 282 | let expected_headers = [
|
282 283 | ("Content-Type", "application/x-amz-json-1.1"),
|
283 284 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
284 285 | ];
|
285 286 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
286 287 | let required_headers = &["Content-Length"];
|
287 288 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
288 289 | let body = http_request.body().bytes().expect("body should be strict");
|
289 290 | ::aws_smithy_protocol_test::assert_ok(
|
290 291 | ::aws_smithy_protocol_test::validate_body(body, "{\"JsonValue\":\"{\\\"string\\\":\\\"value\\\",\\\"number\\\":1234.5,\\\"boolTrue\\\":true,\\\"boolFalse\\\":false,\\\"array\\\":[1,2,3,4],\\\"object\\\":{\\\"key\\\":\\\"value\\\"},\\\"null\\\":null}\"}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
|
291 292 | );
|
292 293 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
293 294 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
294 295 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
295 296 | }
|
296 297 | /// Serializes integer shapes
|
297 298 | /// Test ID: serializes_integer_shapes
|
298 299 | #[::tokio::test]
|
299 - | #[allow(unused_mut)]
|
300 + | #[::tracing_test::traced_test]
|
300 301 | async fn serializes_integer_shapes_request() {
|
301 302 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
302 303 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
303 304 |
|
304 305 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
305 306 | let result = client
|
306 307 | .kitchen_sink_operation()
|
307 308 | .set_integer(::std::option::Option::Some(1234))
|
308 309 | .send()
|
309 310 | .await;
|
310 311 | let _ = dbg!(result);
|
311 312 | let http_request = request_receiver.expect_request();
|
312 313 | let expected_headers = [
|
313 314 | ("Content-Type", "application/x-amz-json-1.1"),
|
314 315 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
315 316 | ];
|
316 317 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
317 318 | let required_headers = &["Content-Length"];
|
318 319 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
319 320 | let body = http_request.body().bytes().expect("body should be strict");
|
320 321 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
321 322 | body,
|
322 323 | "{\"Integer\":1234}",
|
323 324 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
324 325 | ));
|
325 326 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
326 327 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
327 328 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
328 329 | }
|
329 330 | /// Serializes long shapes
|
330 331 | /// Test ID: serializes_long_shapes
|
331 332 | #[::tokio::test]
|
332 - | #[allow(unused_mut)]
|
333 + | #[::tracing_test::traced_test]
|
333 334 | async fn serializes_long_shapes_request() {
|
334 335 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
335 336 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
336 337 |
|
337 338 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
338 339 | let result = client
|
339 340 | .kitchen_sink_operation()
|
340 341 | .set_long(::std::option::Option::Some(999999999999))
|
341 342 | .send()
|
342 343 | .await;
|
343 344 | let _ = dbg!(result);
|
344 345 | let http_request = request_receiver.expect_request();
|
345 346 | let expected_headers = [
|
346 347 | ("Content-Type", "application/x-amz-json-1.1"),
|
347 348 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
348 349 | ];
|
349 350 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
350 351 | let required_headers = &["Content-Length"];
|
351 352 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
352 353 | let body = http_request.body().bytes().expect("body should be strict");
|
353 354 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
354 355 | body,
|
355 356 | "{\"Long\":999999999999}",
|
356 357 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
357 358 | ));
|
358 359 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
359 360 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
360 361 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
361 362 | }
|
362 363 | /// Serializes float shapes
|
363 364 | /// Test ID: serializes_float_shapes
|
364 365 | #[::tokio::test]
|
365 - | #[allow(unused_mut)]
|
366 + | #[::tracing_test::traced_test]
|
366 367 | async fn serializes_float_shapes_request() {
|
367 368 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
368 369 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
369 370 |
|
370 371 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
371 372 | let result = client
|
372 373 | .kitchen_sink_operation()
|
373 374 | .set_float(::std::option::Option::Some(1234.5_f32))
|
374 375 | .send()
|
375 376 | .await;
|
376 377 | let _ = dbg!(result);
|
377 378 | let http_request = request_receiver.expect_request();
|
378 379 | let expected_headers = [
|
379 380 | ("Content-Type", "application/x-amz-json-1.1"),
|
380 381 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
381 382 | ];
|
382 383 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
383 384 | let required_headers = &["Content-Length"];
|
384 385 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_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 | "{\"Float\":1234.5}",
|
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 double shapes
|
396 397 | /// Test ID: serializes_double_shapes
|
397 398 | #[::tokio::test]
|
398 - | #[allow(unused_mut)]
|
399 + | #[::tracing_test::traced_test]
|
399 400 | async fn serializes_double_shapes_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 | .kitchen_sink_operation()
|
406 407 | .set_double(::std::option::Option::Some(1234.5_f64))
|
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 = [
|
412 413 | ("Content-Type", "application/x-amz-json-1.1"),
|
413 414 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
414 415 | ];
|
415 416 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
416 417 | let required_headers = &["Content-Length"];
|
417 418 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
418 419 | let body = http_request.body().bytes().expect("body should be strict");
|
419 420 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
420 421 | body,
|
421 422 | "{\"Double\":1234.5}",
|
422 423 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
423 424 | ));
|
424 425 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
425 426 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
426 427 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
427 428 | }
|
428 429 | /// Serializes blob shapes
|
429 430 | /// Test ID: serializes_blob_shapes
|
430 431 | #[::tokio::test]
|
431 - | #[allow(unused_mut)]
|
432 + | #[::tracing_test::traced_test]
|
432 433 | async fn serializes_blob_shapes_request() {
|
433 434 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
434 435 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
435 436 |
|
436 437 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
437 438 | let result = client
|
438 439 | .kitchen_sink_operation()
|
439 440 | .set_blob(::std::option::Option::Some(::aws_smithy_types::Blob::new("binary-value")))
|
440 441 | .send()
|
441 442 | .await;
|
442 443 | let _ = dbg!(result);
|
443 444 | let http_request = request_receiver.expect_request();
|
444 445 | let expected_headers = [
|
445 446 | ("Content-Type", "application/x-amz-json-1.1"),
|
446 447 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
447 448 | ];
|
448 449 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
449 450 | let required_headers = &["Content-Length"];
|
450 451 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
451 452 | let body = http_request.body().bytes().expect("body should be strict");
|
452 453 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
453 454 | body,
|
454 455 | "{\"Blob\":\"YmluYXJ5LXZhbHVl\"}",
|
455 456 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
456 457 | ));
|
457 458 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
458 459 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
459 460 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
460 461 | }
|
461 462 | /// Serializes boolean shapes (true)
|
462 463 | /// Test ID: serializes_boolean_shapes_true
|
463 464 | #[::tokio::test]
|
464 - | #[allow(unused_mut)]
|
465 + | #[::tracing_test::traced_test]
|
465 466 | async fn serializes_boolean_shapes_true_request() {
|
466 467 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
467 468 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
468 469 |
|
469 470 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
470 471 | let result = client
|
471 472 | .kitchen_sink_operation()
|
472 473 | .set_boolean(::std::option::Option::Some(true))
|
473 474 | .send()
|
474 475 | .await;
|
475 476 | let _ = dbg!(result);
|
476 477 | let http_request = request_receiver.expect_request();
|
477 478 | let expected_headers = [
|
478 479 | ("Content-Type", "application/x-amz-json-1.1"),
|
479 480 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
480 481 | ];
|
481 482 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
482 483 | let required_headers = &["Content-Length"];
|
483 484 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
484 485 | let body = http_request.body().bytes().expect("body should be strict");
|
485 486 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
486 487 | body,
|
487 488 | "{\"Boolean\":true}",
|
488 489 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
489 490 | ));
|
490 491 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
491 492 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
492 493 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
493 494 | }
|
494 495 | /// Serializes boolean shapes (false)
|
495 496 | /// Test ID: serializes_boolean_shapes_false
|
496 497 | #[::tokio::test]
|
497 - | #[allow(unused_mut)]
|
498 + | #[::tracing_test::traced_test]
|
498 499 | async fn serializes_boolean_shapes_false_request() {
|
499 500 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
500 501 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
501 502 |
|
502 503 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
503 504 | let result = client
|
504 505 | .kitchen_sink_operation()
|
505 506 | .set_boolean(::std::option::Option::Some(false))
|
506 507 | .send()
|
507 508 | .await;
|
508 509 | let _ = dbg!(result);
|
509 510 | let http_request = request_receiver.expect_request();
|
510 511 | let expected_headers = [
|
511 512 | ("Content-Type", "application/x-amz-json-1.1"),
|
512 513 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
513 514 | ];
|
514 515 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
515 516 | let required_headers = &["Content-Length"];
|
516 517 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
517 518 | let body = http_request.body().bytes().expect("body should be strict");
|
518 519 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
519 520 | body,
|
520 521 | "{\"Boolean\":false}",
|
521 522 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
522 523 | ));
|
523 524 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
524 525 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
525 526 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
526 527 | }
|
527 528 | /// Serializes timestamp shapes
|
528 529 | /// Test ID: serializes_timestamp_shapes
|
529 530 | #[::tokio::test]
|
530 - | #[allow(unused_mut)]
|
531 + | #[::tracing_test::traced_test]
|
531 532 | async fn serializes_timestamp_shapes_request() {
|
532 533 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
533 534 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
534 535 |
|
535 536 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
536 537 | let result = client
|
537 538 | .kitchen_sink_operation()
|
538 539 | .set_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
539 540 | 946845296, 0_f64,
|
540 541 | )))
|
541 542 | .send()
|
542 543 | .await;
|
543 544 | let _ = dbg!(result);
|
544 545 | let http_request = request_receiver.expect_request();
|
545 546 | let expected_headers = [
|
546 547 | ("Content-Type", "application/x-amz-json-1.1"),
|
547 548 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
548 549 | ];
|
549 550 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
550 551 | let required_headers = &["Content-Length"];
|
551 552 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
552 553 | let body = http_request.body().bytes().expect("body should be strict");
|
553 554 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
554 555 | body,
|
555 556 | "{\"Timestamp\":946845296}",
|
556 557 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
557 558 | ));
|
558 559 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
559 560 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
560 561 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
561 562 | }
|
562 563 | /// Serializes timestamp shapes with iso8601 timestampFormat
|
563 564 | /// Test ID: serializes_timestamp_shapes_with_iso8601_timestampformat
|
564 565 | #[::tokio::test]
|
565 - | #[allow(unused_mut)]
|
566 + | #[::tracing_test::traced_test]
|
566 567 | async fn serializes_timestamp_shapes_with_iso8601_timestampformat_request() {
|
567 568 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
568 569 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
569 570 |
|
570 571 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
571 572 | let result = client
|
572 573 | .kitchen_sink_operation()
|
573 574 | .set_iso8601_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
574 575 | 946845296, 0_f64,
|
575 576 | )))
|
576 577 | .send()
|
577 578 | .await;
|
578 579 | let _ = dbg!(result);
|
579 580 | let http_request = request_receiver.expect_request();
|
580 581 | let expected_headers = [
|
581 582 | ("Content-Type", "application/x-amz-json-1.1"),
|
582 583 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
583 584 | ];
|
584 585 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
585 586 | let required_headers = &["Content-Length"];
|
586 587 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
587 588 | let body = http_request.body().bytes().expect("body should be strict");
|
588 589 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
589 590 | body,
|
590 591 | "{\"Iso8601Timestamp\":\"2000-01-02T20:34:56Z\"}",
|
591 592 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
592 593 | ));
|
593 594 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
594 595 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
595 596 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
596 597 | }
|
597 598 | /// Serializes timestamp shapes with httpdate timestampFormat
|
598 599 | /// Test ID: serializes_timestamp_shapes_with_httpdate_timestampformat
|
599 600 | #[::tokio::test]
|
600 - | #[allow(unused_mut)]
|
601 + | #[::tracing_test::traced_test]
|
601 602 | async fn serializes_timestamp_shapes_with_httpdate_timestampformat_request() {
|
602 603 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
603 604 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
604 605 |
|
605 606 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
606 607 | let result = client
|
607 608 | .kitchen_sink_operation()
|
608 609 | .set_httpdate_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
609 610 | 946845296, 0_f64,
|
610 611 | )))
|
611 612 | .send()
|
612 613 | .await;
|
613 614 | let _ = dbg!(result);
|
614 615 | let http_request = request_receiver.expect_request();
|
615 616 | let expected_headers = [
|
616 617 | ("Content-Type", "application/x-amz-json-1.1"),
|
617 618 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
618 619 | ];
|
619 620 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
620 621 | let required_headers = &["Content-Length"];
|
621 622 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
622 623 | let body = http_request.body().bytes().expect("body should be strict");
|
623 624 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
624 625 | body,
|
625 626 | "{\"HttpdateTimestamp\":\"Sun, 02 Jan 2000 20:34:56 GMT\"}",
|
626 627 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
627 628 | ));
|
628 629 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
629 630 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
630 631 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
631 632 | }
|
632 633 | /// Serializes timestamp shapes with unixTimestamp timestampFormat
|
633 634 | /// Test ID: serializes_timestamp_shapes_with_unixtimestamp_timestampformat
|
634 635 | #[::tokio::test]
|
635 - | #[allow(unused_mut)]
|
636 + | #[::tracing_test::traced_test]
|
636 637 | async fn serializes_timestamp_shapes_with_unixtimestamp_timestampformat_request() {
|
637 638 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
638 639 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
639 640 |
|
640 641 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
641 642 | let result = client
|
642 643 | .kitchen_sink_operation()
|
643 644 | .set_unix_timestamp(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
644 645 | 946845296, 0_f64,
|
645 646 | )))
|
646 647 | .send()
|
647 648 | .await;
|
648 649 | let _ = dbg!(result);
|
649 650 | let http_request = request_receiver.expect_request();
|
650 651 | let expected_headers = [
|
651 652 | ("Content-Type", "application/x-amz-json-1.1"),
|
652 653 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
653 654 | ];
|
654 655 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
655 656 | let required_headers = &["Content-Length"];
|
656 657 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
657 658 | let body = http_request.body().bytes().expect("body should be strict");
|
658 659 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
659 660 | body,
|
660 661 | "{\"UnixTimestamp\":946845296}",
|
661 662 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
662 663 | ));
|
663 664 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
664 665 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
665 666 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
666 667 | }
|
667 668 | /// Serializes list shapes
|
668 669 | /// Test ID: serializes_list_shapes
|
669 670 | #[::tokio::test]
|
670 - | #[allow(unused_mut)]
|
671 + | #[::tracing_test::traced_test]
|
671 672 | async fn serializes_list_shapes_request() {
|
672 673 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
673 674 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
674 675 |
|
675 676 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
676 677 | let result = client
|
677 678 | .kitchen_sink_operation()
|
678 679 | .set_list_of_strings(::std::option::Option::Some(vec!["abc".to_owned(), "mno".to_owned(), "xyz".to_owned()]))
|
679 680 | .send()
|
680 681 | .await;
|
681 682 | let _ = dbg!(result);
|
682 683 | let http_request = request_receiver.expect_request();
|
683 684 | let expected_headers = [
|
684 685 | ("Content-Type", "application/x-amz-json-1.1"),
|
685 686 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
686 687 | ];
|
687 688 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
688 689 | let required_headers = &["Content-Length"];
|
689 690 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
690 691 | let body = http_request.body().bytes().expect("body should be strict");
|
691 692 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
692 693 | body,
|
693 694 | "{\"ListOfStrings\":[\"abc\",\"mno\",\"xyz\"]}",
|
694 695 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
695 696 | ));
|
696 697 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
697 698 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
698 699 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
699 700 | }
|
700 701 | /// Serializes empty list shapes
|
701 702 | /// Test ID: serializes_empty_list_shapes
|
702 703 | #[::tokio::test]
|
703 - | #[allow(unused_mut)]
|
704 + | #[::tracing_test::traced_test]
|
704 705 | async fn serializes_empty_list_shapes_request() {
|
705 706 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
706 707 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
707 708 |
|
708 709 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
709 710 | let result = client
|
710 711 | .kitchen_sink_operation()
|
711 712 | .set_list_of_strings(::std::option::Option::Some(vec![]))
|
712 713 | .send()
|
713 714 | .await;
|
714 715 | let _ = dbg!(result);
|
715 716 | let http_request = request_receiver.expect_request();
|
716 717 | let expected_headers = [
|
717 718 | ("Content-Type", "application/x-amz-json-1.1"),
|
718 719 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
719 720 | ];
|
720 721 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
721 722 | let required_headers = &["Content-Length"];
|
722 723 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
723 724 | let body = http_request.body().bytes().expect("body should be strict");
|
724 725 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
725 726 | body,
|
726 727 | "{\"ListOfStrings\":[]}",
|
727 728 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
728 729 | ));
|
729 730 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
730 731 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
731 732 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
732 733 | }
|
733 734 | /// Serializes list of map shapes
|
734 735 | /// Test ID: serializes_list_of_map_shapes
|
735 736 | #[::tokio::test]
|
736 - | #[allow(unused_mut)]
|
737 + | #[::tracing_test::traced_test]
|
737 738 | async fn serializes_list_of_map_shapes_request() {
|
738 739 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
739 740 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
740 741 |
|
741 742 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
742 743 | let result = client
|
743 744 | .kitchen_sink_operation()
|
744 745 | .set_list_of_maps_of_strings(::std::option::Option::Some(vec![
|
745 746 | {
|
746 747 | let mut ret = ::std::collections::HashMap::new();
|
747 748 | ret.insert("foo".to_owned(), "bar".to_owned());
|
748 749 | ret
|
749 750 | },
|
750 751 | {
|
751 752 | let mut ret = ::std::collections::HashMap::new();
|
752 753 | ret.insert("abc".to_owned(), "xyz".to_owned());
|
753 754 | ret
|
754 755 | },
|
755 756 | {
|
756 757 | let mut ret = ::std::collections::HashMap::new();
|
757 758 | ret.insert("red".to_owned(), "blue".to_owned());
|
758 759 | ret
|
759 760 | },
|
760 761 | ]))
|
761 762 | .send()
|
762 763 | .await;
|
763 764 | let _ = dbg!(result);
|
764 765 | let http_request = request_receiver.expect_request();
|
765 766 | let expected_headers = [
|
766 767 | ("Content-Type", "application/x-amz-json-1.1"),
|
767 768 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
768 769 | ];
|
769 770 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
770 771 | let required_headers = &["Content-Length"];
|
771 772 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
772 773 | let body = http_request.body().bytes().expect("body should be strict");
|
773 774 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
774 775 | body,
|
775 776 | "{\"ListOfMapsOfStrings\":[{\"foo\":\"bar\"},{\"abc\":\"xyz\"},{\"red\":\"blue\"}]}",
|
776 777 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
777 778 | ));
|
778 779 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
779 780 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
780 781 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
781 782 | }
|
782 783 | /// Serializes list of structure shapes
|
783 784 | /// Test ID: serializes_list_of_structure_shapes
|
784 785 | #[::tokio::test]
|
785 - | #[allow(unused_mut)]
|
786 + | #[::tracing_test::traced_test]
|
786 787 | async fn serializes_list_of_structure_shapes_request() {
|
787 788 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
788 789 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
789 790 |
|
790 791 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
791 792 | let result = client
|
792 793 | .kitchen_sink_operation()
|
793 794 | .set_list_of_structs(::std::option::Option::Some(vec![
|
794 795 | crate::types::SimpleStruct::builder()
|
795 796 | .set_value(::std::option::Option::Some("abc".to_owned()))
|
796 797 | .build(),
|
797 798 | crate::types::SimpleStruct::builder()
|
798 799 | .set_value(::std::option::Option::Some("mno".to_owned()))
|
799 800 | .build(),
|
800 801 | crate::types::SimpleStruct::builder()
|
801 802 | .set_value(::std::option::Option::Some("xyz".to_owned()))
|
802 803 | .build(),
|
803 804 | ]))
|
804 805 | .send()
|
805 806 | .await;
|
806 807 | let _ = dbg!(result);
|
807 808 | let http_request = request_receiver.expect_request();
|
808 809 | let expected_headers = [
|
809 810 | ("Content-Type", "application/x-amz-json-1.1"),
|
810 811 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
811 812 | ];
|
812 813 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
813 814 | let required_headers = &["Content-Length"];
|
814 815 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
815 816 | let body = http_request.body().bytes().expect("body should be strict");
|
816 817 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
817 818 | body,
|
818 819 | "{\"ListOfStructs\":[{\"Value\":\"abc\"},{\"Value\":\"mno\"},{\"Value\":\"xyz\"}]}",
|
819 820 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
820 821 | ));
|
821 822 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
822 823 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
823 824 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
824 825 | }
|
825 826 | /// Serializes list of recursive structure shapes
|
826 827 | /// Test ID: serializes_list_of_recursive_structure_shapes
|
827 828 | #[::tokio::test]
|
828 - | #[allow(unused_mut)]
|
829 + | #[::tracing_test::traced_test]
|
829 830 | async fn serializes_list_of_recursive_structure_shapes_request() {
|
830 831 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
831 832 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
832 833 |
|
833 834 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
834 835 | let result = client
|
835 836 | .kitchen_sink_operation()
|
836 837 | .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
|
837 838 | .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
|
838 839 | .set_recursive_list(::std::option::Option::Some(vec![crate::types::KitchenSink::builder()
|
839 840 | .set_integer(::std::option::Option::Some(123))
|
840 841 | .build()]))
|
841 842 | .build()]))
|
842 843 | .build()]))
|
843 844 | .send()
|
844 845 | .await;
|
845 846 | let _ = dbg!(result);
|
846 847 | let http_request = request_receiver.expect_request();
|
847 848 | let expected_headers = [
|
848 849 | ("Content-Type", "application/x-amz-json-1.1"),
|
849 850 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
850 851 | ];
|
851 852 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
852 853 | let required_headers = &["Content-Length"];
|
853 854 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
854 855 | let body = http_request.body().bytes().expect("body should be strict");
|
855 856 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
856 857 | body,
|
857 858 | "{\"RecursiveList\":[{\"RecursiveList\":[{\"RecursiveList\":[{\"Integer\":123}]}]}]}",
|
858 859 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
859 860 | ));
|
860 861 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
861 862 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
862 863 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
863 864 | }
|
864 865 | /// Serializes map shapes
|
865 866 | /// Test ID: serializes_map_shapes
|
866 867 | #[::tokio::test]
|
867 - | #[allow(unused_mut)]
|
868 + | #[::tracing_test::traced_test]
|
868 869 | async fn serializes_map_shapes_request() {
|
869 870 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
870 871 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
871 872 |
|
872 873 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
873 874 | let result = client
|
874 875 | .kitchen_sink_operation()
|
875 876 | .set_map_of_strings(::std::option::Option::Some({
|
876 877 | let mut ret = ::std::collections::HashMap::new();
|
877 878 | ret.insert("abc".to_owned(), "xyz".to_owned());
|
878 879 | ret.insert("mno".to_owned(), "hjk".to_owned());
|
879 880 | ret
|
880 881 | }))
|
881 882 | .send()
|
882 883 | .await;
|
883 884 | let _ = dbg!(result);
|
884 885 | let http_request = request_receiver.expect_request();
|
885 886 | let expected_headers = [
|
886 887 | ("Content-Type", "application/x-amz-json-1.1"),
|
887 888 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
888 889 | ];
|
889 890 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
890 891 | let required_headers = &["Content-Length"];
|
891 892 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
892 893 | let body = http_request.body().bytes().expect("body should be strict");
|
893 894 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
894 895 | body,
|
895 896 | "{\"MapOfStrings\":{\"abc\":\"xyz\",\"mno\":\"hjk\"}}",
|
896 897 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
897 898 | ));
|
898 899 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
899 900 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
900 901 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
901 902 | }
|
902 903 | /// Serializes empty map shapes
|
903 904 | /// Test ID: serializes_empty_map_shapes
|
904 905 | #[::tokio::test]
|
905 - | #[allow(unused_mut)]
|
906 + | #[::tracing_test::traced_test]
|
906 907 | async fn serializes_empty_map_shapes_request() {
|
907 908 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
908 909 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
909 910 |
|
910 911 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
911 912 | let result = client
|
912 913 | .kitchen_sink_operation()
|
913 914 | .set_map_of_strings(::std::option::Option::Some(::std::collections::HashMap::new()))
|
914 915 | .send()
|
915 916 | .await;
|
916 917 | let _ = dbg!(result);
|
917 918 | let http_request = request_receiver.expect_request();
|
918 919 | let expected_headers = [
|
919 920 | ("Content-Type", "application/x-amz-json-1.1"),
|
920 921 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
921 922 | ];
|
922 923 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
923 924 | let required_headers = &["Content-Length"];
|
924 925 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
925 926 | let body = http_request.body().bytes().expect("body should be strict");
|
926 927 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
927 928 | body,
|
928 929 | "{\"MapOfStrings\":{}}",
|
929 930 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
930 931 | ));
|
931 932 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
932 933 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
933 934 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
934 935 | }
|
935 936 | /// Serializes map of list shapes
|
936 937 | /// Test ID: serializes_map_of_list_shapes
|
937 938 | #[::tokio::test]
|
938 - | #[allow(unused_mut)]
|
939 + | #[::tracing_test::traced_test]
|
939 940 | async fn serializes_map_of_list_shapes_request() {
|
940 941 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
941 942 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
942 943 |
|
943 944 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
944 945 | let result = client
|
945 946 | .kitchen_sink_operation()
|
946 947 | .set_map_of_lists_of_strings(::std::option::Option::Some({
|
947 948 | let mut ret = ::std::collections::HashMap::new();
|
948 949 | ret.insert("abc".to_owned(), vec!["abc".to_owned(), "xyz".to_owned()]);
|
949 950 | ret.insert("mno".to_owned(), vec!["xyz".to_owned(), "abc".to_owned()]);
|
950 951 | ret
|
951 952 | }))
|
952 953 | .send()
|
953 954 | .await;
|
954 955 | let _ = dbg!(result);
|
955 956 | let http_request = request_receiver.expect_request();
|
956 957 | let expected_headers = [
|
957 958 | ("Content-Type", "application/x-amz-json-1.1"),
|
958 959 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
959 960 | ];
|
960 961 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
961 962 | let required_headers = &["Content-Length"];
|
962 963 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
963 964 | let body = http_request.body().bytes().expect("body should be strict");
|
964 965 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
965 966 | body,
|
966 967 | "{\"MapOfListsOfStrings\":{\"abc\":[\"abc\",\"xyz\"],\"mno\":[\"xyz\",\"abc\"]}}",
|
967 968 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
968 969 | ));
|
969 970 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
970 971 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
971 972 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
972 973 | }
|
973 974 | /// Serializes map of structure shapes
|
974 975 | /// Test ID: serializes_map_of_structure_shapes
|
975 976 | #[::tokio::test]
|
976 - | #[allow(unused_mut)]
|
977 + | #[::tracing_test::traced_test]
|
977 978 | async fn serializes_map_of_structure_shapes_request() {
|
978 979 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
979 980 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
980 981 |
|
981 982 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
982 983 | let result = client
|
983 984 | .kitchen_sink_operation()
|
984 985 | .set_map_of_structs(::std::option::Option::Some({
|
985 986 | let mut ret = ::std::collections::HashMap::new();
|
986 987 | ret.insert(
|
987 988 | "key1".to_owned(),
|
988 989 | crate::types::SimpleStruct::builder()
|
989 990 | .set_value(::std::option::Option::Some("value-1".to_owned()))
|
990 991 | .build(),
|
991 992 | );
|
992 993 | ret.insert(
|
993 994 | "key2".to_owned(),
|
994 995 | crate::types::SimpleStruct::builder()
|
995 996 | .set_value(::std::option::Option::Some("value-2".to_owned()))
|
996 997 | .build(),
|
997 998 | );
|
998 999 | ret
|
999 1000 | }))
|
1000 1001 | .send()
|
1001 1002 | .await;
|
1002 1003 | let _ = dbg!(result);
|
1003 1004 | let http_request = request_receiver.expect_request();
|
1004 1005 | let expected_headers = [
|
1005 1006 | ("Content-Type", "application/x-amz-json-1.1"),
|
1006 1007 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1007 1008 | ];
|
1008 1009 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1009 1010 | let required_headers = &["Content-Length"];
|
1010 1011 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1011 1012 | let body = http_request.body().bytes().expect("body should be strict");
|
1012 1013 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1013 1014 | body,
|
1014 1015 | "{\"MapOfStructs\":{\"key1\":{\"Value\":\"value-1\"},\"key2\":{\"Value\":\"value-2\"}}}",
|
1015 1016 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1016 1017 | ));
|
1017 1018 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1018 1019 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1019 1020 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1020 1021 | }
|
1021 1022 | /// Serializes map of recursive structure shapes
|
1022 1023 | /// Test ID: serializes_map_of_recursive_structure_shapes
|
1023 1024 | #[::tokio::test]
|
1024 - | #[allow(unused_mut)]
|
1025 + | #[::tracing_test::traced_test]
|
1025 1026 | async fn serializes_map_of_recursive_structure_shapes_request() {
|
1026 1027 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1027 1028 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1028 1029 |
|
1029 1030 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1030 1031 | let result = client
|
1031 1032 | .kitchen_sink_operation()
|
1032 1033 | .set_recursive_map(::std::option::Option::Some({
|
1033 1034 | let mut ret = ::std::collections::HashMap::new();
|
1034 1035 | ret.insert(
|
1035 1036 | "key1".to_owned(),
|
1036 1037 | crate::types::KitchenSink::builder()
|
1037 1038 | .set_recursive_map(::std::option::Option::Some({
|
1038 1039 | let mut ret = ::std::collections::HashMap::new();
|
1039 1040 | ret.insert(
|
1040 1041 | "key2".to_owned(),
|
1041 1042 | crate::types::KitchenSink::builder()
|
1042 1043 | .set_recursive_map(::std::option::Option::Some({
|
1043 1044 | let mut ret = ::std::collections::HashMap::new();
|
1044 1045 | ret.insert(
|
1045 1046 | "key3".to_owned(),
|
1046 1047 | crate::types::KitchenSink::builder()
|
1047 1048 | .set_boolean(::std::option::Option::Some(false))
|
1048 1049 | .build(),
|
1049 1050 | );
|
1050 1051 | ret
|
1051 1052 | }))
|
1052 1053 | .build(),
|
1053 1054 | );
|
1054 1055 | ret
|
1055 1056 | }))
|
1056 1057 | .build(),
|
1057 1058 | );
|
1058 1059 | ret
|
1059 1060 | }))
|
1060 1061 | .send()
|
1061 1062 | .await;
|
1062 1063 | let _ = dbg!(result);
|
1063 1064 | let http_request = request_receiver.expect_request();
|
1064 1065 | let expected_headers = [
|
1065 1066 | ("Content-Type", "application/x-amz-json-1.1"),
|
1066 1067 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1067 1068 | ];
|
1068 1069 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1069 1070 | let required_headers = &["Content-Length"];
|
1070 1071 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1071 1072 | let body = http_request.body().bytes().expect("body should be strict");
|
1072 1073 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1073 1074 | body,
|
1074 1075 | "{\"RecursiveMap\":{\"key1\":{\"RecursiveMap\":{\"key2\":{\"RecursiveMap\":{\"key3\":{\"Boolean\":false}}}}}}}",
|
1075 1076 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1076 1077 | ));
|
1077 1078 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1078 1079 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1079 1080 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1080 1081 | }
|
1081 1082 | /// Serializes structure shapes
|
1082 1083 | /// Test ID: serializes_structure_shapes
|
1083 1084 | #[::tokio::test]
|
1084 - | #[allow(unused_mut)]
|
1085 + | #[::tracing_test::traced_test]
|
1085 1086 | async fn serializes_structure_shapes_request() {
|
1086 1087 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1087 1088 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1088 1089 |
|
1089 1090 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1090 1091 | let result = client
|
1091 1092 | .kitchen_sink_operation()
|
1092 1093 | .set_simple_struct(::std::option::Option::Some(
|
1093 1094 | crate::types::SimpleStruct::builder()
|
1094 1095 | .set_value(::std::option::Option::Some("abc".to_owned()))
|
1095 1096 | .build(),
|
1096 1097 | ))
|
1097 1098 | .send()
|
1098 1099 | .await;
|
1099 1100 | let _ = dbg!(result);
|
1100 1101 | let http_request = request_receiver.expect_request();
|
1101 1102 | let expected_headers = [
|
1102 1103 | ("Content-Type", "application/x-amz-json-1.1"),
|
1103 1104 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1104 1105 | ];
|
1105 1106 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1106 1107 | let required_headers = &["Content-Length"];
|
1107 1108 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1108 1109 | let body = http_request.body().bytes().expect("body should be strict");
|
1109 1110 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1110 1111 | body,
|
1111 1112 | "{\"SimpleStruct\":{\"Value\":\"abc\"}}",
|
1112 1113 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1113 1114 | ));
|
1114 1115 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1115 1116 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1116 1117 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1117 1118 | }
|
1118 1119 | /// Serializes structure members with locationName traits
|
1119 1120 | /// Test ID: serializes_structure_members_with_locationname_traits
|
1120 1121 | #[::tokio::test]
|
1121 - | #[allow(unused_mut)]
|
1122 + | #[::tracing_test::traced_test]
|
1122 1123 | async fn serializes_structure_members_with_locationname_traits_request() {
|
1123 1124 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1124 1125 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1125 1126 |
|
1126 1127 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1127 1128 | let result = client
|
1128 1129 | .kitchen_sink_operation()
|
1129 1130 | .set_struct_with_json_name(::std::option::Option::Some(
|
1130 1131 | crate::types::StructWithJsonName::builder()
|
1131 1132 | .set_value(::std::option::Option::Some("some-value".to_owned()))
|
1132 1133 | .build(),
|
1133 1134 | ))
|
1134 1135 | .send()
|
1135 1136 | .await;
|
1136 1137 | let _ = dbg!(result);
|
1137 1138 | let http_request = request_receiver.expect_request();
|
1138 1139 | let expected_headers = [
|
1139 1140 | ("Content-Type", "application/x-amz-json-1.1"),
|
1140 1141 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1141 1142 | ];
|
1142 1143 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1143 1144 | let required_headers = &["Content-Length"];
|
1144 1145 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1145 1146 | let body = http_request.body().bytes().expect("body should be strict");
|
1146 1147 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1147 1148 | body,
|
1148 1149 | "{\"StructWithJsonName\":{\"Value\":\"some-value\"}}",
|
1149 1150 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1150 1151 | ));
|
1151 1152 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1152 1153 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1153 1154 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1154 1155 | }
|
1155 1156 | /// Serializes empty structure shapes
|
1156 1157 | /// Test ID: serializes_empty_structure_shapes
|
1157 1158 | #[::tokio::test]
|
1158 - | #[allow(unused_mut)]
|
1159 + | #[::tracing_test::traced_test]
|
1159 1160 | async fn serializes_empty_structure_shapes_request() {
|
1160 1161 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1161 1162 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1162 1163 |
|
1163 1164 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1164 1165 | let result = client
|
1165 1166 | .kitchen_sink_operation()
|
1166 1167 | .set_simple_struct(::std::option::Option::Some(crate::types::SimpleStruct::builder().build()))
|
1167 1168 | .send()
|
1168 1169 | .await;
|
1169 1170 | let _ = dbg!(result);
|
1170 1171 | let http_request = request_receiver.expect_request();
|
1171 1172 | let expected_headers = [
|
1172 1173 | ("Content-Type", "application/x-amz-json-1.1"),
|
1173 1174 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1174 1175 | ];
|
1175 1176 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1176 1177 | let required_headers = &["Content-Length"];
|
1177 1178 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1178 1179 | let body = http_request.body().bytes().expect("body should be strict");
|
1179 1180 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1180 1181 | body,
|
1181 1182 | "{\"SimpleStruct\":{}}",
|
1182 1183 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1183 1184 | ));
|
1184 1185 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1185 1186 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1186 1187 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1187 1188 | }
|
1188 1189 | /// Serializes structure which have no members
|
1189 1190 | /// Test ID: serializes_structure_which_have_no_members
|
1190 1191 | #[::tokio::test]
|
1191 - | #[allow(unused_mut)]
|
1192 + | #[::tracing_test::traced_test]
|
1192 1193 | async fn serializes_structure_which_have_no_members_request() {
|
1193 1194 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1194 1195 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1195 1196 |
|
1196 1197 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1197 1198 | let result = client
|
1198 1199 | .kitchen_sink_operation()
|
1199 1200 | .set_empty_struct(::std::option::Option::Some(crate::types::EmptyStruct::builder().build()))
|
1200 1201 | .send()
|
1201 1202 | .await;
|
1202 1203 | let _ = dbg!(result);
|
1203 1204 | let http_request = request_receiver.expect_request();
|
1204 1205 | let expected_headers = [
|
1205 1206 | ("Content-Type", "application/x-amz-json-1.1"),
|
1206 1207 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1207 1208 | ];
|
1208 1209 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1209 1210 | let required_headers = &["Content-Length"];
|
1210 1211 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1211 1212 | let body = http_request.body().bytes().expect("body should be strict");
|
1212 1213 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
1213 1214 | body,
|
1214 1215 | "{\"EmptyStruct\":{}}",
|
1215 1216 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
1216 1217 | ));
|
1217 1218 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1218 1219 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1219 1220 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1220 1221 | }
|
1221 1222 | /// Serializes recursive structure shapes
|
1222 1223 | /// Test ID: serializes_recursive_structure_shapes
|
1223 1224 | #[::tokio::test]
|
1224 - | #[allow(unused_mut)]
|
1225 + | #[::tracing_test::traced_test]
|
1225 1226 | async fn serializes_recursive_structure_shapes_request() {
|
1226 1227 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
1227 1228 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
1228 1229 |
|
1229 1230 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
1230 1231 | let result = client
|
1231 1232 | .kitchen_sink_operation()
|
1232 1233 | .set_string(::std::option::Option::Some("top-value".to_owned()))
|
1233 1234 | .set_boolean(::std::option::Option::Some(false))
|
1234 1235 | .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
|
1235 1236 | crate::types::KitchenSink::builder()
|
1236 1237 | .set_string(::std::option::Option::Some("nested-value".to_owned()))
|
1237 1238 | .set_boolean(::std::option::Option::Some(true))
|
1238 1239 | .set_recursive_list(::std::option::Option::Some(vec![
|
1239 1240 | crate::types::KitchenSink::builder()
|
1240 1241 | .set_string(::std::option::Option::Some("string-only".to_owned()))
|
1241 1242 | .build(),
|
1242 1243 | crate::types::KitchenSink::builder()
|
1243 1244 | .set_recursive_struct(::std::option::Option::Some(::std::boxed::Box::new(
|
1244 1245 | crate::types::KitchenSink::builder()
|
1245 1246 | .set_map_of_strings(::std::option::Option::Some({
|
1246 1247 | let mut ret = ::std::collections::HashMap::new();
|
1247 1248 | ret.insert("color".to_owned(), "red".to_owned());
|
1248 1249 | ret.insert("size".to_owned(), "large".to_owned());
|
1249 1250 | ret
|
1250 1251 | }))
|
1251 1252 | .build(),
|
1252 1253 | )))
|
1253 1254 | .build(),
|
1254 1255 | ]))
|
1255 1256 | .build(),
|
1256 1257 | )))
|
1257 1258 | .send()
|
1258 1259 | .await;
|
1259 1260 | let _ = dbg!(result);
|
1260 1261 | let http_request = request_receiver.expect_request();
|
1261 1262 | let expected_headers = [
|
1262 1263 | ("Content-Type", "application/x-amz-json-1.1"),
|
1263 1264 | ("X-Amz-Target", "JsonProtocol.KitchenSinkOperation"),
|
1264 1265 | ];
|
1265 1266 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
1266 1267 | let required_headers = &["Content-Length"];
|
1267 1268 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
1268 1269 | let body = http_request.body().bytes().expect("body should be strict");
|
1269 1270 | ::aws_smithy_protocol_test::assert_ok(
|
1270 1271 | ::aws_smithy_protocol_test::validate_body(body, "{\"String\":\"top-value\",\"Boolean\":false,\"RecursiveStruct\":{\"String\":\"nested-value\",\"Boolean\":true,\"RecursiveList\":[{\"String\":\"string-only\"},{\"RecursiveStruct\":{\"MapOfStrings\":{\"color\":\"red\",\"size\":\"large\"}}}]}}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
|
1271 1272 | );
|
1272 1273 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
1273 1274 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
1274 1275 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
1275 1276 | }
|
1276 1277 | /// Parses operations with empty JSON bodies
|
1277 1278 | /// Test ID: parses_operations_with_empty_json_bodies
|
1278 1279 | #[::tokio::test]
|
1279 - | #[allow(unused_mut)]
|
1280 + | #[::tracing_test::traced_test]
|
1280 1281 | async fn parses_operations_with_empty_json_bodies_response() {
|
1281 1282 | let expected_output = crate::operation::kitchen_sink_operation::KitchenSinkOperationOutput::builder().build();
|
1282 1283 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
1283 1284 | ::http::response::Builder::new()
|
1284 1285 | .header("Content-Type", "application/x-amz-json-1.1")
|
1285 1286 | .status(200)
|
1286 1287 | .body(::aws_smithy_types::body::SdkBody::from("{}"))
|
1287 1288 | .unwrap(),
|
1288 1289 | )
|
1289 1290 | .unwrap();
|