credentials.TestHookOS - Code Metrics - Inspection of "move inner method into internal package" - aliyun/credentials-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f0e98e...e6ece0 )

by Jackson

created 2024-08-16 14:39 UTC

credentials.TestHookOS A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	21
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	17
dl	0
loc	21
rs	9.55
c	0
b	0
f	0
nop	1

package credentials

import (
	"os"
	"runtime"
	"strings"
	"testing"

	"github.com/alibabacloud-go/tea/tea"
	"github.com/stretchr/testify/assert"
)

var inistr = `
[default]
enable = true
type = access_key
access_key_id = foo
access_key_secret = bar

[notype]
access_key_id = foo
access_key_secret = bar

[noak]
type = access_key
access_key_secret = bar

[emptyak]
type = access_key
access_key_id =
access_key_secret = bar

[noaksecret]
type = access_key
access_key_id =  bar

[emptyaksecret]
type = access_key
access_key_id =  bar
access_key_secret =

[ecs]
type = ecs_ram_role
role_name = EcsRamRoleTest

[noecs]
type = ecs_ram_role

[emptyecs]
type = ecs_ram_role
role_name =

[invalidRuntimeEcs]
type = ecs_ram_role
role_name = EcsRamRoleTest
timeout = a

[ram]
type = ram_role_arn
access_key_id = foo
access_key_secret = bar
role_arn = role_arn
role_session_name = session_name

[noramak]
type = ram_role_arn
access_key_secret = bar
role_arn = role_arn
role_session_name = session_name

[emptyramak]
type = ram_role_arn
access_key_id =
access_key_secret = bar
role_arn = role_arn
role_session_name = session_name

[noramsecret]
type = ram_role_arn
access_key_id = id
role_arn = role_arn
role_session_name = session_name  

[emptyramsecret]
type = ram_role_arn
access_key_id = id
access_key_secret =
role_arn = role_arn
role_session_name = session_name

[noramarn]
type = ram_role_arn
access_key_id = id
access_key_secret = bar
role_session_name = session_name

[emptyramarn]
type = ram_role_arn
access_key_id = id
access_key_secret = bar
role_arn =
role_session_name = session_name

[noramsessionname]                                         
type = ram_role_arn   
access_key_id = id             
access_key_secret = bar
role_arn = role_arn

[emptyramsessionname]                                         
type = ram_role_arn                
access_key_id = id
access_key_secret = bar
role_arn = role_arn
role_session_name =

[invalidexpirationram]                                         
type = ram_role_arn                
access_key_id = foo
access_key_secret = bar
role_arn = role_arn
role_session_name = session_name
role_session_expiration = a

[invalidRuntimeram]                         
type = ram_role_arn                
access_key_id = foo
access_key_secret = bar
role_arn = role_arn
role_session_name = session_name
timeout = a

[sts]                                         
type = sts                
access_key_id = foo
access_key_secret = bar
security_token= token

[nostskey]                                         
type = sts                
access_key_secret = bar
security_token= token 

[emptystskey]                                         
type = sts                
access_key_id =
access_key_secret = bar
security_token= token

[nostssecret]                                         
type = sts    
access_key_id = id          
security_token= token 

[emptystssecret]                                         
type = sts                
access_key_id = id
access_key_secret =
security_token= token

[noststoken]                                         
type = sts     
access_key_id = id           
access_key_secret = bar

[emptyststoken]                                         
type = sts                
access_key_id = id
access_key_secret = bar
security_token=

[bearer]                                         
type = bearer                
bearer_token = foo 

[nobearer]                                         
type = bearer                

[emptybearer]                                         
type = bearer                
bearer_token = 

[rsa]                          
type = rsa_key_pair               
public_key_id = publicKeyId       
private_key_file = ./pk.pem
proxy = www.aliyun.com
timeout = 10
connect_timeout = 10
host = www.aliyun.com

[norsaprivate]
type = rsa_key_pair
public_key_id = publicKeyId

[emptyrsaprivate]
type = rsa_key_pair
public_key_id = publicKeyId
private_key_file = 

[norsapublic]
type = rsa_key_pair
private_key_file = ./pk.pem

[emptyrsapublic]
type = rsa_key_pair
public_key_id =
private_key_file = ./pk.pem

[invalidexpirationrsa]
type = rsa_key_pair
public_key_id = publicKeyId
private_key_file = ./pk.pem
session_expiration = a

[invalidTimeoutrsa]
type = rsa_key_pair
public_key_id = publicKeyId
private_key_file = ./pk.pem
timeout = a

[invalidConnectTimeoutrsa]
type = rsa_key_pair
public_key_id = publicKeyId
private_key_file = ./pk.pem
connect_timeout = a

[error_type]
type = error_type
public_key_id = publicKeyId
private_key_file = ./pk_error.pem
`

