Fix/tcr ip access e2e case

tencentcloud/data_source_tc_kubernetes_available_cluster_versions.go

@@ -0,0 +1,180 @@
+/*
+Use this data source to query detailed information of kubernetes available_cluster_versions
+
+Example Usage
+
+```hcl
+data "tencentcloud_kubernetes_available_cluster_versions" "query_by_id" {
+  cluster_id = "xxx"
+}
+
+output "versions_id"{
+  description = "Query versions from id."
+  value = data.tencentcloud_kubernetes_available_cluster_versions.query_by_id.versions
+}
+
+data "tencentcloud_kubernetes_available_cluster_versions" "query_by_ids" {
+  cluster_ids = ["xxx"]
+}
+
+output "versions_ids"{
+  description = "Query versions from ids."
+  value = data.tencentcloud_kubernetes_available_cluster_versions.query_by_ids.clusters
+}
+```
+*/
+package tencentcloud
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	tke "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/tke/v20180525"
+	"github.com/tencentcloudstack/terraform-provider-tencentcloud/tencentcloud/internal/helper"
+)
+
+func dataSourceTencentCloudKubernetesAvailableClusterVersions() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceTencentCloudKubernetesAvailableClusterVersionsRead,
+		Schema: map[string]*schema.Schema{
+			"cluster_id": {
+				Optional:    true,
+				Type:        schema.TypeString,
+				Description: "Cluster Id.",
+			},
+
+			"cluster_ids": {
+				Optional: true,
+				Type:     schema.TypeSet,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+				Description: "list of cluster IDs.",
+			},
+
+			"versions": {
+				Computed: true,
+				Type:     schema.TypeSet,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+				Description: "Upgradable cluster version number. Note: This field may return null, indicating that no valid value can be obtained.",
+			},
+
+			"clusters": {
+				Computed:    true,
+				Type:        schema.TypeList,
+				Description: "cluster information. Note: This field may return null, indicating that no valid value can be obtained.",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"cluster_id": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "Cluster ID.",
+						},
+						"versions": {
+							Type: schema.TypeSet,
+							Elem: &schema.Schema{
+								Type: schema.TypeString,
+							},
+							Computed:    true,
+							Description: "list of cluster major version numbers, for example 1.18.4.",
+						},
+					},
+				},
+			},
+
+			"result_output_file": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "Used to save results.",
+			},
+		},
+	}
+}
+
+func dataSourceTencentCloudKubernetesAvailableClusterVersionsRead(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("data_source.tencentcloud_kubernetes_available_cluster_versions.read")()
+	defer inconsistentCheck(d, meta)()
+
+	logId := getLogId(contextNil)
+
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	var (
+		versions []*string
+		clusters []*tke.ClusterVersion
+		id       *string
+		ids      []string
+	)
+
+	paramMap := make(map[string]interface{})
+	if v, ok := d.GetOk("cluster_id"); ok {
+		id = helper.String(v.(string))
+		paramMap["cluster_id"] = id
+	}
+
+	if v, ok := d.GetOk("cluster_ids"); ok {
+		clusterIdsSet := v.(*schema.Set).List()
+		ids = helper.InterfacesStrings(clusterIdsSet)
+		paramMap["cluster_ids"] = helper.InterfacesStringsPoint(clusterIdsSet)
+	}
+
+	service := TkeService{client: meta.(*TencentCloudClient).apiV3Conn}
+
+	err := resource.Retry(readRetryTimeout, func() *resource.RetryError {
+		result, e := service.DescribeKubernetesAvailableClusterVersionsByFilter(ctx, paramMap)
+		if e != nil {
+			return retryError(e)
+		}
+		if result != nil {
+			versions = result.Versions
+			clusters = result.Clusters
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	if versions != nil {
+		_ = d.Set("versions", versions)
+	}
+
+	tmpList := make([]map[string]interface{}, 0, len(clusters))
+
+	if clusters != nil {
+		for _, clusterVersion := range clusters {
+			clusterVersionMap := map[string]interface{}{}
+
+			if clusterVersion.ClusterId != nil {
+				clusterVersionMap["cluster_id"] = clusterVersion.ClusterId
+			}
+
+			if clusterVersion.Versions != nil {
+				clusterVersionMap["versions"] = clusterVersion.Versions
+			}
+
+			tmpList = append(tmpList, clusterVersionMap)
+		}
+
+		_ = d.Set("clusters", tmpList)
+	}
+
+	var clusterIds []string
+	if id != nil {
+		clusterIds = []string{*id}
+	} else {
+		clusterIds = ids
+	}
+
+	d.SetId(helper.DataResourceIdsHash(clusterIds))
+	output, ok := d.GetOk("result_output_file")
+	if ok && output.(string) != "" {
+		if e := writeToFile(output.(string), tmpList); e != nil {
+			return e
+		}
+	}
+	return nil
+}

tencentcloud/data_source_tc_kubernetes_available_cluster_versions_test.go

@@ -0,0 +1,56 @@
+package tencentcloud
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+)
+
+func TestAccTencentCloudKubernetesAvailableClusterVersionsDataSource_basic(t *testing.T) {
+	t.Parallel()
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: fmt.Sprintf(testAccKubernetesAvailableClusterVersionsDataSource_basic, defaultTkeClusterId),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckTencentCloudDataSourceID("data.tencentcloud_kubernetes_available_cluster_versions.id"),
+					resource.TestCheckResourceAttrSet("data.tencentcloud_kubernetes_available_cluster_versions.id", "versions.#"),
+					resource.TestCheckResourceAttrSet("data.tencentcloud_kubernetes_available_cluster_versions.id", "clusters.#"),
+				),
+			},
+			{
+				Config: fmt.Sprintf(testAccKubernetesAvailableClusterVersionsDataSource_multiple, defaultTkeClusterId),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckTencentCloudDataSourceID("data.tencentcloud_kubernetes_available_cluster_versions.ids"),
+					resource.TestCheckResourceAttrSet("data.tencentcloud_kubernetes_available_cluster_versions.ids", "clusters.#"),
+					resource.TestCheckResourceAttr("data.tencentcloud_kubernetes_available_cluster_versions.ids", "clusters.0.cluster_id", defaultTkeClusterId),
+				),
+			},
+		},
+	})
+}
+
+const testAccKubernetesAvailableClusterVersionsDataSource_basic = `
+
+data "tencentcloud_kubernetes_available_cluster_versions" "id" {
+  cluster_id = "%s"
+}
+
+output "versions"{
+  value = data.tencentcloud_kubernetes_available_cluster_versions.id.versions
+}
+
+`
+
+const testAccKubernetesAvailableClusterVersionsDataSource_multiple = `
+
+data "tencentcloud_kubernetes_available_cluster_versions" "ids" {
+  cluster_ids = ["%s"]
+}
+
+`

