Fix acceptance test (#83)

* data_source_gcore_instance_test.go fixed

* k8s and k8s's pools datasource fixed

* lb pool/member/listener resource test fixed

* router/instance/snapshot resource test fixed

* k8s/k8s pool resources test fixed

* add build tag on tests
fix k8s/k8s pool resource test

Co-authored-by: Alexandr Sokolov <[email protected]>

Author: alexk53

gcore/data_source_gcore_floatingip_test.go

@@ -1,3 +1,6 @@
+//go:build cloud
+// +build cloud
+
 package gcore
 
 import (

gcore/data_source_gcore_image_test.go

@@ -1,3 +1,6 @@
+//go:build cloud
+// +build cloud
+
 package gcore
 
 import (

gcore/data_source_gcore_instance_test.go

@@ -1,10 +1,14 @@
+//go:build cloud
+// +build cloud
+
 package gcore
 
 import (
 	"fmt"
 	"testing"
 
 	gcorecloud "github.com/G-Core/gcorelabscloud-go"
+	"github.com/G-Core/gcorelabscloud-go/gcore/image/v1/images"
 	"github.com/G-Core/gcorelabscloud-go/gcore/instance/v1/instances"
 	"github.com/G-Core/gcorelabscloud-go/gcore/instance/v1/types"
 	"github.com/G-Core/gcorelabscloud-go/gcore/task/v1/tasks"
@@ -13,10 +17,9 @@ import (
 )
 
 const (
-	flavorID = "g1-standard-1-2"
-	//todo need to get actual image id
-	imageID          = "44e136a7-15c1-4b5f-a086-20b7b3237d40"
+	flavorID         = "g1-standard-1-2"
 	instanceTestName = "test-vm"
+	testOsDistro     = "ubuntu"
 )
 
 func TestAccInstanceDataSource(t *testing.T) {
@@ -30,12 +33,33 @@ func TestAccInstanceDataSource(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	clientImage, err := CreateTestClient(cfg.Provider, imagesPoint, versionPointV1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	imgs, err := images.ListAll(clientImage, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var img images.Image
+	for _, i := range imgs {
+		if i.OsDistro == testOsDistro {
+			img = i
+			break
+		}
+	}
+	if img.ID == "" {
+		t.Fatalf("images with os_distro='%s' does not exist", testOsDistro)
+	}
+
 	optsV := volumes.CreateOpts{
 		Name:     volumeTestName,
 		Size:     volumeTestSize * 5,
 		Source:   volumes.Image,
 		TypeName: volumes.Standard,
-		ImageID:  imageID,
+		ImageID:  img.ID,
 	}
 	volumeID, err := createTestVolume(clientVolume, optsV)
 	if err != nil {

gcore/data_source_gcore_k8s_pool_test.go

@@ -1,34 +1,144 @@
+//go:build cloud
+// +build cloud
+
 package gcore
 
 import (
 	"fmt"
+	"net"
+	"os"
+	"strconv"
 	"testing"
 
+	"github.com/G-Core/gcorelabscloud-go/gcore/k8s/v1/clusters"
+	"github.com/G-Core/gcorelabscloud-go/gcore/k8s/v1/pools"
+	"github.com/G-Core/gcorelabscloud-go/gcore/keypair/v2/keypairs"
+	"github.com/G-Core/gcorelabscloud-go/gcore/network/v1/networks"
+	"github.com/G-Core/gcorelabscloud-go/gcore/subnet/v1/subnets"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 )
 
 func TestAccK8sPoolDataSource(t *testing.T) {
-	fullName := "data.gcore_k8s_pool.acctest"
+	cfg, err := createTestConfig()
+	if err != nil {
+		t.Fatal(err)
+	}
+	k8sClient, err := CreateTestClient(cfg.Provider, K8sPoint, versionPointV1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	netClient, err := CreateTestClient(cfg.Provider, networksPoint, versionPointV1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	subnetClient, err := CreateTestClient(cfg.Provider, subnetPoint, versionPointV1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	kpClient, err := CreateTestClient(cfg.Provider, keypairsPoint, versionPointV2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	netOpts := networks.CreateOpts{
+		Name:         networkTestName,
+		CreateRouter: true,
+	}
+	networkID, err := createTestNetwork(netClient, netOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer deleteTestNetwork(netClient, networkID)
+
+	gw := net.ParseIP("")
+	subnetOpts := subnets.CreateOpts{
+		Name:                   subnetTestName,
+		NetworkID:              networkID,
+		ConnectToNetworkRouter: true,
+		EnableDHCP:             true,
+		GatewayIP:              &gw,
+	}
 
+	subnetID, err := CreateTestSubnet(subnetClient, subnetOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// update our new network router so that the k8s nodes will have access to the Nexus
+	// registry to download images
+	if err := patchRouterForK8S(cfg.Provider, networkID); err != nil {
+		t.Fatal(err)
+	}
+
+	pid, err := strconv.Atoi(os.Getenv("TEST_PROJECT_ID"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	kpOpts := keypairs.CreateOpts{
+		Name:      kpName,
+		PublicKey: pkTest,
+		ProjectID: pid,
+	}
+	keyPair, err := keypairs.Create(kpClient, kpOpts).Extract()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer keypairs.Delete(kpClient, keyPair.ID)
+
+	k8sOpts := clusters.CreateOpts{
+		Name:               testClusterName,
+		FixedNetwork:       networkID,
+		FixedSubnet:        subnetID,
+		AutoHealingEnabled: true,
+		KeyPair:            keyPair.ID,
+		Version:            testClusterVersion,
+		Pools: []pools.CreateOpts{{
+			Name:             testClusterPoolName,
+			FlavorID:         testPoolFlavor,
+			NodeCount:        testNodeCount,
+			DockerVolumeSize: testDockerVolumeSize,
+			DockerVolumeType: testDockerVolumeType,
+			MinNodeCount:     testMinNodeCount,
+			MaxNodeCount:     testMaxNodeCount,
+		}},
+	}
+	clusterID, err := createTestCluster(k8sClient, k8sOpts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer deleteTestCluster(k8sClient, clusterID)
+
+	cluster, err := clusters.Get(k8sClient, clusterID).Extract()
+	if err != nil {
+		t.Fatal(err)
+	}
+	pool := cluster.Pools[0]
+
+	fullName := "data.gcore_k8s_pool.acctest"
 	ipTemplate := fmt.Sprintf(`
 			data "gcore_k8s_pool" "acctest" {
 			  %s
               %s
               cluster_id = "%s"
 			  pool_id = "%s"
 			}
-		`, projectInfo(), regionInfo(), GCORE_CLUSTER_ID, GCORE_CLUSTER_POOL_ID)
+		`, projectInfo(), regionInfo(), clusterID, pool.UUID)
 
 	resource.Test(t, resource.TestCase{
-		PreCheck:          func() { testAccPreCheckK8sPoolDataSource(t) },
+		PreCheck:          func() { testAccPreCheck(t) },
 		ProviderFactories: testAccProviders,
 		Steps: []resource.TestStep{
 			{
 				Config: ipTemplate,
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckResourceExists(fullName),
-					resource.TestCheckResourceAttr(fullName, "cluster_id", GCORE_CLUSTER_ID),
-					resource.TestCheckResourceAttr(fullName, "pool_id", GCORE_CLUSTER_POOL_ID),
+					resource.TestCheckResourceAttr(fullName, "cluster_id", clusterID),
+					resource.TestCheckResourceAttr(fullName, "pool_id", pool.UUID),
+					resource.TestCheckResourceAttr(fullName, "name", pool.Name),
 				),
 			},
 		},