func TestProfileProvider(t *testing.T) {
	var HOME string
	if runtime.GOOS == "windows" {
		HOME = "USERPROFILE"
	} else {
		HOME = "HOME"
	}
	path, ok := os.LookupEnv(HOME)
	assert.True(t, ok)
	os.Unsetenv(HOME)

	// testcase 1, no HOME or USERPROFILE environment variable set
	p := newProfileProvider()
	c, err := p.resolve()
	assert.Nil(t, c)
	assert.EqualError(t, err, "the default credential file path is invalid")

	originFilePath := os.Getenv(ENVCredentialFile)
	os.Setenv(ENVCredentialFile, "")
	defer func() {
		os.Setenv(ENVCredentialFile, originFilePath)
	}()
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.EqualError(t, err, "ALIBABA_CLOUD_CREDENTIALS_FILE cannot be empty")

	// testcase 2, default profile object
	os.Unsetenv(ENVCredentialFile)
	os.Setenv(HOME, path)
	p = newProfileProvider()
	value, ok := p.(*profileProvider)
	assert.True(t, ok)
	assert.Equal(t, value.Profile, "default")

	// testcase 3, credential file does not exist in the default path
	// and section name does not exist
	p = newProfileProvider("first")
	value, ok = p.(*profileProvider)
	assert.True(t, ok)
	assert.Equal(t, value.Profile, "first")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Nil(t, err)

	// testcase 4, credential file path is error
	os.Setenv(ENVCredentialFile, "../../credentials_error")
	p = newProfileProvider()
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.True(t, strings.Contains(err.Error(), "ERROR: Can not open file"))

	// create profile
	os.Setenv(ENVCredentialFile, "./credentials")

	file, err := os.Create("./credentials")
	assert.Nil(t, err)
	file.WriteString(inistr)
	file.Close()
	defer os.Remove("./credentials")

	// testcase 5, section does not exist
	p = newProfileProvider("NonExist")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Contains(t, err.Error(), "ERROR: Can not load section section")

	// testcase 6, credential type does not set
	p = newProfileProvider("notype")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Contains(t, err.Error(), "missing required type option error when getting key of section")

	// testcase 7, normal AK
	p = newProfileProvider()
	c, err = p.resolve()
	assert.Equal(t, "access_key", tea.StringValue(c.Type))
	assert.Nil(t, err)
	// testcase 8, access_key_id key does not exist
	p = newProfileProvider("noak")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_id option in profile for access_key", err.Error())
	// testcase 9, access_key_id value is empty
	p = newProfileProvider("emptyak")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_id cannot be empty", err.Error())
	// testcase 10, access_key_secret key does not exist
	p = newProfileProvider("noaksecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_secret option in profile for access_key", err.Error())
	// testcase 11, access_key_secret value is empty
	p = newProfileProvider("emptyaksecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_secret cannot be empty", err.Error())

	//testcase 12, normal EcsRamRole
	p = newProfileProvider("ecs")
	c, err = p.resolve()
	assert.Equal(t, "ecs_ram_role", tea.StringValue(c.Type))
	assert.Nil(t, err)
	//testcase 15, timeout is not int
	p = newProfileProvider("invalidRuntimeEcs")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "please set timeout with an int value", err.Error())

	//testcase 16, normal RamRoleArn
	p = newProfileProvider("ram")
	c, err = p.resolve()
	assert.Equal(t, "ram_role_arn", tea.StringValue(c.Type))
	assert.Nil(t, err)
	//testcase 17, access_key_id key does not exist
	p = newProfileProvider("noramak")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_id option in profile for ram_role_arn", err.Error())
	//testcase 18, access_key_id value is empty
	p = newProfileProvider("emptyramak")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_id cannot be empty", err.Error())
	//testcase 19, access_key_secret key does not exist
	p = newProfileProvider("noramsecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_secret option in profile for ram_role_arn", err.Error())
	//testcase 20, access_key_secret value is empty
	p = newProfileProvider("emptyramsecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_secret cannot be empty", err.Error())
	//testcase 21, role_arn key does not exist
	p = newProfileProvider("noramarn")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required role_arn option in profile for ram_role_arn", err.Error())
	//testcase 22, role_arn value is empty
	p = newProfileProvider("emptyramarn")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "role_arn cannot be empty", err.Error())
	//testcase 23, role_session_name key does not exist
	p = newProfileProvider("noramsessionname")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required role_session_name option in profile for ram_role_arn", err.Error())
	//testcase 24, role_session_name value is empty
	p = newProfileProvider("emptyramsessionname")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "role_session_name cannot be empty", err.Error())
	//testcase 25, role_session_expiration is not int
	p = newProfileProvider("invalidexpirationram")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "role_session_expiration must be an int", err.Error())
	//testcase 26, timeout is not int
	p = newProfileProvider("invalidRuntimeram")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "please set timeout with an int value", err.Error())

	//testase 27, normal RsaKeyPair
	file, err = os.Create("./pk.pem")
	assert.Nil(t, err)
	_, err = file.WriteString(privatekey)
	assert.Nil(t, err)
	file.Close()

	p = newProfileProvider("rsa")
	c, err = p.resolve()
	assert.Equal(t, "rsa_key_pair", tea.StringValue(c.Type))
	assert.Nil(t, err)
	defer os.Remove(`./pk.pem`)
	//testcase 28, private_key_file key does not exist
	p = newProfileProvider("norsaprivate")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required private_key_file option in profile for rsa_key_pair", err.Error())
	//testcase 29, private_key_file value is empty
	p = newProfileProvider("emptyrsaprivate")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "private_key_file cannot be empty", err.Error())
	//testcase 30, public_key_id key does not exist
	p = newProfileProvider("norsapublic")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required public_key_id option in profile for rsa_key_pair", err.Error())
	//testcase 31, public_key_id value is empty
	p = newProfileProvider("emptyrsapublic")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "public_key_id cannot be empty", err.Error())
	//testcase 32, session_expiration is not int
	p = newProfileProvider("invalidexpirationrsa")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "session_expiration must be an int", err.Error())
	//testcase 33, timeout is not int
	p = newProfileProvider("invalidTimeoutrsa")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "please set timeout with an int value", err.Error())
	//testcase 34, connect_timeout is not int
	p = newProfileProvider("invalidConnectTimeoutrsa")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "please set connect_timeout with an int value", err.Error())

	//testcase 35, normal RamRoleArn
	p = newProfileProvider("sts")
	c, err = p.resolve()
	assert.Equal(t, "sts", tea.StringValue(c.Type))
	assert.Nil(t, err)
	//testcase 36, access_key_id key does not exist
	p = newProfileProvider("nostskey")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_id option in profile for sts", err.Error())
	//testcase 37, access_key_id value is empty
	p = newProfileProvider("emptystskey")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_id cannot be empty", err.Error())
	//testcase 38, access_key_secret key does not exist
	p = newProfileProvider("nostssecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required access_key_secret option in profile for sts", err.Error())
	//testcase 39, access_key_secret value is empty
	p = newProfileProvider("emptystssecret")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "access_key_secret cannot be empty", err.Error())
	//testcase 40, security_token access_key_secretkey does not exist
	p = newProfileProvider("noststoken")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required security_token option in profile for sts", err.Error())
	//testcase 41, security_token value is empty
	p = newProfileProvider("emptyststoken")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "security_token cannot be empty", err.Error())

	//testcase 42, normal RamRoleArn
	p = newProfileProvider("bearer")
	c, err = p.resolve()
	assert.Equal(t, "bearer", tea.StringValue(c.Type))
	assert.Nil(t, err)
	//testcase 43, key does not exist
	p = newProfileProvider("nobearer")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "missing required bearer_token option in profile for bearer", err.Error())
	//testcase 44, value is empty
	p = newProfileProvider("emptybearer")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "bearer_token cannot be empty", err.Error())

	//testcase 45, credential type is error
	p = newProfileProvider("error_type")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "invalid type option, support: access_key, sts, ecs_ram_role, ram_role_arn, rsa_key_pair", err.Error())
}

func TestHookState(t *testing.T) {
	info, err := hookState(nil, nil)
	assert.Nil(t, info)
	assert.Nil(t, err)

	originHookState := hookState
	hookState = func(info os.FileInfo, err error) (os.FileInfo, error) {
		return nil, nil
	}
	defer func() {
		hookState = originHookState
	}()
	path, err := checkDefaultPath()
	assert.Nil(t, err)
	assert.NotNil(t, path)
}


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

aliyun / credentials-go

GitHub Access Token became invalid

Push — master ( f0e98e...e6ece0 )

credentials.TestHookOS A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like