credentials/ecs_ram_role_test.go - Code Metrics - Inspection of "docs: update IMDSv2 doc for ecs ram role" - aliyun/credentials-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 461384...5f7217 )

unknown

created 2024-05-24 03:59 UTC

credentials/ecs_ram_role_test.go A

↳ Parent: Project

Size/Duplication

Total Lines	264
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	40
eloc	192
dl	0
loc	264
rs	9.2
c	0
b	0
f	0

2 Methods

Rating	Name	Duplication	Size	Complexity
F	credentials.Test_EcsRAmRoleCredential	0	127	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) {
	auth := newEcsRAMRoleCredential("go sdk", 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.Equal(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.Equal(t, "", *accesskeyId)

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

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

aliyun / credentials-go

GitHub Access Token became invalid

Push — master ( 461384...5f7217 )

credentials/ecs_ram_role_test.go A

Size/Duplication

Importance

2 Methods

Duplication Side-by-Side

Filter issues like