credentials/profile_provider_test.go - Code Metrics - Inspection of "fix .scrutinizer.yml" - aliyun/credentials-go - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#9)

by zuochao

created 2019-09-06 07:29 UTC

credentials/profile_provider_test.go A

↳ Parent: Project

Size/Duplication

Total Lines	546
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	9
eloc	245
dl	0
loc	546
rs	10
c	0
b	0
f	0

3 Methods

Rating	Name	Size	Complexity
B	credentials.TestProfileProvider	274	3
A	credentials.TestHookOS	21	3
A	credentials.TestHookState	15	3

package credentials

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

	"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.Equal(t, "ERROR: Can not load section section 'NonExist' does not exist", err.Error())

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

	// testcase 7, normal AK
	p = newProfileProvider()
	c, err = p.resolve()
	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.Nil(t, err)
	//testcase 13, key does not exist
	p = newProfileProvider("noecs")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "Missing required role_name option in profile for ecs_ram_role", err.Error())
	//testcase 14, value is empty
	p = newProfileProvider("emptyecs")
	c, err = p.resolve()
	assert.Nil(t, c)
	assert.Equal(t, "role_name cannot be empty", err.Error())
	//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.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.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.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.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 TestHookOS(t *testing.T) {
	goos := "windows"
	goos = hookOS(goos)
	assert.Equal(t, "windows", goos)

	originHookOs := hookOS
	originUserProfile := os.Getenv("USERPROFILE")
	hookOS = func(goos string) string {
		return "windows"
	}
	defer func() {
		hookOS = originHookOs
		os.Setenv("USERPROFILE", originUserProfile)
	}()
	os.Unsetenv("USERPROFILE")
	path := getHomePath()
	assert.Equal(t, "", path)

	os.Setenv("USERPROFILE", "ok")
	path = getHomePath()
	assert.Equal(t, "ok", path)
}

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

aliyun / credentials-go

GitHub Access Token became invalid

Pull Request — master (#9)

credentials/profile_provider_test.go A

Size/Duplication

Importance

3 Methods

Duplication Side-by-Side

Filter issues like