tencentcloud/provider.go

@@ -395,6 +395,7 @@ Tencent Kubernetes Engine(TKE)
     tencentcloud_kubernetes_cluster_levels
     tencentcloud_kubernetes_charts
     tencentcloud_kubernetes_cluster_common_names
+	tencentcloud_kubernetes_available_cluster_versions
 
   Resource
     tencentcloud_kubernetes_cluster
@@ -1145,6 +1146,7 @@ func Provider() terraform.ResourceProvider {
 			"tencentcloud_kubernetes_charts":                        dataSourceTencentCloudKubernetesCharts(),
 			"tencentcloud_kubernetes_cluster_levels":                datasourceTencentCloudKubernetesClusterLevels(),
 			"tencentcloud_kubernetes_cluster_common_names":          datasourceTencentCloudKubernetesClusterCommonNames(),
+			"tencentcloud_kubernetes_available_cluster_versions":    dataSourceTencentCloudKubernetesAvailableClusterVersions(),
 			"tencentcloud_eks_clusters":                             dataSourceTencentCloudEKSClusters(),
 			"tencentcloud_eks_cluster_credential":                   datasourceTencentCloudEksClusterCredential(),
 			"tencentcloud_container_clusters":                       dataSourceTencentCloudContainerClusters(),

tencentcloud/resource_tc_tcr_vpc_attachment_test.go

@@ -20,15 +20,15 @@ func TestAccTencentCloudTCRVPCAttachment_basic(t *testing.T) {
 			{
 				Config: testAccTCRVPCAttachment_basic,
 				Check: resource.ComposeAggregateTestCheckFunc(
-					testAccCheckTCRVPCAttachmentExists("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment"),
-					resource.TestCheckResourceAttrSet("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment", "status"),
+					testAccCheckTCRVPCAttachmentExists("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment_resource"),
+					resource.TestCheckResourceAttrSet("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment_resource", "status"),
 					//this access ip will solve out with very long time
-					//resource.TestCheckResourceAttrSet("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment", "access_ip"),
+					//resource.TestCheckResourceAttrSet("tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment_resource", "access_ip"),
 				),
-				Destroy: false,
+				// Destroy: false,
 			},
 			{
-				ResourceName:      "tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment",
+				ResourceName:      "tencentcloud_tcr_vpc_attachment.mytcr_vpc_attachment_resource",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
@@ -105,7 +105,7 @@ resource "tencentcloud_tcr_instance" "mytcr_instance" {
   delete_bucket = true
 }
 
-resource "tencentcloud_tcr_vpc_attachment" "mytcr_vpc_attachment" {
+resource "tencentcloud_tcr_vpc_attachment" "mytcr_vpc_attachment_resource" {
   instance_id = tencentcloud_tcr_instance.mytcr_instance.id
   vpc_id = local.vpc_id
   subnet_id = local.subnet_id

tencentcloud/service_tencentcloud_tke.go

@@ -1039,6 +1039,42 @@ func (me *TkeService) ModifyClusterVersion(ctx context.Context, id string, clust
 	return
 }
 
+func (me *TkeService) DescribeKubernetesAvailableClusterVersionsByFilter(ctx context.Context, param map[string]interface{}) (availableClusterVersions *tke.DescribeAvailableClusterVersionResponseParams, errRet error) {
+	var (
+		logId   = getLogId(ctx)
+		request = tke.NewDescribeAvailableClusterVersionRequest()
+	)
+
+	defer func() {
+		if errRet != nil {
+			log.Printf("[CRITAL]%s api[%s] fail, request body [%s], reason[%s]\n", logId, request.GetAction(), request.ToJsonString(), errRet.Error())
+		}
+	}()
+
+	for k, v := range param {
+		if k == "cluster_id" {
+			request.ClusterId = v.(*string)
+		}
+		if k == "cluster_ids" {
+			request.ClusterIds = v.([]*string)
+		}
+	}
+
+	ratelimit.Check(request.GetAction())
+
+	response, err := me.client.UseTkeClient().DescribeAvailableClusterVersion(request)
+	if err != nil {
+		errRet = err
+		return
+	}
+	log.Printf("[DEBUG]%s api[%s] success, request body [%s], response body [%s]\n", logId, request.GetAction(), request.ToJsonString(), response.ToJsonString())
+
+	if response != nil {
+		availableClusterVersions = response.Response
+	}
+	return
+}
+
 func (me *TkeService) CheckClusterVersion(ctx context.Context, id string, clusterVersion string) (isOk bool, errRet error) {
 	logId := getLogId(ctx)
 	request := tke.NewDescribeAvailableClusterVersionRequest()