Fix/importsubnet

ovh/data_source_ovh_publiccloud_region.go → ovh/data_source_ovh_cloud_region.go

@@ -11,9 +11,9 @@ import (
 	"github.com/ovh/go-ovh/ovh"
 )
 
-func dataSourcePublicCloudRegion() *schema.Resource {
+func dataSourceCloudRegion() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourcePublicCloudRegionRead,
+		Read: dataSourceCloudRegionRead,
 		Schema: map[string]*schema.Schema{
 			"project_id": {
 				Type:        schema.TypeString,
@@ -28,7 +28,7 @@ func dataSourcePublicCloudRegion() *schema.Resource {
 			},
 			"services": {
 				Type:     schema.TypeSet,
-				Set:      publicCloudServiceHash,
+				Set:      cloudServiceHash,
 				Computed: true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
@@ -68,7 +68,7 @@ func dataSourcePublicCloudRegion() *schema.Resource {
 	}
 }
 
-func dataSourcePublicCloudRegionRead(d *schema.ResourceData, meta interface{}) error {
+func dataSourceCloudRegionRead(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 	projectId := d.Get("project_id").(string)
 	name := d.Get("name").(string)
@@ -87,7 +87,7 @@ func dataSourcePublicCloudRegionRead(d *schema.ResourceData, meta interface{}) e
 	d.Set("continent_code", region.ContinentCode)
 
 	services := &schema.Set{
-		F: publicCloudServiceHash,
+		F: cloudServiceHash,
 	}
 	for i := range region.Services {
 		service := map[string]interface{}{
@@ -103,10 +103,10 @@ func dataSourcePublicCloudRegionRead(d *schema.ResourceData, meta interface{}) e
 	return nil
 }
 
-func getCloudRegion(projectId, region string, client *ovh.Client) (*PublicCloudRegionResponse, error) {
+func getCloudRegion(projectId, region string, client *ovh.Client) (*CloudRegionResponse, error) {
 	log.Printf("[DEBUG] Will read public cloud region %s for project: %s", region, projectId)
 
-	response := &PublicCloudRegionResponse{}
+	response := &CloudRegionResponse{}
 	endpoint := fmt.Sprintf(
 		"/cloud/project/%s/region/%s",
 		url.PathEscape(projectId),
@@ -120,7 +120,7 @@ func getCloudRegion(projectId, region string, client *ovh.Client) (*PublicCloudR
 	return response, nil
 }
 
-func publicCloudServiceHash(v interface{}) int {
+func cloudServiceHash(v interface{}) int {
 	r := v.(map[string]interface{})
 	return hashcode.String(r["name"].(string))
 }

ovh/data_source_ovh_publiccloud_region_test.go → ovh/data_source_ovh_cloud_region_test.go

@@ -8,13 +8,13 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
 )
 
-func TestAccPublicCloudRegionDataSource_basic(t *testing.T) {
+func TestAccCloudRegionDataSource_basic(t *testing.T) {
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheckPublicCloud(t) },
+		PreCheck:  func() { testAccPreCheckCloud(t) },
 		Providers: testAccProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccPublicCloudRegionDatasourceConfig,
+				Config: testAccCloudRegionDatasourceConfig,
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttrSet("data.ovh_cloud_region.region_attr.0", "name"),
 					resource.TestCheckResourceAttrSet("data.ovh_cloud_region.region_attr.0", "services.#"),
@@ -28,7 +28,7 @@ func TestAccPublicCloudRegionDataSource_basic(t *testing.T) {
 	})
 }
 
-var testAccPublicCloudRegionDatasourceConfig = fmt.Sprintf(`
+var testAccCloudRegionDatasourceConfig = fmt.Sprintf(`
 data "ovh_cloud_regions" "regions" {
   project_id = "%s"
 }

ovh/data_source_ovh_publiccloud_regions.go → ovh/data_source_ovh_cloud_regions.go

@@ -8,9 +8,9 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
 )
 
-func dataSourcePublicCloudRegions() *schema.Resource {
+func dataSourceCloudRegions() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourcePublicCloudRegionsRead,
+		Read: dataSourceCloudRegionsRead,
 		Schema: map[string]*schema.Schema{
 			"project_id": {
 				Type:        schema.TypeString,
@@ -34,7 +34,7 @@ func dataSourcePublicCloudRegions() *schema.Resource {
 	}
 }
 
-func dataSourcePublicCloudRegionsRead(d *schema.ResourceData, meta interface{}) error {
+func dataSourceCloudRegionsRead(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 	projectId := d.Get("project_id").(string)
 

ovh/data_source_ovh_publiccloud_regions_test.go → ovh/data_source_ovh_cloud_regions_test.go

@@ -8,58 +8,58 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
 )
 
-func TestAccPublicCloudRegionsDataSource_basic(t *testing.T) {
+func TestAccCloudRegionsDataSource_basic(t *testing.T) {
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheckPublicCloud(t) },
+		PreCheck:  func() { testAccPreCheckCloud(t) },
 		Providers: testAccProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccPublicCloudRegionsDatasourceConfig,
+				Config: testAccCloudRegionsDatasourceConfig,
 				Check:  resource.TestCheckResourceAttrSet("data.ovh_cloud_regions.regions", "names.#"),
 			},
 		},
 	})
 }
 
-func TestAccPublicCloudRegionsDataSource_withNetworkUp(t *testing.T) {
+func TestAccCloudRegionsDataSource_withNetworkUp(t *testing.T) {
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheckPublicCloud(t) },
+		PreCheck:  func() { testAccPreCheckCloud(t) },
 		Providers: testAccProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccPublicCloudRegionsDatasourceConfig_withNetwork,
+				Config: testAccCloudRegionsDatasourceConfig_withNetwork,
 				Check:  resource.TestCheckResourceAttrSet("data.ovh_cloud_regions.regions", "names.#"),
 			},
 		},
 	})
 }
 
-func TestAccPublicCloudRegionsDataSource_withProjectIdEnvVar(t *testing.T) {
+func TestAccCloudRegionsDataSource_withProjectIdEnvVar(t *testing.T) {
 	os.Setenv("OVH_PROJECT_ID", os.Getenv("OVH_PUBLIC_CLOUD"))
 
 	resource.Test(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheckPublicCloud(t) },
+		PreCheck:  func() { testAccPreCheckCloud(t) },
 		Providers: testAccProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccPublicCloudRegionsDatasourceConfig_withProjectIdEnvVar,
+				Config: testAccCloudRegionsDatasourceConfig_withProjectIdEnvVar,
 				Check:  resource.TestCheckResourceAttrSet("data.ovh_cloud_regions.regions", "names.#"),
 			},
 		},
 	})
 }
 
