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  }