credentials/ecs_ram_role_credentials_provider_test.go - Code Metrics - aliyun/credentials-go - Measure and Improve Code Quality continuously with Scrutinizer

credentials/ecs_ram_role_credentials_provider_test.go A
last analyzed 2025-04-18 09:05 UTC

↳ Parent: Project

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	40
eloc	197
dl	0
loc	270
rs	9.2
c	0
b	0
f	0

2 Methods

Rating	Name	Duplication	Size	Complexity
F	credentials.Test_EcsRAmRoleCredential	0	133	20
F	credentials.Test_EcsRAmRoleCredentialEnableIMDSv2	0	125	20

package credentials

import (
	"errors"
	"net/http"
	"testing"

	"github.com/stretchr/testify/assert"
)

func Test_EcsRAmRoleCredential(t *testing.T) {
	credentialUpdater := new(credentialUpdater)
	credentialUpdater.inAdvanceScale = 0.5
	auth := &ECSRAMRoleCredentialsProvider{
		RoleName:          "go sdk",
		credentialUpdater: credentialUpdater,
		runtime:           nil,
	}
	origTestHookDo := hookDo
	defer func() { hookDo = origTestHookDo }()

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(300, ``, errors.New("sdk test"))
		}
	}
	accesskeyId, err := auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: sdk test", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(300, ``, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
	assert.Nil(t, accesskeyId)

	accesskeySecret, err := auth.GetAccessKeySecret()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
	assert.Nil(t, accesskeySecret)

	ststoken, err := auth.GetSecurityToken()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
	assert.Nil(t, ststoken)

	assert.Equal(t, "", *auth.GetBearerToken())

	assert.Equal(t, "ecs_ram_role", *auth.GetType())

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(400, `role`, nil)
		}
	}
	auth.RoleName = ""
	_, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: httpStatus: 400, message = role", err.Error())

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `role`, nil)
		}
	}
	_, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character 'r' looking for beginning of value", err.Error())
	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration"`, nil)
		}
	}
	auth.RoleName = "role"
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character ':' after top-level value", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"fail"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Code is not Success", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"Success"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: AccessKeyId: , AccessKeySecret: accessKeySecret, SecurityToken: securitytoken, Expiration: expiration", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"2018-01-02T15:04:05Z","Code":"Success"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeyId", *accesskeyId)

	accesskeySecret, err = auth.GetAccessKeySecret()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeySecret", *accesskeySecret)

	ststoken, err = auth.GetSecurityToken()
	assert.Nil(t, err)
	assert.Equal(t, "securitytoken", *ststoken)

	err = errors.New("credentials")
	err = hookParse(err)
	assert.Equal(t, "credentials", err.Error())

	cred, err := auth.GetCredential()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeyId", *cred.AccessKeyId)
	assert.Equal(t, "accessKeySecret", *cred.AccessKeySecret)
	assert.Equal(t, "securitytoken", *cred.SecurityToken)
	assert.Nil(t, cred.BearerToken)
	assert.Equal(t, "ecs_ram_role", *cred.Type)

	originHookParse := hookParse
	hookParse = func(err error) error {
		return errors.New("error parse")
	}
	defer func() {
		hookParse = originHookParse
	}()
	accesskeyId, err = auth.GetAccessKeyId()
	assert.Equal(t, "refresh Ecs sts token err: error parse", err.Error())
	assert.Nil(t, accesskeyId)
}

