providers.TestECSRAMRoleCredentialsProvider_getRoleNameWithMetadataV2 - Code Metrics - Inspection of "refine ecs ram role credentials provider" - aliyun/credentials-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b5116a...3bd38f )

unknown

created 2024-08-23 09:12 UTC

NameWithMetadataV2 B

↳ Parent: credentials/internal/providers/ecs_ram_role_test.go

Complexity

Conditions

Size

Total Lines	38
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	25
nop	1
dl	0
loc	38
rs	8.8133
c	0
b	0
f	0

package providers

import (
	"errors"
	"testing"
	"time"

	httputil "github.com/aliyun/credentials-go/credentials/internal/http"
	"github.com/stretchr/testify/assert"
)

func TestNewECSRAMRoleCredentialsProvider(t *testing.T) {
	p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
	assert.Nil(t, err)
	assert.Equal(t, "", p.roleName)
	assert.Equal(t, 21600, p.metadataTokenDurationSeconds)

	_, err = NewECSRAMRoleCredentialsProviderBuilder().WithMetadataTokenDurationSeconds(1000000000).Build()
	assert.EqualError(t, err, "the metadata token duration seconds must be 1-21600")

	p, err = NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("role").WithMetadataTokenDurationSeconds(3600).Build()
	assert.Nil(t, err)
	assert.Equal(t, "role", p.roleName)
	assert.Equal(t, 3600, p.metadataTokenDurationSeconds)

	assert.True(t, p.needUpdateCredential())
}

func TestECSRAMRoleCredentialsProvider_getRoleName(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
	assert.Nil(t, err)

	// case 1: server error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}

	_, err = p.getRoleName()
	assert.NotNil(t, err)
	assert.Equal(t, "get role name failed: mock server error", err.Error())

	// case 2: 4xx error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		res = &httputil.Response{
			StatusCode: 400,
			Body:       []byte("4xx error"),
		}
		return
	}

	_, err = p.getRoleName()
	assert.NotNil(t, err)
	assert.Equal(t, "get role name failed: GET http://100.100.100.200/latest/meta-data/ram/security-credentials/ 400", err.Error())

	// case 3: ok
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte("rolename"),
		}
		return
	}
	roleName, err := p.getRoleName()
	assert.Nil(t, err)
	assert.Equal(t, "rolename", roleName)
}

func TestECSRAMRoleCredentialsProvider_getRoleNameWithMetadataV2(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().WithEnableIMDSv2(true).Build()
	assert.Nil(t, err)

	// case 1: get metadata token failed
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}

	_, err = p.getRoleName()
	assert.NotNil(t, err)
	assert.Equal(t, "get metadata token failed: mock server error", err.Error())

	// case 2: return token
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/api/token" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("tokenxxxxx"),
			}
		} else {
			assert.Equal(t, "tokenxxxxx", req.Headers["x-aliyun-ecs-metadata-token"])

			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
		}
		return
	}

	roleName, err := p.getRoleName()
	assert.Nil(t, err)
	assert.Equal(t, "rolename", roleName)
}

func TestECSRAMRoleCredentialsProvider_getCredentials(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
	assert.Nil(t, err)

	// case 1: server error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}
	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "get role name failed: mock server error", err.Error())

	// case 2: get role name ok, get credentials failed with server error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}
		err = errors.New("mock server error")
		return
	}

	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: mock server error", err.Error())

	// case 3: 4xx error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 400,
			Body:       []byte("4xx error"),
		}
		return
	}

	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err, httpStatus: 400, message = 4xx error", err.Error())

	// case 4: invalid json
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte("invalid json"),
		}
		return
	}

	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err, json.Unmarshal fail: invalid character 'i' looking for beginning of value", err.Error())

	// case 5: empty response json
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte("null"),
		}
		return
	}

	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err, fail to get credentials", err.Error())

	// case 6: empty session ak response json
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte("{}"),
		}
		return
	}
	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err, fail to get credentials", err.Error())

	// case 7: non-success response
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Failed"}`),
		}
		return
	}
	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err, Code is not Success", err.Error())

	// case 8: mock ok value
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/meta-data/ram/security-credentials/" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("rolename"),
			}
			return
		}

		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
		}
		return
	}
	creds, err := p.getCredentials()
	assert.Nil(t, err)
	assert.Equal(t, "saki", creds.AccessKeyId)
	assert.Equal(t, "saks", creds.AccessKeySecret)
	assert.Equal(t, "token", creds.SecurityToken)
	assert.Equal(t, "2021-10-20T04:27:09Z", creds.Expiration)

	// needUpdateCredential
	assert.True(t, p.needUpdateCredential())
	p.expirationTimestamp = time.Now().Unix()
	assert.True(t, p.needUpdateCredential())

	p.expirationTimestamp = time.Now().Unix() + 300
	assert.False(t, p.needUpdateCredential())
}

