perfect integratio(2)

integration/api_test.go

@@ -14,7 +14,135 @@ import (
 	"testing"
 )
 
-func Test_ECS_DescribeRegionsWithRPCrequest(t *testing.T) {
+var (
+	securityGroupId = ""
+	flag            = false
+)
+
+func Test_ECS_CreateSecurityGroupWithRPCrequestWithXMLWithNestingparameters(t *testing.T) {
+	request := ecs.CreateCreateSecurityGroupRequest()
+	request.SetContentType("XML")
+	tag := ecs.CreateSecurityGroupTag{
+		Key:   "test",
+		Value: "test",
+	}
+	request.Tag = &[]ecs.CreateSecurityGroupTag{tag}
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.CreateSecurityGroup(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, len(response.SecurityGroupId) > 0)
+	securityGroupId = response.SecurityGroupId
+}
+
+func Test_ECS_DescribeSecurityGroupsWithRPCrequestWithXMLWithNestingparameters(t *testing.T) {
+	request := ecs.CreateDescribeSecurityGroupsRequest()
+	request.SetContentType("XML")
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.DescribeSecurityGroups(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	for _, securitygroup := range response.SecurityGroups.SecurityGroup {
+		if securitygroup.SecurityGroupId == securityGroupId {
+			flag = true
+			break
+		}
+	}
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, flag)
+	flag = false
+
+}
+
+func Test_ECS_ModifyImageAttributeWithRPCrequestWithXML(t *testing.T) {
+	request := ecs.CreateModifySecurityGroupAttributeRequest()
+	request.SetContentType("XML")
+	request.SecurityGroupName = "testintegration"
+	request.SecurityGroupId = securityGroupId
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.ModifySecurityGroupAttribute(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+}
+
+func Test_ECS_DeleteImageWithRPCrequestWithXMLWithNestingparameters(t *testing.T) {
+	request := ecs.CreateDeleteSecurityGroupRequest()
+	request.SetContentType("XML")
+	request.SecurityGroupId = securityGroupId
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.DeleteSecurityGroup(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+	securityGroupId = ""
+}
+
+func Test_ECS_CreateSecurityGroupWithRPCrequestWithJSONWithNestingparameters(t *testing.T) {
+	request := ecs.CreateCreateSecurityGroupRequest()
+	request.SetContentType("JSON")
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.CreateSecurityGroup(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, len(response.SecurityGroupId) > 0)
+	securityGroupId = response.SecurityGroupId
+}
+
+func Test_ECS_DescribeSecurityGroupsWithRPCrequestWithJSONWithNestingparameters(t *testing.T) {
+	request := ecs.CreateDescribeSecurityGroupsRequest()
+	request.SetContentType("JSON")
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.DescribeSecurityGroups(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	for _, securitygroup := range response.SecurityGroups.SecurityGroup {
+		if securitygroup.SecurityGroupId == securityGroupId {
+			flag = true
+			break
+		}
+	}
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, flag)
+	flag = false
+
+}
+
+func Test_ECS_ModifyImageAttributeWithRPCrequestWithJSON(t *testing.T) {
+	request := ecs.CreateModifySecurityGroupAttributeRequest()
+	request.SetContentType("JSON")
+	request.SecurityGroupName = "testintegration"
+	request.SecurityGroupId = securityGroupId
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.ModifySecurityGroupAttribute(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+}
+
+func Test_ECS_DeleteImageWithRPCrequestWithJSONWithNestingparameters(t *testing.T) {
+	request := ecs.CreateDeleteSecurityGroupRequest()
+	request.SetContentType("JSON")
+	request.SecurityGroupId = securityGroupId
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	response, err := client.DeleteSecurityGroup(request)
+	assert.Nil(t, err)
+	assert.True(t, response.IsSuccess())
+	assert.Equal(t, 36, len(response.RequestId))
+	securityGroupId = ""
+}
+
+func Test_ECS_DescribeRegionsWithRPCrequestWith(t *testing.T) {
 	request := ecs.CreateDescribeRegionsRequest()
 	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 	assert.Nil(t, err)
@@ -26,7 +154,7 @@ func Test_ECS_DescribeRegionsWithRPCrequest(t *testing.T) {
 }
 
 func Test_RDS_DescribeDBInstancesWithRPCrequest(t *testing.T) {
-	client, err := rds.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"), )
+	client, err := rds.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 	assert.Nil(t, err)
 	assert.NotNil(t, client)
 	request := rds.CreateDescribeDBInstancesRequest()
@@ -37,12 +165,11 @@ func Test_RDS_DescribeDBInstancesWithRPCrequest(t *testing.T) {
 }
 
 func Test_CDN_DescribeCdnDomainDetailWithRPCrequest(t *testing.T) {
-	client, err := cdn.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"), )
+	client, err := cdn.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 	assert.Nil(t, err)
 	assert.NotNil(t, client)
-	request := cdn.CreateDescribeCdnCertificateDetailRequest()
-	request.CertName = "sdk-test"
-	response, err := client.DescribeCdnCertificateDetail(request)
+	request := cdn.CreateDescribeRefreshTasksRequest()
+	response, err := client.DescribeRefreshTasks(request)
 	assert.Nil(t, err)
 	assert.NotNil(t, response)
 	assert.Equal(t, 36, len(response.RequestId))
@@ -81,26 +208,43 @@ func Test_VPC_DescribeRegionsWithUnicodeSpecificParams(t *testing.T) {
 	assert.True(t, len(response.Regions.Region) > 0)
 }
 
-//func Test_DescribeRegionsWithHTTPS(t *testing.T) {
-//	request := ecs.CreateDescribeRegionsRequest()
+//
+//func mockServer(status int, json string) (server *httptest.Server) {
+//	// Start a test server locally.
+//	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+//		w.WriteHeader(status)
+//		w.Write([]byte(json))
+//	}))
+//	return ts
+//}
+
+//func Test_ListRolesWithRPCrequestWithoutRedirecting(t *testing.T) {
 //	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 //	assert.Nil(t, err)
+//	request := ecs.CreateDescribeRegionsRequest()
+//	request.Scheme = "HTTP"
+//	ts := mockServer(303, "{}")
+//
+//	defer ts.Close()
+//	domain := strings.Replace(ts.URL, "http://", "",1)
+//	request.Domain = domain
+//	assert.Nil(t, ts.URL)
+//	assert.Nil(t, request.BuildUrl())
 //	response, err := client.DescribeRegions(request)
 //	assert.Nil(t, err)
-//	assert.True(t, response.IsSuccess())
-//	assert.Equal(t, 36, len(response.RequestId))
-//	assert.True(t, len(response.Regions.Region) > 0)
+//	assert.Equal(t, 303, response.GetHttpStatus())
+//	assert.Equal(t, "", response.GetHttpContentString())
 //}
-//
-//func Test_DescribeRegionsWithSTStoken(t *testing.T) {
-//	assumeresponse, err := createAssumeRole()
+
+//func Test_DescribeClusterDetailWithROArequest(t *testing.T) {
+//	client, err := cs.NewClientWithAccessKey("default", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 //	assert.Nil(t, err)
-//	credential := assumeresponse.Credentials
-//	request := ecs.CreateDescribeRegionsRequest()
-//	client, err := ecs.NewClientWithStsToken("cn-hangzhou", credential.AccessKeyId, credential.AccessKeySecret, credential.SecurityToken)
-//	response, err := client.DescribeRegions(request)
+//	request := cs.CreateDescribeClusterDetailRequest()
+//	request.SetDomain("cs.aliyuncs.com")
+//	request.QueryParams["RegionId"] = "default"
+//	request.Method = "GET"
+//	response, err := client.DescribeClusterDetail(request)
 //	assert.Nil(t, err)
 //	assert.True(t, response.IsSuccess())
-//	assert.Equal(t, 36, len(response.RequestId))
-//	assert.True(t, len(response.Regions.Region) > 0)
+//	assert.Nil(t, response.GetHttpHeaders())
 //}

integration/base.go

@@ -1,13 +1,14 @@
 package integration
 
 import (
-	"fmt"
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/ram"
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/sts"
-	"strings"
 
+	"fmt"
 	"os"
+	"strings"
 )
+
 var role_doc = `{
 		"Statement": [{
 		    "Action": "sts:AssumeRole",
@@ -21,34 +22,35 @@ var role_doc = `{
 	   "Version": "1"
 	}`
 
-func createRole(userid string) error{
-	listRequest :=ram.CreateListRolesRequest()
+func createRole(userid string) (string, string, error) {
+	ram.CreateGetRoleRequest()
+	listRequest := ram.CreateListRolesRequest()
 	listRequest.Scheme = "HTTPS"
 	client, err := ram.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 	if err != nil {
-		return err
+		return "", "", err
 	}
-	listResponse, err :=client.ListRoles(listRequest)
+	listResponse, err := client.ListRoles(listRequest)
 	if err != nil {
-		return err
+		return "", "", err
 	}
 	for _, role := range listResponse.Roles.Role {
 		if strings.ToLower(role.RoleName) == "testrole" {
-			return nil
+			return role.RoleName, role.Arn, nil
 		}
 	}
 	createRequest := ram.CreateCreateRoleRequest()
 	createRequest.Scheme = "HTTPS"
 	createRequest.RoleName = "testrole"
 	createRequest.AssumeRolePolicyDocument = fmt.Sprintf(role_doc, userid)
-	_, err = client.CreateRole(createRequest)
+	res, err := client.CreateRole(createRequest)
 	if err != nil {
-		return err
+		return "", "", err
 	}
-	return nil
+	return res.Role.RoleName, res.Role.Arn, nil
 }
 
-func createUser()(error){
+func createUser() error {
 	listRequest := ram.CreateListUsersRequest()
 	listRequest.Scheme = "HTTPS"
 	client, err := ram.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
@@ -74,9 +76,9 @@ func createUser()(error){
 	return nil
 }
 
-func createAttachPolicyToUser()error{
+func createAttachPolicyToUser() error {
 	listRequest := ram.CreateListPoliciesForUserRequest()
-	listRequest.UserName ="alice"
+	listRequest.UserName = "alice"
 	listRequest.Scheme = "HTTPS"
 	client, err := ram.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 	if err != nil {
@@ -103,69 +105,67 @@ func createAttachPolicyToUser()error{
 	return nil
 }
 
-//func createAccessKey()(string, string, error){
-//	client, err := ram.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
-//	if err != nil {
-//		return "", "", err
-//	}
-//	listrequest := ram.CreateListAccessKeysRequest()
-//	listrequest.UserName = "alice"
-//	listrequest.Scheme = "HTTPS"
-//	listresponse, err := client.ListAccessKeys(listrequest)
-//	if err != nil {
-//		return "", "", err
-//	}
-//	if listresponse.AccessKeys.AccessKey != nil {
-//		accesskey := listresponse.AccessKeys.AccessKey[0]
-//		if accesskey.AccessKeySecret != "" && accesskey.AccessKeySecret != "---" {
-//			return accesskey.AccessKeyId, accesskey.AccessKeySecret, err
-//		} else {
-//			deleterequest := ram.CreateDeleteAccessKeyRequest()
-//			deleterequest.UserAccessKeyId = accesskey.AccessKeyId
-//			deleterequest.UserName = "alice"
-//			_, err := client.DeleteAccessKey(deleterequest)
-//			if err != nil {
-//				return "", "", err
-//			}
-//		}
-//	}
-//	request := ram.CreateCreateAccessKeyRequest()
-//	request.Scheme = "HTTPS"
-//	request.UserName = "alice"
-//	response, err := client.CreateAccessKey(request)
-//	if err != nil {
-//		return "", "",err
-//	}
-//
-//	return response.AccessKey.AccessKeyId, response.AccessKey.AccessKeySecret, nil
-//}
+func createAccessKey() (string, string, error) {
+	client, err := ram.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	if err != nil {
+		return "", "", err
+	}
+	listrequest := ram.CreateListAccessKeysRequest()
+	listrequest.UserName = "alice"
+	listrequest.Scheme = "HTTPS"
+	listresponse, err := client.ListAccessKeys(listrequest)
+	if err != nil {
+		return "", "", err
+	}
+	if listresponse.AccessKeys.AccessKey != nil {
+		if len(listresponse.AccessKeys.AccessKey) >= 2 {
+			accesskey := listresponse.AccessKeys.AccessKey[0]
+			deleterequest := ram.CreateDeleteAccessKeyRequest()
+			deleterequest.UserAccessKeyId = accesskey.AccessKeyId
+			deleterequest.UserName = "alice"
+			deleterequest.Scheme = "HTTPS"
+			_, err := client.DeleteAccessKey(deleterequest)
+			if err != nil {
+				return "", "", err
+			}
+		}
+	}
+	request := ram.CreateCreateAccessKeyRequest()
+	request.Scheme = "HTTPS"
+	request.UserName = "alice"
+	response, err := client.CreateAccessKey(request)
+	if err != nil {
+		return "", "", err
+	}
+
+	return response.AccessKey.AccessKeyId, response.AccessKey.AccessKeySecret, nil
+}
 
-func createAssumeRole()(*sts.AssumeRoleResponse, error){
+func createAssumeRole() (*sts.AssumeRoleResponse, error) {
 	err := createUser()
 	if err != nil {
-		return nil,err
+		return nil, err
 	}
-	err = createRole(os.Getenv("USER_ID"))
+	_, _, err = createRole(os.Getenv("USER_ID"))
 	if err != nil {
-		return nil,err
+		return nil, err
 	}
 	err = createAttachPolicyToUser()
 	if err != nil {
-		return nil,err
+		return nil, err
+	}
+	subaccesskeyid, subaccesskeysecret, err := createAccessKey()
+	if err != nil {
+		return nil, err
 	}
-	//subaccesskeyid, subaccesskeysecret, err := createAccessKey()
-	//if err != nil {
-	//	return "","","",err
-	//}
 	request := sts.CreateAssumeRoleRequest()
 	request.RoleArn = fmt.Sprintf("acs:ram::%s:role/testrole", os.Getenv("USER_ID"))
 	request.RoleSessionName = "alice_test"
 	request.Scheme = "HTTPS"
-	client, err := sts.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	client, err := sts.NewClientWithAccessKey("cn-hangzhou", subaccesskeyid, subaccesskeysecret)
 	response, err := client.AssumeRole(request)
 	if err != nil {
-		return nil,err
+		return nil, err
 	}
 	return response, nil
 }
-

integration/core_test.go

@@ -14,7 +14,7 @@ import (
 
 func Test_DescribeRegionsWithCommonRequestWithRPCrequest(t *testing.T) {
 	request := requests.NewCommonRequest()
-	request.Version =  "2014-05-26"
+	request.Version = "2014-05-26"
 	request.Product = "Ecs"
 	request.ApiName = "DescribeRegions"
 	request.SetDomain("ecs.aliyuncs.com")
@@ -31,7 +31,7 @@ func Test_DescribeRegionsWithCommonRequestWithSTStoken(t *testing.T) {
 	assert.Nil(t, err)
 	credential := assumeresponse.Credentials
 	request := requests.NewCommonRequest()
-	request.Version =  "2014-05-26"
+	request.Version = "2014-05-26"
 	request.Product = "Ecs"
 	request.ApiName = "DescribeRegions"
 	request.SetDomain("ecs.aliyuncs.com")
@@ -45,7 +45,7 @@ func Test_DescribeRegionsWithCommonRequestWithSTStoken(t *testing.T) {
 
 func Test_DescribeRegionsWithCommonRequestWithHTTPS(t *testing.T) {
 	request := requests.NewCommonRequest()
-	request.Version =  "2014-05-26"
+	request.Version = "2014-05-26"
 	request.Product = "Ecs"
 	request.ApiName = "DescribeRegions"
 	request.SetDomain("ecs.aliyuncs.com")
@@ -60,7 +60,7 @@ func Test_DescribeRegionsWithCommonRequestWithHTTPS(t *testing.T) {
 
 func Test_DescribeRegionsWithCommonRequestWithUnicodeSpecificParams(t *testing.T) {
 	request := requests.NewCommonRequest()
-	request.Version =  "2014-05-26"
+	request.Version = "2014-05-26"
 	request.Product = "Ecs"
 	request.ApiName = "DescribeRegions"
 	request.SetDomain("ecs.aliyuncs.com")
@@ -75,7 +75,7 @@ func Test_DescribeRegionsWithCommonRequestWithUnicodeSpecificParams(t *testing.T
 
 func Test_DescribeRegionsWithCommonRequestWithError(t *testing.T) {
 	request := requests.NewCommonRequest()
-	request.Version =  "2014-05-26"
+	request.Version = "2014-05-26"
 	request.Product = "Ecs"
 	request.ApiName = "Describe"
 	request.SetDomain("ecs.aliyuncs.com")
@@ -90,16 +90,15 @@ func Test_DescribeRegionsWithCommonRequestWithError(t *testing.T) {
 }
 
 //func Test_DescribeClusterDetailWithCommonRequestWithROArequest(t *testing.T) {
+//	client, err := sdk.NewClientWithAccessKey("default", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+//	assert.Nil(t, err)
 //	request := requests.NewCommonRequest()
-//	request.Version =  "2015-12-15"
-//	request.Product = "CS"
-//	request.ApiName = "DescribeClusterDetail"
-//	request.PathPattern = "/resource_types"
-//	request.SetDomain("cs.aliyuncs.com")
-//	request.Scheme = "HTTPS"
+//	request.Method = "GET"
+//	request.Domain = "cs.aliyuncs.com"
+//	request.Version = "2015-12-15"
+//	request.PathPattern = "/clusters/[ClusterId]"
+//	request.QueryParams["RegionId"] = "default"
 //	request.TransToAcsRequest()
-//	client, err := sdk.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
-//	assert.Nil(t, err)
 //	response, err := client.ProcessCommonRequest(request)
 //	assert.Nil(t, err)
 //	assert.True(t, response.IsSuccess())
@@ -109,12 +108,12 @@ func Test_DescribeRegionsWithCommonRequestWithError(t *testing.T) {
 //	request := requests.NewCommonRequest()
 //	request.Version =  "2015-12-15"
 //	request.Product = "CS"
+//	request.Method = requests.GET
 //	request.ApiName = "DescribeClusterDetail"
-//	request.PathPattern = "/resource_types"
-//	request.SetDomain(""cs.aliyuncs.com"")
+//	request.PathPattern = "/clusters/[ClusterId]"
+//	request.SetDomain("cs.aliyuncs.com")
 //	request.Scheme = "HTTPS"
 //	request.TransToAcsRequest()
-//	request.Method = requests.GET
 //	client, err := sdk.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
 //	assert.Nil(t, err)
 //	response, err := client.ProcessCommonRequest(request)

integration/credential_test.go

@@ -0,0 +1,82 @@
+package integration
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+
+	"github.com/stretchr/testify/assert"
+
+	"os"
+	"testing"
+)
+
+var securityCredURL = "http://100.100.100.200/latest/meta-data/ram/security-credentials/"
+
+func Test_DescribeRegionsWithRPCrequestWithAK(t *testing.T) {
+	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	assert.NotNil(t, client)
+	request := ecs.CreateDescribeRegionsRequest()
+	request.Scheme = "https"
+	response, err := client.DescribeRegions(request)
+	assert.Nil(t, err)
+	assert.NotNil(t, response)
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, len(response.Regions.Region) > 0)
+}
+
+func Test_DescribeRegionsWithRPCrequestWithSTStoken(t *testing.T) {
+	assumeresponse, err := createAssumeRole()
+	assert.Nil(t, err)
+	credential := assumeresponse.Credentials
+	client, err := ecs.NewClientWithStsToken("cn-hangzhou", credential.AccessKeyId, credential.AccessKeySecret, credential.SecurityToken)
+	assert.Nil(t, err)
+	assert.NotNil(t, client)
+	request := ecs.CreateDescribeRegionsRequest()
+	request.Scheme = "https"
+	response, err := client.DescribeRegions(request)
+	assert.Nil(t, err)
+	assert.NotNil(t, response)
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, len(response.Regions.Region) > 0)
+}
+
+//func Test_DescribeClusterDetailWithROArequestWithAK(t *testing.T) {
+//	client, err := cs.NewClientWithAccessKey("default", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+//	assert.Nil(t, err)
+//	request := cs.CreateDescribeClusterDetailRequest()
+//	request.SetDomain("cs.aliyuncs.com")
+//	request.QueryParams["RegionId"] = "default"
+//	request.Method = "GET"
+//	response, err := client.DescribeClusterDetail(request)
+//	assert.Nil(t, err)
+//	assert.True(t, response.IsSuccess())
+//	assert.Nil(t, response.GetHttpHeaders())
+//}
+
+func Test_DescribeRegionsWithRPCrequestWithArn(t *testing.T) {
+	_, arn, err := createRole(os.Getenv("USER_ID"))
+	client, err := ecs.NewClientWithRamRoleArn("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"), arn, "role-test")
+	assert.Nil(t, err)
+	assert.NotNil(t, client)
+	request := ecs.CreateDescribeRegionsRequest()
+	request.Scheme = "https"
+	response, err := client.DescribeRegions(request)
+	assert.Nil(t, err)
+	assert.NotNil(t, response)
+	assert.Equal(t, 36, len(response.RequestId))
+	assert.True(t, len(response.Regions.Region) > 0)
+}
+
+//
+//func Test_DescribeRegionsWithECSmetaService(t *testing.T) {
+//	rolename, _,err:=createRole(os.Getenv("USER_ID"))
+//	assert.Nil(t, err)
+//	client, err := ecs.NewClientWithEcsRamRole("cn-hangzhou", rolename)
+//	assert.Nil(t, err)
+//	request := ecs.CreateDescribeRegionsRequest()
+//	response, err := client.DescribeRegions(request)
+//	assert.Nil(t, err)
+//	assert.NotNil(t, response)
+//	assert.Equal(t, 36, len(response.RequestId))
+//	assert.True(t, len(response.Regions.Region)>0)
+//}

integration/error_test.go

@@ -0,0 +1,43 @@
+package integration
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+
+	"github.com/stretchr/testify/assert"
+
+	"os"
+	"testing"
+)
+
+func Test_DescribeRegionsWithParameterError(t *testing.T) {
+	request := requests.NewCommonRequest()
+	request.Version = "2014-05-26"
+	request.Product = "Ecs"
+	request.ApiName = "Describe"
+	request.SetDomain("ecs.aliyuncs.com")
+	request.TransToAcsRequest()
+	client, err := sdk.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+	assert.Nil(t, err)
+	_, err = client.ProcessCommonRequest(request)
+	realerr := err.(errors.Error)
+	assert.Equal(t, "InvalidParameter", realerr.ErrorCode())
+	assert.Equal(t, "The specified parameter \"Action or Version\" is not valid.", realerr.Message())
+}
+
+//
+//func Test_DescribeRegionsWithUnreachableError(t *testing.T) {
+//	request := ecs.CreateDescribeRegionsRequest()
+//	request.SetDomain("www.aliyun-hangzhou.com")
+//	client, err := ecs.NewClientWithAccessKey("cn-hangzhou", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
+//	assert.Nil(t, err)
+//	_, err = client.DescribeRegions(request)
+//	realerr := err.(errors.Error)
+//	assert.Equal(t, "InvalidParameter", realerr.ErrorCode())
+//	assert.Equal(t, "The specified parameter \"Action or Version\" is not valid.", realerr.Message())
+//}
+
+//func Test_DescribeRegionsWithTimeOutError(t *testing.T) {
+//
+//}