func Test_EcsRAmRoleCredentialEnableIMDSv2(t *testing.T) {
	auth := newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", false, 0, 0.5, nil)
	origTestHookDo := hookDo
	defer func() { hookDo = origTestHookDo }()

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(300, ``, errors.New("sdk test"))
		}
	}
	accesskeyId, err := auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: sdk test", err.Error())
	assert.Nil(t, accesskeyId)

	auth = newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", true, 0, 0.5, nil)
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "failed to get token from ECS Metadata Service: sdk test", err.Error())
	assert.Nil(t, accesskeyId)

	auth = newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", true, 180, 0.5, nil)
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "failed to get token from ECS Metadata Service: sdk test", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(300, ``, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "failed to get token from ECS Metadata Service: httpStatus: 300, message = ", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(400, `role`, nil)
		}
	}
	auth.RoleName = ""
	_, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: httpStatus: 400, message = role", err.Error())

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `role`, nil)
		}
	}
	_, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character 'r' looking for beginning of value", err.Error())
	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration"`, nil)
		}
	}
	auth.RoleName = "role"
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character ':' after top-level value", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"fail"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: Code is not Success", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"Success"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: AccessKeyId: , AccessKeySecret: accessKeySecret, SecurityToken: securitytoken, Expiration: expiration", err.Error())
	assert.Nil(t, accesskeyId)

	hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) {
		return func(req *http.Request) (*http.Response, error) {
			return mockResponse(200, `{"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"2018-01-02T15:04:05Z","Code":"Success"}`, nil)
		}
	}
	accesskeyId, err = auth.GetAccessKeyId()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeyId", *accesskeyId)

	accesskeySecret, err := auth.GetAccessKeySecret()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeySecret", *accesskeySecret)

	ststoken, err := auth.GetSecurityToken()
	assert.Nil(t, err)
	assert.Equal(t, "securitytoken", *ststoken)

	err = errors.New("credentials")
	err = hookParse(err)
	assert.Equal(t, "credentials", err.Error())

	cred, err := auth.GetCredential()
	assert.Nil(t, err)
	assert.Equal(t, "accessKeyId", *cred.AccessKeyId)
	assert.Equal(t, "accessKeySecret", *cred.AccessKeySecret)
	assert.Equal(t, "securitytoken", *cred.SecurityToken)
	assert.Nil(t, cred.BearerToken)
	assert.Equal(t, "ecs_ram_role", *cred.Type)

	originHookParse := hookParse
	hookParse = func(err error) error {
		return errors.New("error parse")
	}
	defer func() {
		hookParse = originHookParse
	}()
	accesskeyId, err = auth.GetAccessKeyId()
	assert.Equal(t, "refresh Ecs sts token err: error parse", err.Error())
	assert.Nil(t, accesskeyId)
}