func TestECSRAMRoleCredentialsProvider_getCredentialsWithMetadataV2(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("rolename").WithEnableIMDSv2(true).Build()
	assert.Nil(t, err)

	// case 1: get metadata token failed
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}

	_, err = p.getCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "get metadata token failed: mock server error", err.Error())

	// case 2: return token
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		if req.Path == "/latest/api/token" {
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte("tokenxxxxx"),
			}
		} else if req.Path == "/latest/meta-data/ram/security-credentials/rolename" {
			assert.Equal(t, "tokenxxxxx", req.Headers["x-aliyun-ecs-metadata-token"])
			res = &httputil.Response{
				StatusCode: 200,
				Body:       []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
			}
		}
		return
	}

	creds, err := p.getCredentials()
	assert.Nil(t, err)
	assert.Equal(t, "saki", creds.AccessKeyId)
	assert.Equal(t, "saks", creds.AccessKeySecret)
	assert.Equal(t, "token", creds.SecurityToken)
	assert.Equal(t, "2021-10-20T04:27:09Z", creds.Expiration)

	// needUpdateCredential
	assert.True(t, p.needUpdateCredential())
	p.expirationTimestamp = time.Now().Unix()
	assert.True(t, p.needUpdateCredential())

	p.expirationTimestamp = time.Now().Unix() + 300
	assert.False(t, p.needUpdateCredential())
}

func TestECSRAMRoleCredentialsProviderGetCredentials(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("rolename").Build()
	assert.Nil(t, err)
	// case 1: get credentials failed
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}
	_, err = p.GetCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "refresh Ecs sts token err: mock server error", err.Error())

	// case 2: get invalid expiration
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"invalidexpiration","SecurityToken":"token","Code":"Success"}`),
		}
		return
	}
	_, err = p.GetCredentials()
	assert.NotNil(t, err)
	assert.Equal(t, "parsing time \"invalidexpiration\" as \"2006-01-02T15:04:05Z\": cannot parse \"invalidexpiration\" as \"2006\"", err.Error())

	// case 3: happy result
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte(`{"AccessKeyId":"akid","AccessKeySecret":"aksecret","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
		}
		return
	}
	cc, err := p.GetCredentials()
	assert.Nil(t, err)
	assert.Equal(t, "akid", cc.AccessKeyId)
	assert.Equal(t, "aksecret", cc.AccessKeySecret)
	assert.Equal(t, "token", cc.SecurityToken)
	assert.True(t, p.needUpdateCredential())
}

func TestECSRAMRoleCredentialsProvider_getMetadataToken(t *testing.T) {
	originHttpDo := httpDo
	defer func() { httpDo = originHttpDo }()

	p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
	assert.Nil(t, err)

	// case 1: server error
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		err = errors.New("mock server error")
		return
	}

	_, err = p.getMetadataToken()
	assert.NotNil(t, err)
	assert.Equal(t, "get metadata token failed: mock server error", err.Error())
	// case 2: return token
	httpDo = func(req *httputil.Request) (res *httputil.Response, err error) {
		res = &httputil.Response{
			StatusCode: 200,
			Body:       []byte("tokenxxxxx"),
		}
		return
	}
	metadataToken, err := p.getMetadataToken()
	assert.Nil(t, err)
	assert.Equal(t, "tokenxxxxx", metadataToken)
}