-var testAccPublicCloudRegionsDatasourceConfig = fmt.Sprintf(`
+var testAccCloudRegionsDatasourceConfig = fmt.Sprintf(`
 data "ovh_cloud_regions" "regions" {
   project_id = "%s"
 }
 `, os.Getenv("OVH_PUBLIC_CLOUD"))
 
-var testAccPublicCloudRegionsDatasourceConfig_withProjectIdEnvVar = `
+var testAccCloudRegionsDatasourceConfig_withProjectIdEnvVar = `
 data "ovh_cloud_regions" "regions" {}
 `
 
-var testAccPublicCloudRegionsDatasourceConfig_withNetwork = fmt.Sprintf(`
+var testAccCloudRegionsDatasourceConfig_withNetwork = fmt.Sprintf(`
 data "ovh_cloud_regions" "regions" {
   project_id      = "%s"
   has_services_up = ["network"]

ovh/import_cloud_network_private_subnet_test.go

@@ -0,0 +1,46 @@
+package ovh
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+)
+
+func TestAccCloudNetworkPrivateSubnet_importBasic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheckCredentials(t)
+			testAccCheckcCloudNetworkPrivateSubnetPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCloudNetworkPrivateSubnetConfig(),
+			},
+			{
+				ResourceName:      "ovh_cloud_network_private_subnet.subnet",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateIdFunc: testAccCloudNetworkPrivateSubnetImportId("ovh_cloud_network_private_subnet.subnet"),
+			},
+		},
+	})
+}
+
+func testAccCloudNetworkPrivateSubnetImportId(resourceName string) resource.ImportStateIdFunc {
+	return func(s *terraform.State) (string, error) {
+		subnet, ok := s.RootModule().Resources[resourceName]
+		if !ok {
+			return "", fmt.Errorf("subnet not found: %s", resourceName)
+		}
+
+		return fmt.Sprintf(
+			"%s/%s/%s",
+			subnet.Primary.Attributes["project_id"],
+			subnet.Primary.Attributes["network_id"],
+			subnet.Primary.ID,
+		), nil
+	}
+}

