209 209 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
210 210 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
211 211 | })?;
|
212 212 | cfg.interceptor_state()
|
213 213 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
214 214 | ::std::result::Result::Ok(())
|
215 215 | }
|
216 216 | }
|
217 217 | #[allow(unreachable_code, unused_variables)]
|
218 218 | #[cfg(test)]
|
219 - | mod xml_timestamps_request_test {
|
219 + | mod xml_timestamps_test {
|
220 + |
|
220 221 | /// Tests how normal timestamps are serialized
|
221 222 | /// Test ID: QueryXmlTimestamps
|
222 223 | #[::tokio::test]
|
223 - | #[allow(unused_mut)]
|
224 + | #[::tracing_test::traced_test]
|
224 225 | async fn query_xml_timestamps_response() {
|
225 226 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
226 227 | .set_normal(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
227 228 | 1398796238, 0_f64,
|
228 229 | )))
|
229 230 | .build();
|
230 231 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
231 232 | .header("Content-Type", "text/xml")
|
232 233 | .status(200)
|
233 234 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <normal>2014-04-29T18:30:38Z</normal>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
234 235 | .unwrap()
|
235 236 | ).unwrap();
|
236 237 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
237 238 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
238 239 |
|
239 240 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
240 241 | let config = op.config().expect("the operation has config");
|
241 242 | let de = config
|
242 243 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
243 244 | .expect("the config must have a deserializer");
|
244 245 |
|
245 246 | let parsed = de.deserialize_streaming(&mut http_response);
|
246 247 | let parsed = parsed.unwrap_or_else(|| {
|
247 248 | let http_response =
|
248 249 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
249 250 | de.deserialize_nonstreaming(&http_response)
|
250 251 | });
|
251 252 | let parsed = parsed
|
252 253 | .expect("should be successful response")
|
253 254 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
254 255 | .unwrap();
|
255 256 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
256 257 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
257 258 | ::pretty_assertions::assert_eq!(
|
258 259 | parsed.date_time_on_target,
|
259 260 | expected_output.date_time_on_target,
|
260 261 | "Unexpected value for `date_time_on_target`"
|
261 262 | );
|
262 263 | ::pretty_assertions::assert_eq!(
|
263 264 | parsed.epoch_seconds,
|
264 265 | expected_output.epoch_seconds,
|
265 266 | "Unexpected value for `epoch_seconds`"
|
266 267 | );
|
267 268 | ::pretty_assertions::assert_eq!(
|
268 269 | parsed.epoch_seconds_on_target,
|
269 270 | expected_output.epoch_seconds_on_target,
|
270 271 | "Unexpected value for `epoch_seconds_on_target`"
|
271 272 | );
|
272 273 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
273 274 | ::pretty_assertions::assert_eq!(
|
274 275 | parsed.http_date_on_target,
|
275 276 | expected_output.http_date_on_target,
|
276 277 | "Unexpected value for `http_date_on_target`"
|
277 278 | );
|
278 279 | }
|
279 280 | /// Ensures that the timestampFormat of date-time works like normal timestamps
|
280 281 | /// Test ID: QueryXmlTimestampsWithDateTimeFormat
|
281 282 | #[::tokio::test]
|
282 - | #[allow(unused_mut)]
|
283 + | #[::tracing_test::traced_test]
|
283 284 | async fn query_xml_timestamps_with_date_time_format_response() {
|
284 285 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
285 286 | .set_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
286 287 | 1398796238, 0_f64,
|
287 288 | )))
|
288 289 | .build();
|
289 290 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
290 291 | .header("Content-Type", "text/xml")
|
291 292 | .status(200)
|
292 293 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <dateTime>2014-04-29T18:30:38Z</dateTime>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
293 294 | .unwrap()
|
294 295 | ).unwrap();
|
295 296 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
296 297 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
297 298 |
|
298 299 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
299 300 | let config = op.config().expect("the operation has config");
|
300 301 | let de = config
|
301 302 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
302 303 | .expect("the config must have a deserializer");
|
303 304 |
|
304 305 | let parsed = de.deserialize_streaming(&mut http_response);
|
305 306 | let parsed = parsed.unwrap_or_else(|| {
|
306 307 | let http_response =
|
307 308 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
308 309 | de.deserialize_nonstreaming(&http_response)
|
309 310 | });
|
310 311 | let parsed = parsed
|
311 312 | .expect("should be successful response")
|
312 313 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
313 314 | .unwrap();
|
314 315 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
315 316 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
316 317 | ::pretty_assertions::assert_eq!(
|
317 318 | parsed.date_time_on_target,
|
318 319 | expected_output.date_time_on_target,
|
319 320 | "Unexpected value for `date_time_on_target`"
|
320 321 | );
|
321 322 | ::pretty_assertions::assert_eq!(
|
322 323 | parsed.epoch_seconds,
|
323 324 | expected_output.epoch_seconds,
|
324 325 | "Unexpected value for `epoch_seconds`"
|
325 326 | );
|
326 327 | ::pretty_assertions::assert_eq!(
|
327 328 | parsed.epoch_seconds_on_target,
|
328 329 | expected_output.epoch_seconds_on_target,
|
329 330 | "Unexpected value for `epoch_seconds_on_target`"
|
330 331 | );
|
331 332 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
332 333 | ::pretty_assertions::assert_eq!(
|
333 334 | parsed.http_date_on_target,
|
334 335 | expected_output.http_date_on_target,
|
335 336 | "Unexpected value for `http_date_on_target`"
|
336 337 | );
|
337 338 | }
|
338 339 | /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
|
339 340 | /// Test ID: QueryXmlTimestampsWithDateTimeOnTargetFormat
|
340 341 | #[::tokio::test]
|
341 - | #[allow(unused_mut)]
|
342 + | #[::tracing_test::traced_test]
|
342 343 | async fn query_xml_timestamps_with_date_time_on_target_format_response() {
|
343 344 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
344 345 | .set_date_time_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
345 346 | 1398796238, 0_f64,
|
346 347 | )))
|
347 348 | .build();
|
348 349 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
349 350 | .header("Content-Type", "text/xml")
|
350 351 | .status(200)
|
351 352 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <dateTimeOnTarget>2014-04-29T18:30:38Z</dateTimeOnTarget>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
352 353 | .unwrap()
|
353 354 | ).unwrap();
|
354 355 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
355 356 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
356 357 |
|
357 358 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
358 359 | let config = op.config().expect("the operation has config");
|
359 360 | let de = config
|
360 361 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
361 362 | .expect("the config must have a deserializer");
|
362 363 |
|
363 364 | let parsed = de.deserialize_streaming(&mut http_response);
|
364 365 | let parsed = parsed.unwrap_or_else(|| {
|
365 366 | let http_response =
|
366 367 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
367 368 | de.deserialize_nonstreaming(&http_response)
|
368 369 | });
|
369 370 | let parsed = parsed
|
370 371 | .expect("should be successful response")
|
371 372 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
372 373 | .unwrap();
|
373 374 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
374 375 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
375 376 | ::pretty_assertions::assert_eq!(
|
376 377 | parsed.date_time_on_target,
|
377 378 | expected_output.date_time_on_target,
|
378 379 | "Unexpected value for `date_time_on_target`"
|
379 380 | );
|
380 381 | ::pretty_assertions::assert_eq!(
|
381 382 | parsed.epoch_seconds,
|
382 383 | expected_output.epoch_seconds,
|
383 384 | "Unexpected value for `epoch_seconds`"
|
384 385 | );
|
385 386 | ::pretty_assertions::assert_eq!(
|
386 387 | parsed.epoch_seconds_on_target,
|
387 388 | expected_output.epoch_seconds_on_target,
|
388 389 | "Unexpected value for `epoch_seconds_on_target`"
|
389 390 | );
|
390 391 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
391 392 | ::pretty_assertions::assert_eq!(
|
392 393 | parsed.http_date_on_target,
|
393 394 | expected_output.http_date_on_target,
|
394 395 | "Unexpected value for `http_date_on_target`"
|
395 396 | );
|
396 397 | }
|
397 398 | /// Ensures that the timestampFormat of epoch-seconds works
|
398 399 | /// Test ID: QueryXmlTimestampsWithEpochSecondsFormat
|
399 400 | #[::tokio::test]
|
400 - | #[allow(unused_mut)]
|
401 + | #[::tracing_test::traced_test]
|
401 402 | async fn query_xml_timestamps_with_epoch_seconds_format_response() {
|
402 403 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
403 404 | .set_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
404 405 | 1398796238, 0_f64,
|
405 406 | )))
|
406 407 | .build();
|
407 408 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
408 409 | .header("Content-Type", "text/xml")
|
409 410 | .status(200)
|
410 411 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <epochSeconds>1398796238</epochSeconds>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
411 412 | .unwrap()
|
412 413 | ).unwrap();
|
413 414 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
414 415 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
415 416 |
|
416 417 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
417 418 | let config = op.config().expect("the operation has config");
|
418 419 | let de = config
|
419 420 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
420 421 | .expect("the config must have a deserializer");
|
421 422 |
|
422 423 | let parsed = de.deserialize_streaming(&mut http_response);
|
423 424 | let parsed = parsed.unwrap_or_else(|| {
|
424 425 | let http_response =
|
425 426 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
426 427 | de.deserialize_nonstreaming(&http_response)
|
427 428 | });
|
428 429 | let parsed = parsed
|
429 430 | .expect("should be successful response")
|
430 431 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
431 432 | .unwrap();
|
432 433 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
433 434 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
434 435 | ::pretty_assertions::assert_eq!(
|
435 436 | parsed.date_time_on_target,
|
436 437 | expected_output.date_time_on_target,
|
437 438 | "Unexpected value for `date_time_on_target`"
|
438 439 | );
|
439 440 | ::pretty_assertions::assert_eq!(
|
440 441 | parsed.epoch_seconds,
|
441 442 | expected_output.epoch_seconds,
|
442 443 | "Unexpected value for `epoch_seconds`"
|
443 444 | );
|
444 445 | ::pretty_assertions::assert_eq!(
|
445 446 | parsed.epoch_seconds_on_target,
|
446 447 | expected_output.epoch_seconds_on_target,
|
447 448 | "Unexpected value for `epoch_seconds_on_target`"
|
448 449 | );
|
449 450 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
450 451 | ::pretty_assertions::assert_eq!(
|
451 452 | parsed.http_date_on_target,
|
452 453 | expected_output.http_date_on_target,
|
453 454 | "Unexpected value for `http_date_on_target`"
|
454 455 | );
|
455 456 | }
|
456 457 | /// Ensures that the timestampFormat of epoch-seconds on the target shape works
|
457 458 | /// Test ID: QueryXmlTimestampsWithEpochSecondsOnTargetFormat
|
458 459 | #[::tokio::test]
|
459 - | #[allow(unused_mut)]
|
460 + | #[::tracing_test::traced_test]
|
460 461 | async fn query_xml_timestamps_with_epoch_seconds_on_target_format_response() {
|
461 462 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
462 463 | .set_epoch_seconds_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
463 464 | 1398796238, 0_f64,
|
464 465 | )))
|
465 466 | .build();
|
466 467 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
467 468 | .header("Content-Type", "text/xml")
|
468 469 | .status(200)
|
469 470 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <epochSecondsOnTarget>1398796238</epochSecondsOnTarget>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
470 471 | .unwrap()
|
471 472 | ).unwrap();
|
472 473 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
473 474 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
474 475 |
|
475 476 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
476 477 | let config = op.config().expect("the operation has config");
|
477 478 | let de = config
|
478 479 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
479 480 | .expect("the config must have a deserializer");
|
480 481 |
|
481 482 | let parsed = de.deserialize_streaming(&mut http_response);
|
482 483 | let parsed = parsed.unwrap_or_else(|| {
|
483 484 | let http_response =
|
484 485 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
485 486 | de.deserialize_nonstreaming(&http_response)
|
486 487 | });
|
487 488 | let parsed = parsed
|
488 489 | .expect("should be successful response")
|
489 490 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
490 491 | .unwrap();
|
491 492 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
492 493 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
493 494 | ::pretty_assertions::assert_eq!(
|
494 495 | parsed.date_time_on_target,
|
495 496 | expected_output.date_time_on_target,
|
496 497 | "Unexpected value for `date_time_on_target`"
|
497 498 | );
|
498 499 | ::pretty_assertions::assert_eq!(
|
499 500 | parsed.epoch_seconds,
|
500 501 | expected_output.epoch_seconds,
|
501 502 | "Unexpected value for `epoch_seconds`"
|
502 503 | );
|
503 504 | ::pretty_assertions::assert_eq!(
|
504 505 | parsed.epoch_seconds_on_target,
|
505 506 | expected_output.epoch_seconds_on_target,
|
506 507 | "Unexpected value for `epoch_seconds_on_target`"
|
507 508 | );
|
508 509 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
509 510 | ::pretty_assertions::assert_eq!(
|
510 511 | parsed.http_date_on_target,
|
511 512 | expected_output.http_date_on_target,
|
512 513 | "Unexpected value for `http_date_on_target`"
|
513 514 | );
|
514 515 | }
|
515 516 | /// Ensures that the timestampFormat of http-date works
|
516 517 | /// Test ID: QueryXmlTimestampsWithHttpDateFormat
|
517 518 | #[::tokio::test]
|
518 - | #[allow(unused_mut)]
|
519 + | #[::tracing_test::traced_test]
|
519 520 | async fn query_xml_timestamps_with_http_date_format_response() {
|
520 521 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
521 522 | .set_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
522 523 | 1398796238, 0_f64,
|
523 524 | )))
|
524 525 | .build();
|
525 526 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
526 527 | .header("Content-Type", "text/xml")
|
527 528 | .status(200)
|
528 529 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <httpDate>Tue, 29 Apr 2014 18:30:38 GMT</httpDate>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|
529 530 | .unwrap()
|
530 531 | ).unwrap();
|
531 532 | use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
|
532 533 | use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
|
533 534 |
|
534 535 | let op = crate::operation::xml_timestamps::XmlTimestamps::new();
|
535 536 | let config = op.config().expect("the operation has config");
|
536 537 | let de = config
|
537 538 | .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
|
538 539 | .expect("the config must have a deserializer");
|
539 540 |
|
540 541 | let parsed = de.deserialize_streaming(&mut http_response);
|
541 542 | let parsed = parsed.unwrap_or_else(|| {
|
542 543 | let http_response =
|
543 544 | http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
|
544 545 | de.deserialize_nonstreaming(&http_response)
|
545 546 | });
|
546 547 | let parsed = parsed
|
547 548 | .expect("should be successful response")
|
548 549 | .downcast::<crate::operation::xml_timestamps::XmlTimestampsOutput>()
|
549 550 | .unwrap();
|
550 551 | ::pretty_assertions::assert_eq!(parsed.normal, expected_output.normal, "Unexpected value for `normal`");
|
551 552 | ::pretty_assertions::assert_eq!(parsed.date_time, expected_output.date_time, "Unexpected value for `date_time`");
|
552 553 | ::pretty_assertions::assert_eq!(
|
553 554 | parsed.date_time_on_target,
|
554 555 | expected_output.date_time_on_target,
|
555 556 | "Unexpected value for `date_time_on_target`"
|
556 557 | );
|
557 558 | ::pretty_assertions::assert_eq!(
|
558 559 | parsed.epoch_seconds,
|
559 560 | expected_output.epoch_seconds,
|
560 561 | "Unexpected value for `epoch_seconds`"
|
561 562 | );
|
562 563 | ::pretty_assertions::assert_eq!(
|
563 564 | parsed.epoch_seconds_on_target,
|
564 565 | expected_output.epoch_seconds_on_target,
|
565 566 | "Unexpected value for `epoch_seconds_on_target`"
|
566 567 | );
|
567 568 | ::pretty_assertions::assert_eq!(parsed.http_date, expected_output.http_date, "Unexpected value for `http_date`");
|
568 569 | ::pretty_assertions::assert_eq!(
|
569 570 | parsed.http_date_on_target,
|
570 571 | expected_output.http_date_on_target,
|
571 572 | "Unexpected value for `http_date_on_target`"
|
572 573 | );
|
573 574 | }
|
574 575 | /// Ensures that the timestampFormat of http-date on the target shape works
|
575 576 | /// Test ID: QueryXmlTimestampsWithHttpDateOnTargetFormat
|
576 577 | #[::tokio::test]
|
577 - | #[allow(unused_mut)]
|
578 + | #[::tracing_test::traced_test]
|
578 579 | async fn query_xml_timestamps_with_http_date_on_target_format_response() {
|
579 580 | let expected_output = crate::operation::xml_timestamps::XmlTimestampsOutput::builder()
|
580 581 | .set_http_date_on_target(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
|
581 582 | 1398796238, 0_f64,
|
582 583 | )))
|
583 584 | .build();
|
584 585 | let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
|
585 586 | .header("Content-Type", "text/xml")
|
586 587 | .status(200)
|
587 588 | .body(::aws_smithy_types::body::SdkBody::from("<XmlTimestampsResponse xmlns=\"https://example.com/\">\n <XmlTimestampsResult>\n <httpDateOnTarget>Tue, 29 Apr 2014 18:30:38 GMT</httpDateOnTarget>\n </XmlTimestampsResult>\n</XmlTimestampsResponse>\n"))
|