Improve testcase cover of package provider

sdk/auth/credentials/provider/instance_credentials_test.go

@@ -12,21 +12,29 @@ import (
 )
 
 func TestInstanceCredentialsProvider(t *testing.T) {
+	//testcase 1
+	//return nil, nil
 	p := provider.NewInstanceCredentialsProvider()
 	c, err := p.Resolve()
 	assert.Nil(t, c)
 	assert.Nil(t, err)
 
+	//testcase 2
+	//return nil, errors.New("Environmental variable 'ALIBABA_CLOUD_ECS_METADATA' are empty")
 	os.Setenv(provider.ENVEcsMetadata, "")
 	c, err = p.Resolve()
 	assert.Nil(t, c)
 	assert.EqualError(t, err, "Environmental variable 'ALIBABA_CLOUD_ECS_METADATA' are empty")
 
+	//testcase 3
+	//return nil, err
 	os.Setenv(provider.ENVEcsMetadata, "test")
 	c, err = p.Resolve()
 	assert.Nil(t, c)
 	assert.NotNil(t, err)
 
+	//testcase 4
+	//return nil, fmt.Errorf("The role was not found in the instance")
 	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
 		return func(string) (int, []byte, error) {
 			return 404, []byte(""), nil
@@ -36,6 +44,8 @@ func TestInstanceCredentialsProvider(t *testing.T) {
 	assert.Nil(t, c)
 	assert.EqualError(t, err, "The role was not found in the instance")
 
+	//testcase 5
+	//return nil, fmt.Errorf("Received %d when getting security credentials for %s", status, roleName)
 	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
 		return func(string) (int, []byte, error) {
 			return 400, []byte(""), nil
@@ -45,13 +55,75 @@ func TestInstanceCredentialsProvider(t *testing.T) {
 	assert.Nil(t, c)
 	assert.EqualError(t, err, "Received 400 when getting security credentials for test")
 
+	//testcase 6
+	//json unmarshal error
+	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
+		return func(string) (int, []byte, error) {
+			return 200, []byte(`{
+				AccessKSTS.*******
+			  }`), nil
+		}
+	}
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.NotNil(t, err)
+
+	//testcase 7, AccessKeyId does not receive
+	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
+		return func(string) (int, []byte, error) {
+			return 200, []byte(`{
+				"AccessKeySecret" : "*******",
+				"Expiration" : "2019-01-28T15:15:56Z",
+				"SecurityToken" : "SecurityToken",
+				"LastUpdated" : "2019-01-28T09:15:55Z",
+				"Code" : "Success"
+			  }`), nil
+		}
+	}
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "AccessKeyId not in map")
+
+	//testcase 8,AccessKeySecret does not receive
+	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
+		return func(string) (int, []byte, error) {
+			return 200, []byte(`{
+				"AccessKeyId" : "STS.*******",
+				"Expiration" : "2019-01-28T15:15:56Z",
+				"SecurityToken" : "SecurityToken",
+				"LastUpdated" : "2019-01-28T09:15:55Z",
+				"Code" : "Success"
+			  }`), nil
+		}
+	}
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "AccessKeySecret not in map")
+
+	//testcase 9, SecurityToken does not receive
+	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
+		return func(string) (int, []byte, error) {
+			return 200, []byte(`{
+				"AccessKeyId" : "STS.*******",
+				"AccessKeySecret" : "*******",
+				"Expiration" : "2019-01-28T15:15:56Z",
+				"LastUpdated" : "2019-01-28T09:15:55Z",
+				"Code" : "Success"
+			  }`), nil
+		}
+	}
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "SecurityToken not in map")
+
+	//testcase, normal receive
 	provider.HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) {
 		return func(string) (int, []byte, error) {
 			return 200, []byte(`{
 				"AccessKeyId" : "STS.*******",
 				"AccessKeySecret" : "*******",
 				"Expiration" : "2019-01-28T15:15:56Z",
-				"SecurityToken" : "bbbbb",
+				"SecurityToken" : "SecurityToken",
 				"LastUpdated" : "2019-01-28T09:15:55Z",
 				"Code" : "Success"
 			  }`), nil
@@ -59,6 +131,6 @@ func TestInstanceCredentialsProvider(t *testing.T) {
 	}
 	c, err = p.Resolve()
 	assert.Nil(t, err)
-	assert.Equal(t, credentials.NewStsTokenCredential("STS.*******", "*******", "bbbbb"), c)
+	assert.Equal(t, credentials.NewStsTokenCredential("STS.*******", "*******", "SecurityToken"), c)
 
 }

sdk/auth/credentials/provider/profile_credentials_test.go

@@ -2,6 +2,8 @@ package provider_test
 
 import (
 	"os"
+	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
@@ -17,44 +19,119 @@ enable = true
 type = access_key                
 access_key_id = foo               
 access_key_secret = bar            
-                   
-[client1]                         
+				   
+[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     
+
+[ecs]                         
+type = ecs_ram_role                
+role_name = EcsRamRoleTest
+
+[noecs]
 type = ecs_ram_role                
-role_name = EcsRamRoleTest       
 
-[client2]                                         
+[emptyecs]                         
+type = ecs_ram_role                
+role_name = 
+
+[ram]                                         
 type = ram_role_arn                
 access_key_id = foo
 access_key_secret = bar
 role_arn = role_arn
-role_session_name = session_name
+role_session_name = session_name  
+
+[noram]                                         
+type = ram_role_arn                
+access_key_secret = bar
+role_arn = role_arn
+role_session_name = session_name  
 
-[client3]                          
-type = bearer_token                
-bearer_token = bearer_token        
+[emptyram]                                         
+type = ram_role_arn                
+access_key_id = 
+access_key_secret = bar
+role_arn = role_arn
+role_session_name = session_name  
 
-[client4]                          
+[rsa]                          
 type = rsa_key_pair               
 public_key_id = publicKeyId       
 private_key_file = ./pk.pem
+
+[norsa]                          
+type = rsa_key_pair               
+public_key_id = publicKeyId       
+
+[emptyrsa]                          
+type = rsa_key_pair               
+public_key_id = publicKeyId       
+private_key_file = 
+
+[error_rsa]                          
+type = rsa_key_pair               
+public_key_id = publicKeyId       
+private_key_file = ./pk_error.pem
+
+[error_type]                          
+type = error_type               
+public_key_id = publicKeyId       
+private_key_file = ./pk_error.pem
 `
 var privatekey = `this is privatekey`
 
 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 := provider.NewProfileProvider()
+	c, err := p.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "The default credential file path is invalid")
+
+	// testcase 2, default profile object
+	os.Setenv(HOME, path)
+	p = provider.NewProfileProvider()
 	value, ok := p.(*provider.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 = provider.NewProfileProvider("first")
 	value, ok = p.(*provider.ProfileProvider)
 	assert.True(t, ok)
 	assert.Equal(t, value.Profile, "first")
-
-	c, err := p.Resolve()
+	c, err = p.Resolve()
 	assert.Nil(t, c)
 	assert.Nil(t, err)
 
+	// testcase 4, credential file path is error
+	os.Setenv(provider.ENVCredentialFile, "../../credentials_error")
+	p = provider.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(provider.ENVCredentialFile, "./credentials")
 
 	file, err := os.Create("./credentials")
@@ -63,34 +140,97 @@ func TestProfileProvider(t *testing.T) {
 	file.Close()
 	defer os.Remove("./credentials")
 
+	// testcase 5, section does not exist
+	p = provider.NewProfileProvider("NonExist")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Can not load section"))
+
+	// testcase 6, credential type does not set
+	p = provider.NewProfileProvider("notype")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Can not find credential type"))
+
+	// testcase 7, normal AK
 	p = provider.NewProfileProvider()
 	c, err = p.Resolve()
 	assert.Equal(t, credentials.NewAccessKeyCredential("foo", "bar"), c)
 	assert.Nil(t, err)
+	// testcase 8, key does not exist
+	p = provider.NewProfileProvider("noak")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Failed to get value"))
+	// testcase 9, value is empty
+	p = provider.NewProfileProvider("emptyak")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Value can't be empty"))
 
-	p = provider.NewProfileProvider("client1")
+	//testcase 10, normal EcsRamRole
+	p = provider.NewProfileProvider("ecs")
 	c, err = p.Resolve()
 	assert.Equal(t, credentials.NewEcsRamRoleCredential("EcsRamRoleTest"), c)
 	assert.Nil(t, err)
+	//testcase 11, key does not exist
+	p = provider.NewProfileProvider("noecs")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Failed to get value"))
+	//testcase 12, value is empty
+	p = provider.NewProfileProvider("emptyecs")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Value can't be empty"))
 
-	p = provider.NewProfileProvider("client2")
+	//testcase 13, normal RamRoleArn
+	p = provider.NewProfileProvider("ram")
 	c, err = p.Resolve()
 	assert.Equal(t, credentials.NewRamRoleArnCredential("foo", "bar", "role_arn", "session_name", 3600), c)
 	assert.Nil(t, err)
+	//testcase 14, key does not exist
+	p = provider.NewProfileProvider("noram")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Failed to get value"))
+	//testcase 15, value is empty
+	p = provider.NewProfileProvider("emptyram")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Value can't be empty"))
 
+	//testase 16, normal RsaKeyPair
 	file, err = os.Create("./pk.pem")
 	assert.Nil(t, err)
 	file.WriteString(privatekey)
 	file.Close()
 
-	p = provider.NewProfileProvider("client4")
+	p = provider.NewProfileProvider("rsa")
 	c, err = p.Resolve()
 	assert.Equal(t, credentials.NewRsaKeyPairCredential("", "publicKeyId", 3600), c)
 	assert.Nil(t, err)
 	defer os.Remove(`./pk.pem`)
+	//testcase 17, key does not exist
+	p = provider.NewProfileProvider("norsa")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Failed to get value"))
+	//testcase 18, value is empty
+	p = provider.NewProfileProvider("emptyrsa")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Value can't be empty"))
+
+	//testcase 19, the value is error
+	p = provider.NewProfileProvider("error_rsa")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Can not get private_key"))
 
-	// p = provider.NewProfileProvider("client3")
-	// c, err = p.Resolve()
-	// assert.Equal(t, credentials.NewBearerCredential("bearer_token"), c)
-	// assert.Nil(t, err)
+	//testcase 20, credential type is error
+	p = provider.NewProfileProvider("error_type")
+	c, err = p.Resolve()
+	assert.Nil(t, c)
+	assert.True(t, strings.Contains(err.Error(), "ERROR: Failed to get credential"))
 }

sdk/auth/credentials/provider/provider_chain_test.go

@@ -1,6 +1,7 @@
 package provider_test
 
 import (
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -19,4 +20,18 @@ func TestProviderChain(t *testing.T) {
 	c, err := pc.Resolve()
 	assert.Equal(t, &credentials.AccessKeyCredential{AccessKeyId: "AccessKeyId", AccessKeySecret: "AccessKeySecret"}, c)
 	assert.Nil(t, err)
+
+	os.Setenv(provider.ENVAccessKeyID, "")
+	os.Setenv(provider.ENVAccessKeySecret, "")
+	c, err = pc.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "Environmental variable (ALIBABACLOUD_ACCESS_KEY_ID or ALIBABACLOUD_ACCESS_KEY_SECRET) is empty")
+
+	os.Unsetenv(provider.ENVAccessKeyID)
+	os.Unsetenv(provider.ENVCredentialFile)
+	os.Unsetenv(provider.ENVEcsMetadata)
+
+	c, err = pc.Resolve()
+	assert.Nil(t, c)
+	assert.EqualError(t, err, "No credential found")
 }