GitHub Access Token became invalid

It seems like the GitHub access token used for retrieving details about this repository from GitHub became invalid. This might prevent certain types of inspections from being run (in particular, everything related to pull requests).
Please ask an admin of your repository to re-new the access token on this website.
Passed
Push — master ( f0e98e...e6ece0 )
by Jackson
07:44
created

credentials.TestHookOS   A

Complexity

Conditions 3

Size

Total Lines 21
Code Lines 17

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 3
eloc 17
dl 0
loc 21
rs 9.55
c 0
b 0
f 0
nop 1
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