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