1
|
|
|
package credentials |
2
|
|
|
|
3
|
|
|
import ( |
4
|
|
|
"os" |
5
|
|
|
"runtime" |
6
|
|
|
"strings" |
7
|
|
|
"testing" |
8
|
|
|
|
9
|
|
|
"github.com/alibabacloud-go/tea/tea" |
10
|
|
|
"github.com/stretchr/testify/assert" |
11
|
|
|
) |
12
|
|
|
|
13
|
|
|
var inistr = ` |
14
|
|
|
[default] |
15
|
|
|
enable = true |
16
|
|
|
type = access_key |
17
|
|
|
access_key_id = foo |
18
|
|
|
access_key_secret = bar |
19
|
|
|
|
20
|
|
|
[notype] |
21
|
|
|
access_key_id = foo |
22
|
|
|
access_key_secret = bar |
23
|
|
|
|
24
|
|
|
[noak] |
25
|
|
|
type = access_key |
26
|
|
|
access_key_secret = bar |
27
|
|
|
|
28
|
|
|
[emptyak] |
29
|
|
|
type = access_key |
30
|
|
|
access_key_id = |
31
|
|
|
access_key_secret = bar |
32
|
|
|
|
33
|
|
|
[noaksecret] |
34
|
|
|
type = access_key |
35
|
|
|
access_key_id = bar |
36
|
|
|
|
37
|
|
|
[emptyaksecret] |
38
|
|
|
type = access_key |
39
|
|
|
access_key_id = bar |
40
|
|
|
access_key_secret = |
41
|
|
|
|
42
|
|
|
[ecs] |
43
|
|
|
type = ecs_ram_role |
44
|
|
|
role_name = EcsRamRoleTest |
45
|
|
|
|
46
|
|
|
[noecs] |
47
|
|
|
type = ecs_ram_role |
48
|
|
|
|
49
|
|
|
[emptyecs] |
50
|
|
|
type = ecs_ram_role |
51
|
|
|
role_name = |
52
|
|
|
|
53
|
|
|
[invalidRuntimeEcs] |
54
|
|
|
type = ecs_ram_role |
55
|
|
|
role_name = EcsRamRoleTest |
56
|
|
|
timeout = a |
57
|
|
|
|
58
|
|
|
[ram] |
59
|
|
|
type = ram_role_arn |
60
|
|
|
access_key_id = foo |
61
|
|
|
access_key_secret = bar |
62
|
|
|
role_arn = role_arn |
63
|
|
|
role_session_name = session_name |
64
|
|
|
|
65
|
|
|
[noramak] |
66
|
|
|
type = ram_role_arn |
67
|
|
|
access_key_secret = bar |
68
|
|
|
role_arn = role_arn |
69
|
|
|
role_session_name = session_name |
70
|
|
|
|
71
|
|
|
[emptyramak] |
72
|
|
|
type = ram_role_arn |
73
|
|
|
access_key_id = |
74
|
|
|
access_key_secret = bar |
75
|
|
|
role_arn = role_arn |
76
|
|
|
role_session_name = session_name |
77
|
|
|
|
78
|
|
|
[noramsecret] |
79
|
|
|
type = ram_role_arn |
80
|
|
|
access_key_id = id |
81
|
|
|
role_arn = role_arn |
82
|
|
|
role_session_name = session_name |
83
|
|
|
|
84
|
|
|
[emptyramsecret] |
85
|
|
|
type = ram_role_arn |
86
|
|
|
access_key_id = id |
87
|
|
|
access_key_secret = |
88
|
|
|
role_arn = role_arn |
89
|
|
|
role_session_name = session_name |
90
|
|
|
|
91
|
|
|
[noramarn] |
92
|
|
|
type = ram_role_arn |
93
|
|
|
access_key_id = id |
94
|
|
|
access_key_secret = bar |
95
|
|
|
role_session_name = session_name |
96
|
|
|
|
97
|
|
|
[emptyramarn] |
98
|
|
|
type = ram_role_arn |
99
|
|
|
access_key_id = id |
100
|
|
|
access_key_secret = bar |
101
|
|
|
role_arn = |
102
|
|
|
role_session_name = session_name |
103
|
|
|
|
104
|
|
|
[noramsessionname] |
105
|
|
|
type = ram_role_arn |
106
|
|
|
access_key_id = id |
107
|
|
|
access_key_secret = bar |
108
|
|
|
role_arn = role_arn |
109
|
|
|
|
110
|
|
|
[emptyramsessionname] |
111
|
|
|
type = ram_role_arn |
112
|
|
|
access_key_id = id |
113
|
|
|
access_key_secret = bar |
114
|
|
|
role_arn = role_arn |
115
|
|
|
role_session_name = |
116
|
|
|
|
117
|
|
|
[invalidexpirationram] |
118
|
|
|
type = ram_role_arn |
119
|
|
|
access_key_id = foo |
120
|
|
|
access_key_secret = bar |
121
|
|
|
role_arn = role_arn |
122
|
|
|
role_session_name = session_name |
123
|
|
|
role_session_expiration = a |
124
|
|
|
|
125
|
|
|
[invalidRuntimeram] |
126
|
|
|
type = ram_role_arn |
127
|
|
|
access_key_id = foo |
128
|
|
|
access_key_secret = bar |
129
|
|
|
role_arn = role_arn |
130
|
|
|
role_session_name = session_name |
131
|
|
|
timeout = a |
132
|
|
|
|
133
|
|
|
[sts] |
134
|
|
|
type = sts |
135
|
|
|
access_key_id = foo |
136
|
|
|
access_key_secret = bar |
137
|
|
|
security_token= token |
138
|
|
|
|
139
|
|
|
[nostskey] |
140
|
|
|
type = sts |
141
|
|
|
access_key_secret = bar |
142
|
|
|
security_token= token |
143
|
|
|
|
144
|
|
|
[emptystskey] |
145
|
|
|
type = sts |
146
|
|
|
access_key_id = |
147
|
|
|
access_key_secret = bar |
148
|
|
|
security_token= token |
149
|
|
|
|
150
|
|
|
[nostssecret] |
151
|
|
|
type = sts |
152
|
|
|
access_key_id = id |
153
|
|
|
security_token= token |
154
|
|
|
|
155
|
|
|
[emptystssecret] |
156
|
|
|
type = sts |
157
|
|
|
access_key_id = id |
158
|
|
|
access_key_secret = |
159
|
|
|
security_token= token |
160
|
|
|
|
161
|
|
|
[noststoken] |
162
|
|
|
type = sts |
163
|
|
|
access_key_id = id |
164
|
|
|
access_key_secret = bar |
165
|
|
|
|
166
|
|
|
[emptyststoken] |
167
|
|
|
type = sts |
168
|
|
|
access_key_id = id |
169
|
|
|
access_key_secret = bar |
170
|
|
|
security_token= |
171
|
|
|
|
172
|
|
|
[bearer] |
173
|
|
|
type = bearer |
174
|
|
|
bearer_token = foo |
175
|
|
|
|
176
|
|
|
[nobearer] |
177
|
|
|
type = bearer |
178
|
|
|
|
179
|
|
|
[emptybearer] |
180
|
|
|
type = bearer |
181
|
|
|
bearer_token = |
182
|
|
|
|
183
|
|
|
[rsa] |
184
|
|
|
type = rsa_key_pair |
185
|
|
|
public_key_id = publicKeyId |
186
|
|
|
private_key_file = ./pk.pem |
187
|
|
|
proxy = www.aliyun.com |
188
|
|
|
timeout = 10 |
189
|
|
|
connect_timeout = 10 |
190
|
|
|
host = www.aliyun.com |
191
|
|
|
|
192
|
|
|
[norsaprivate] |
193
|
|
|
type = rsa_key_pair |
194
|
|
|
public_key_id = publicKeyId |
195
|
|
|
|
196
|
|
|
[emptyrsaprivate] |
197
|
|
|
type = rsa_key_pair |
198
|
|
|
public_key_id = publicKeyId |
199
|
|
|
private_key_file = |
200
|
|
|
|
201
|
|
|
[norsapublic] |
202
|
|
|
type = rsa_key_pair |
203
|
|
|
private_key_file = ./pk.pem |
204
|
|
|
|
205
|
|
|
[emptyrsapublic] |
206
|
|
|
type = rsa_key_pair |
207
|
|
|
public_key_id = |
208
|
|
|
private_key_file = ./pk.pem |
209
|
|
|
|
210
|
|
|
[invalidexpirationrsa] |
211
|
|
|
type = rsa_key_pair |
212
|
|
|
public_key_id = publicKeyId |
213
|
|
|
private_key_file = ./pk.pem |
214
|
|
|
session_expiration = a |
215
|
|
|
|
216
|
|
|
[invalidTimeoutrsa] |
217
|
|
|
type = rsa_key_pair |
218
|
|
|
public_key_id = publicKeyId |
219
|
|
|
private_key_file = ./pk.pem |
220
|
|
|
timeout = a |
221
|
|
|
|
222
|
|
|
[invalidConnectTimeoutrsa] |
223
|
|
|
type = rsa_key_pair |
224
|
|
|
public_key_id = publicKeyId |
225
|
|
|
private_key_file = ./pk.pem |
226
|
|
|
connect_timeout = a |
227
|
|
|
|
228
|
|
|
[error_type] |
229
|
|
|
type = error_type |
230
|
|
|
public_key_id = publicKeyId |
231
|
|
|
private_key_file = ./pk_error.pem |
232
|
|
|
` |
233
|
|
|
|
234
|
|
|
func TestProfileProvider(t *testing.T) { |
235
|
|
|
var HOME string |
236
|
|
|
if runtime.GOOS == "windows" { |
237
|
|
|
HOME = "USERPROFILE" |
238
|
|
|
} else { |
239
|
|
|
HOME = "HOME" |
240
|
|
|
} |
241
|
|
|
path, ok := os.LookupEnv(HOME) |
242
|
|
|
assert.True(t, ok) |
243
|
|
|
os.Unsetenv(HOME) |
244
|
|
|
|
245
|
|
|
// testcase 1, no HOME or USERPROFILE environment variable set |
246
|
|
|
p := newProfileProvider() |
247
|
|
|
c, err := p.resolve() |
248
|
|
|
assert.Nil(t, c) |
249
|
|
|
assert.EqualError(t, err, "the default credential file path is invalid") |
250
|
|
|
|
251
|
|
|
originFilePath := os.Getenv(ENVCredentialFile) |
252
|
|
|
os.Setenv(ENVCredentialFile, "") |
253
|
|
|
defer func() { |
254
|
|
|
os.Setenv(ENVCredentialFile, originFilePath) |
255
|
|
|
}() |
256
|
|
|
c, err = p.resolve() |
257
|
|
|
assert.Nil(t, c) |
258
|
|
|
assert.EqualError(t, err, "ALIBABA_CLOUD_CREDENTIALS_FILE cannot be empty") |
259
|
|
|
|
260
|
|
|
// testcase 2, default profile object |
261
|
|
|
os.Unsetenv(ENVCredentialFile) |
262
|
|
|
os.Setenv(HOME, path) |
263
|
|
|
p = newProfileProvider() |
264
|
|
|
value, ok := p.(*profileProvider) |
265
|
|
|
assert.True(t, ok) |
266
|
|
|
assert.Equal(t, value.Profile, "default") |
267
|
|
|
|
268
|
|
|
// testcase 3, credential file does not exist in the default path |
269
|
|
|
// and section name does not exist |
270
|
|
|
p = newProfileProvider("first") |
271
|
|
|
value, ok = p.(*profileProvider) |
272
|
|
|
assert.True(t, ok) |
273
|
|
|
assert.Equal(t, value.Profile, "first") |
274
|
|
|
c, err = p.resolve() |
275
|
|
|
assert.Nil(t, c) |
276
|
|
|
assert.Nil(t, err) |
277
|
|
|
|
278
|
|
|
// testcase 4, credential file path is error |
279
|
|
|
os.Setenv(ENVCredentialFile, "../../credentials_error") |
280
|
|
|
p = newProfileProvider() |
281
|
|
|
c, err = p.resolve() |
282
|
|
|
assert.Nil(t, c) |
283
|
|
|
assert.True(t, strings.Contains(err.Error(), "ERROR: Can not open file")) |
284
|
|
|
|
285
|
|
|
// create profile |
286
|
|
|
os.Setenv(ENVCredentialFile, "./credentials") |
287
|
|
|
|
288
|
|
|
file, err := os.Create("./credentials") |
289
|
|
|
assert.Nil(t, err) |
290
|
|
|
file.WriteString(inistr) |
291
|
|
|
file.Close() |
292
|
|
|
defer os.Remove("./credentials") |
293
|
|
|
|
294
|
|
|
// testcase 5, section does not exist |
295
|
|
|
p = newProfileProvider("NonExist") |
296
|
|
|
c, err = p.resolve() |
297
|
|
|
assert.Nil(t, c) |
298
|
|
|
assert.Contains(t, err.Error(), "ERROR: Can not load section section") |
299
|
|
|
|
300
|
|
|
// testcase 6, credential type does not set |
301
|
|
|
p = newProfileProvider("notype") |
302
|
|
|
c, err = p.resolve() |
303
|
|
|
assert.Nil(t, c) |
304
|
|
|
assert.Contains(t, err.Error(), "missing required type option error when getting key of section") |
305
|
|
|
|
306
|
|
|
// testcase 7, normal AK |
307
|
|
|
p = newProfileProvider() |
308
|
|
|
c, err = p.resolve() |
309
|
|
|
assert.Equal(t, "access_key", tea.StringValue(c.Type)) |
310
|
|
|
assert.Nil(t, err) |
311
|
|
|
// testcase 8, access_key_id key does not exist |
312
|
|
|
p = newProfileProvider("noak") |
313
|
|
|
c, err = p.resolve() |
314
|
|
|
assert.Nil(t, c) |
315
|
|
|
assert.Equal(t, "missing required access_key_id option in profile for access_key", err.Error()) |
316
|
|
|
// testcase 9, access_key_id value is empty |
317
|
|
|
p = newProfileProvider("emptyak") |
318
|
|
|
c, err = p.resolve() |
319
|
|
|
assert.Nil(t, c) |
320
|
|
|
assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
321
|
|
|
// testcase 10, access_key_secret key does not exist |
322
|
|
|
p = newProfileProvider("noaksecret") |
323
|
|
|
c, err = p.resolve() |
324
|
|
|
assert.Nil(t, c) |
325
|
|
|
assert.Equal(t, "missing required access_key_secret option in profile for access_key", err.Error()) |
326
|
|
|
// testcase 11, access_key_secret value is empty |
327
|
|
|
p = newProfileProvider("emptyaksecret") |
328
|
|
|
c, err = p.resolve() |
329
|
|
|
assert.Nil(t, c) |
330
|
|
|
assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
331
|
|
|
|
332
|
|
|
//testcase 12, normal EcsRamRole |
333
|
|
|
p = newProfileProvider("ecs") |
334
|
|
|
c, err = p.resolve() |
335
|
|
|
assert.Equal(t, "ecs_ram_role", tea.StringValue(c.Type)) |
336
|
|
|
assert.Nil(t, err) |
337
|
|
|
//testcase 15, timeout is not int |
338
|
|
|
p = newProfileProvider("invalidRuntimeEcs") |
339
|
|
|
c, err = p.resolve() |
340
|
|
|
assert.Nil(t, c) |
341
|
|
|
assert.Equal(t, "please set timeout with an int value", err.Error()) |
342
|
|
|
|
343
|
|
|
//testcase 16, normal RamRoleArn |
344
|
|
|
p = newProfileProvider("ram") |
345
|
|
|
c, err = p.resolve() |
346
|
|
|
assert.Equal(t, "ram_role_arn", tea.StringValue(c.Type)) |
347
|
|
|
assert.Nil(t, err) |
348
|
|
|
//testcase 17, access_key_id key does not exist |
349
|
|
|
p = newProfileProvider("noramak") |
350
|
|
|
c, err = p.resolve() |
351
|
|
|
assert.Nil(t, c) |
352
|
|
|
assert.Equal(t, "missing required access_key_id option in profile for ram_role_arn", err.Error()) |
353
|
|
|
//testcase 18, access_key_id value is empty |
354
|
|
|
p = newProfileProvider("emptyramak") |
355
|
|
|
c, err = p.resolve() |
356
|
|
|
assert.Nil(t, c) |
357
|
|
|
assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
358
|
|
|
//testcase 19, access_key_secret key does not exist |
359
|
|
|
p = newProfileProvider("noramsecret") |
360
|
|
|
c, err = p.resolve() |
361
|
|
|
assert.Nil(t, c) |
362
|
|
|
assert.Equal(t, "missing required access_key_secret option in profile for ram_role_arn", err.Error()) |
363
|
|
|
//testcase 20, access_key_secret value is empty |
364
|
|
|
p = newProfileProvider("emptyramsecret") |
365
|
|
|
c, err = p.resolve() |
366
|
|
|
assert.Nil(t, c) |
367
|
|
|
assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
368
|
|
|
//testcase 21, role_arn key does not exist |
369
|
|
|
p = newProfileProvider("noramarn") |
370
|
|
|
c, err = p.resolve() |
371
|
|
|
assert.Nil(t, c) |
372
|
|
|
assert.Equal(t, "missing required role_arn option in profile for ram_role_arn", err.Error()) |
373
|
|
|
//testcase 22, role_arn value is empty |
374
|
|
|
p = newProfileProvider("emptyramarn") |
375
|
|
|
c, err = p.resolve() |
376
|
|
|
assert.Nil(t, c) |
377
|
|
|
assert.Equal(t, "role_arn cannot be empty", err.Error()) |
378
|
|
|
//testcase 23, role_session_name key does not exist |
379
|
|
|
p = newProfileProvider("noramsessionname") |
380
|
|
|
c, err = p.resolve() |
381
|
|
|
assert.Nil(t, c) |
382
|
|
|
assert.Equal(t, "missing required role_session_name option in profile for ram_role_arn", err.Error()) |
383
|
|
|
//testcase 24, role_session_name value is empty |
384
|
|
|
p = newProfileProvider("emptyramsessionname") |
385
|
|
|
c, err = p.resolve() |
386
|
|
|
assert.Nil(t, c) |
387
|
|
|
assert.Equal(t, "role_session_name cannot be empty", err.Error()) |
388
|
|
|
//testcase 25, role_session_expiration is not int |
389
|
|
|
p = newProfileProvider("invalidexpirationram") |
390
|
|
|
c, err = p.resolve() |
391
|
|
|
assert.Nil(t, c) |
392
|
|
|
assert.Equal(t, "role_session_expiration must be an int", err.Error()) |
393
|
|
|
//testcase 26, timeout is not int |
394
|
|
|
p = newProfileProvider("invalidRuntimeram") |
395
|
|
|
c, err = p.resolve() |
396
|
|
|
assert.Nil(t, c) |
397
|
|
|
assert.Equal(t, "please set timeout with an int value", err.Error()) |
398
|
|
|
|
399
|
|
|
//testase 27, normal RsaKeyPair |
400
|
|
|
file, err = os.Create("./pk.pem") |
401
|
|
|
assert.Nil(t, err) |
402
|
|
|
_, err = file.WriteString(privatekey) |
403
|
|
|
assert.Nil(t, err) |
404
|
|
|
file.Close() |
405
|
|
|
|
406
|
|
|
p = newProfileProvider("rsa") |
407
|
|
|
c, err = p.resolve() |
408
|
|
|
assert.Equal(t, "rsa_key_pair", tea.StringValue(c.Type)) |
409
|
|
|
assert.Nil(t, err) |
410
|
|
|
defer os.Remove(`./pk.pem`) |
411
|
|
|
//testcase 28, private_key_file key does not exist |
412
|
|
|
p = newProfileProvider("norsaprivate") |
413
|
|
|
c, err = p.resolve() |
414
|
|
|
assert.Nil(t, c) |
415
|
|
|
assert.Equal(t, "missing required private_key_file option in profile for rsa_key_pair", err.Error()) |
416
|
|
|
//testcase 29, private_key_file value is empty |
417
|
|
|
p = newProfileProvider("emptyrsaprivate") |
418
|
|
|
c, err = p.resolve() |
419
|
|
|
assert.Nil(t, c) |
420
|
|
|
assert.Equal(t, "private_key_file cannot be empty", err.Error()) |
421
|
|
|
//testcase 30, public_key_id key does not exist |
422
|
|
|
p = newProfileProvider("norsapublic") |
423
|
|
|
c, err = p.resolve() |
424
|
|
|
assert.Nil(t, c) |
425
|
|
|
assert.Equal(t, "missing required public_key_id option in profile for rsa_key_pair", err.Error()) |
426
|
|
|
//testcase 31, public_key_id value is empty |
427
|
|
|
p = newProfileProvider("emptyrsapublic") |
428
|
|
|
c, err = p.resolve() |
429
|
|
|
assert.Nil(t, c) |
430
|
|
|
assert.Equal(t, "public_key_id cannot be empty", err.Error()) |
431
|
|
|
//testcase 32, session_expiration is not int |
432
|
|
|
p = newProfileProvider("invalidexpirationrsa") |
433
|
|
|
c, err = p.resolve() |
434
|
|
|
assert.Nil(t, c) |
435
|
|
|
assert.Equal(t, "session_expiration must be an int", err.Error()) |
436
|
|
|
//testcase 33, timeout is not int |
437
|
|
|
p = newProfileProvider("invalidTimeoutrsa") |
438
|
|
|
c, err = p.resolve() |
439
|
|
|
assert.Nil(t, c) |
440
|
|
|
assert.Equal(t, "please set timeout with an int value", err.Error()) |
441
|
|
|
//testcase 34, connect_timeout is not int |
442
|
|
|
p = newProfileProvider("invalidConnectTimeoutrsa") |
443
|
|
|
c, err = p.resolve() |
444
|
|
|
assert.Nil(t, c) |
445
|
|
|
assert.Equal(t, "please set connect_timeout with an int value", err.Error()) |
446
|
|
|
|
447
|
|
|
//testcase 35, normal RamRoleArn |
448
|
|
|
p = newProfileProvider("sts") |
449
|
|
|
c, err = p.resolve() |
450
|
|
|
assert.Equal(t, "sts", tea.StringValue(c.Type)) |
451
|
|
|
assert.Nil(t, err) |
452
|
|
|
//testcase 36, access_key_id key does not exist |
453
|
|
|
p = newProfileProvider("nostskey") |
454
|
|
|
c, err = p.resolve() |
455
|
|
|
assert.Nil(t, c) |
456
|
|
|
assert.Equal(t, "missing required access_key_id option in profile for sts", err.Error()) |
457
|
|
|
//testcase 37, access_key_id value is empty |
458
|
|
|
p = newProfileProvider("emptystskey") |
459
|
|
|
c, err = p.resolve() |
460
|
|
|
assert.Nil(t, c) |
461
|
|
|
assert.Equal(t, "access_key_id cannot be empty", err.Error()) |
462
|
|
|
//testcase 38, access_key_secret key does not exist |
463
|
|
|
p = newProfileProvider("nostssecret") |
464
|
|
|
c, err = p.resolve() |
465
|
|
|
assert.Nil(t, c) |
466
|
|
|
assert.Equal(t, "missing required access_key_secret option in profile for sts", err.Error()) |
467
|
|
|
//testcase 39, access_key_secret value is empty |
468
|
|
|
p = newProfileProvider("emptystssecret") |
469
|
|
|
c, err = p.resolve() |
470
|
|
|
assert.Nil(t, c) |
471
|
|
|
assert.Equal(t, "access_key_secret cannot be empty", err.Error()) |
472
|
|
|
//testcase 40, security_token access_key_secretkey does not exist |
473
|
|
|
p = newProfileProvider("noststoken") |
474
|
|
|
c, err = p.resolve() |
475
|
|
|
assert.Nil(t, c) |
476
|
|
|
assert.Equal(t, "missing required security_token option in profile for sts", err.Error()) |
477
|
|
|
//testcase 41, security_token value is empty |
478
|
|
|
p = newProfileProvider("emptyststoken") |
479
|
|
|
c, err = p.resolve() |
480
|
|
|
assert.Nil(t, c) |
481
|
|
|
assert.Equal(t, "security_token cannot be empty", err.Error()) |
482
|
|
|
|
483
|
|
|
//testcase 42, normal RamRoleArn |
484
|
|
|
p = newProfileProvider("bearer") |
485
|
|
|
c, err = p.resolve() |
486
|
|
|
assert.Equal(t, "bearer", tea.StringValue(c.Type)) |
487
|
|
|
assert.Nil(t, err) |
488
|
|
|
//testcase 43, key does not exist |
489
|
|
|
p = newProfileProvider("nobearer") |
490
|
|
|
c, err = p.resolve() |
491
|
|
|
assert.Nil(t, c) |
492
|
|
|
assert.Equal(t, "missing required bearer_token option in profile for bearer", err.Error()) |
493
|
|
|
//testcase 44, value is empty |
494
|
|
|
p = newProfileProvider("emptybearer") |
495
|
|
|
c, err = p.resolve() |
496
|
|
|
assert.Nil(t, c) |
497
|
|
|
assert.Equal(t, "bearer_token cannot be empty", err.Error()) |
498
|
|
|
|
499
|
|
|
//testcase 45, credential type is error |
500
|
|
|
p = newProfileProvider("error_type") |
501
|
|
|
c, err = p.resolve() |
502
|
|
|
assert.Nil(t, c) |
503
|
|
|
assert.Equal(t, "invalid type option, support: access_key, sts, ecs_ram_role, ram_role_arn, rsa_key_pair", err.Error()) |
504
|
|
|
} |
505
|
|
|
|
506
|
|
|
func TestHookState(t *testing.T) { |
507
|
|
|
info, err := hookState(nil, nil) |
508
|
|
|
assert.Nil(t, info) |
509
|
|
|
assert.Nil(t, err) |
510
|
|
|
|
511
|
|
|
originHookState := hookState |
512
|
|
|
hookState = func(info os.FileInfo, err error) (os.FileInfo, error) { |
513
|
|
|
return nil, nil |
514
|
|
|
} |
515
|
|
|
defer func() { |
516
|
|
|
hookState = originHookState |
517
|
|
|
}() |
518
|
|
|
path, err := checkDefaultPath() |
519
|
|
|
assert.Nil(t, err) |
520
|
|
|
assert.NotNil(t, path) |
521
|
|
|
} |
522
|
|
|
|