ovh/provider.go

@@ -41,8 +41,8 @@ func Provider() terraform.ResourceProvider {
 		},
 
 		DataSourcesMap: map[string]*schema.Resource{
-			"ovh_cloud_region":                     dataSourcePublicCloudRegion(),
-			"ovh_cloud_regions":                    dataSourcePublicCloudRegions(),
+			"ovh_cloud_region":                     dataSourceCloudRegion(),
+			"ovh_cloud_regions":                    dataSourceCloudRegions(),
 			"ovh_dedicated_installation_templates": dataSourceDedicatedInstallationTemplates(),
 			"ovh_dedicated_server":                 dataSourceDedicatedServer(),
 			"ovh_dedicated_server_boots":           dataSourceDedicatedServerBoots(),
@@ -58,16 +58,16 @@ func Provider() terraform.ResourceProvider {
 			"ovh_vracks":                           dataSourceVracks(),
 
 			// Legacy naming schema (publiccloud)
-			"ovh_publiccloud_region": deprecated(dataSourcePublicCloudRegion(),
+			"ovh_publiccloud_region": deprecated(dataSourceCloudRegion(),
 				"Use ovh_cloud_region data source instead"),
-			"ovh_publiccloud_regions": deprecated(dataSourcePublicCloudRegions(),
+			"ovh_publiccloud_regions": deprecated(dataSourceCloudRegions(),
 				"Use ovh_cloud_regions data source instead"),
 		},
 
 		ResourcesMap: map[string]*schema.Resource{
-			"ovh_cloud_network_private":                                   resourcePublicCloudPrivateNetwork(),
-			"ovh_cloud_network_private_subnet":                            resourcePublicCloudPrivateNetworkSubnet(),
-			"ovh_cloud_user":                                              resourcePublicCloudUser(),
+			"ovh_cloud_network_private":                                   resourceCloudNetworkPrivate(),
+			"ovh_cloud_network_private_subnet":                            resourceCloudNetworkPrivateSubnet(),
+			"ovh_cloud_user":                                              resourceCloudUser(),
 			"ovh_dedicated_server_update":                                 resourceDedicatedServerUpdate(),
 			"ovh_dedicated_server_install_task":                           resourceDedicatedServerInstallTask(),
 			"ovh_dedicated_server_reboot_task":                            resourceDedicatedServerRebootTask(),
@@ -93,11 +93,11 @@ func Provider() terraform.ResourceProvider {
 			"ovh_vrack_dedicated_server_interface":                        resourceVrackDedicatedServerInterface(),
 
 			// Legacy naming schema (publiccloud)
-			"ovh_publiccloud_private_network": deprecated(resourcePublicCloudPrivateNetwork(),
+			"ovh_publiccloud_private_network": deprecated(resourceCloudNetworkPrivate(),
 				"Use ovh_cloud_network_private resource instead"),
-			"ovh_publiccloud_private_network_subnet": deprecated(resourcePublicCloudPrivateNetworkSubnet(),
+			"ovh_publiccloud_private_network_subnet": deprecated(resourceCloudNetworkPrivateSubnet(),
 				"Use ovh_cloud_network_private_subnet resource instead"),
-			"ovh_publiccloud_user": deprecated(resourcePublicCloudUser(),
+			"ovh_publiccloud_user": deprecated(resourceCloudUser(),
 				"Use ovh_cloud_user resource instead"),
 			"ovh_vrack_publiccloud_attachment": deprecated(resourceVrackCloudProject(),
 				"Use ovh_vrack_cloudproject resource instead"),

ovh/provider_test.go

@@ -88,7 +88,7 @@ func testAccPreCheckDomain(t *testing.T) {
 
 // Checks that the environment variables needed for the /cloud acceptance tests
 // are set.
-func testAccPreCheckPublicCloud(t *testing.T) {
+func testAccPreCheckCloud(t *testing.T) {
 	testAccPreCheckCredentials(t)
 	checkEnvOrSkip(t, "OVH_PUBLIC_CLOUD")
 }
@@ -137,7 +137,7 @@ func testAccCheckVRackExists(t *testing.T) {
 
 }
 
-func testAccCheckPublicCloudExists(t *testing.T) {
+func testAccCheckCloudExists(t *testing.T) {
 	type cloudProjectResponse struct {
 		ID          string `json:"project_id"`
 		Status      string `json:"status"`