1pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
3pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
4pub use ::aws_smithy_types::endpoint::Endpoint;
5
6#[derive(Debug, Default)]
8pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;
9
10impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
11 fn name(&self) -> &'static str {
12 "EndpointOverrideFeatureTrackerInterceptor"
13 }
14
15 fn read_before_execution(
16 &self,
17 _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
18 cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
19 ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
20 if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
21 cfg.interceptor_state()
22 .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
23 }
24 ::std::result::Result::Ok(())
25 }
26}
27
28#[cfg(test)]
29mod test {
30
31 #[test]
33 fn test_1() {
34 let params = crate::config::endpoint::Params::builder()
35 .region("af-south-1".to_string())
36 .use_fips(false)
37 .use_dual_stack(false)
38 .build()
39 .expect("invalid params");
40 let resolver = crate::config::endpoint::DefaultResolver::new();
41 let endpoint = resolver.resolve_endpoint(¶ms);
42 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.af-south-1.amazonaws.com");
43 assert_eq!(
44 endpoint,
45 ::aws_smithy_types::endpoint::Endpoint::builder()
46 .url("https://ec2.af-south-1.amazonaws.com")
47 .build()
48 );
49 }
50
51 #[test]
53 fn test_2() {
54 let params = crate::config::endpoint::Params::builder()
55 .region("ap-east-1".to_string())
56 .use_fips(false)
57 .use_dual_stack(false)
58 .build()
59 .expect("invalid params");
60 let resolver = crate::config::endpoint::DefaultResolver::new();
61 let endpoint = resolver.resolve_endpoint(¶ms);
62 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-east-1.amazonaws.com");
63 assert_eq!(
64 endpoint,
65 ::aws_smithy_types::endpoint::Endpoint::builder()
66 .url("https://ec2.ap-east-1.amazonaws.com")
67 .build()
68 );
69 }
70
71 #[test]
73 fn test_3() {
74 let params = crate::config::endpoint::Params::builder()
75 .region("ap-northeast-1".to_string())
76 .use_fips(false)
77 .use_dual_stack(false)
78 .build()
79 .expect("invalid params");
80 let resolver = crate::config::endpoint::DefaultResolver::new();
81 let endpoint = resolver.resolve_endpoint(¶ms);
82 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-northeast-1.amazonaws.com");
83 assert_eq!(
84 endpoint,
85 ::aws_smithy_types::endpoint::Endpoint::builder()
86 .url("https://ec2.ap-northeast-1.amazonaws.com")
87 .build()
88 );
89 }
90
91 #[test]
93 fn test_4() {
94 let params = crate::config::endpoint::Params::builder()
95 .region("ap-northeast-2".to_string())
96 .use_fips(false)
97 .use_dual_stack(false)
98 .build()
99 .expect("invalid params");
100 let resolver = crate::config::endpoint::DefaultResolver::new();
101 let endpoint = resolver.resolve_endpoint(¶ms);
102 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-northeast-2.amazonaws.com");
103 assert_eq!(
104 endpoint,
105 ::aws_smithy_types::endpoint::Endpoint::builder()
106 .url("https://ec2.ap-northeast-2.amazonaws.com")
107 .build()
108 );
109 }
110
111 #[test]
113 fn test_5() {
114 let params = crate::config::endpoint::Params::builder()
115 .region("ap-northeast-3".to_string())
116 .use_fips(false)
117 .use_dual_stack(false)
118 .build()
119 .expect("invalid params");
120 let resolver = crate::config::endpoint::DefaultResolver::new();
121 let endpoint = resolver.resolve_endpoint(¶ms);
122 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-northeast-3.amazonaws.com");
123 assert_eq!(
124 endpoint,
125 ::aws_smithy_types::endpoint::Endpoint::builder()
126 .url("https://ec2.ap-northeast-3.amazonaws.com")
127 .build()
128 );
129 }
130
131 #[test]
133 fn test_6() {
134 let params = crate::config::endpoint::Params::builder()
135 .region("ap-south-1".to_string())
136 .use_fips(false)
137 .use_dual_stack(false)
138 .build()
139 .expect("invalid params");
140 let resolver = crate::config::endpoint::DefaultResolver::new();
141 let endpoint = resolver.resolve_endpoint(¶ms);
142 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-south-1.amazonaws.com");
143 assert_eq!(
144 endpoint,
145 ::aws_smithy_types::endpoint::Endpoint::builder()
146 .url("https://ec2.ap-south-1.amazonaws.com")
147 .build()
148 );
149 }
150
151 #[test]
153 fn test_7() {
154 let params = crate::config::endpoint::Params::builder()
155 .region("ap-south-1".to_string())
156 .use_fips(false)
157 .use_dual_stack(true)
158 .build()
159 .expect("invalid params");
160 let resolver = crate::config::endpoint::DefaultResolver::new();
161 let endpoint = resolver.resolve_endpoint(¶ms);
162 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-south-1.api.aws");
163 assert_eq!(
164 endpoint,
165 ::aws_smithy_types::endpoint::Endpoint::builder()
166 .url("https://ec2.ap-south-1.api.aws")
167 .build()
168 );
169 }
170
171 #[test]
173 fn test_8() {
174 let params = crate::config::endpoint::Params::builder()
175 .region("ap-southeast-1".to_string())
176 .use_fips(false)
177 .use_dual_stack(false)
178 .build()
179 .expect("invalid params");
180 let resolver = crate::config::endpoint::DefaultResolver::new();
181 let endpoint = resolver.resolve_endpoint(¶ms);
182 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-southeast-1.amazonaws.com");
183 assert_eq!(
184 endpoint,
185 ::aws_smithy_types::endpoint::Endpoint::builder()
186 .url("https://ec2.ap-southeast-1.amazonaws.com")
187 .build()
188 );
189 }
190
191 #[test]
193 fn test_9() {
194 let params = crate::config::endpoint::Params::builder()
195 .region("ap-southeast-2".to_string())
196 .use_fips(false)
197 .use_dual_stack(false)
198 .build()
199 .expect("invalid params");
200 let resolver = crate::config::endpoint::DefaultResolver::new();
201 let endpoint = resolver.resolve_endpoint(¶ms);
202 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-southeast-2.amazonaws.com");
203 assert_eq!(
204 endpoint,
205 ::aws_smithy_types::endpoint::Endpoint::builder()
206 .url("https://ec2.ap-southeast-2.amazonaws.com")
207 .build()
208 );
209 }
210
211 #[test]
213 fn test_10() {
214 let params = crate::config::endpoint::Params::builder()
215 .region("ap-southeast-3".to_string())
216 .use_fips(false)
217 .use_dual_stack(false)
218 .build()
219 .expect("invalid params");
220 let resolver = crate::config::endpoint::DefaultResolver::new();
221 let endpoint = resolver.resolve_endpoint(¶ms);
222 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ap-southeast-3.amazonaws.com");
223 assert_eq!(
224 endpoint,
225 ::aws_smithy_types::endpoint::Endpoint::builder()
226 .url("https://ec2.ap-southeast-3.amazonaws.com")
227 .build()
228 );
229 }
230
231 #[test]
233 fn test_11() {
234 let params = crate::config::endpoint::Params::builder()
235 .region("ca-central-1".to_string())
236 .use_fips(false)
237 .use_dual_stack(false)
238 .build()
239 .expect("invalid params");
240 let resolver = crate::config::endpoint::DefaultResolver::new();
241 let endpoint = resolver.resolve_endpoint(¶ms);
242 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.ca-central-1.amazonaws.com");
243 assert_eq!(
244 endpoint,
245 ::aws_smithy_types::endpoint::Endpoint::builder()
246 .url("https://ec2.ca-central-1.amazonaws.com")
247 .build()
248 );
249 }
250
251 #[test]
253 fn test_12() {
254 let params = crate::config::endpoint::Params::builder()
255 .region("ca-central-1".to_string())
256 .use_fips(true)
257 .use_dual_stack(false)
258 .build()
259 .expect("invalid params");
260 let resolver = crate::config::endpoint::DefaultResolver::new();
261 let endpoint = resolver.resolve_endpoint(¶ms);
262 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.ca-central-1.amazonaws.com");
263 assert_eq!(
264 endpoint,
265 ::aws_smithy_types::endpoint::Endpoint::builder()
266 .url("https://ec2-fips.ca-central-1.amazonaws.com")
267 .build()
268 );
269 }
270
271 #[test]
273 fn test_13() {
274 let params = crate::config::endpoint::Params::builder()
275 .region("eu-central-1".to_string())
276 .use_fips(false)
277 .use_dual_stack(false)
278 .build()
279 .expect("invalid params");
280 let resolver = crate::config::endpoint::DefaultResolver::new();
281 let endpoint = resolver.resolve_endpoint(¶ms);
282 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-central-1.amazonaws.com");
283 assert_eq!(
284 endpoint,
285 ::aws_smithy_types::endpoint::Endpoint::builder()
286 .url("https://ec2.eu-central-1.amazonaws.com")
287 .build()
288 );
289 }
290
291 #[test]
293 fn test_14() {
294 let params = crate::config::endpoint::Params::builder()
295 .region("eu-north-1".to_string())
296 .use_fips(false)
297 .use_dual_stack(false)
298 .build()
299 .expect("invalid params");
300 let resolver = crate::config::endpoint::DefaultResolver::new();
301 let endpoint = resolver.resolve_endpoint(¶ms);
302 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-north-1.amazonaws.com");
303 assert_eq!(
304 endpoint,
305 ::aws_smithy_types::endpoint::Endpoint::builder()
306 .url("https://ec2.eu-north-1.amazonaws.com")
307 .build()
308 );
309 }
310
311 #[test]
313 fn test_15() {
314 let params = crate::config::endpoint::Params::builder()
315 .region("eu-south-1".to_string())
316 .use_fips(false)
317 .use_dual_stack(false)
318 .build()
319 .expect("invalid params");
320 let resolver = crate::config::endpoint::DefaultResolver::new();
321 let endpoint = resolver.resolve_endpoint(¶ms);
322 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-south-1.amazonaws.com");
323 assert_eq!(
324 endpoint,
325 ::aws_smithy_types::endpoint::Endpoint::builder()
326 .url("https://ec2.eu-south-1.amazonaws.com")
327 .build()
328 );
329 }
330
331 #[test]
333 fn test_16() {
334 let params = crate::config::endpoint::Params::builder()
335 .region("eu-west-1".to_string())
336 .use_fips(false)
337 .use_dual_stack(false)
338 .build()
339 .expect("invalid params");
340 let resolver = crate::config::endpoint::DefaultResolver::new();
341 let endpoint = resolver.resolve_endpoint(¶ms);
342 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-west-1.amazonaws.com");
343 assert_eq!(
344 endpoint,
345 ::aws_smithy_types::endpoint::Endpoint::builder()
346 .url("https://ec2.eu-west-1.amazonaws.com")
347 .build()
348 );
349 }
350
351 #[test]
353 fn test_17() {
354 let params = crate::config::endpoint::Params::builder()
355 .region("eu-west-1".to_string())
356 .use_fips(false)
357 .use_dual_stack(true)
358 .build()
359 .expect("invalid params");
360 let resolver = crate::config::endpoint::DefaultResolver::new();
361 let endpoint = resolver.resolve_endpoint(¶ms);
362 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-west-1.api.aws");
363 assert_eq!(
364 endpoint,
365 ::aws_smithy_types::endpoint::Endpoint::builder()
366 .url("https://ec2.eu-west-1.api.aws")
367 .build()
368 );
369 }
370
371 #[test]
373 fn test_18() {
374 let params = crate::config::endpoint::Params::builder()
375 .region("eu-west-2".to_string())
376 .use_fips(false)
377 .use_dual_stack(false)
378 .build()
379 .expect("invalid params");
380 let resolver = crate::config::endpoint::DefaultResolver::new();
381 let endpoint = resolver.resolve_endpoint(¶ms);
382 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-west-2.amazonaws.com");
383 assert_eq!(
384 endpoint,
385 ::aws_smithy_types::endpoint::Endpoint::builder()
386 .url("https://ec2.eu-west-2.amazonaws.com")
387 .build()
388 );
389 }
390
391 #[test]
393 fn test_19() {
394 let params = crate::config::endpoint::Params::builder()
395 .region("eu-west-3".to_string())
396 .use_fips(false)
397 .use_dual_stack(false)
398 .build()
399 .expect("invalid params");
400 let resolver = crate::config::endpoint::DefaultResolver::new();
401 let endpoint = resolver.resolve_endpoint(¶ms);
402 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.eu-west-3.amazonaws.com");
403 assert_eq!(
404 endpoint,
405 ::aws_smithy_types::endpoint::Endpoint::builder()
406 .url("https://ec2.eu-west-3.amazonaws.com")
407 .build()
408 );
409 }
410
411 #[test]
413 fn test_20() {
414 let params = crate::config::endpoint::Params::builder()
415 .region("me-south-1".to_string())
416 .use_fips(false)
417 .use_dual_stack(false)
418 .build()
419 .expect("invalid params");
420 let resolver = crate::config::endpoint::DefaultResolver::new();
421 let endpoint = resolver.resolve_endpoint(¶ms);
422 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.me-south-1.amazonaws.com");
423 assert_eq!(
424 endpoint,
425 ::aws_smithy_types::endpoint::Endpoint::builder()
426 .url("https://ec2.me-south-1.amazonaws.com")
427 .build()
428 );
429 }
430
431 #[test]
433 fn test_21() {
434 let params = crate::config::endpoint::Params::builder()
435 .region("sa-east-1".to_string())
436 .use_fips(false)
437 .use_dual_stack(false)
438 .build()
439 .expect("invalid params");
440 let resolver = crate::config::endpoint::DefaultResolver::new();
441 let endpoint = resolver.resolve_endpoint(¶ms);
442 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.sa-east-1.amazonaws.com");
443 assert_eq!(
444 endpoint,
445 ::aws_smithy_types::endpoint::Endpoint::builder()
446 .url("https://ec2.sa-east-1.amazonaws.com")
447 .build()
448 );
449 }
450
451 #[test]
453 fn test_22() {
454 let params = crate::config::endpoint::Params::builder()
455 .region("sa-east-1".to_string())
456 .use_fips(false)
457 .use_dual_stack(true)
458 .build()
459 .expect("invalid params");
460 let resolver = crate::config::endpoint::DefaultResolver::new();
461 let endpoint = resolver.resolve_endpoint(¶ms);
462 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.sa-east-1.api.aws");
463 assert_eq!(
464 endpoint,
465 ::aws_smithy_types::endpoint::Endpoint::builder()
466 .url("https://ec2.sa-east-1.api.aws")
467 .build()
468 );
469 }
470
471 #[test]
473 fn test_23() {
474 let params = crate::config::endpoint::Params::builder()
475 .region("us-east-1".to_string())
476 .use_fips(false)
477 .use_dual_stack(false)
478 .build()
479 .expect("invalid params");
480 let resolver = crate::config::endpoint::DefaultResolver::new();
481 let endpoint = resolver.resolve_endpoint(¶ms);
482 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-east-1.amazonaws.com");
483 assert_eq!(
484 endpoint,
485 ::aws_smithy_types::endpoint::Endpoint::builder()
486 .url("https://ec2.us-east-1.amazonaws.com")
487 .build()
488 );
489 }
490
491 #[test]
493 fn test_24() {
494 let params = crate::config::endpoint::Params::builder()
495 .region("us-east-1".to_string())
496 .use_fips(true)
497 .use_dual_stack(false)
498 .build()
499 .expect("invalid params");
500 let resolver = crate::config::endpoint::DefaultResolver::new();
501 let endpoint = resolver.resolve_endpoint(¶ms);
502 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-east-1.amazonaws.com");
503 assert_eq!(
504 endpoint,
505 ::aws_smithy_types::endpoint::Endpoint::builder()
506 .url("https://ec2-fips.us-east-1.amazonaws.com")
507 .build()
508 );
509 }
510
511 #[test]
513 fn test_25() {
514 let params = crate::config::endpoint::Params::builder()
515 .region("us-east-1".to_string())
516 .use_fips(false)
517 .use_dual_stack(true)
518 .build()
519 .expect("invalid params");
520 let resolver = crate::config::endpoint::DefaultResolver::new();
521 let endpoint = resolver.resolve_endpoint(¶ms);
522 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-east-1.api.aws");
523 assert_eq!(
524 endpoint,
525 ::aws_smithy_types::endpoint::Endpoint::builder()
526 .url("https://ec2.us-east-1.api.aws")
527 .build()
528 );
529 }
530
531 #[test]
533 fn test_26() {
534 let params = crate::config::endpoint::Params::builder()
535 .region("us-east-2".to_string())
536 .use_fips(false)
537 .use_dual_stack(false)
538 .build()
539 .expect("invalid params");
540 let resolver = crate::config::endpoint::DefaultResolver::new();
541 let endpoint = resolver.resolve_endpoint(¶ms);
542 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-east-2.amazonaws.com");
543 assert_eq!(
544 endpoint,
545 ::aws_smithy_types::endpoint::Endpoint::builder()
546 .url("https://ec2.us-east-2.amazonaws.com")
547 .build()
548 );
549 }
550
551 #[test]
553 fn test_27() {
554 let params = crate::config::endpoint::Params::builder()
555 .region("us-east-2".to_string())
556 .use_fips(true)
557 .use_dual_stack(false)
558 .build()
559 .expect("invalid params");
560 let resolver = crate::config::endpoint::DefaultResolver::new();
561 let endpoint = resolver.resolve_endpoint(¶ms);
562 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-east-2.amazonaws.com");
563 assert_eq!(
564 endpoint,
565 ::aws_smithy_types::endpoint::Endpoint::builder()
566 .url("https://ec2-fips.us-east-2.amazonaws.com")
567 .build()
568 );
569 }
570
571 #[test]
573 fn test_28() {
574 let params = crate::config::endpoint::Params::builder()
575 .region("us-east-2".to_string())
576 .use_fips(false)
577 .use_dual_stack(true)
578 .build()
579 .expect("invalid params");
580 let resolver = crate::config::endpoint::DefaultResolver::new();
581 let endpoint = resolver.resolve_endpoint(¶ms);
582 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-east-2.api.aws");
583 assert_eq!(
584 endpoint,
585 ::aws_smithy_types::endpoint::Endpoint::builder()
586 .url("https://ec2.us-east-2.api.aws")
587 .build()
588 );
589 }
590
591 #[test]
593 fn test_29() {
594 let params = crate::config::endpoint::Params::builder()
595 .region("us-west-1".to_string())
596 .use_fips(false)
597 .use_dual_stack(false)
598 .build()
599 .expect("invalid params");
600 let resolver = crate::config::endpoint::DefaultResolver::new();
601 let endpoint = resolver.resolve_endpoint(¶ms);
602 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-west-1.amazonaws.com");
603 assert_eq!(
604 endpoint,
605 ::aws_smithy_types::endpoint::Endpoint::builder()
606 .url("https://ec2.us-west-1.amazonaws.com")
607 .build()
608 );
609 }
610
611 #[test]
613 fn test_30() {
614 let params = crate::config::endpoint::Params::builder()
615 .region("us-west-1".to_string())
616 .use_fips(true)
617 .use_dual_stack(false)
618 .build()
619 .expect("invalid params");
620 let resolver = crate::config::endpoint::DefaultResolver::new();
621 let endpoint = resolver.resolve_endpoint(¶ms);
622 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-west-1.amazonaws.com");
623 assert_eq!(
624 endpoint,
625 ::aws_smithy_types::endpoint::Endpoint::builder()
626 .url("https://ec2-fips.us-west-1.amazonaws.com")
627 .build()
628 );
629 }
630
631 #[test]
633 fn test_31() {
634 let params = crate::config::endpoint::Params::builder()
635 .region("us-west-2".to_string())
636 .use_fips(false)
637 .use_dual_stack(false)
638 .build()
639 .expect("invalid params");
640 let resolver = crate::config::endpoint::DefaultResolver::new();
641 let endpoint = resolver.resolve_endpoint(¶ms);
642 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-west-2.amazonaws.com");
643 assert_eq!(
644 endpoint,
645 ::aws_smithy_types::endpoint::Endpoint::builder()
646 .url("https://ec2.us-west-2.amazonaws.com")
647 .build()
648 );
649 }
650
651 #[test]
653 fn test_32() {
654 let params = crate::config::endpoint::Params::builder()
655 .region("us-west-2".to_string())
656 .use_fips(true)
657 .use_dual_stack(false)
658 .build()
659 .expect("invalid params");
660 let resolver = crate::config::endpoint::DefaultResolver::new();
661 let endpoint = resolver.resolve_endpoint(¶ms);
662 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-west-2.amazonaws.com");
663 assert_eq!(
664 endpoint,
665 ::aws_smithy_types::endpoint::Endpoint::builder()
666 .url("https://ec2-fips.us-west-2.amazonaws.com")
667 .build()
668 );
669 }
670
671 #[test]
673 fn test_33() {
674 let params = crate::config::endpoint::Params::builder()
675 .region("us-west-2".to_string())
676 .use_fips(false)
677 .use_dual_stack(true)
678 .build()
679 .expect("invalid params");
680 let resolver = crate::config::endpoint::DefaultResolver::new();
681 let endpoint = resolver.resolve_endpoint(¶ms);
682 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-west-2.api.aws");
683 assert_eq!(
684 endpoint,
685 ::aws_smithy_types::endpoint::Endpoint::builder()
686 .url("https://ec2.us-west-2.api.aws")
687 .build()
688 );
689 }
690
691 #[test]
693 fn test_34() {
694 let params = crate::config::endpoint::Params::builder()
695 .region("us-east-1".to_string())
696 .use_fips(true)
697 .use_dual_stack(true)
698 .build()
699 .expect("invalid params");
700 let resolver = crate::config::endpoint::DefaultResolver::new();
701 let endpoint = resolver.resolve_endpoint(¶ms);
702 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-east-1.api.aws");
703 assert_eq!(
704 endpoint,
705 ::aws_smithy_types::endpoint::Endpoint::builder()
706 .url("https://ec2-fips.us-east-1.api.aws")
707 .build()
708 );
709 }
710
711 #[test]
713 fn test_35() {
714 let params = crate::config::endpoint::Params::builder()
715 .region("cn-north-1".to_string())
716 .use_fips(false)
717 .use_dual_stack(false)
718 .build()
719 .expect("invalid params");
720 let resolver = crate::config::endpoint::DefaultResolver::new();
721 let endpoint = resolver.resolve_endpoint(¶ms);
722 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.cn-north-1.amazonaws.com.cn");
723 assert_eq!(
724 endpoint,
725 ::aws_smithy_types::endpoint::Endpoint::builder()
726 .url("https://ec2.cn-north-1.amazonaws.com.cn")
727 .build()
728 );
729 }
730
731 #[test]
733 fn test_36() {
734 let params = crate::config::endpoint::Params::builder()
735 .region("cn-northwest-1".to_string())
736 .use_fips(false)
737 .use_dual_stack(false)
738 .build()
739 .expect("invalid params");
740 let resolver = crate::config::endpoint::DefaultResolver::new();
741 let endpoint = resolver.resolve_endpoint(¶ms);
742 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.cn-northwest-1.amazonaws.com.cn");
743 assert_eq!(
744 endpoint,
745 ::aws_smithy_types::endpoint::Endpoint::builder()
746 .url("https://ec2.cn-northwest-1.amazonaws.com.cn")
747 .build()
748 );
749 }
750
751 #[test]
753 fn test_37() {
754 let params = crate::config::endpoint::Params::builder()
755 .region("cn-north-1".to_string())
756 .use_fips(true)
757 .use_dual_stack(true)
758 .build()
759 .expect("invalid params");
760 let resolver = crate::config::endpoint::DefaultResolver::new();
761 let endpoint = resolver.resolve_endpoint(¶ms);
762 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.cn-north-1.api.amazonwebservices.com.cn");
763 assert_eq!(
764 endpoint,
765 ::aws_smithy_types::endpoint::Endpoint::builder()
766 .url("https://ec2-fips.cn-north-1.api.amazonwebservices.com.cn")
767 .build()
768 );
769 }
770
771 #[test]
773 fn test_38() {
774 let params = crate::config::endpoint::Params::builder()
775 .region("cn-north-1".to_string())
776 .use_fips(true)
777 .use_dual_stack(false)
778 .build()
779 .expect("invalid params");
780 let resolver = crate::config::endpoint::DefaultResolver::new();
781 let endpoint = resolver.resolve_endpoint(¶ms);
782 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.cn-north-1.amazonaws.com.cn");
783 assert_eq!(
784 endpoint,
785 ::aws_smithy_types::endpoint::Endpoint::builder()
786 .url("https://ec2-fips.cn-north-1.amazonaws.com.cn")
787 .build()
788 );
789 }
790
791 #[test]
793 fn test_39() {
794 let params = crate::config::endpoint::Params::builder()
795 .region("cn-north-1".to_string())
796 .use_fips(false)
797 .use_dual_stack(true)
798 .build()
799 .expect("invalid params");
800 let resolver = crate::config::endpoint::DefaultResolver::new();
801 let endpoint = resolver.resolve_endpoint(¶ms);
802 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.cn-north-1.api.amazonwebservices.com.cn");
803 assert_eq!(
804 endpoint,
805 ::aws_smithy_types::endpoint::Endpoint::builder()
806 .url("https://ec2.cn-north-1.api.amazonwebservices.com.cn")
807 .build()
808 );
809 }
810
811 #[test]
813 fn test_40() {
814 let params = crate::config::endpoint::Params::builder()
815 .region("us-gov-east-1".to_string())
816 .use_fips(false)
817 .use_dual_stack(false)
818 .build()
819 .expect("invalid params");
820 let resolver = crate::config::endpoint::DefaultResolver::new();
821 let endpoint = resolver.resolve_endpoint(¶ms);
822 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-gov-east-1.amazonaws.com");
823 assert_eq!(
824 endpoint,
825 ::aws_smithy_types::endpoint::Endpoint::builder()
826 .url("https://ec2.us-gov-east-1.amazonaws.com")
827 .build()
828 );
829 }
830
831 #[test]
833 fn test_41() {
834 let params = crate::config::endpoint::Params::builder()
835 .region("us-gov-west-1".to_string())
836 .use_fips(false)
837 .use_dual_stack(false)
838 .build()
839 .expect("invalid params");
840 let resolver = crate::config::endpoint::DefaultResolver::new();
841 let endpoint = resolver.resolve_endpoint(¶ms);
842 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-gov-west-1.amazonaws.com");
843 assert_eq!(
844 endpoint,
845 ::aws_smithy_types::endpoint::Endpoint::builder()
846 .url("https://ec2.us-gov-west-1.amazonaws.com")
847 .build()
848 );
849 }
850
851 #[test]
853 fn test_42() {
854 let params = crate::config::endpoint::Params::builder()
855 .region("us-gov-east-1".to_string())
856 .use_fips(true)
857 .use_dual_stack(true)
858 .build()
859 .expect("invalid params");
860 let resolver = crate::config::endpoint::DefaultResolver::new();
861 let endpoint = resolver.resolve_endpoint(¶ms);
862 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-gov-east-1.api.aws");
863 assert_eq!(
864 endpoint,
865 ::aws_smithy_types::endpoint::Endpoint::builder()
866 .url("https://ec2-fips.us-gov-east-1.api.aws")
867 .build()
868 );
869 }
870
871 #[test]
873 fn test_43() {
874 let params = crate::config::endpoint::Params::builder()
875 .region("us-gov-east-1".to_string())
876 .use_fips(true)
877 .use_dual_stack(false)
878 .build()
879 .expect("invalid params");
880 let resolver = crate::config::endpoint::DefaultResolver::new();
881 let endpoint = resolver.resolve_endpoint(¶ms);
882 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-gov-east-1.amazonaws.com");
883 assert_eq!(
884 endpoint,
885 ::aws_smithy_types::endpoint::Endpoint::builder()
886 .url("https://ec2.us-gov-east-1.amazonaws.com")
887 .build()
888 );
889 }
890
891 #[test]
893 fn test_44() {
894 let params = crate::config::endpoint::Params::builder()
895 .region("us-gov-east-1".to_string())
896 .use_fips(false)
897 .use_dual_stack(true)
898 .build()
899 .expect("invalid params");
900 let resolver = crate::config::endpoint::DefaultResolver::new();
901 let endpoint = resolver.resolve_endpoint(¶ms);
902 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-gov-east-1.api.aws");
903 assert_eq!(
904 endpoint,
905 ::aws_smithy_types::endpoint::Endpoint::builder()
906 .url("https://ec2.us-gov-east-1.api.aws")
907 .build()
908 );
909 }
910
911 #[test]
913 fn test_45() {
914 let params = crate::config::endpoint::Params::builder()
915 .region("us-iso-east-1".to_string())
916 .use_fips(false)
917 .use_dual_stack(false)
918 .build()
919 .expect("invalid params");
920 let resolver = crate::config::endpoint::DefaultResolver::new();
921 let endpoint = resolver.resolve_endpoint(¶ms);
922 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-iso-east-1.c2s.ic.gov");
923 assert_eq!(
924 endpoint,
925 ::aws_smithy_types::endpoint::Endpoint::builder()
926 .url("https://ec2.us-iso-east-1.c2s.ic.gov")
927 .build()
928 );
929 }
930
931 #[test]
933 fn test_46() {
934 let params = crate::config::endpoint::Params::builder()
935 .region("us-iso-west-1".to_string())
936 .use_fips(false)
937 .use_dual_stack(false)
938 .build()
939 .expect("invalid params");
940 let resolver = crate::config::endpoint::DefaultResolver::new();
941 let endpoint = resolver.resolve_endpoint(¶ms);
942 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-iso-west-1.c2s.ic.gov");
943 assert_eq!(
944 endpoint,
945 ::aws_smithy_types::endpoint::Endpoint::builder()
946 .url("https://ec2.us-iso-west-1.c2s.ic.gov")
947 .build()
948 );
949 }
950
951 #[test]
953 fn test_47() {
954 let params = crate::config::endpoint::Params::builder()
955 .region("us-iso-east-1".to_string())
956 .use_fips(true)
957 .use_dual_stack(false)
958 .build()
959 .expect("invalid params");
960 let resolver = crate::config::endpoint::DefaultResolver::new();
961 let endpoint = resolver.resolve_endpoint(¶ms);
962 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-iso-east-1.c2s.ic.gov");
963 assert_eq!(
964 endpoint,
965 ::aws_smithy_types::endpoint::Endpoint::builder()
966 .url("https://ec2-fips.us-iso-east-1.c2s.ic.gov")
967 .build()
968 );
969 }
970
971 #[test]
973 fn test_48() {
974 let params = crate::config::endpoint::Params::builder()
975 .region("us-isob-east-1".to_string())
976 .use_fips(false)
977 .use_dual_stack(false)
978 .build()
979 .expect("invalid params");
980 let resolver = crate::config::endpoint::DefaultResolver::new();
981 let endpoint = resolver.resolve_endpoint(¶ms);
982 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2.us-isob-east-1.sc2s.sgov.gov");
983 assert_eq!(
984 endpoint,
985 ::aws_smithy_types::endpoint::Endpoint::builder()
986 .url("https://ec2.us-isob-east-1.sc2s.sgov.gov")
987 .build()
988 );
989 }
990
991 #[test]
993 fn test_49() {
994 let params = crate::config::endpoint::Params::builder()
995 .region("us-isob-east-1".to_string())
996 .use_fips(true)
997 .use_dual_stack(false)
998 .build()
999 .expect("invalid params");
1000 let resolver = crate::config::endpoint::DefaultResolver::new();
1001 let endpoint = resolver.resolve_endpoint(¶ms);
1002 let endpoint = endpoint.expect("Expected valid endpoint: https://ec2-fips.us-isob-east-1.sc2s.sgov.gov");
1003 assert_eq!(
1004 endpoint,
1005 ::aws_smithy_types::endpoint::Endpoint::builder()
1006 .url("https://ec2-fips.us-isob-east-1.sc2s.sgov.gov")
1007 .build()
1008 );
1009 }
1010
1011 #[test]
1013 fn test_50() {
1014 let params = crate::config::endpoint::Params::builder()
1015 .region("us-east-1".to_string())
1016 .use_fips(false)
1017 .use_dual_stack(false)
1018 .endpoint("https://example.com".to_string())
1019 .build()
1020 .expect("invalid params");
1021 let resolver = crate::config::endpoint::DefaultResolver::new();
1022 let endpoint = resolver.resolve_endpoint(¶ms);
1023 let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1024 assert_eq!(
1025 endpoint,
1026 ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
1027 );
1028 }
1029
1030 #[test]
1032 fn test_51() {
1033 let params = crate::config::endpoint::Params::builder()
1034 .use_fips(false)
1035 .use_dual_stack(false)
1036 .endpoint("https://example.com".to_string())
1037 .build()
1038 .expect("invalid params");
1039 let resolver = crate::config::endpoint::DefaultResolver::new();
1040 let endpoint = resolver.resolve_endpoint(¶ms);
1041 let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1042 assert_eq!(
1043 endpoint,
1044 ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
1045 );
1046 }
1047
1048 #[test]
1050 fn test_52() {
1051 let params = crate::config::endpoint::Params::builder()
1052 .region("us-east-1".to_string())
1053 .use_fips(true)
1054 .use_dual_stack(false)
1055 .endpoint("https://example.com".to_string())
1056 .build()
1057 .expect("invalid params");
1058 let resolver = crate::config::endpoint::DefaultResolver::new();
1059 let endpoint = resolver.resolve_endpoint(¶ms);
1060 let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and custom endpoint are not supported [For custom endpoint with fips enabled and dualstack disabled]");
1061 assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and custom endpoint are not supported")
1062 }
1063
1064 #[test]
1066 fn test_53() {
1067 let params = crate::config::endpoint::Params::builder()
1068 .region("us-east-1".to_string())
1069 .use_fips(false)
1070 .use_dual_stack(true)
1071 .endpoint("https://example.com".to_string())
1072 .build()
1073 .expect("invalid params");
1074 let resolver = crate::config::endpoint::DefaultResolver::new();
1075 let endpoint = resolver.resolve_endpoint(¶ms);
1076 let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and custom endpoint are not supported [For custom endpoint with fips disabled and dualstack enabled]");
1077 assert_eq!(
1078 format!("{}", error),
1079 "Invalid Configuration: Dualstack and custom endpoint are not supported"
1080 )
1081 }
1082
1083 #[test]
1085 fn test_54() {
1086 let params = crate::config::endpoint::Params::builder().build().expect("invalid params");
1087 let resolver = crate::config::endpoint::DefaultResolver::new();
1088 let endpoint = resolver.resolve_endpoint(¶ms);
1089 let error = endpoint.expect_err("expected error: Invalid Configuration: Missing Region [Missing region]");
1090 assert_eq!(format!("{}", error), "Invalid Configuration: Missing Region")
1091 }
1092}
1093
1094pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
1096 fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
1098
1099 fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
1103 where
1104 Self: Sized + 'static,
1105 {
1106 ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
1107 }
1108}
1109
1110#[derive(Debug)]
1111struct DowncastParams<T>(T);
1112impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
1113where
1114 T: ResolveEndpoint,
1115{
1116 fn resolve_endpoint<'a>(
1117 &'a self,
1118 params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
1119 ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
1120 let ep = match params.get::<crate::config::endpoint::Params>() {
1121 Some(params) => self.0.resolve_endpoint(params),
1122 None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
1123 };
1124 ep
1125 }
1126}
1127
1128#[derive(Debug, Default)]
1130pub struct DefaultResolver {
1131 partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
1132}
1133
1134impl DefaultResolver {
1135 pub fn new() -> Self {
1137 Self {
1138 partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
1139 }
1140 }
1141
1142 fn resolve_endpoint(
1143 &self,
1144 params: &crate::config::endpoint::Params,
1145 ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
1146 let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
1147 Ok(
1148 crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
1149 .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
1150 )
1151 }
1152}
1153
1154impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
1155 fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'_> {
1156 ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
1157 }
1158}
1159
1160#[non_exhaustive]
1161#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
1162pub struct Params {
1164 pub(crate) region: ::std::option::Option<::std::string::String>,
1166 pub(crate) use_dual_stack: bool,
1168 pub(crate) use_fips: bool,
1170 pub(crate) endpoint: ::std::option::Option<::std::string::String>,
1172}
1173impl Params {
1174 pub fn builder() -> crate::config::endpoint::ParamsBuilder {
1176 crate::config::endpoint::ParamsBuilder::default()
1177 }
1178 pub fn region(&self) -> ::std::option::Option<&str> {
1180 self.region.as_deref()
1181 }
1182 pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
1184 Some(self.use_dual_stack)
1185 }
1186 pub fn use_fips(&self) -> ::std::option::Option<bool> {
1188 Some(self.use_fips)
1189 }
1190 pub fn endpoint(&self) -> ::std::option::Option<&str> {
1192 self.endpoint.as_deref()
1193 }
1194}
1195
1196#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
1198pub struct ParamsBuilder {
1199 region: ::std::option::Option<::std::string::String>,
1200 use_dual_stack: ::std::option::Option<bool>,
1201 use_fips: ::std::option::Option<bool>,
1202 endpoint: ::std::option::Option<::std::string::String>,
1203}
1204impl ParamsBuilder {
1205 pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
1207 if let Some(region) = &self.region {
1208 if !crate::endpoint_lib::host::is_valid_host_label(
1209 region.as_ref() as &str,
1210 true,
1211 &mut crate::endpoint_lib::diagnostic::DiagnosticCollector::new(),
1212 ) {
1213 return Err(crate::config::endpoint::InvalidParams::invalid_value(
1214 "region",
1215 "must be a valid host label",
1216 ));
1217 }
1218 };
1219 Ok(
1220 #[allow(clippy::unnecessary_lazy_evaluations)]
1221 crate::config::endpoint::Params {
1222 region: self.region,
1223 use_dual_stack: self
1224 .use_dual_stack
1225 .or_else(|| Some(false))
1226 .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
1227 use_fips: self
1228 .use_fips
1229 .or_else(|| Some(false))
1230 .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
1231 endpoint: self.endpoint,
1232 },
1233 )
1234 }
1235 pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
1239 self.region = Some(value.into());
1240 self
1241 }
1242
1243 pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
1247 self.region = param;
1248 self
1249 }
1250 pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
1255 self.use_dual_stack = Some(value.into());
1256 self
1257 }
1258
1259 pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
1264 self.use_dual_stack = param;
1265 self
1266 }
1267 pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
1272 self.use_fips = Some(value.into());
1273 self
1274 }
1275
1276 pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
1281 self.use_fips = param;
1282 self
1283 }
1284 pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
1288 self.endpoint = Some(value.into());
1289 self
1290 }
1291
1292 pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
1296 self.endpoint = param;
1297 self
1298 }
1299}
1300
1301#[derive(Debug)]
1303pub struct InvalidParams {
1304 field: std::borrow::Cow<'static, str>,
1305 kind: InvalidParamsErrorKind,
1306}
1307
1308#[derive(Debug)]
1310enum InvalidParamsErrorKind {
1311 MissingField,
1312 InvalidValue { message: &'static str },
1313}
1314
1315impl InvalidParams {
1316 #[allow(dead_code)]
1317 fn missing(field: &'static str) -> Self {
1318 Self {
1319 field: field.into(),
1320 kind: InvalidParamsErrorKind::MissingField,
1321 }
1322 }
1323
1324 #[allow(dead_code)]
1325 fn invalid_value(field: &'static str, message: &'static str) -> Self {
1326 Self {
1327 field: field.into(),
1328 kind: InvalidParamsErrorKind::InvalidValue { message },
1329 }
1330 }
1331}
1332
1333impl std::fmt::Display for InvalidParams {
1334 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335 match self.kind {
1336 InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
1337 InvalidParamsErrorKind::InvalidValue { message } => write!(f, "invalid value for field: `{}` - {}", self.field, message),
1338 }
1339 }
1340}
1341
1342impl std::error::Error for InvalidParams {}
1343
1344mod internals;