1			package credentials
2
3			import (
4			"errors"
5			"net/http"
6			"testing"
7
8			"github.com/stretchr/testify/assert"
9			)
10
11			func Test_EcsRAmRoleCredential(t *testing.T) {
12			credentialUpdater := new(credentialUpdater)
13			credentialUpdater.inAdvanceScale = 0.5
14			auth := &ECSRAMRoleCredentialsProvider{
15			RoleName: "go sdk",
16			credentialUpdater: credentialUpdater,
17			runtime: nil,
18			}
19			origTestHookDo := hookDo
20			defer func() { hookDo = origTestHookDo }()
21
22			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
23			return func(req http.Request) (http.Response, error) {
24			return mockResponse(300, ``, errors.New("sdk test"))
25			}
26			}
27			accesskeyId, err := auth.GetAccessKeyId()
28			assert.NotNil(t, err)
29			assert.Equal(t, "refresh Ecs sts token err: sdk test", err.Error())
30			assert.Nil(t, accesskeyId)
31
32			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
33			return func(req http.Request) (http.Response, error) {
34			return mockResponse(300, ``, nil)
35			}
36			}
37			accesskeyId, err = auth.GetAccessKeyId()
38			assert.NotNil(t, err)
39			assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
40			assert.Nil(t, accesskeyId)
41
42			accesskeySecret, err := auth.GetAccessKeySecret()
43			assert.NotNil(t, err)
44			assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
45			assert.Nil(t, accesskeySecret)
46
47			ststoken, err := auth.GetSecurityToken()
48			assert.NotNil(t, err)
49			assert.Equal(t, "refresh Ecs sts token err: httpStatus: 300, message = ", err.Error())
50			assert.Nil(t, ststoken)
51
52			assert.Equal(t, "", *auth.GetBearerToken())
53
54			assert.Equal(t, "ecs_ram_role", *auth.GetType())
55
56			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
57			return func(req http.Request) (http.Response, error) {
58			return mockResponse(400, `role`, nil)
59			}
60			}
61			auth.RoleName = ""
62			_, err = auth.GetAccessKeyId()
63			assert.NotNil(t, err)
64			assert.Equal(t, "refresh Ecs sts token err: httpStatus: 400, message = role", err.Error())
65
66			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
67			return func(req http.Request) (http.Response, error) {
68			return mockResponse(200, `role`, nil)
69			}
70			}
71			_, err = auth.GetAccessKeyId()
72			assert.NotNil(t, err)
73			assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character 'r' looking for beginning of value", err.Error())
74			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
75			return func(req http.Request) (http.Response, error) {
76			return mockResponse(200, `"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration"`, nil)
77			}
78			}
79			auth.RoleName = "role"
80			accesskeyId, err = auth.GetAccessKeyId()
81			assert.NotNil(t, err)
82			assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character ':' after top-level value", err.Error())
83			assert.Nil(t, accesskeyId)
84
85			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
86			return func(req http.Request) (http.Response, error) {
87			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"fail"}`, nil)
88			}
89			}
90			accesskeyId, err = auth.GetAccessKeyId()
91			assert.NotNil(t, err)
92			assert.Equal(t, "refresh Ecs sts token err: Code is not Success", err.Error())
93			assert.Nil(t, accesskeyId)
94
95			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
96			return func(req http.Request) (http.Response, error) {
97			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"Success"}`, nil)
98			}
99			}
100			accesskeyId, err = auth.GetAccessKeyId()
101			assert.NotNil(t, err)
102			assert.Equal(t, "refresh Ecs sts token err: AccessKeyId: , AccessKeySecret: accessKeySecret, SecurityToken: securitytoken, Expiration: expiration", err.Error())
103			assert.Nil(t, accesskeyId)
104
105			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
106			return func(req http.Request) (http.Response, error) {
107			return mockResponse(200, `{"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"2018-01-02T15:04:05Z","Code":"Success"}`, nil)
108			}
109			}
110			accesskeyId, err = auth.GetAccessKeyId()
111			assert.Nil(t, err)
112			assert.Equal(t, "accessKeyId", *accesskeyId)
113
114			accesskeySecret, err = auth.GetAccessKeySecret()
115			assert.Nil(t, err)
116			assert.Equal(t, "accessKeySecret", *accesskeySecret)
117
118			ststoken, err = auth.GetSecurityToken()
119			assert.Nil(t, err)
120			assert.Equal(t, "securitytoken", *ststoken)
121
122			err = errors.New("credentials")
123			err = hookParse(err)
124			assert.Equal(t, "credentials", err.Error())
125
126			cred, err := auth.GetCredential()
127			assert.Nil(t, err)
128			assert.Equal(t, "accessKeyId", *cred.AccessKeyId)
129			assert.Equal(t, "accessKeySecret", *cred.AccessKeySecret)
130			assert.Equal(t, "securitytoken", *cred.SecurityToken)
131			assert.Nil(t, cred.BearerToken)
132			assert.Equal(t, "ecs_ram_role", *cred.Type)
133
134			originHookParse := hookParse
135			hookParse = func(err error) error {
136			return errors.New("error parse")
137			}
138			defer func() {
139			hookParse = originHookParse
140			}()
141			accesskeyId, err = auth.GetAccessKeyId()
142			assert.Equal(t, "refresh Ecs sts token err: error parse", err.Error())
143			assert.Nil(t, accesskeyId)
144			}
145
146			func Test_EcsRAmRoleCredentialEnableIMDSv2(t *testing.T) {
147			auth := newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", false, 0, 0.5, nil)
148			origTestHookDo := hookDo
149			defer func() { hookDo = origTestHookDo }()
150
151			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
152			return func(req http.Request) (http.Response, error) {
153			return mockResponse(300, ``, errors.New("sdk test"))
154			}
155			}
156			accesskeyId, err := auth.GetAccessKeyId()
157			assert.NotNil(t, err)
158			assert.Equal(t, "refresh Ecs sts token err: sdk test", err.Error())
159			assert.Nil(t, accesskeyId)
160
161			auth = newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", true, 0, 0.5, nil)
162			accesskeyId, err = auth.GetAccessKeyId()
163			assert.NotNil(t, err)
164			assert.Equal(t, "failed to get token from ECS Metadata Service: sdk test", err.Error())
165			assert.Nil(t, accesskeyId)
166
167			auth = newEcsRAMRoleCredentialWithEnableIMDSv2("go sdk", true, 180, 0.5, nil)
168			accesskeyId, err = auth.GetAccessKeyId()
169			assert.NotNil(t, err)
170			assert.Equal(t, "failed to get token from ECS Metadata Service: sdk test", err.Error())
171			assert.Nil(t, accesskeyId)
172
173			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
174			return func(req http.Request) (http.Response, error) {
175			return mockResponse(300, ``, nil)
176			}
177			}
178			accesskeyId, err = auth.GetAccessKeyId()
179			assert.NotNil(t, err)
180			assert.Equal(t, "failed to get token from ECS Metadata Service: httpStatus: 300, message = ", err.Error())
181			assert.Nil(t, accesskeyId)
182
183			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
184			return func(req http.Request) (http.Response, error) {
185			return mockResponse(400, `role`, nil)
186			}
187			}
188			auth.RoleName = ""
189			_, err = auth.GetAccessKeyId()
190			assert.NotNil(t, err)
191			assert.Equal(t, "refresh Ecs sts token err: httpStatus: 400, message = role", err.Error())
192
193			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
194			return func(req http.Request) (http.Response, error) {
195			return mockResponse(200, `role`, nil)
196			}
197			}
198			_, err = auth.GetAccessKeyId()
199			assert.NotNil(t, err)
200			assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character 'r' looking for beginning of value", err.Error())
201			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
202			return func(req http.Request) (http.Response, error) {
203			return mockResponse(200, `"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration"`, nil)
204			}
205			}
206			auth.RoleName = "role"
207			accesskeyId, err = auth.GetAccessKeyId()
208			assert.NotNil(t, err)
209			assert.Equal(t, "refresh Ecs sts token err: Json Unmarshal fail: invalid character ':' after top-level value", err.Error())
210			assert.Nil(t, accesskeyId)
211
212			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
213			return func(req http.Request) (http.Response, error) {
214			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"fail"}`, nil)
215			}
216			}
217			accesskeyId, err = auth.GetAccessKeyId()
218			assert.NotNil(t, err)
219			assert.Equal(t, "refresh Ecs sts token err: Code is not Success", err.Error())
220			assert.Nil(t, accesskeyId)
221
222			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
223			return func(req http.Request) (http.Response, error) {
224			return mockResponse(200, `{"AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"expiration","Code":"Success"}`, nil)
225			}
226			}
227			accesskeyId, err = auth.GetAccessKeyId()
228			assert.NotNil(t, err)
229			assert.Equal(t, "refresh Ecs sts token err: AccessKeyId: , AccessKeySecret: accessKeySecret, SecurityToken: securitytoken, Expiration: expiration", err.Error())
230			assert.Nil(t, accesskeyId)
231
232			hookDo = func(fn func(req http.Request) (http.Response, error)) func(req http.Request) (http.Response, error) {
233			return func(req http.Request) (http.Response, error) {
234			return mockResponse(200, `{"AccessKeyId":"accessKeyId","AccessKeySecret":"accessKeySecret","SecurityToken":"securitytoken","Expiration":"2018-01-02T15:04:05Z","Code":"Success"}`, nil)
235			}
236			}
237			accesskeyId, err = auth.GetAccessKeyId()
238			assert.Nil(t, err)
239			assert.Equal(t, "accessKeyId", *accesskeyId)
240
241			accesskeySecret, err := auth.GetAccessKeySecret()
242			assert.Nil(t, err)
243			assert.Equal(t, "accessKeySecret", *accesskeySecret)
244
245			ststoken, err := auth.GetSecurityToken()
246			assert.Nil(t, err)
247			assert.Equal(t, "securitytoken", *ststoken)
248
249			err = errors.New("credentials")
250			err = hookParse(err)
251			assert.Equal(t, "credentials", err.Error())
252
253			cred, err := auth.GetCredential()
254			assert.Nil(t, err)
255			assert.Equal(t, "accessKeyId", *cred.AccessKeyId)
256			assert.Equal(t, "accessKeySecret", *cred.AccessKeySecret)
257			assert.Equal(t, "securitytoken", *cred.SecurityToken)
258			assert.Nil(t, cred.BearerToken)
259			assert.Equal(t, "ecs_ram_role", *cred.Type)
260
261			originHookParse := hookParse
262			hookParse = func(err error) error {
263			return errors.New("error parse")
264			}
265			defer func() {
266			hookParse = originHookParse
267			}()
268			accesskeyId, err = auth.GetAccessKeyId()
269			assert.Equal(t, "refresh Ecs sts token err: error parse", err.Error())
270			assert.Nil(t, accesskeyId)
271			}
272

aliyun / credentials-go

GitHub Access Token became invalid

credentials/ecs_ram_role_credentials_provider_test.go A last analyzed 2025-04-18 09:05 UTC

Size/Duplication

Importance

2 Methods

Duplication Side-by-Side

Filter issues like

credentials/ecs_ram_role_credentials_provider_test.go A
last analyzed 2025-04-18 09:05 UTC