213 213 | let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
|
214 214 | ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
|
215 215 | })?;
|
216 216 | cfg.interceptor_state()
|
217 217 | .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
|
218 218 | ::std::result::Result::Ok(())
|
219 219 | }
|
220 220 | }
|
221 221 | #[allow(unreachable_code, unused_variables)]
|
222 222 | #[cfg(test)]
|
223 - | mod simple_input_params_request_test {
|
223 + | mod simple_input_params_test {
|
224 + |
|
224 225 | /// Serializes strings
|
225 226 | /// Test ID: Ec2SimpleInputParamsStrings
|
226 227 | #[::tokio::test]
|
227 - | #[allow(unused_mut)]
|
228 + | #[::tracing_test::traced_test]
|
228 229 | async fn ec2_simple_input_params_strings_request() {
|
229 230 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
230 231 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
231 232 |
|
232 233 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
233 234 | let result = client
|
234 235 | .simple_input_params()
|
235 236 | .set_foo(::std::option::Option::Some("val1".to_owned()))
|
236 237 | .set_bar(::std::option::Option::Some("val2".to_owned()))
|
237 238 | .send()
|
238 239 | .await;
|
239 240 | let _ = dbg!(result);
|
240 241 | let http_request = request_receiver.expect_request();
|
241 242 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
242 243 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
243 244 | let required_headers = &["Content-Length"];
|
244 245 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
245 246 | let body = http_request.body().bytes().expect("body should be strict");
|
246 247 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
247 248 | body,
|
248 249 | "Action=SimpleInputParams&Version=2020-01-08&Foo=val1&Bar=val2",
|
249 250 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
250 251 | ));
|
251 252 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
252 253 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
253 254 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
254 255 | }
|
255 256 | /// Serializes booleans that are true
|
256 257 | /// Test ID: Ec2SimpleInputParamsStringAndBooleanTrue
|
257 258 | #[::tokio::test]
|
258 - | #[allow(unused_mut)]
|
259 + | #[::tracing_test::traced_test]
|
259 260 | async fn ec2_simple_input_params_string_and_boolean_true_request() {
|
260 261 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
261 262 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
262 263 |
|
263 264 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
264 265 | let result = client
|
265 266 | .simple_input_params()
|
266 267 | .set_foo(::std::option::Option::Some("val1".to_owned()))
|
267 268 | .set_baz(::std::option::Option::Some(true))
|
268 269 | .send()
|
269 270 | .await;
|
270 271 | let _ = dbg!(result);
|
271 272 | let http_request = request_receiver.expect_request();
|
272 273 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
273 274 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
274 275 | let required_headers = &["Content-Length"];
|
275 276 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
276 277 | let body = http_request.body().bytes().expect("body should be strict");
|
277 278 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
278 279 | body,
|
279 280 | "Action=SimpleInputParams&Version=2020-01-08&Foo=val1&Baz=true",
|
280 281 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
281 282 | ));
|
282 283 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
283 284 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
284 285 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
285 286 | }
|
286 287 | /// Serializes booleans that are false
|
287 288 | /// Test ID: Ec2SimpleInputParamsStringsAndBooleanFalse
|
288 289 | #[::tokio::test]
|
289 - | #[allow(unused_mut)]
|
290 + | #[::tracing_test::traced_test]
|
290 291 | async fn ec2_simple_input_params_strings_and_boolean_false_request() {
|
291 292 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
292 293 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
293 294 |
|
294 295 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
295 296 | let result = client.simple_input_params().set_baz(::std::option::Option::Some(false)).send().await;
|
296 297 | let _ = dbg!(result);
|
297 298 | let http_request = request_receiver.expect_request();
|
298 299 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
299 300 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
300 301 | let required_headers = &["Content-Length"];
|
301 302 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
302 303 | let body = http_request.body().bytes().expect("body should be strict");
|
303 304 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
304 305 | body,
|
305 306 | "Action=SimpleInputParams&Version=2020-01-08&Baz=false",
|
306 307 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
307 308 | ));
|
308 309 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
309 310 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
310 311 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
311 312 | }
|
312 313 | /// Serializes integers
|
313 314 | /// Test ID: Ec2SimpleInputParamsInteger
|
314 315 | #[::tokio::test]
|
315 - | #[allow(unused_mut)]
|
316 + | #[::tracing_test::traced_test]
|
316 317 | async fn ec2_simple_input_params_integer_request() {
|
317 318 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
318 319 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
319 320 |
|
320 321 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
321 322 | let result = client.simple_input_params().set_bam(::std::option::Option::Some(10)).send().await;
|
322 323 | let _ = dbg!(result);
|
323 324 | let http_request = request_receiver.expect_request();
|
324 325 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
325 326 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
326 327 | let required_headers = &["Content-Length"];
|
327 328 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
328 329 | let body = http_request.body().bytes().expect("body should be strict");
|
329 330 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
330 331 | body,
|
331 332 | "Action=SimpleInputParams&Version=2020-01-08&Bam=10",
|
332 333 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
333 334 | ));
|
334 335 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
335 336 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
336 337 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
337 338 | }
|
338 339 | /// Serializes floats
|
339 340 | /// Test ID: Ec2SimpleInputParamsFloat
|
340 341 | #[::tokio::test]
|
341 - | #[allow(unused_mut)]
|
342 + | #[::tracing_test::traced_test]
|
342 343 | async fn ec2_simple_input_params_float_request() {
|
343 344 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
344 345 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
345 346 |
|
346 347 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
347 348 | let result = client.simple_input_params().set_boo(::std::option::Option::Some(10.8_f64)).send().await;
|
348 349 | let _ = dbg!(result);
|
349 350 | let http_request = request_receiver.expect_request();
|
350 351 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
351 352 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
352 353 | let required_headers = &["Content-Length"];
|
353 354 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
354 355 | let body = http_request.body().bytes().expect("body should be strict");
|
355 356 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
356 357 | body,
|
357 358 | "Action=SimpleInputParams&Version=2020-01-08&Boo=10.8",
|
358 359 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
359 360 | ));
|
360 361 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
361 362 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
362 363 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
363 364 | }
|
364 365 | /// Blobs are base64 encoded in the query string
|
365 366 | /// Test ID: Ec2SimpleInputParamsBlob
|
366 367 | #[::tokio::test]
|
367 - | #[allow(unused_mut)]
|
368 + | #[::tracing_test::traced_test]
|
368 369 | async fn ec2_simple_input_params_blob_request() {
|
369 370 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
370 371 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
371 372 |
|
372 373 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
373 374 | let result = client
|
374 375 | .simple_input_params()
|
375 376 | .set_qux(::std::option::Option::Some(::aws_smithy_types::Blob::new("value")))
|
376 377 | .send()
|
377 378 | .await;
|
378 379 | let _ = dbg!(result);
|
379 380 | let http_request = request_receiver.expect_request();
|
380 381 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
381 382 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
382 383 | let required_headers = &["Content-Length"];
|
383 384 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
384 385 | let body = http_request.body().bytes().expect("body should be strict");
|
385 386 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
386 387 | body,
|
387 388 | "Action=SimpleInputParams&Version=2020-01-08&Qux=dmFsdWU%3D",
|
388 389 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
389 390 | ));
|
390 391 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
391 392 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
392 393 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
393 394 | }
|
394 395 | /// Serializes enums in the query string
|
395 396 | /// Test ID: Ec2Enums
|
396 397 | #[::tokio::test]
|
397 - | #[allow(unused_mut)]
|
398 + | #[::tracing_test::traced_test]
|
398 399 | async fn ec2_enums_request() {
|
399 400 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
400 401 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
401 402 |
|
402 403 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
403 404 | let result = client
|
404 405 | .simple_input_params()
|
405 406 | .set_foo_enum(::std::option::Option::Some(
|
406 407 | "Foo".parse::<crate::types::FooEnum>().expect("static value validated to member"),
|
407 408 | ))
|
408 409 | .send()
|
409 410 | .await;
|
410 411 | let _ = dbg!(result);
|
411 412 | let http_request = request_receiver.expect_request();
|
412 413 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
413 414 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
414 415 | let required_headers = &["Content-Length"];
|
415 416 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
416 417 | let body = http_request.body().bytes().expect("body should be strict");
|
417 418 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
418 419 | body,
|
419 420 | "Action=SimpleInputParams&Version=2020-01-08&FooEnum=Foo",
|
420 421 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
421 422 | ));
|
422 423 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
423 424 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
424 425 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
425 426 | }
|
426 427 | /// Serializes query using ec2QueryName trait.
|
427 428 | /// Test ID: Ec2Query
|
428 429 | #[::tokio::test]
|
429 - | #[allow(unused_mut)]
|
430 + | #[::tracing_test::traced_test]
|
430 431 | async fn ec2_query_request() {
|
431 432 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
432 433 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
433 434 |
|
434 435 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
435 436 | let result = client
|
436 437 | .simple_input_params()
|
437 438 | .set_has_query_name(::std::option::Option::Some("Hi".to_owned()))
|
438 439 | .send()
|
439 440 | .await;
|
440 441 | let _ = dbg!(result);
|
441 442 | let http_request = request_receiver.expect_request();
|
442 443 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
443 444 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
444 445 | let required_headers = &["Content-Length"];
|
445 446 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
446 447 | let body = http_request.body().bytes().expect("body should be strict");
|
447 448 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
448 449 | body,
|
449 450 | "Action=SimpleInputParams&Version=2020-01-08&HasQueryName=Hi",
|
450 451 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
451 452 | ));
|
452 453 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
453 454 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
454 455 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
455 456 | }
|
456 457 | /// ec2QueryName trait is preferred over xmlName.
|
457 458 | /// Test ID: Ec2QueryIsPreferred
|
458 459 | #[::tokio::test]
|
459 - | #[allow(unused_mut)]
|
460 + | #[::tracing_test::traced_test]
|
460 461 | async fn ec2_query_is_preferred_request() {
|
461 462 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
462 463 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
463 464 |
|
464 465 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
465 466 | let result = client
|
466 467 | .simple_input_params()
|
467 468 | .set_has_query_and_xml_name(::std::option::Option::Some("Hi".to_owned()))
|
468 469 | .send()
|
469 470 | .await;
|
470 471 | let _ = dbg!(result);
|
471 472 | let http_request = request_receiver.expect_request();
|
472 473 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
473 474 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
474 475 | let required_headers = &["Content-Length"];
|
475 476 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
476 477 | let body = http_request.body().bytes().expect("body should be strict");
|
477 478 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
478 479 | body,
|
479 480 | "Action=SimpleInputParams&Version=2020-01-08&HasQueryAndXmlName=Hi",
|
480 481 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
481 482 | ));
|
482 483 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
483 484 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
484 485 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
485 486 | }
|
486 487 | /// xmlName is used with the ec2 protocol, but the first character is uppercased
|
487 488 | /// Test ID: Ec2XmlNameIsUppercased
|
488 489 | #[::tokio::test]
|
489 - | #[allow(unused_mut)]
|
490 + | #[::tracing_test::traced_test]
|
490 491 | async fn ec2_xml_name_is_uppercased_request() {
|
491 492 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
492 493 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
493 494 |
|
494 495 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
495 496 | let result = client
|
496 497 | .simple_input_params()
|
497 498 | .set_uses_xml_name(::std::option::Option::Some("Hi".to_owned()))
|
498 499 | .send()
|
499 500 | .await;
|
500 501 | let _ = dbg!(result);
|
501 502 | let http_request = request_receiver.expect_request();
|
502 503 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
503 504 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
504 505 | let required_headers = &["Content-Length"];
|
505 506 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
506 507 | let body = http_request.body().bytes().expect("body should be strict");
|
507 508 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
508 509 | body,
|
509 510 | "Action=SimpleInputParams&Version=2020-01-08&UsesXmlName=Hi",
|
510 511 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
511 512 | ));
|
512 513 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
513 514 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
514 515 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
515 516 | }
|
516 517 | /// Supports handling NaN float values.
|
517 518 | /// Test ID: Ec2QuerySupportsNaNFloatInputs
|
518 519 | #[::tokio::test]
|
519 - | #[allow(unused_mut)]
|
520 + | #[::tracing_test::traced_test]
|
520 521 | async fn ec2_query_supports_na_n_float_inputs_request() {
|
521 522 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
522 523 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
523 524 |
|
524 525 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
525 526 | let result = client
|
526 527 | .simple_input_params()
|
527 528 | .set_float_value(::std::option::Option::Some(
|
528 529 | <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
|
529 530 | ))
|
530 531 | .set_boo(::std::option::Option::Some(
|
531 532 | <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number"),
|
532 533 | ))
|
533 534 | .send()
|
534 535 | .await;
|
535 536 | let _ = dbg!(result);
|
536 537 | let http_request = request_receiver.expect_request();
|
537 538 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
538 539 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
539 540 | let required_headers = &["Content-Length"];
|
540 541 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
541 542 | let body = http_request.body().bytes().expect("body should be strict");
|
542 543 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
543 544 | body,
|
544 545 | "Action=SimpleInputParams&Version=2020-01-08&FloatValue=NaN&Boo=NaN",
|
545 546 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
546 547 | ));
|
547 548 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
548 549 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
549 550 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
550 551 | }
|
551 552 | /// Supports handling Infinity float values.
|
552 553 | /// Test ID: Ec2QuerySupportsInfinityFloatInputs
|
553 554 | #[::tokio::test]
|
554 - | #[allow(unused_mut)]
|
555 + | #[::tracing_test::traced_test]
|
555 556 | async fn ec2_query_supports_infinity_float_inputs_request() {
|
556 557 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
557 558 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
558 559 |
|
559 560 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
560 561 | let result = client
|
561 562 | .simple_input_params()
|
562 563 | .set_float_value(::std::option::Option::Some(
|
563 564 | <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
|
564 565 | ))
|
565 566 | .set_boo(::std::option::Option::Some(
|
566 567 | <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number"),
|
567 568 | ))
|
568 569 | .send()
|
569 570 | .await;
|
570 571 | let _ = dbg!(result);
|
571 572 | let http_request = request_receiver.expect_request();
|
572 573 | let expected_headers = [("Content-Type", "application/x-www-form-urlencoded")];
|
573 574 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
|
574 575 | let required_headers = &["Content-Length"];
|
575 576 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));
|
576 577 | let body = http_request.body().bytes().expect("body should be strict");
|
577 578 | ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
|
578 579 | body,
|
579 580 | "Action=SimpleInputParams&Version=2020-01-08&FloatValue=Infinity&Boo=Infinity",
|
580 581 | ::aws_smithy_protocol_test::MediaType::from("application/x-www-form-urlencoded"),
|
581 582 | ));
|
582 583 | let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
|
583 584 | ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
|
584 585 | ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");
|
585 586 | }
|
586 587 | /// Supports handling -Infinity float values.
|
587 588 | /// Test ID: Ec2QuerySupportsNegativeInfinityFloatInputs
|
588 589 | #[::tokio::test]
|
589 - | #[allow(unused_mut)]
|
590 + | #[::tracing_test::traced_test]
|
590 591 | async fn ec2_query_supports_negative_infinity_float_inputs_request() {
|
591 592 | let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
|
592 593 | let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
|
593 594 |
|
594 595 | let client = crate::Client::from_conf(config_builder.http_client(http_client).build());
|
595 596 | let result = client
|
596 597 | .simple_input_params()
|
597 598 | .set_float_value(::std::option::Option::Some(
|
598 599 | <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number"),
|
599 600 | ))
|