github.com/aavshr/aws-sdk-go@v1.41.3/aws/session/env_config_test.go (about) 1 //go:build go1.7 2 // +build go1.7 3 4 package session 5 6 import ( 7 "os" 8 "reflect" 9 "strconv" 10 "testing" 11 12 "github.com/aavshr/aws-sdk-go/aws/credentials" 13 "github.com/aavshr/aws-sdk-go/aws/endpoints" 14 "github.com/aavshr/aws-sdk-go/awstesting" 15 "github.com/aavshr/aws-sdk-go/internal/sdktesting" 16 "github.com/aavshr/aws-sdk-go/internal/shareddefaults" 17 ) 18 19 func TestLoadEnvConfig_Creds(t *testing.T) { 20 cases := []struct { 21 Env map[string]string 22 Val credentials.Value 23 }{ 24 { 25 Env: map[string]string{ 26 "AWS_ACCESS_KEY": "AKID", 27 }, 28 Val: credentials.Value{}, 29 }, 30 { 31 Env: map[string]string{ 32 "AWS_ACCESS_KEY_ID": "AKID", 33 }, 34 Val: credentials.Value{}, 35 }, 36 { 37 Env: map[string]string{ 38 "AWS_SECRET_KEY": "SECRET", 39 }, 40 Val: credentials.Value{}, 41 }, 42 { 43 Env: map[string]string{ 44 "AWS_SECRET_ACCESS_KEY": "SECRET", 45 }, 46 Val: credentials.Value{}, 47 }, 48 { 49 Env: map[string]string{ 50 "AWS_ACCESS_KEY_ID": "AKID", 51 "AWS_SECRET_ACCESS_KEY": "SECRET", 52 }, 53 Val: credentials.Value{ 54 AccessKeyID: "AKID", SecretAccessKey: "SECRET", 55 ProviderName: "EnvConfigCredentials", 56 }, 57 }, 58 { 59 Env: map[string]string{ 60 "AWS_ACCESS_KEY": "AKID", 61 "AWS_SECRET_KEY": "SECRET", 62 }, 63 Val: credentials.Value{ 64 AccessKeyID: "AKID", SecretAccessKey: "SECRET", 65 ProviderName: "EnvConfigCredentials", 66 }, 67 }, 68 { 69 Env: map[string]string{ 70 "AWS_ACCESS_KEY": "AKID", 71 "AWS_SECRET_KEY": "SECRET", 72 "AWS_SESSION_TOKEN": "TOKEN", 73 }, 74 Val: credentials.Value{ 75 AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "TOKEN", 76 ProviderName: "EnvConfigCredentials", 77 }, 78 }, 79 } 80 81 for i, c := range cases { 82 t.Run(strconv.Itoa(i), func(t *testing.T) { 83 restoreEnvFn := sdktesting.StashEnv() 84 defer restoreEnvFn() 85 for k, v := range c.Env { 86 os.Setenv(k, v) 87 } 88 89 cfg, err := loadEnvConfig() 90 if err != nil { 91 t.Fatalf("failed to load env config, %v", err) 92 } 93 if !reflect.DeepEqual(c.Val, cfg.Creds) { 94 t.Errorf("expect credentials to match.\n%s", 95 awstesting.SprintExpectActual(c.Val, cfg.Creds)) 96 } 97 }) 98 99 } 100 } 101 102 func TestLoadEnvConfig(t *testing.T) { 103 restoreEnvFn := sdktesting.StashEnv() 104 defer restoreEnvFn() 105 106 cases := []struct { 107 Env map[string]string 108 UseSharedConfigCall bool 109 Config envConfig 110 WantErr bool 111 }{ 112 0: { 113 Env: map[string]string{ 114 "AWS_REGION": "region", 115 "AWS_PROFILE": "profile", 116 }, 117 Config: envConfig{ 118 Region: "region", Profile: "profile", 119 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 120 SharedConfigFile: shareddefaults.SharedConfigFilename(), 121 }, 122 }, 123 1: { 124 Env: map[string]string{ 125 "AWS_REGION": "region", 126 "AWS_DEFAULT_REGION": "default_region", 127 "AWS_PROFILE": "profile", 128 "AWS_DEFAULT_PROFILE": "default_profile", 129 }, 130 Config: envConfig{ 131 Region: "region", Profile: "profile", 132 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 133 SharedConfigFile: shareddefaults.SharedConfigFilename(), 134 }, 135 }, 136 2: { 137 Env: map[string]string{ 138 "AWS_REGION": "region", 139 "AWS_DEFAULT_REGION": "default_region", 140 "AWS_PROFILE": "profile", 141 "AWS_DEFAULT_PROFILE": "default_profile", 142 "AWS_SDK_LOAD_CONFIG": "1", 143 }, 144 Config: envConfig{ 145 Region: "region", Profile: "profile", 146 EnableSharedConfig: true, 147 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 148 SharedConfigFile: shareddefaults.SharedConfigFilename(), 149 }, 150 }, 151 3: { 152 Env: map[string]string{ 153 "AWS_DEFAULT_REGION": "default_region", 154 "AWS_DEFAULT_PROFILE": "default_profile", 155 }, 156 Config: envConfig{ 157 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 158 SharedConfigFile: shareddefaults.SharedConfigFilename(), 159 }, 160 }, 161 4: { 162 Env: map[string]string{ 163 "AWS_DEFAULT_REGION": "default_region", 164 "AWS_DEFAULT_PROFILE": "default_profile", 165 "AWS_SDK_LOAD_CONFIG": "1", 166 }, 167 Config: envConfig{ 168 Region: "default_region", Profile: "default_profile", 169 EnableSharedConfig: true, 170 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 171 SharedConfigFile: shareddefaults.SharedConfigFilename(), 172 }, 173 }, 174 5: { 175 Env: map[string]string{ 176 "AWS_REGION": "region", 177 "AWS_PROFILE": "profile", 178 }, 179 Config: envConfig{ 180 Region: "region", Profile: "profile", 181 EnableSharedConfig: true, 182 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 183 SharedConfigFile: shareddefaults.SharedConfigFilename(), 184 }, 185 UseSharedConfigCall: true, 186 }, 187 6: { 188 Env: map[string]string{ 189 "AWS_REGION": "region", 190 "AWS_DEFAULT_REGION": "default_region", 191 "AWS_PROFILE": "profile", 192 "AWS_DEFAULT_PROFILE": "default_profile", 193 }, 194 Config: envConfig{ 195 Region: "region", Profile: "profile", 196 EnableSharedConfig: true, 197 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 198 SharedConfigFile: shareddefaults.SharedConfigFilename(), 199 }, 200 UseSharedConfigCall: true, 201 }, 202 7: { 203 Env: map[string]string{ 204 "AWS_REGION": "region", 205 "AWS_DEFAULT_REGION": "default_region", 206 "AWS_PROFILE": "profile", 207 "AWS_DEFAULT_PROFILE": "default_profile", 208 "AWS_SDK_LOAD_CONFIG": "1", 209 }, 210 Config: envConfig{ 211 Region: "region", Profile: "profile", 212 EnableSharedConfig: true, 213 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 214 SharedConfigFile: shareddefaults.SharedConfigFilename(), 215 }, 216 UseSharedConfigCall: true, 217 }, 218 8: { 219 Env: map[string]string{ 220 "AWS_DEFAULT_REGION": "default_region", 221 "AWS_DEFAULT_PROFILE": "default_profile", 222 }, 223 Config: envConfig{ 224 Region: "default_region", Profile: "default_profile", 225 EnableSharedConfig: true, 226 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 227 SharedConfigFile: shareddefaults.SharedConfigFilename(), 228 }, 229 UseSharedConfigCall: true, 230 }, 231 9: { 232 Env: map[string]string{ 233 "AWS_DEFAULT_REGION": "default_region", 234 "AWS_DEFAULT_PROFILE": "default_profile", 235 "AWS_SDK_LOAD_CONFIG": "1", 236 }, 237 Config: envConfig{ 238 Region: "default_region", Profile: "default_profile", 239 EnableSharedConfig: true, 240 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 241 SharedConfigFile: shareddefaults.SharedConfigFilename(), 242 }, 243 UseSharedConfigCall: true, 244 }, 245 10: { 246 Env: map[string]string{ 247 "AWS_CA_BUNDLE": "custom_ca_bundle", 248 }, 249 Config: envConfig{ 250 CustomCABundle: "custom_ca_bundle", 251 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 252 SharedConfigFile: shareddefaults.SharedConfigFilename(), 253 }, 254 }, 255 11: { 256 Env: map[string]string{ 257 "AWS_CA_BUNDLE": "custom_ca_bundle", 258 }, 259 Config: envConfig{ 260 CustomCABundle: "custom_ca_bundle", 261 EnableSharedConfig: true, 262 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 263 SharedConfigFile: shareddefaults.SharedConfigFilename(), 264 }, 265 UseSharedConfigCall: true, 266 }, 267 12: { 268 Env: map[string]string{ 269 "AWS_SDK_GO_CLIENT_TLS_CERT": "client_tls_cert", 270 }, 271 Config: envConfig{ 272 ClientTLSCert: "client_tls_cert", 273 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 274 SharedConfigFile: shareddefaults.SharedConfigFilename(), 275 }, 276 }, 277 13: { 278 Env: map[string]string{ 279 "AWS_SDK_GO_CLIENT_TLS_CERT": "client_tls_cert", 280 }, 281 Config: envConfig{ 282 ClientTLSCert: "client_tls_cert", 283 EnableSharedConfig: true, 284 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 285 SharedConfigFile: shareddefaults.SharedConfigFilename(), 286 }, 287 UseSharedConfigCall: true, 288 }, 289 14: { 290 Env: map[string]string{ 291 "AWS_SDK_GO_CLIENT_TLS_KEY": "client_tls_key", 292 }, 293 Config: envConfig{ 294 ClientTLSKey: "client_tls_key", 295 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 296 SharedConfigFile: shareddefaults.SharedConfigFilename(), 297 }, 298 }, 299 15: { 300 Env: map[string]string{ 301 "AWS_SDK_GO_CLIENT_TLS_KEY": "client_tls_key", 302 }, 303 Config: envConfig{ 304 ClientTLSKey: "client_tls_key", 305 EnableSharedConfig: true, 306 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 307 SharedConfigFile: shareddefaults.SharedConfigFilename(), 308 }, 309 UseSharedConfigCall: true, 310 }, 311 16: { 312 Env: map[string]string{ 313 "AWS_SHARED_CREDENTIALS_FILE": "/path/to/credentials/file", 314 "AWS_CONFIG_FILE": "/path/to/config/file", 315 }, 316 Config: envConfig{ 317 SharedCredentialsFile: "/path/to/credentials/file", 318 SharedConfigFile: "/path/to/config/file", 319 }, 320 }, 321 17: { 322 Env: map[string]string{ 323 "AWS_STS_REGIONAL_ENDPOINTS": "regional", 324 }, 325 Config: envConfig{ 326 STSRegionalEndpoint: endpoints.RegionalSTSEndpoint, 327 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 328 SharedConfigFile: shareddefaults.SharedConfigFilename(), 329 }, 330 }, 331 18: { 332 Env: map[string]string{ 333 "AWS_S3_US_EAST_1_REGIONAL_ENDPOINT": "regional", 334 }, 335 Config: envConfig{ 336 S3UsEast1RegionalEndpoint: endpoints.RegionalS3UsEast1Endpoint, 337 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 338 SharedConfigFile: shareddefaults.SharedConfigFilename(), 339 }, 340 }, 341 19: { 342 Env: map[string]string{ 343 "AWS_S3_USE_ARN_REGION": "true", 344 }, 345 Config: envConfig{ 346 S3UseARNRegion: true, 347 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 348 SharedConfigFile: shareddefaults.SharedConfigFilename(), 349 }, 350 }, 351 20: { 352 Env: map[string]string{ 353 "AWS_EC2_METADATA_SERVICE_ENDPOINT": "http://example.aws", 354 }, 355 Config: envConfig{ 356 EC2IMDSEndpoint: "http://example.aws", 357 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 358 SharedConfigFile: shareddefaults.SharedConfigFilename(), 359 }, 360 }, 361 21: { 362 Env: map[string]string{ 363 "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE": "IPv6", 364 }, 365 Config: envConfig{ 366 EC2IMDSEndpointMode: endpoints.EC2IMDSEndpointModeStateIPv6, 367 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 368 SharedConfigFile: shareddefaults.SharedConfigFilename(), 369 }, 370 }, 371 22: { 372 Env: map[string]string{ 373 "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE": "IPv4", 374 }, 375 Config: envConfig{ 376 EC2IMDSEndpointMode: endpoints.EC2IMDSEndpointModeStateIPv4, 377 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 378 SharedConfigFile: shareddefaults.SharedConfigFilename(), 379 }, 380 }, 381 23: { 382 Env: map[string]string{ 383 "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE": "foobar", 384 }, 385 WantErr: true, 386 }, 387 24: { 388 Env: map[string]string{ 389 "AWS_EC2_METADATA_SERVICE_ENDPOINT": "http://endpoint.localhost", 390 }, 391 Config: envConfig{ 392 EC2IMDSEndpoint: "http://endpoint.localhost", 393 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 394 SharedConfigFile: shareddefaults.SharedConfigFilename(), 395 }, 396 }, 397 25: { 398 Env: map[string]string{ 399 "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE": "IPv6", 400 "AWS_EC2_METADATA_SERVICE_ENDPOINT": "http://endpoint.localhost", 401 }, 402 Config: envConfig{ 403 EC2IMDSEndpoint: "http://endpoint.localhost", 404 EC2IMDSEndpointMode: endpoints.EC2IMDSEndpointModeStateIPv6, 405 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 406 SharedConfigFile: shareddefaults.SharedConfigFilename(), 407 }, 408 }, 409 26: { 410 Env: map[string]string{ 411 "AWS_EC2_METADATA_DISABLED": "false", 412 }, 413 Config: envConfig{ 414 SharedCredentialsFile: shareddefaults.SharedCredentialsFilename(), 415 SharedConfigFile: shareddefaults.SharedConfigFilename(), 416 }, 417 }, 418 } 419 420 for i, c := range cases { 421 t.Run(strconv.Itoa(i), func(t *testing.T) { 422 restoreEnvFn = sdktesting.StashEnv() 423 defer restoreEnvFn() 424 for k, v := range c.Env { 425 os.Setenv(k, v) 426 } 427 428 var cfg envConfig 429 var err error 430 if c.UseSharedConfigCall { 431 cfg, err = loadSharedEnvConfig() 432 if (err != nil) != c.WantErr { 433 t.Errorf("WantErr=%v, got err=%v", c.WantErr, err) 434 return 435 } 436 } else { 437 cfg, err = loadEnvConfig() 438 if (err != nil) != c.WantErr { 439 t.Errorf("WantErr=%v, got err=%v", c.WantErr, err) 440 return 441 } 442 } 443 444 if !reflect.DeepEqual(c.Config, cfg) { 445 t.Errorf("expect config to match.\n%s", 446 awstesting.SprintExpectActual(c.Config, cfg)) 447 } 448 }) 449 } 450 } 451 452 func TestSetEnvValue(t *testing.T) { 453 restoreEnvFn := sdktesting.StashEnv() 454 defer restoreEnvFn() 455 456 os.Setenv("empty_key", "") 457 os.Setenv("second_key", "2") 458 os.Setenv("third_key", "3") 459 460 var dst string 461 setFromEnvVal(&dst, []string{ 462 "empty_key", "first_key", "second_key", "third_key", 463 }) 464 465 if e, a := "2", dst; e != a { 466 t.Errorf("expect %s value from environment, got %s", e, a) 467 } 468 }