1pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
3 pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
4 pub use ::aws_smithy_types::endpoint::Endpoint;
5
6#[derive(Debug, Default)]
8 pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;
9
10 #[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
11 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
12 fn name(&self) -> &'static str {
13 "EndpointOverrideFeatureTrackerInterceptor"
14 }
15
16 fn read_before_execution(
17 &self,
18 _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
19 cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
20 ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
21 if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
22 cfg.interceptor_state()
23 .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
24 }
25 ::std::result::Result::Ok(())
26 }
27 }
28
29#[cfg(test)]
30mod test {
31
32 #[test]
34 fn test_1() {
35 let params = crate::config::endpoint::Params::builder()
36 .region("af-south-1".to_string())
37 .use_fips(false)
38 .use_dual_stack(false)
39 .build().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://sts.af-south-1.amazonaws.com");
43 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.af-south-1.amazonaws.com")
44 .build());
45 }
46
47 #[test]
49 fn test_2() {
50 let params = crate::config::endpoint::Params::builder()
51 .region("ap-east-1".to_string())
52 .use_fips(false)
53 .use_dual_stack(false)
54 .build().expect("invalid params");
55 let resolver = crate::config::endpoint::DefaultResolver::new();
56 let endpoint = resolver.resolve_endpoint(¶ms);
57 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-east-1.amazonaws.com");
58 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-east-1.amazonaws.com")
59 .build());
60 }
61
62 #[test]
64 fn test_3() {
65 let params = crate::config::endpoint::Params::builder()
66 .region("ap-northeast-1".to_string())
67 .use_fips(false)
68 .use_dual_stack(false)
69 .build().expect("invalid params");
70 let resolver = crate::config::endpoint::DefaultResolver::new();
71 let endpoint = resolver.resolve_endpoint(¶ms);
72 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-northeast-1.amazonaws.com");
73 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-northeast-1.amazonaws.com")
74 .build());
75 }
76
77 #[test]
79 fn test_4() {
80 let params = crate::config::endpoint::Params::builder()
81 .region("ap-northeast-2".to_string())
82 .use_fips(false)
83 .use_dual_stack(false)
84 .build().expect("invalid params");
85 let resolver = crate::config::endpoint::DefaultResolver::new();
86 let endpoint = resolver.resolve_endpoint(¶ms);
87 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-northeast-2.amazonaws.com");
88 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-northeast-2.amazonaws.com")
89 .build());
90 }
91
92 #[test]
94 fn test_5() {
95 let params = crate::config::endpoint::Params::builder()
96 .region("ap-northeast-3".to_string())
97 .use_fips(false)
98 .use_dual_stack(false)
99 .build().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://sts.ap-northeast-3.amazonaws.com");
103 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-northeast-3.amazonaws.com")
104 .build());
105 }
106
107 #[test]
109 fn test_6() {
110 let params = crate::config::endpoint::Params::builder()
111 .region("ap-south-1".to_string())
112 .use_fips(false)
113 .use_dual_stack(false)
114 .build().expect("invalid params");
115 let resolver = crate::config::endpoint::DefaultResolver::new();
116 let endpoint = resolver.resolve_endpoint(¶ms);
117 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-south-1.amazonaws.com");
118 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-south-1.amazonaws.com")
119 .build());
120 }
121
122 #[test]
124 fn test_7() {
125 let params = crate::config::endpoint::Params::builder()
126 .region("ap-southeast-1".to_string())
127 .use_fips(false)
128 .use_dual_stack(false)
129 .build().expect("invalid params");
130 let resolver = crate::config::endpoint::DefaultResolver::new();
131 let endpoint = resolver.resolve_endpoint(¶ms);
132 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-southeast-1.amazonaws.com");
133 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-southeast-1.amazonaws.com")
134 .build());
135 }
136
137 #[test]
139 fn test_8() {
140 let params = crate::config::endpoint::Params::builder()
141 .region("ap-southeast-2".to_string())
142 .use_fips(false)
143 .use_dual_stack(false)
144 .build().expect("invalid params");
145 let resolver = crate::config::endpoint::DefaultResolver::new();
146 let endpoint = resolver.resolve_endpoint(¶ms);
147 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-southeast-2.amazonaws.com");
148 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-southeast-2.amazonaws.com")
149 .build());
150 }
151
152 #[test]
154 fn test_9() {
155 let params = crate::config::endpoint::Params::builder()
156 .region("ap-southeast-3".to_string())
157 .use_fips(false)
158 .use_dual_stack(false)
159 .build().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://sts.ap-southeast-3.amazonaws.com");
163 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ap-southeast-3.amazonaws.com")
164 .build());
165 }
166
167 #[test]
169 fn test_10() {
170 let params = crate::config::endpoint::Params::builder()
171 .region("aws-global".to_string())
172 .use_fips(false)
173 .use_dual_stack(false)
174 .build().expect("invalid params");
175 let resolver = crate::config::endpoint::DefaultResolver::new();
176 let endpoint = resolver.resolve_endpoint(¶ms);
177 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
178 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
179 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
180 .put("signingName", "sts".to_string())
181 .put("signingRegion", "us-east-1".to_string())
182 )
183 .build());
184 }
185
186 #[test]
188 fn test_11() {
189 let params = crate::config::endpoint::Params::builder()
190 .region("ca-central-1".to_string())
191 .use_fips(false)
192 .use_dual_stack(false)
193 .build().expect("invalid params");
194 let resolver = crate::config::endpoint::DefaultResolver::new();
195 let endpoint = resolver.resolve_endpoint(¶ms);
196 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ca-central-1.amazonaws.com");
197 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.ca-central-1.amazonaws.com")
198 .build());
199 }
200
201 #[test]
203 fn test_12() {
204 let params = crate::config::endpoint::Params::builder()
205 .region("eu-central-1".to_string())
206 .use_fips(false)
207 .use_dual_stack(false)
208 .build().expect("invalid params");
209 let resolver = crate::config::endpoint::DefaultResolver::new();
210 let endpoint = resolver.resolve_endpoint(¶ms);
211 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-central-1.amazonaws.com");
212 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-central-1.amazonaws.com")
213 .build());
214 }
215
216 #[test]
218 fn test_13() {
219 let params = crate::config::endpoint::Params::builder()
220 .region("eu-north-1".to_string())
221 .use_fips(false)
222 .use_dual_stack(false)
223 .build().expect("invalid params");
224 let resolver = crate::config::endpoint::DefaultResolver::new();
225 let endpoint = resolver.resolve_endpoint(¶ms);
226 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-north-1.amazonaws.com");
227 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-north-1.amazonaws.com")
228 .build());
229 }
230
231 #[test]
233 fn test_14() {
234 let params = crate::config::endpoint::Params::builder()
235 .region("eu-south-1".to_string())
236 .use_fips(false)
237 .use_dual_stack(false)
238 .build().expect("invalid params");
239 let resolver = crate::config::endpoint::DefaultResolver::new();
240 let endpoint = resolver.resolve_endpoint(¶ms);
241 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-south-1.amazonaws.com");
242 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-south-1.amazonaws.com")
243 .build());
244 }
245
246 #[test]
248 fn test_15() {
249 let params = crate::config::endpoint::Params::builder()
250 .region("eu-west-1".to_string())
251 .use_fips(false)
252 .use_dual_stack(false)
253 .build().expect("invalid params");
254 let resolver = crate::config::endpoint::DefaultResolver::new();
255 let endpoint = resolver.resolve_endpoint(¶ms);
256 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-1.amazonaws.com");
257 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-west-1.amazonaws.com")
258 .build());
259 }
260
261 #[test]
263 fn test_16() {
264 let params = crate::config::endpoint::Params::builder()
265 .region("eu-west-2".to_string())
266 .use_fips(false)
267 .use_dual_stack(false)
268 .build().expect("invalid params");
269 let resolver = crate::config::endpoint::DefaultResolver::new();
270 let endpoint = resolver.resolve_endpoint(¶ms);
271 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-2.amazonaws.com");
272 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-west-2.amazonaws.com")
273 .build());
274 }
275
276 #[test]
278 fn test_17() {
279 let params = crate::config::endpoint::Params::builder()
280 .region("eu-west-3".to_string())
281 .use_fips(false)
282 .use_dual_stack(false)
283 .build().expect("invalid params");
284 let resolver = crate::config::endpoint::DefaultResolver::new();
285 let endpoint = resolver.resolve_endpoint(¶ms);
286 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-3.amazonaws.com");
287 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.eu-west-3.amazonaws.com")
288 .build());
289 }
290
291 #[test]
293 fn test_18() {
294 let params = crate::config::endpoint::Params::builder()
295 .region("me-south-1".to_string())
296 .use_fips(false)
297 .use_dual_stack(false)
298 .build().expect("invalid params");
299 let resolver = crate::config::endpoint::DefaultResolver::new();
300 let endpoint = resolver.resolve_endpoint(¶ms);
301 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.me-south-1.amazonaws.com");
302 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.me-south-1.amazonaws.com")
303 .build());
304 }
305
306 #[test]
308 fn test_19() {
309 let params = crate::config::endpoint::Params::builder()
310 .region("sa-east-1".to_string())
311 .use_fips(false)
312 .use_dual_stack(false)
313 .build().expect("invalid params");
314 let resolver = crate::config::endpoint::DefaultResolver::new();
315 let endpoint = resolver.resolve_endpoint(¶ms);
316 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.sa-east-1.amazonaws.com");
317 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.sa-east-1.amazonaws.com")
318 .build());
319 }
320
321 #[test]
323 fn test_20() {
324 let params = crate::config::endpoint::Params::builder()
325 .region("us-east-1".to_string())
326 .use_fips(false)
327 .use_dual_stack(false)
328 .build().expect("invalid params");
329 let resolver = crate::config::endpoint::DefaultResolver::new();
330 let endpoint = resolver.resolve_endpoint(¶ms);
331 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-1.amazonaws.com");
332 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-east-1.amazonaws.com")
333 .build());
334 }
335
336 #[test]
338 fn test_21() {
339 let params = crate::config::endpoint::Params::builder()
340 .region("us-east-1".to_string())
341 .use_fips(true)
342 .use_dual_stack(false)
343 .build().expect("invalid params");
344 let resolver = crate::config::endpoint::DefaultResolver::new();
345 let endpoint = resolver.resolve_endpoint(¶ms);
346 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-1.amazonaws.com");
347 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-east-1.amazonaws.com")
348 .build());
349 }
350
351 #[test]
353 fn test_22() {
354 let params = crate::config::endpoint::Params::builder()
355 .region("us-east-2".to_string())
356 .use_fips(false)
357 .use_dual_stack(false)
358 .build().expect("invalid params");
359 let resolver = crate::config::endpoint::DefaultResolver::new();
360 let endpoint = resolver.resolve_endpoint(¶ms);
361 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-2.amazonaws.com");
362 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-east-2.amazonaws.com")
363 .build());
364 }
365
366 #[test]
368 fn test_23() {
369 let params = crate::config::endpoint::Params::builder()
370 .region("us-east-2".to_string())
371 .use_fips(true)
372 .use_dual_stack(false)
373 .build().expect("invalid params");
374 let resolver = crate::config::endpoint::DefaultResolver::new();
375 let endpoint = resolver.resolve_endpoint(¶ms);
376 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-2.amazonaws.com");
377 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-east-2.amazonaws.com")
378 .build());
379 }
380
381 #[test]
383 fn test_24() {
384 let params = crate::config::endpoint::Params::builder()
385 .region("us-west-1".to_string())
386 .use_fips(false)
387 .use_dual_stack(false)
388 .build().expect("invalid params");
389 let resolver = crate::config::endpoint::DefaultResolver::new();
390 let endpoint = resolver.resolve_endpoint(¶ms);
391 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-west-1.amazonaws.com");
392 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-west-1.amazonaws.com")
393 .build());
394 }
395
396 #[test]
398 fn test_25() {
399 let params = crate::config::endpoint::Params::builder()
400 .region("us-west-1".to_string())
401 .use_fips(true)
402 .use_dual_stack(false)
403 .build().expect("invalid params");
404 let resolver = crate::config::endpoint::DefaultResolver::new();
405 let endpoint = resolver.resolve_endpoint(¶ms);
406 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-west-1.amazonaws.com");
407 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-west-1.amazonaws.com")
408 .build());
409 }
410
411 #[test]
413 fn test_26() {
414 let params = crate::config::endpoint::Params::builder()
415 .region("us-west-2".to_string())
416 .use_fips(false)
417 .use_dual_stack(false)
418 .build().expect("invalid params");
419 let resolver = crate::config::endpoint::DefaultResolver::new();
420 let endpoint = resolver.resolve_endpoint(¶ms);
421 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-west-2.amazonaws.com");
422 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-west-2.amazonaws.com")
423 .build());
424 }
425
426 #[test]
428 fn test_27() {
429 let params = crate::config::endpoint::Params::builder()
430 .region("us-west-2".to_string())
431 .use_fips(true)
432 .use_dual_stack(false)
433 .build().expect("invalid params");
434 let resolver = crate::config::endpoint::DefaultResolver::new();
435 let endpoint = resolver.resolve_endpoint(¶ms);
436 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-west-2.amazonaws.com");
437 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-west-2.amazonaws.com")
438 .build());
439 }
440
441 #[test]
443 fn test_28() {
444 let params = crate::config::endpoint::Params::builder()
445 .region("us-east-1".to_string())
446 .use_fips(true)
447 .use_dual_stack(true)
448 .build().expect("invalid params");
449 let resolver = crate::config::endpoint::DefaultResolver::new();
450 let endpoint = resolver.resolve_endpoint(¶ms);
451 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-1.api.aws");
452 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-east-1.api.aws")
453 .build());
454 }
455
456 #[test]
458 fn test_29() {
459 let params = crate::config::endpoint::Params::builder()
460 .region("us-east-1".to_string())
461 .use_fips(false)
462 .use_dual_stack(true)
463 .build().expect("invalid params");
464 let resolver = crate::config::endpoint::DefaultResolver::new();
465 let endpoint = resolver.resolve_endpoint(¶ms);
466 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-1.api.aws");
467 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-east-1.api.aws")
468 .build());
469 }
470
471 #[test]
473 fn test_30() {
474 let params = crate::config::endpoint::Params::builder()
475 .region("cn-north-1".to_string())
476 .use_fips(false)
477 .use_dual_stack(false)
478 .build().expect("invalid params");
479 let resolver = crate::config::endpoint::DefaultResolver::new();
480 let endpoint = resolver.resolve_endpoint(¶ms);
481 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-north-1.amazonaws.com.cn");
482 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.cn-north-1.amazonaws.com.cn")
483 .build());
484 }
485
486 #[test]
488 fn test_31() {
489 let params = crate::config::endpoint::Params::builder()
490 .region("cn-northwest-1".to_string())
491 .use_fips(false)
492 .use_dual_stack(false)
493 .build().expect("invalid params");
494 let resolver = crate::config::endpoint::DefaultResolver::new();
495 let endpoint = resolver.resolve_endpoint(¶ms);
496 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-northwest-1.amazonaws.com.cn");
497 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.cn-northwest-1.amazonaws.com.cn")
498 .build());
499 }
500
501 #[test]
503 fn test_32() {
504 let params = crate::config::endpoint::Params::builder()
505 .region("cn-north-1".to_string())
506 .use_fips(true)
507 .use_dual_stack(true)
508 .build().expect("invalid params");
509 let resolver = crate::config::endpoint::DefaultResolver::new();
510 let endpoint = resolver.resolve_endpoint(¶ms);
511 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.cn-north-1.api.amazonwebservices.com.cn");
512 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.cn-north-1.api.amazonwebservices.com.cn")
513 .build());
514 }
515
516 #[test]
518 fn test_33() {
519 let params = crate::config::endpoint::Params::builder()
520 .region("cn-north-1".to_string())
521 .use_fips(true)
522 .use_dual_stack(false)
523 .build().expect("invalid params");
524 let resolver = crate::config::endpoint::DefaultResolver::new();
525 let endpoint = resolver.resolve_endpoint(¶ms);
526 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.cn-north-1.amazonaws.com.cn");
527 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.cn-north-1.amazonaws.com.cn")
528 .build());
529 }
530
531 #[test]
533 fn test_34() {
534 let params = crate::config::endpoint::Params::builder()
535 .region("cn-north-1".to_string())
536 .use_fips(false)
537 .use_dual_stack(true)
538 .build().expect("invalid params");
539 let resolver = crate::config::endpoint::DefaultResolver::new();
540 let endpoint = resolver.resolve_endpoint(¶ms);
541 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-north-1.api.amazonwebservices.com.cn");
542 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.cn-north-1.api.amazonwebservices.com.cn")
543 .build());
544 }
545
546 #[test]
548 fn test_35() {
549 let params = crate::config::endpoint::Params::builder()
550 .region("us-gov-east-1".to_string())
551 .use_fips(false)
552 .use_dual_stack(false)
553 .build().expect("invalid params");
554 let resolver = crate::config::endpoint::DefaultResolver::new();
555 let endpoint = resolver.resolve_endpoint(¶ms);
556 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.amazonaws.com");
557 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-gov-east-1.amazonaws.com")
558 .build());
559 }
560
561 #[test]
563 fn test_36() {
564 let params = crate::config::endpoint::Params::builder()
565 .region("us-gov-east-1".to_string())
566 .use_fips(true)
567 .use_dual_stack(false)
568 .build().expect("invalid params");
569 let resolver = crate::config::endpoint::DefaultResolver::new();
570 let endpoint = resolver.resolve_endpoint(¶ms);
571 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.amazonaws.com");
572 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-gov-east-1.amazonaws.com")
573 .build());
574 }
575
576 #[test]
578 fn test_37() {
579 let params = crate::config::endpoint::Params::builder()
580 .region("us-gov-west-1".to_string())
581 .use_fips(false)
582 .use_dual_stack(false)
583 .build().expect("invalid params");
584 let resolver = crate::config::endpoint::DefaultResolver::new();
585 let endpoint = resolver.resolve_endpoint(¶ms);
586 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-west-1.amazonaws.com");
587 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-gov-west-1.amazonaws.com")
588 .build());
589 }
590
591 #[test]
593 fn test_38() {
594 let params = crate::config::endpoint::Params::builder()
595 .region("us-gov-west-1".to_string())
596 .use_fips(true)
597 .use_dual_stack(false)
598 .build().expect("invalid params");
599 let resolver = crate::config::endpoint::DefaultResolver::new();
600 let endpoint = resolver.resolve_endpoint(¶ms);
601 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-west-1.amazonaws.com");
602 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-gov-west-1.amazonaws.com")
603 .build());
604 }
605
606 #[test]
608 fn test_39() {
609 let params = crate::config::endpoint::Params::builder()
610 .region("us-gov-east-1".to_string())
611 .use_fips(true)
612 .use_dual_stack(true)
613 .build().expect("invalid params");
614 let resolver = crate::config::endpoint::DefaultResolver::new();
615 let endpoint = resolver.resolve_endpoint(¶ms);
616 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-gov-east-1.api.aws");
617 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-gov-east-1.api.aws")
618 .build());
619 }
620
621 #[test]
623 fn test_40() {
624 let params = crate::config::endpoint::Params::builder()
625 .region("us-gov-east-1".to_string())
626 .use_fips(false)
627 .use_dual_stack(true)
628 .build().expect("invalid params");
629 let resolver = crate::config::endpoint::DefaultResolver::new();
630 let endpoint = resolver.resolve_endpoint(¶ms);
631 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.api.aws");
632 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-gov-east-1.api.aws")
633 .build());
634 }
635
636 #[test]
638 fn test_41() {
639 let params = crate::config::endpoint::Params::builder()
640 .region("us-iso-east-1".to_string())
641 .use_fips(false)
642 .use_dual_stack(false)
643 .build().expect("invalid params");
644 let resolver = crate::config::endpoint::DefaultResolver::new();
645 let endpoint = resolver.resolve_endpoint(¶ms);
646 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-iso-east-1.c2s.ic.gov");
647 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-iso-east-1.c2s.ic.gov")
648 .build());
649 }
650
651 #[test]
653 fn test_42() {
654 let params = crate::config::endpoint::Params::builder()
655 .region("us-iso-west-1".to_string())
656 .use_fips(false)
657 .use_dual_stack(false)
658 .build().expect("invalid params");
659 let resolver = crate::config::endpoint::DefaultResolver::new();
660 let endpoint = resolver.resolve_endpoint(¶ms);
661 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-iso-west-1.c2s.ic.gov");
662 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-iso-west-1.c2s.ic.gov")
663 .build());
664 }
665
666 #[test]
668 fn test_43() {
669 let params = crate::config::endpoint::Params::builder()
670 .region("us-iso-east-1".to_string())
671 .use_fips(true)
672 .use_dual_stack(false)
673 .build().expect("invalid params");
674 let resolver = crate::config::endpoint::DefaultResolver::new();
675 let endpoint = resolver.resolve_endpoint(¶ms);
676 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-iso-east-1.c2s.ic.gov");
677 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-iso-east-1.c2s.ic.gov")
678 .build());
679 }
680
681 #[test]
683 fn test_44() {
684 let params = crate::config::endpoint::Params::builder()
685 .region("us-isob-east-1".to_string())
686 .use_fips(false)
687 .use_dual_stack(false)
688 .build().expect("invalid params");
689 let resolver = crate::config::endpoint::DefaultResolver::new();
690 let endpoint = resolver.resolve_endpoint(¶ms);
691 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-isob-east-1.sc2s.sgov.gov");
692 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-isob-east-1.sc2s.sgov.gov")
693 .build());
694 }
695
696 #[test]
698 fn test_45() {
699 let params = crate::config::endpoint::Params::builder()
700 .region("us-isob-east-1".to_string())
701 .use_fips(true)
702 .use_dual_stack(false)
703 .build().expect("invalid params");
704 let resolver = crate::config::endpoint::DefaultResolver::new();
705 let endpoint = resolver.resolve_endpoint(¶ms);
706 let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-isob-east-1.sc2s.sgov.gov");
707 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts-fips.us-isob-east-1.sc2s.sgov.gov")
708 .build());
709 }
710
711 #[test]
713 fn test_46() {
714 let params = crate::config::endpoint::Params::builder()
715 .region("us-east-1".to_string())
716 .use_fips(false)
717 .use_dual_stack(false)
718 .endpoint("https://example.com".to_string())
719 .build().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://example.com");
723 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com")
724 .build());
725 }
726
727 #[test]
729 fn test_47() {
730 let params = crate::config::endpoint::Params::builder()
731 .use_fips(false)
732 .use_dual_stack(false)
733 .endpoint("https://example.com".to_string())
734 .build().expect("invalid params");
735 let resolver = crate::config::endpoint::DefaultResolver::new();
736 let endpoint = resolver.resolve_endpoint(¶ms);
737 let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
738 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com")
739 .build());
740 }
741
742 #[test]
744 fn test_48() {
745 let params = crate::config::endpoint::Params::builder()
746 .region("us-east-1".to_string())
747 .use_fips(true)
748 .use_dual_stack(false)
749 .endpoint("https://example.com".to_string())
750 .build().expect("invalid params");
751 let resolver = crate::config::endpoint::DefaultResolver::new();
752 let endpoint = resolver.resolve_endpoint(¶ms);
753 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]");
754 assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and custom endpoint are not supported")
755 }
756
757 #[test]
759 fn test_49() {
760 let params = crate::config::endpoint::Params::builder()
761 .region("us-east-1".to_string())
762 .use_fips(false)
763 .use_dual_stack(true)
764 .endpoint("https://example.com".to_string())
765 .build().expect("invalid params");
766 let resolver = crate::config::endpoint::DefaultResolver::new();
767 let endpoint = resolver.resolve_endpoint(¶ms);
768 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]");
769 assert_eq!(format!("{}", error), "Invalid Configuration: Dualstack and custom endpoint are not supported")
770 }
771
772 #[test]
774 fn test_50() {
775 let params = crate::config::endpoint::Params::builder()
776 .build().expect("invalid params");
777 let resolver = crate::config::endpoint::DefaultResolver::new();
778 let endpoint = resolver.resolve_endpoint(¶ms);
779 let error = endpoint.expect_err("expected error: Invalid Configuration: Missing Region [Missing region]");
780 assert_eq!(format!("{}", error), "Invalid Configuration: Missing Region")
781 }
782
783 #[test]
785 fn test_51() {
786 let params = crate::config::endpoint::Params::builder()
787 .region("ap-northeast-1".to_string())
788 .use_fips(false)
789 .use_dual_stack(false)
790 .use_global_endpoint(true)
791 .build().expect("invalid params");
792 let resolver = crate::config::endpoint::DefaultResolver::new();
793 let endpoint = resolver.resolve_endpoint(¶ms);
794 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
795 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
796 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
797 .put("signingName", "sts".to_string())
798 .put("signingRegion", "us-east-1".to_string())
799 )
800 .build());
801 }
802
803 #[test]
805 fn test_52() {
806 let params = crate::config::endpoint::Params::builder()
807 .region("ap-south-1".to_string())
808 .use_fips(false)
809 .use_dual_stack(false)
810 .use_global_endpoint(true)
811 .build().expect("invalid params");
812 let resolver = crate::config::endpoint::DefaultResolver::new();
813 let endpoint = resolver.resolve_endpoint(¶ms);
814 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
815 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
816 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
817 .put("signingName", "sts".to_string())
818 .put("signingRegion", "us-east-1".to_string())
819 )
820 .build());
821 }
822
823 #[test]
825 fn test_53() {
826 let params = crate::config::endpoint::Params::builder()
827 .region("ap-southeast-1".to_string())
828 .use_fips(false)
829 .use_dual_stack(false)
830 .use_global_endpoint(true)
831 .build().expect("invalid params");
832 let resolver = crate::config::endpoint::DefaultResolver::new();
833 let endpoint = resolver.resolve_endpoint(¶ms);
834 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
835 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
836 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
837 .put("signingName", "sts".to_string())
838 .put("signingRegion", "us-east-1".to_string())
839 )
840 .build());
841 }
842
843 #[test]
845 fn test_54() {
846 let params = crate::config::endpoint::Params::builder()
847 .region("ap-southeast-2".to_string())
848 .use_fips(false)
849 .use_dual_stack(false)
850 .use_global_endpoint(true)
851 .build().expect("invalid params");
852 let resolver = crate::config::endpoint::DefaultResolver::new();
853 let endpoint = resolver.resolve_endpoint(¶ms);
854 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
855 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
856 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
857 .put("signingName", "sts".to_string())
858 .put("signingRegion", "us-east-1".to_string())
859 )
860 .build());
861 }
862
863 #[test]
865 fn test_55() {
866 let params = crate::config::endpoint::Params::builder()
867 .region("aws-global".to_string())
868 .use_fips(false)
869 .use_dual_stack(false)
870 .use_global_endpoint(true)
871 .build().expect("invalid params");
872 let resolver = crate::config::endpoint::DefaultResolver::new();
873 let endpoint = resolver.resolve_endpoint(¶ms);
874 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
875 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
876 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
877 .put("signingName", "sts".to_string())
878 .put("signingRegion", "us-east-1".to_string())
879 )
880 .build());
881 }
882
883 #[test]
885 fn test_56() {
886 let params = crate::config::endpoint::Params::builder()
887 .region("ca-central-1".to_string())
888 .use_fips(false)
889 .use_dual_stack(false)
890 .use_global_endpoint(true)
891 .build().expect("invalid params");
892 let resolver = crate::config::endpoint::DefaultResolver::new();
893 let endpoint = resolver.resolve_endpoint(¶ms);
894 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
895 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
896 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
897 .put("signingName", "sts".to_string())
898 .put("signingRegion", "us-east-1".to_string())
899 )
900 .build());
901 }
902
903 #[test]
905 fn test_57() {
906 let params = crate::config::endpoint::Params::builder()
907 .region("eu-central-1".to_string())
908 .use_fips(false)
909 .use_dual_stack(false)
910 .use_global_endpoint(true)
911 .build().expect("invalid params");
912 let resolver = crate::config::endpoint::DefaultResolver::new();
913 let endpoint = resolver.resolve_endpoint(¶ms);
914 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
915 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
916 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
917 .put("signingName", "sts".to_string())
918 .put("signingRegion", "us-east-1".to_string())
919 )
920 .build());
921 }
922
923 #[test]
925 fn test_58() {
926 let params = crate::config::endpoint::Params::builder()
927 .region("eu-north-1".to_string())
928 .use_fips(false)
929 .use_dual_stack(false)
930 .use_global_endpoint(true)
931 .build().expect("invalid params");
932 let resolver = crate::config::endpoint::DefaultResolver::new();
933 let endpoint = resolver.resolve_endpoint(¶ms);
934 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
935 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
936 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
937 .put("signingName", "sts".to_string())
938 .put("signingRegion", "us-east-1".to_string())
939 )
940 .build());
941 }
942
943 #[test]
945 fn test_59() {
946 let params = crate::config::endpoint::Params::builder()
947 .region("eu-west-1".to_string())
948 .use_fips(false)
949 .use_dual_stack(false)
950 .use_global_endpoint(true)
951 .build().expect("invalid params");
952 let resolver = crate::config::endpoint::DefaultResolver::new();
953 let endpoint = resolver.resolve_endpoint(¶ms);
954 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
955 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
956 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
957 .put("signingName", "sts".to_string())
958 .put("signingRegion", "us-east-1".to_string())
959 )
960 .build());
961 }
962
963 #[test]
965 fn test_60() {
966 let params = crate::config::endpoint::Params::builder()
967 .region("eu-west-2".to_string())
968 .use_fips(false)
969 .use_dual_stack(false)
970 .use_global_endpoint(true)
971 .build().expect("invalid params");
972 let resolver = crate::config::endpoint::DefaultResolver::new();
973 let endpoint = resolver.resolve_endpoint(¶ms);
974 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
975 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
976 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
977 .put("signingName", "sts".to_string())
978 .put("signingRegion", "us-east-1".to_string())
979 )
980 .build());
981 }
982
983 #[test]
985 fn test_61() {
986 let params = crate::config::endpoint::Params::builder()
987 .region("eu-west-3".to_string())
988 .use_fips(false)
989 .use_dual_stack(false)
990 .use_global_endpoint(true)
991 .build().expect("invalid params");
992 let resolver = crate::config::endpoint::DefaultResolver::new();
993 let endpoint = resolver.resolve_endpoint(¶ms);
994 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
995 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
996 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
997 .put("signingName", "sts".to_string())
998 .put("signingRegion", "us-east-1".to_string())
999 )
1000 .build());
1001 }
1002
1003 #[test]
1005 fn test_62() {
1006 let params = crate::config::endpoint::Params::builder()
1007 .region("sa-east-1".to_string())
1008 .use_fips(false)
1009 .use_dual_stack(false)
1010 .use_global_endpoint(true)
1011 .build().expect("invalid params");
1012 let resolver = crate::config::endpoint::DefaultResolver::new();
1013 let endpoint = resolver.resolve_endpoint(¶ms);
1014 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1015 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
1016 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1017 .put("signingName", "sts".to_string())
1018 .put("signingRegion", "us-east-1".to_string())
1019 )
1020 .build());
1021 }
1022
1023 #[test]
1025 fn test_63() {
1026 let params = crate::config::endpoint::Params::builder()
1027 .region("us-east-1".to_string())
1028 .use_fips(false)
1029 .use_dual_stack(false)
1030 .use_global_endpoint(true)
1031 .build().expect("invalid params");
1032 let resolver = crate::config::endpoint::DefaultResolver::new();
1033 let endpoint = resolver.resolve_endpoint(¶ms);
1034 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1035 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
1036 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1037 .put("signingName", "sts".to_string())
1038 .put("signingRegion", "us-east-1".to_string())
1039 )
1040 .build());
1041 }
1042
1043 #[test]
1045 fn test_64() {
1046 let params = crate::config::endpoint::Params::builder()
1047 .region("us-east-2".to_string())
1048 .use_fips(false)
1049 .use_dual_stack(false)
1050 .use_global_endpoint(true)
1051 .build().expect("invalid params");
1052 let resolver = crate::config::endpoint::DefaultResolver::new();
1053 let endpoint = resolver.resolve_endpoint(¶ms);
1054 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1055 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
1056 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1057 .put("signingName", "sts".to_string())
1058 .put("signingRegion", "us-east-1".to_string())
1059 )
1060 .build());
1061 }
1062
1063 #[test]
1065 fn test_65() {
1066 let params = crate::config::endpoint::Params::builder()
1067 .region("us-west-1".to_string())
1068 .use_fips(false)
1069 .use_dual_stack(false)
1070 .use_global_endpoint(true)
1071 .build().expect("invalid params");
1072 let resolver = crate::config::endpoint::DefaultResolver::new();
1073 let endpoint = resolver.resolve_endpoint(¶ms);
1074 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1075 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
1076 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1077 .put("signingName", "sts".to_string())
1078 .put("signingRegion", "us-east-1".to_string())
1079 )
1080 .build());
1081 }
1082
1083 #[test]
1085 fn test_66() {
1086 let params = crate::config::endpoint::Params::builder()
1087 .region("us-west-2".to_string())
1088 .use_fips(false)
1089 .use_dual_stack(false)
1090 .use_global_endpoint(true)
1091 .build().expect("invalid params");
1092 let resolver = crate::config::endpoint::DefaultResolver::new();
1093 let endpoint = resolver.resolve_endpoint(¶ms);
1094 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1095 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com")
1096 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1097 .put("signingName", "sts".to_string())
1098 .put("signingRegion", "us-east-1".to_string())
1099 )
1100 .build());
1101 }
1102
1103 #[test]
1105 fn test_67() {
1106 let params = crate::config::endpoint::Params::builder()
1107 .region("us-east-3".to_string())
1108 .use_fips(false)
1109 .use_dual_stack(false)
1110 .use_global_endpoint(true)
1111 .build().expect("invalid params");
1112 let resolver = crate::config::endpoint::DefaultResolver::new();
1113 let endpoint = resolver.resolve_endpoint(¶ms);
1114 let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-3.amazonaws.com");
1115 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.us-east-3.amazonaws.com")
1116 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1117 .put("signingName", "sts".to_string())
1118 .put("signingRegion", "us-east-3".to_string())
1119 )
1120 .build());
1121 }
1122
1123 #[test]
1125 fn test_68() {
1126 let params = crate::config::endpoint::Params::builder()
1127 .region("us-west-1".to_string())
1128 .use_fips(false)
1129 .use_dual_stack(false)
1130 .use_global_endpoint(true)
1131 .endpoint("https://example.com".to_string())
1132 .build().expect("invalid params");
1133 let resolver = crate::config::endpoint::DefaultResolver::new();
1134 let endpoint = resolver.resolve_endpoint(¶ms);
1135 let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1136 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com")
1137 .build());
1138 }
1139
1140 #[test]
1142 fn test_69() {
1143 let params = crate::config::endpoint::Params::builder()
1144 .use_fips(false)
1145 .use_dual_stack(false)
1146 .use_global_endpoint(false)
1147 .endpoint("https://example.com".to_string())
1148 .build().expect("invalid params");
1149 let resolver = crate::config::endpoint::DefaultResolver::new();
1150 let endpoint = resolver.resolve_endpoint(¶ms);
1151 let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1152 assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com")
1153 .build());
1154 }
1155
1156
1157}
1158
1159pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
1161 fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
1163
1164 fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
1168 where
1169 Self: Sized + 'static,
1170 {
1171 ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
1172 }
1173 }
1174
1175 #[derive(Debug)]
1176 struct DowncastParams<T>(T);
1177 impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
1178 where
1179 T: ResolveEndpoint,
1180 {
1181 fn resolve_endpoint<'a>(&'a self, params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
1182 let ep = match params.get::<crate::config::endpoint::Params>() {
1183 Some(params) => self.0.resolve_endpoint(params),
1184 None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
1185 };
1186 ep
1187 }
1188
1189 }
1190
1191#[derive(Debug)]
1192 pub struct DefaultResolver {
1194 partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
1195 endpoint_cache: ::arc_swap::ArcSwap<::std::option::Option<(Params, ::aws_smithy_types::endpoint::Endpoint)>>,
1196 }
1197
1198 impl Default for DefaultResolver {
1199 fn default() -> Self {
1200 Self::new()
1201 }
1202 }
1203
1204 impl DefaultResolver {
1205 pub fn new() -> Self {
1207 Self {
1208 partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
1209 endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
1210 }
1211 }
1212
1213 #[allow(unused_variables, unused_parens, clippy::double_parens, clippy::useless_conversion, clippy::bool_comparison, clippy::comparison_to_empty, clippy::needless_borrow, clippy::useless_asref, clippy::redundant_closure_call, clippy::clone_on_copy, clippy::single_char_add_str)]
1214 fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
1215 let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
1216 #[allow(unused_mut)]
1217 let mut context = ConditionContext::default();
1218
1219 let region = ¶ms.region;
1221let use_dual_stack = ¶ms.use_dual_stack;
1222let use_fips = ¶ms.use_fips;
1223let endpoint = ¶ms.endpoint;
1224let use_global_endpoint = ¶ms.use_global_endpoint;
1225
1226 let mut current_ref: i32 = 2;
1227 loop {
1228 match current_ref {
1229 ref_val if ref_val >= 100_000_000 => {
1230 return match (ref_val - 100_000_000) as usize {
1231 0 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched")) as ::aws_smithy_runtime_api::box_error::BoxError),
12321 => {
1233
1234 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url("https://sts.amazonaws.com"
1235.to_string())
1236.auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4"
1237.to_string(), 2)
1238.put("signingName", "sts")
1239.put("signingRegion", "us-east-1")
1240)
1241.build())
1242 },
12432 => {
1244 let region = params.region.as_deref().unwrap_or_default();
1245let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1246 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1247out.push_str("https://sts.");
1248#[allow(clippy::needless_borrow)]
1249out.push_str(®ion.as_ref());
1250out.push_str(".");
1251#[allow(clippy::needless_borrow)]
1252out.push_str(&partition_result.dns_suffix());
1253out })
1254.auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4"
1255.to_string(), 2)
1256.put("signingName", "sts")
1257.put("signingRegion", region.as_ref())
1258)
1259.build())
1260 },
12613 => {
1262
1263 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: FIPS and custom endpoint are not supported"
1264.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1265 },
12664 => {
1267
1268 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: Dualstack and custom endpoint are not supported"
1269.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1270 },
12715 => {
1272 let endpoint = params.endpoint.as_deref().unwrap_or_default();
1273 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url(endpoint.to_owned())
1274.build())
1275 },
12766 => {
1277 let region = params.region.as_deref().unwrap_or_default();
1278let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1279 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1280out.push_str("https://sts-fips.");
1281#[allow(clippy::needless_borrow)]
1282out.push_str(®ion.as_ref());
1283out.push_str(".");
1284#[allow(clippy::needless_borrow)]
1285out.push_str(&partition_result.dual_stack_dns_suffix());
1286out })
1287.build())
1288 },
12897 => {
1290
1291 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("FIPS and DualStack are enabled, but this partition does not support one or both"
1292.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1293 },
12948 => {
1295 let region = params.region.as_deref().unwrap_or_default();
1296 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1297out.push_str("https://sts.");
1298#[allow(clippy::needless_borrow)]
1299out.push_str(®ion.as_ref());
1300out.push_str(".amazonaws.com");
1301out })
1302.build())
1303 },
13049 => {
1305 let region = params.region.as_deref().unwrap_or_default();
1306let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1307 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1308out.push_str("https://sts-fips.");
1309#[allow(clippy::needless_borrow)]
1310out.push_str(®ion.as_ref());
1311out.push_str(".");
1312#[allow(clippy::needless_borrow)]
1313out.push_str(&partition_result.dns_suffix());
1314out })
1315.build())
1316 },
131710 => {
1318
1319 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("FIPS is enabled but this partition does not support FIPS"
1320.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1321 },
132211 => {
1323 let region = params.region.as_deref().unwrap_or_default();
1324let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1325 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1326out.push_str("https://sts.");
1327#[allow(clippy::needless_borrow)]
1328out.push_str(®ion.as_ref());
1329out.push_str(".");
1330#[allow(clippy::needless_borrow)]
1331out.push_str(&partition_result.dual_stack_dns_suffix());
1332out })
1333.build())
1334 },
133512 => {
1336
1337 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("DualStack is enabled but this partition does not support DualStack"
1338.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1339 },
134013 => {
1341 let region = params.region.as_deref().unwrap_or_default();
1342let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1343 ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
1344out.push_str("https://sts.");
1345#[allow(clippy::needless_borrow)]
1346out.push_str(®ion.as_ref());
1347out.push_str(".");
1348#[allow(clippy::needless_borrow)]
1349out.push_str(&partition_result.dns_suffix());
1350out })
1351.build())
1352 },
135314 => {
1354
1355 ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: Missing Region"
1356.to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
1357 },
1358 _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched")) as ::aws_smithy_runtime_api::box_error::BoxError),
1359 };
1360 }
1361 1 | -1 => return ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched")) as ::aws_smithy_runtime_api::box_error::BoxError),
1362 ref_val => {
1363 let is_complement = ref_val < 0;
1364 let node = &NODES[(ref_val.unsigned_abs() as usize) - 1];
1365 let condition_result = match node.condition_index {
1366 0 => endpoint.is_some(),
13671 => region.is_some(),
13682 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1369 let partition_result = &mut context.partition_result;
1370 let partition_resolver = &self.partition_resolver;
1371 {
1372 *partition_result = partition_resolver.resolve_partition(if let Some(param) = region{
1373 param
1374 } else {
1375 return false
1376 }, _diagnostic_collector).map(|inner| inner.into());
1377 partition_result.is_some()
1378}
1379 })(&mut _diagnostic_collector),
13803 => (use_fips) == (&true),
13814 => (use_dual_stack) == (&true),
13825 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1383
1384 let partition_resolver = &self.partition_resolver;
1385 (region)
1386==
1387&mut Some(
1388 ("aws-global"
1389 .to_string().into())
1390)
1391 })(&mut _diagnostic_collector),
13926 => (use_global_endpoint) == (&true),
13937 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1394
1395 let partition_resolver = &self.partition_resolver;
1396 (region)
1397==
1398&mut Some(
1399 ("eu-central-1"
1400 .to_string().into())
1401)
1402 })(&mut _diagnostic_collector),
14038 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1404 let partition_result = & context.partition_result;
1405 let partition_resolver = &self.partition_resolver;
1406 (if let Some(inner) = partition_result {
1407 inner.supports_dual_stack()
1408}else{
1409 return false
1410})
1411==
1412(true)
1413 })(&mut _diagnostic_collector),
14149 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1415 let partition_result = & context.partition_result;
1416 let partition_resolver = &self.partition_resolver;
1417 (if let Some(inner) = partition_result {
1418 inner.supports_fips()
1419}else{
1420 return false
1421})
1422==
1423(true)
1424 })(&mut _diagnostic_collector),
142510 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1426
1427 let partition_resolver = &self.partition_resolver;
1428 (region)
1429==
1430&mut Some(
1431 ("ap-south-1"
1432 .to_string().into())
1433)
1434 })(&mut _diagnostic_collector),
143511 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1436
1437 let partition_resolver = &self.partition_resolver;
1438 (region)
1439==
1440&mut Some(
1441 ("eu-north-1"
1442 .to_string().into())
1443)
1444 })(&mut _diagnostic_collector),
144512 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1446
1447 let partition_resolver = &self.partition_resolver;
1448 (region)
1449==
1450&mut Some(
1451 ("eu-west-1"
1452 .to_string().into())
1453)
1454 })(&mut _diagnostic_collector),
145513 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1456
1457 let partition_resolver = &self.partition_resolver;
1458 (region)
1459==
1460&mut Some(
1461 ("eu-west-2"
1462 .to_string().into())
1463)
1464 })(&mut _diagnostic_collector),
146514 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1466
1467 let partition_resolver = &self.partition_resolver;
1468 (region)
1469==
1470&mut Some(
1471 ("eu-west-3"
1472 .to_string().into())
1473)
1474 })(&mut _diagnostic_collector),
147515 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1476
1477 let partition_resolver = &self.partition_resolver;
1478 (region)
1479==
1480&mut Some(
1481 ("sa-east-1"
1482 .to_string().into())
1483)
1484 })(&mut _diagnostic_collector),
148516 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1486
1487 let partition_resolver = &self.partition_resolver;
1488 (region)
1489==
1490&mut Some(
1491 ("us-east-1"
1492 .to_string().into())
1493)
1494 })(&mut _diagnostic_collector),
149517 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1496
1497 let partition_resolver = &self.partition_resolver;
1498 (region)
1499==
1500&mut Some(
1501 ("us-east-2"
1502 .to_string().into())
1503)
1504 })(&mut _diagnostic_collector),
150518 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1506
1507 let partition_resolver = &self.partition_resolver;
1508 (region)
1509==
1510&mut Some(
1511 ("us-west-2"
1512 .to_string().into())
1513)
1514 })(&mut _diagnostic_collector),
151519 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1516
1517 let partition_resolver = &self.partition_resolver;
1518 (region)
1519==
1520&mut Some(
1521 ("us-west-1"
1522 .to_string().into())
1523)
1524 })(&mut _diagnostic_collector),
152520 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1526
1527 let partition_resolver = &self.partition_resolver;
1528 (region)
1529==
1530&mut Some(
1531 ("ca-central-1"
1532 .to_string().into())
1533)
1534 })(&mut _diagnostic_collector),
153521 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1536
1537 let partition_resolver = &self.partition_resolver;
1538 (region)
1539==
1540&mut Some(
1541 ("ap-southeast-1"
1542 .to_string().into())
1543)
1544 })(&mut _diagnostic_collector),
154522 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1546
1547 let partition_resolver = &self.partition_resolver;
1548 (region)
1549==
1550&mut Some(
1551 ("ap-northeast-1"
1552 .to_string().into())
1553)
1554 })(&mut _diagnostic_collector),
155523 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1556
1557 let partition_resolver = &self.partition_resolver;
1558 (region)
1559==
1560&mut Some(
1561 ("ap-southeast-2"
1562 .to_string().into())
1563)
1564 })(&mut _diagnostic_collector),
156524 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1566 let partition_result = & context.partition_result;
1567 let partition_resolver = &self.partition_resolver;
1568 (if let Some(inner) = partition_result {
1569 inner.name()
1570}else{
1571 return false
1572})
1573==
1574("aws-us-gov")
1575 })(&mut _diagnostic_collector),
1576 _ => unreachable!("Invalid condition index"),
1577 };
1578 current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
1579 }
1580 }
1581 }
1582 }
1583 }
1584
1585 impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
1586 fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
1587 let cached = self.endpoint_cache.load();
1589 if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
1590 if cached_params == params {
1591 return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
1592 }
1593 }
1594 drop(cached);
1595 let result = self.resolve_endpoint(params);
1596 if let ::std::result::Result::Ok(ref endpoint) = result {
1597 self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
1598 }
1599 ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
1600 }
1601 }
1602 const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 31] = [
1603crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: -1, high_ref: 1, low_ref: -1 },
1604crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 0, high_ref: 30, low_ref: 3 },
1605crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 1, high_ref: 4, low_ref: 100000014 },
1606crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 2, high_ref: 5, low_ref: 100000014 },
1607crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 3, high_ref: 25, low_ref: 6 },
1608crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 4, high_ref: 24, low_ref: 7 },
1609crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 5, high_ref: 100000001, low_ref: 8 },
1610crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 6, high_ref: 9, low_ref: 100000013 },
1611crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 7, high_ref: 100000001, low_ref: 10 },
1612crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 10, high_ref: 100000001, low_ref: 11 },
1613crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 11, high_ref: 100000001, low_ref: 12 },
1614crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 12, high_ref: 100000001, low_ref: 13 },
1615crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 13, high_ref: 100000001, low_ref: 14 },
1616crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 14, high_ref: 100000001, low_ref: 15 },
1617crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 15, high_ref: 100000001, low_ref: 16 },
1618crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 16, high_ref: 100000001, low_ref: 17 },
1619crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 17, high_ref: 100000001, low_ref: 18 },
1620crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 18, high_ref: 100000001, low_ref: 19 },
1621crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 19, high_ref: 100000001, low_ref: 20 },
1622crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 20, high_ref: 100000001, low_ref: 21 },
1623crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 21, high_ref: 100000001, low_ref: 22 },
1624crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 22, high_ref: 100000001, low_ref: 23 },
1625crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 23, high_ref: 100000001, low_ref: 100000002 },
1626crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 8, high_ref: 100000011, low_ref: 100000012 },
1627crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 4, high_ref: 28, low_ref: 26 },
1628crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 9, high_ref: 27, low_ref: 100000010 },
1629crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 24, high_ref: 100000008, low_ref: 100000009 },
1630crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 8, high_ref: 29, low_ref: 100000007 },
1631crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 9, high_ref: 100000006, low_ref: 100000007 },
1632crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 3, high_ref: 100000003, low_ref: 31 },
1633crate::endpoint_lib::bdd_interpreter::BddNode { condition_index: 4, high_ref: 100000004, low_ref: 100000005 }
1634];
1635 #[derive(Default)]
1638#[allow(unused_lifetimes)]
1639pub(crate) struct ConditionContext<'a> {
1640 pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
1641 phantom: std::marker::PhantomData<&'a ()>
1643}
1644
1645#[non_exhaustive]
1646#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
1647pub struct Params {
1649 pub(crate) region: ::std::option::Option<::std::string::String>,
1651 pub(crate) use_dual_stack: bool,
1653 pub(crate) use_fips: bool,
1655 pub(crate) endpoint: ::std::option::Option<::std::string::String>,
1657 pub(crate) use_global_endpoint: bool,
1659}
1660impl Params {
1661 pub fn builder() -> crate::config::endpoint::ParamsBuilder {
1663 crate::config::endpoint::ParamsBuilder::default()
1664 }
1665 pub fn region(&self) -> ::std::option::Option<&str> {
1667 self.region.as_deref()
1668 }
1669 pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
1671 Some(self.use_dual_stack)
1672 }
1673 pub fn use_fips(&self) -> ::std::option::Option<bool> {
1675 Some(self.use_fips)
1676 }
1677 pub fn endpoint(&self) -> ::std::option::Option<&str> {
1679 self.endpoint.as_deref()
1680 }
1681 pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
1683 Some(self.use_global_endpoint)
1684 }
1685}
1686
1687#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
1689pub struct ParamsBuilder {
1690 region: ::std::option::Option<::std::string::String>,
1691 use_dual_stack: ::std::option::Option<bool>,
1692 use_fips: ::std::option::Option<bool>,
1693 endpoint: ::std::option::Option<::std::string::String>,
1694 use_global_endpoint: ::std::option::Option<bool>,
1695}
1696impl ParamsBuilder {
1697 pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
1699 if let Some(region) = &self.region {
1700 if !crate::endpoint_lib::host::is_valid_host_label(region.as_ref() as &str, true, &mut crate::endpoint_lib::diagnostic::DiagnosticCollector::new()) {
1701 return Err(crate::config::endpoint::InvalidParams::invalid_value("region", "must be a valid host label"))
1702 }
1703 };
1704 Ok(#[allow(clippy::unnecessary_lazy_evaluations)]
1705 crate::config::endpoint::Params {
1706 region: self.region
1707 ,
1708 use_dual_stack: self.use_dual_stack
1709 .or_else(||Some(false))
1710 .ok_or_else(||crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?
1711 ,
1712 use_fips: self.use_fips
1713 .or_else(||Some(false))
1714 .ok_or_else(||crate::config::endpoint::InvalidParams::missing("use_fips"))?
1715 ,
1716 endpoint: self.endpoint
1717 ,
1718 use_global_endpoint: self.use_global_endpoint
1719 .or_else(||Some(false))
1720 .ok_or_else(||crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?
1721 ,
1722 })
1723 }
1724 pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
1728 self.region = Some(value.into());
1729 self
1730 }
1731
1732 pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
1736 self.region = param;
1737 self
1738 }
1739 pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
1744 self.use_dual_stack = Some(value.into());
1745 self
1746 }
1747
1748 pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
1753 self.use_dual_stack = param;
1754 self
1755 }
1756 pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
1761 self.use_fips = Some(value.into());
1762 self
1763 }
1764
1765 pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
1770 self.use_fips = param;
1771 self
1772 }
1773 pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
1777 self.endpoint = Some(value.into());
1778 self
1779 }
1780
1781 pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
1785 self.endpoint = param;
1786 self
1787 }
1788 pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
1793 self.use_global_endpoint = Some(value.into());
1794 self
1795 }
1796
1797 pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
1802 self.use_global_endpoint = param;
1803 self
1804 }
1805}
1806
1807#[derive(Debug)]
1809 pub struct InvalidParams {
1810 field: std::borrow::Cow<'static, str>,
1811 kind: InvalidParamsErrorKind,
1812 }
1813
1814 #[derive(Debug)]
1816 enum InvalidParamsErrorKind {
1817 MissingField,
1818 InvalidValue {
1819 message: &'static str,
1820 }
1821 }
1822
1823 impl InvalidParams {
1824 #[allow(dead_code)]
1825 fn missing(field: &'static str) -> Self {
1826 Self { field: field.into(), kind: InvalidParamsErrorKind::MissingField }
1827 }
1828
1829 #[allow(dead_code)]
1830 fn invalid_value(field: &'static str, message: &'static str) -> Self {
1831 Self { field: field.into(), kind: InvalidParamsErrorKind::InvalidValue { message }}
1832 }
1833 }
1834
1835 impl std::fmt::Display for InvalidParams {
1836 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1837 match self.kind {
1838 InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
1839 InvalidParamsErrorKind::InvalidValue { message} => write!(f, "invalid value for field: `{}` - {}", self.field, message),
1840 }
1841 }
1842 }
1843
1844 impl std::error::Error for InvalidParams { }
1845