211 211 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
212 212 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
213 213 | })?;
|
214 214 | cfg.interceptor_state()
|
215 215 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
216 216 | ::std::result::Result::Ok(())
|
217 217 | }
|
218 218 | }
|
219 219 | #[allow(unreachable_code, unused_variables)]
|
220 220 | #[cfg(test)]
|
221 - | mod document_type_request_test {
|
221 + | mod document_type_test {
|
222 + |
|
222 223 | /// Serializes document types as part of the JSON request payload with no escaping.
|
223 224 | /// Test ID: DocumentTypeInputWithObject
|
224 225 | #[::tokio::test]
|
225 - | #[allow(unused_mut)]
|
226 + | #[::tracing_test::traced_test]
|
226 227 | async fn document_type_input_with_object_request() {
|
227 228 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
228 229 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
229 230 |
|
230 231 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
231 232 | let result = client
|
232 233 | .document_type()
|
233 234 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
234 235 | .set_document_value(::std::option::Option::Some({
|
235 236 | let json_bytes = br#"{
|
236 237 | "foo": "bar"
|
237 238 | }"#;
|
238 239 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
239 240 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
240 241 | }))
|
241 242 | .send()
|
242 243 | .await;
|
243 244 | let _ = dbg!(result);
|
244 245 | let http_request = request_receiver.expect_request();
|
245 246 | let expected_headers = [("Content-Type", "application/json")];
|
246 247 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
247 248 | let body = http_request.body().bytes().expect("body should be strict");
|
248 249 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
249 250 | body,
|
250 251 | "{\n \"stringValue\": \"string\",\n \"documentValue\": {\n \"foo\": \"bar\"\n }\n}",
|
251 252 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
252 253 | ));
|
253 254 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
254 255 | ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
|
255 256 | ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");
|
256 257 | }
|
257 258 | /// Serializes document types using a string.
|
258 259 | /// Test ID: DocumentInputWithString
|
259 260 | #[::tokio::test]
|
260 - | #[allow(unused_mut)]
|
261 + | #[::tracing_test::traced_test]
|
261 262 | async fn document_input_with_string_request() {
|
262 263 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
263 264 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
264 265 |
|
265 266 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
266 267 | let result = client
|
267 268 | .document_type()
|
268 269 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
269 270 | .set_document_value(::std::option::Option::Some({
|
270 271 | let json_bytes = br#""hello""#;
|
271 272 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
272 273 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
273 274 | }))
|
274 275 | .send()
|
275 276 | .await;
|
276 277 | let _ = dbg!(result);
|
277 278 | let http_request = request_receiver.expect_request();
|
278 279 | let expected_headers = [("Content-Type", "application/json")];
|
279 280 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
280 281 | let body = http_request.body().bytes().expect("body should be strict");
|
281 282 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
282 283 | body,
|
283 284 | "{\n \"stringValue\": \"string\",\n \"documentValue\": \"hello\"\n}",
|
284 285 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
285 286 | ));
|
286 287 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
287 288 | ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
|
288 289 | ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");
|
289 290 | }
|
290 291 | /// Serializes document types using a number.
|
291 292 | /// Test ID: DocumentInputWithNumber
|
292 293 | #[::tokio::test]
|
293 - | #[allow(unused_mut)]
|
294 + | #[::tracing_test::traced_test]
|
294 295 | async fn document_input_with_number_request() {
|
295 296 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
296 297 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
297 298 |
|
298 299 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
299 300 | let result = client
|
300 301 | .document_type()
|
301 302 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
302 303 | .set_document_value(::std::option::Option::Some({
|
303 304 | let json_bytes = br#"10"#;
|
304 305 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
305 306 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
306 307 | }))
|
307 308 | .send()
|
308 309 | .await;
|
309 310 | let _ = dbg!(result);
|
310 311 | let http_request = request_receiver.expect_request();
|
311 312 | let expected_headers = [("Content-Type", "application/json")];
|
312 313 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
313 314 | let body = http_request.body().bytes().expect("body should be strict");
|
314 315 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
315 316 | body,
|
316 317 | "{\n \"stringValue\": \"string\",\n \"documentValue\": 10\n}",
|
317 318 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
318 319 | ));
|
319 320 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
320 321 | ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
|
321 322 | ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");
|
322 323 | }
|
323 324 | /// Serializes document types using a boolean.
|
324 325 | /// Test ID: DocumentInputWithBoolean
|
325 326 | #[::tokio::test]
|
326 - | #[allow(unused_mut)]
|
327 + | #[::tracing_test::traced_test]
|
327 328 | async fn document_input_with_boolean_request() {
|
328 329 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
329 330 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
330 331 |
|
331 332 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
332 333 | let result = client
|
333 334 | .document_type()
|
334 335 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
335 336 | .set_document_value(::std::option::Option::Some({
|
336 337 | let json_bytes = br#"true"#;
|
337 338 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
338 339 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
339 340 | }))
|
340 341 | .send()
|
341 342 | .await;
|
342 343 | let _ = dbg!(result);
|
343 344 | let http_request = request_receiver.expect_request();
|
344 345 | let expected_headers = [("Content-Type", "application/json")];
|
345 346 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
346 347 | let body = http_request.body().bytes().expect("body should be strict");
|
347 348 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
348 349 | body,
|
349 350 | "{\n \"stringValue\": \"string\",\n \"documentValue\": true\n}",
|
350 351 | ::aws_smithy_protocol_test::MediaType::from("application/json"),
|
351 352 | ));
|
352 353 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
353 354 | ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
|
354 355 | ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");
|
355 356 | }
|
356 357 | /// Serializes document types using a list.
|
357 358 | /// Test ID: DocumentInputWithList
|
358 359 | #[::tokio::test]
|
359 - | #[allow(unused_mut)]
|
360 + | #[::tracing_test::traced_test]
|
360 361 | async fn document_input_with_list_request() {
|
361 362 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
362 363 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
363 364 |
|
364 365 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
365 366 | let result = client
|
366 367 | .document_type()
|
367 368 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
368 369 | .set_document_value(::std::option::Option::Some({
|
369 370 | let json_bytes = br#"[
|
370 371 | true,
|
371 372 | "hi",
|
372 373 | [
|
373 374 | 1,
|
374 375 | 2
|
375 376 | ],
|
376 377 | {
|
377 378 | "foo": {
|
378 379 | "baz": [
|
379 380 | 3,
|
380 381 | 4
|
381 382 | ]
|
382 383 | }
|
383 384 | }
|
384 385 | ]"#;
|
385 386 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
386 387 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
387 388 | }))
|
388 389 | .send()
|
389 390 | .await;
|
390 391 | let _ = dbg!(result);
|
391 392 | let http_request = request_receiver.expect_request();
|
392 393 | let expected_headers = [("Content-Type", "application/json")];
|
393 394 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
394 395 | let body = http_request.body().bytes().expect("body should be strict");
|
395 396 | ::aws_smithy_protocol_test::assert_ok(
|
396 397 | ::aws_smithy_protocol_test::validate_body(body, "{\n \"stringValue\": \"string\",\n \"documentValue\": [\n true,\n \"hi\",\n [\n 1,\n 2\n ],\n {\n \"foo\": {\n \"baz\": [\n 3,\n 4\n ]\n }\n }\n ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
|
397 398 | );
|
398 399 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
399 400 | ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
|
400 401 | ::pretty_assertions::assert_eq!(uri.path(), "/DocumentType", "path was incorrect");
|
401 402 | }
|
402 403 | /// Serializes documents as part of the JSON response payload with no escaping.
|
403 404 | /// Test ID: DocumentOutput
|
404 405 | #[::tokio::test]
|
405 - | #[allow(unused_mut)]
|
406 + | #[::tracing_test::traced_test]
|
406 407 | async fn document_output_response() {
|
407 408 | let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()
|
408 409 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
409 410 | .set_document_value(::std::option::Option::Some({
|
410 411 | let json_bytes = br#"{
|
411 412 | "foo": "bar"
|
412 413 | }"#;
|
413 414 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
414 415 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
415 416 | }))
|
416 417 | .build();
|
417 418 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
418 419 | ::http::response::Builder::new()
|
419 420 | .header("Content-Type", "application/json")
|
420 421 | .status(200)
|
421 422 | .body(::aws_smithy_types::body::SdkBody::from(
|
422 423 | "{\n \"stringValue\": \"string\",\n \"documentValue\": {\n \"foo\": \"bar\"\n }\n}",
|
423 424 | ))
|
424 425 | .unwrap(),
|
425 426 | )
|
426 427 | .unwrap();
|
427 428 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
428 429 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
429 430 |
|
430 431 | let op = crate::operation::document_type::DocumentType::new();
|
431 432 | let config = op.config().expect("the operation has config");
|
432 433 | let de = config
|
433 434 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
434 435 | .expect("the config must have a deserializer");
|
435 436 |
|
436 437 | let parsed = de.deserialize_streaming(&mut http_response);
|
437 438 | let parsed = parsed.unwrap_or_else(|| {
|
438 439 | let http_response =
|
439 440 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
440 441 | de.deserialize_nonstreaming(&http_response)
|
441 442 | });
|
442 443 | let parsed = parsed
|
443 444 | .expect("should be successful response")
|
444 445 | .downcast::<crate::operation::document_type::DocumentTypeOutput>()
|
445 446 | .unwrap();
|
446 447 | ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
|
447 448 | ::pretty_assertions::assert_eq!(
|
448 449 | parsed.document_value,
|
449 450 | expected_output.document_value,
|
450 451 | "Unexpected value for `document_value`"
|
451 452 | );
|
452 453 | }
|
453 454 | /// Document types can be JSON scalars too.
|
454 455 | /// Test ID: DocumentOutputString
|
455 456 | #[::tokio::test]
|
456 - | #[allow(unused_mut)]
|
457 + | #[::tracing_test::traced_test]
|
457 458 | async fn document_output_string_response() {
|
458 459 | let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()
|
459 460 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
460 461 | .set_document_value(::std::option::Option::Some({
|
461 462 | let json_bytes = br#""hello""#;
|
462 463 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
463 464 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
464 465 | }))
|
465 466 | .build();
|
466 467 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
467 468 | ::http::response::Builder::new()
|
468 469 | .header("Content-Type", "application/json")
|
469 470 | .status(200)
|
470 471 | .body(::aws_smithy_types::body::SdkBody::from(
|
471 472 | "{\n \"stringValue\": \"string\",\n \"documentValue\": \"hello\"\n}",
|
472 473 | ))
|
473 474 | .unwrap(),
|
474 475 | )
|
475 476 | .unwrap();
|
476 477 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
477 478 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
478 479 |
|
479 480 | let op = crate::operation::document_type::DocumentType::new();
|
480 481 | let config = op.config().expect("the operation has config");
|
481 482 | let de = config
|
482 483 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
483 484 | .expect("the config must have a deserializer");
|
484 485 |
|
485 486 | let parsed = de.deserialize_streaming(&mut http_response);
|
486 487 | let parsed = parsed.unwrap_or_else(|| {
|
487 488 | let http_response =
|
488 489 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
489 490 | de.deserialize_nonstreaming(&http_response)
|
490 491 | });
|
491 492 | let parsed = parsed
|
492 493 | .expect("should be successful response")
|
493 494 | .downcast::<crate::operation::document_type::DocumentTypeOutput>()
|
494 495 | .unwrap();
|
495 496 | ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
|
496 497 | ::pretty_assertions::assert_eq!(
|
497 498 | parsed.document_value,
|
498 499 | expected_output.document_value,
|
499 500 | "Unexpected value for `document_value`"
|
500 501 | );
|
501 502 | }
|
502 503 | /// Document types can be JSON scalars too.
|
503 504 | /// Test ID: DocumentOutputNumber
|
504 505 | #[::tokio::test]
|
505 - | #[allow(unused_mut)]
|
506 + | #[::tracing_test::traced_test]
|
506 507 | async fn document_output_number_response() {
|
507 508 | let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()
|
508 509 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
509 510 | .set_document_value(::std::option::Option::Some({
|
510 511 | let json_bytes = br#"10"#;
|
511 512 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
512 513 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
513 514 | }))
|
514 515 | .build();
|
515 516 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
516 517 | ::http::response::Builder::new()
|
517 518 | .header("Content-Type", "application/json")
|
518 519 | .status(200)
|
519 520 | .body(::aws_smithy_types::body::SdkBody::from(
|
520 521 | "{\n \"stringValue\": \"string\",\n \"documentValue\": 10\n}",
|
521 522 | ))
|
522 523 | .unwrap(),
|
523 524 | )
|
524 525 | .unwrap();
|
525 526 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
526 527 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
527 528 |
|
528 529 | let op = crate::operation::document_type::DocumentType::new();
|
529 530 | let config = op.config().expect("the operation has config");
|
530 531 | let de = config
|
531 532 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
532 533 | .expect("the config must have a deserializer");
|
533 534 |
|
534 535 | let parsed = de.deserialize_streaming(&mut http_response);
|
535 536 | let parsed = parsed.unwrap_or_else(|| {
|
536 537 | let http_response =
|
537 538 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
538 539 | de.deserialize_nonstreaming(&http_response)
|
539 540 | });
|
540 541 | let parsed = parsed
|
541 542 | .expect("should be successful response")
|
542 543 | .downcast::<crate::operation::document_type::DocumentTypeOutput>()
|
543 544 | .unwrap();
|
544 545 | ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
|
545 546 | ::pretty_assertions::assert_eq!(
|
546 547 | parsed.document_value,
|
547 548 | expected_output.document_value,
|
548 549 | "Unexpected value for `document_value`"
|
549 550 | );
|
550 551 | }
|
551 552 | /// Document types can be JSON scalars too.
|
552 553 | /// Test ID: DocumentOutputBoolean
|
553 554 | #[::tokio::test]
|
554 - | #[allow(unused_mut)]
|
555 + | #[::tracing_test::traced_test]
|
555 556 | async fn document_output_boolean_response() {
|
556 557 | let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()
|
557 558 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
558 559 | .set_document_value(::std::option::Option::Some({
|
559 560 | let json_bytes = br#"false"#;
|
560 561 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
561 562 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|
562 563 | }))
|
563 564 | .build();
|
564 565 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
|
565 566 | ::http::response::Builder::new()
|
566 567 | .header("Content-Type", "application/json")
|
567 568 | .status(200)
|
568 569 | .body(::aws_smithy_types::body::SdkBody::from(
|
569 570 | "{\n \"stringValue\": \"string\",\n \"documentValue\": false\n}",
|
570 571 | ))
|
571 572 | .unwrap(),
|
572 573 | )
|
573 574 | .unwrap();
|
574 575 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
575 576 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
576 577 |
|
577 578 | let op = crate::operation::document_type::DocumentType::new();
|
578 579 | let config = op.config().expect("the operation has config");
|
579 580 | let de = config
|
580 581 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
581 582 | .expect("the config must have a deserializer");
|
582 583 |
|
583 584 | let parsed = de.deserialize_streaming(&mut http_response);
|
584 585 | let parsed = parsed.unwrap_or_else(|| {
|
585 586 | let http_response =
|
586 587 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
587 588 | de.deserialize_nonstreaming(&http_response)
|
588 589 | });
|
589 590 | let parsed = parsed
|
590 591 | .expect("should be successful response")
|
591 592 | .downcast::<crate::operation::document_type::DocumentTypeOutput>()
|
592 593 | .unwrap();
|
593 594 | ::pretty_assertions::assert_eq!(parsed.string_value, expected_output.string_value, "Unexpected value for `string_value`");
|
594 595 | ::pretty_assertions::assert_eq!(
|
595 596 | parsed.document_value,
|
596 597 | expected_output.document_value,
|
597 598 | "Unexpected value for `document_value`"
|
598 599 | );
|
599 600 | }
|
600 601 | /// Document types can be JSON arrays.
|
601 602 | /// Test ID: DocumentOutputArray
|
602 603 | #[::tokio::test]
|
603 - | #[allow(unused_mut)]
|
604 + | #[::tracing_test::traced_test]
|
604 605 | async fn document_output_array_response() {
|
605 606 | let expected_output = crate::operation::document_type::DocumentTypeOutput::builder()
|
606 607 | .set_string_value(::std::option::Option::Some("string".to_owned()))
|
607 608 | .set_document_value(::std::option::Option::Some({
|
608 609 | let json_bytes = br#"[
|
609 610 | true,
|
610 611 | false
|
611 612 | ]"#;
|
612 613 | let mut tokens = ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
|
613 614 | ::aws_smithy_json::deserialize::token::expect_document(&mut tokens).expect("well formed json")
|