1			package providers
2
3			import (
4			"errors"
5			"testing"
6			"time"
7
8			httputil "github.com/aliyun/credentials-go/credentials/internal/http"
9			"github.com/stretchr/testify/assert"
10			)
11
12			func TestNewECSRAMRoleCredentialsProvider(t *testing.T) {
13			p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
14			assert.Nil(t, err)
15			assert.Equal(t, "", p.roleName)
16			assert.Equal(t, 21600, p.metadataTokenDurationSeconds)
17
18			_, err = NewECSRAMRoleCredentialsProviderBuilder().WithMetadataTokenDurationSeconds(1000000000).Build()
19			assert.EqualError(t, err, "the metadata token duration seconds must be 1-21600")
20
21			p, err = NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("role").WithMetadataTokenDurationSeconds(3600).Build()
22			assert.Nil(t, err)
23			assert.Equal(t, "role", p.roleName)
24			assert.Equal(t, 3600, p.metadataTokenDurationSeconds)
25
26			assert.True(t, p.needUpdateCredential())
27			}
28
29			func TestECSRAMRoleCredentialsProvider_getRoleName(t *testing.T) {
30			originHttpDo := httpDo
31			defer func() { httpDo = originHttpDo }()
32
33			p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
34			assert.Nil(t, err)
35
36			// case 1: server error
37			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
38			err = errors.New("mock server error")
39			return
40			}
41
42			_, err = p.getRoleName()
43			assert.NotNil(t, err)
44			assert.Equal(t, "get role name failed: mock server error", err.Error())
45
46			// case 2: 4xx error
47			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
48			res = &httputil.Response{
49			StatusCode: 400,
50			Body: []byte("4xx error"),
51			}
52			return
53			}
54
55			_, err = p.getRoleName()
56			assert.NotNil(t, err)
57			assert.Equal(t, "get role name failed: GET http://100.100.100.200/latest/meta-data/ram/security-credentials/ 400", err.Error())
58
59			// case 3: ok
60			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
61			res = &httputil.Response{
62			StatusCode: 200,
63			Body: []byte("rolename"),
64			}
65			return
66			}
67			roleName, err := p.getRoleName()
68			assert.Nil(t, err)
69			assert.Equal(t, "rolename", roleName)
70			}
71
72			func TestECSRAMRoleCredentialsProvider_getRoleNameWithMetadataV2(t *testing.T) {
73			originHttpDo := httpDo
74			defer func() { httpDo = originHttpDo }()
75
76			p, err := NewECSRAMRoleCredentialsProviderBuilder().WithEnableIMDSv2(true).Build()
77			assert.Nil(t, err)
78
79			// case 1: get metadata token failed
80			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
81			err = errors.New("mock server error")
82			return
83			}
84
85			_, err = p.getRoleName()
86			assert.NotNil(t, err)
87			assert.Equal(t, "get metadata token failed: mock server error", err.Error())
88
89			// case 2: return token
90			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
91			if req.Path == "/latest/api/token" {
92			res = &httputil.Response{
93			StatusCode: 200,
94			Body: []byte("tokenxxxxx"),
95			}
96			} else {
97			assert.Equal(t, "tokenxxxxx", req.Headers["x-aliyun-ecs-metadata-token"])
98
99			res = &httputil.Response{
100			StatusCode: 200,
101			Body: []byte("rolename"),
102			}
103			}
104			return
105			}
106
107			roleName, err := p.getRoleName()
108			assert.Nil(t, err)
109			assert.Equal(t, "rolename", roleName)
110			}
111
112			func TestECSRAMRoleCredentialsProvider_getCredentials(t *testing.T) {
113			originHttpDo := httpDo
114			defer func() { httpDo = originHttpDo }()
115
116			p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
117			assert.Nil(t, err)
118
119			// case 1: server error
120			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
121			err = errors.New("mock server error")
122			return
123			}
124			_, err = p.getCredentials()
125			assert.NotNil(t, err)
126			assert.Equal(t, "get role name failed: mock server error", err.Error())
127
128			// case 2: get role name ok, get credentials failed with server error
129			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
130			if req.Path == "/latest/meta-data/ram/security-credentials/" {
131			res = &httputil.Response{
132			StatusCode: 200,
133			Body: []byte("rolename"),
134			}
135			return
136			}
137			err = errors.New("mock server error")
138			return
139			}
140
141			_, err = p.getCredentials()
142			assert.NotNil(t, err)
143			assert.Equal(t, "refresh Ecs sts token err: mock server error", err.Error())
144
145			// case 3: 4xx error
146			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
147			if req.Path == "/latest/meta-data/ram/security-credentials/" {
148			res = &httputil.Response{
149			StatusCode: 200,
150			Body: []byte("rolename"),
151			}
152			return
153			}
154
155			res = &httputil.Response{
156			StatusCode: 400,
157			Body: []byte("4xx error"),
158			}
159			return
160			}
161
162			_, err = p.getCredentials()
163			assert.NotNil(t, err)
164			assert.Equal(t, "refresh Ecs sts token err, httpStatus: 400, message = 4xx error", err.Error())
165
166			// case 4: invalid json
167			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
168			if req.Path == "/latest/meta-data/ram/security-credentials/" {
169			res = &httputil.Response{
170			StatusCode: 200,
171			Body: []byte("rolename"),
172			}
173			return
174			}
175
176			res = &httputil.Response{
177			StatusCode: 200,
178			Body: []byte("invalid json"),
179			}
180			return
181			}
182
183			_, err = p.getCredentials()
184			assert.NotNil(t, err)
185			assert.Equal(t, "refresh Ecs sts token err, json.Unmarshal fail: invalid character 'i' looking for beginning of value", err.Error())
186
187			// case 5: empty response json
188			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
189			if req.Path == "/latest/meta-data/ram/security-credentials/" {
190			res = &httputil.Response{
191			StatusCode: 200,
192			Body: []byte("rolename"),
193			}
194			return
195			}
196
197			res = &httputil.Response{
198			StatusCode: 200,
199			Body: []byte("null"),
200			}
201			return
202			}
203
204			_, err = p.getCredentials()
205			assert.NotNil(t, err)
206			assert.Equal(t, "refresh Ecs sts token err, fail to get credentials", err.Error())
207
208			// case 6: empty session ak response json
209			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
210			if req.Path == "/latest/meta-data/ram/security-credentials/" {
211			res = &httputil.Response{
212			StatusCode: 200,
213			Body: []byte("rolename"),
214			}
215			return
216			}
217
218			res = &httputil.Response{
219			StatusCode: 200,
220			Body: []byte("{}"),
221			}
222			return
223			}
224			_, err = p.getCredentials()
225			assert.NotNil(t, err)
226			assert.Equal(t, "refresh Ecs sts token err, fail to get credentials", err.Error())
227
228			// case 7: non-success response
229			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
230			if req.Path == "/latest/meta-data/ram/security-credentials/" {
231			res = &httputil.Response{
232			StatusCode: 200,
233			Body: []byte("rolename"),
234			}
235			return
236			}
237
238			res = &httputil.Response{
239			StatusCode: 200,
240			Body: []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Failed"}`),
241			}
242			return
243			}
244			_, err = p.getCredentials()
245			assert.NotNil(t, err)
246			assert.Equal(t, "refresh Ecs sts token err, Code is not Success", err.Error())
247
248			// case 8: mock ok value
249			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
250			if req.Path == "/latest/meta-data/ram/security-credentials/" {
251			res = &httputil.Response{
252			StatusCode: 200,
253			Body: []byte("rolename"),
254			}
255			return
256			}
257
258			res = &httputil.Response{
259			StatusCode: 200,
260			Body: []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
261			}
262			return
263			}
264			creds, err := p.getCredentials()
265			assert.Nil(t, err)
266			assert.Equal(t, "saki", creds.AccessKeyId)
267			assert.Equal(t, "saks", creds.AccessKeySecret)
268			assert.Equal(t, "token", creds.SecurityToken)
269			assert.Equal(t, "2021-10-20T04:27:09Z", creds.Expiration)
270
271			// needUpdateCredential
272			assert.True(t, p.needUpdateCredential())
273			p.expirationTimestamp = time.Now().Unix()
274			assert.True(t, p.needUpdateCredential())
275
276			p.expirationTimestamp = time.Now().Unix() + 300
277			assert.False(t, p.needUpdateCredential())
278			}
279
280			func TestECSRAMRoleCredentialsProvider_getCredentialsWithMetadataV2(t *testing.T) {
281			originHttpDo := httpDo
282			defer func() { httpDo = originHttpDo }()
283
284			p, err := NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("rolename").WithEnableIMDSv2(true).Build()
285			assert.Nil(t, err)
286
287			// case 1: get metadata token failed
288			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
289			err = errors.New("mock server error")
290			return
291			}
292
293			_, err = p.getCredentials()
294			assert.NotNil(t, err)
295			assert.Equal(t, "get metadata token failed: mock server error", err.Error())
296
297			// case 2: return token
298			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
299			if req.Path == "/latest/api/token" {
300			res = &httputil.Response{
301			StatusCode: 200,
302			Body: []byte("tokenxxxxx"),
303			}
304			} else if req.Path == "/latest/meta-data/ram/security-credentials/rolename" {
305			assert.Equal(t, "tokenxxxxx", req.Headers["x-aliyun-ecs-metadata-token"])
306			res = &httputil.Response{
307			StatusCode: 200,
308			Body: []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
309			}
310			}
311			return
312			}
313
314			creds, err := p.getCredentials()
315			assert.Nil(t, err)
316			assert.Equal(t, "saki", creds.AccessKeyId)
317			assert.Equal(t, "saks", creds.AccessKeySecret)
318			assert.Equal(t, "token", creds.SecurityToken)
319			assert.Equal(t, "2021-10-20T04:27:09Z", creds.Expiration)
320
321			// needUpdateCredential
322			assert.True(t, p.needUpdateCredential())
323			p.expirationTimestamp = time.Now().Unix()
324			assert.True(t, p.needUpdateCredential())
325
326			p.expirationTimestamp = time.Now().Unix() + 300
327			assert.False(t, p.needUpdateCredential())
328			}
329
330			func TestECSRAMRoleCredentialsProviderGetCredentials(t *testing.T) {
331			originHttpDo := httpDo
332			defer func() { httpDo = originHttpDo }()
333
334			p, err := NewECSRAMRoleCredentialsProviderBuilder().WithRoleName("rolename").Build()
335			assert.Nil(t, err)
336			// case 1: get credentials failed
337			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
338			err = errors.New("mock server error")
339			return
340			}
341			_, err = p.GetCredentials()
342			assert.NotNil(t, err)
343			assert.Equal(t, "refresh Ecs sts token err: mock server error", err.Error())
344
345			// case 2: get invalid expiration
346			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
347			res = &httputil.Response{
348			StatusCode: 200,
349			Body: []byte(`{"AccessKeyId":"saki","AccessKeySecret":"saks","Expiration":"invalidexpiration","SecurityToken":"token","Code":"Success"}`),
350			}
351			return
352			}
353			_, err = p.GetCredentials()
354			assert.NotNil(t, err)
355			assert.Equal(t, "parsing time \"invalidexpiration\" as \"2006-01-02T15:04:05Z\": cannot parse \"invalidexpiration\" as \"2006\"", err.Error())
356
357			// case 3: happy result
358			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
359			res = &httputil.Response{
360			StatusCode: 200,
361			Body: []byte(`{"AccessKeyId":"akid","AccessKeySecret":"aksecret","Expiration":"2021-10-20T04:27:09Z","SecurityToken":"token","Code":"Success"}`),
362			}
363			return
364			}
365			cc, err := p.GetCredentials()
366			assert.Nil(t, err)
367			assert.Equal(t, "akid", cc.AccessKeyId)
368			assert.Equal(t, "aksecret", cc.AccessKeySecret)
369			assert.Equal(t, "token", cc.SecurityToken)
370			assert.True(t, p.needUpdateCredential())
371			}
372
373			func TestECSRAMRoleCredentialsProvider_getMetadataToken(t *testing.T) {
374			originHttpDo := httpDo
375			defer func() { httpDo = originHttpDo }()
376
377			p, err := NewECSRAMRoleCredentialsProviderBuilder().Build()
378			assert.Nil(t, err)
379
380			// case 1: server error
381			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
382			err = errors.New("mock server error")
383			return
384			}
385
386			_, err = p.getMetadataToken()
387			assert.NotNil(t, err)
388			assert.Equal(t, "get metadata token failed: mock server error", err.Error())
389			// case 2: return token
390			httpDo = func(req httputil.Request) (res httputil.Response, err error) {
391			res = &httputil.Response{
392			StatusCode: 200,
393			Body: []byte("tokenxxxxx"),
394			}
395			return
396			}
397			metadataToken, err := p.getMetadataToken()
398			assert.Nil(t, err)
399			assert.Equal(t, "tokenxxxxx", metadataToken)
400			}
401

aliyun / credentials-go

GitHub Access Token became invalid

Push — master ( b5116a...3bd38f )

NameWithMetadataV2 B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like