feat: add test

Author: jremy42

docs/resources/rdb_snapshot.md

@@ -204,6 +204,7 @@ func Provider(config *Config) plugin.ProviderFunc {
 				"scaleway_rdb_privilege":                       rdb.ResourcePrivilege(),
 				"scaleway_rdb_read_replica":                    rdb.ResourceReadReplica(),
 				"scaleway_rdb_user":                            rdb.ResourceUser(),
+				"scaleway_rdb_snapshot":                        rdb.ResourceSnapshot(),
 				"scaleway_redis_cluster":                       redis.ResourceCluster(),
 				"scaleway_registry_namespace":                  registry.ResourceNamespace(),
 				"scaleway_sdb_sql_database":                    sdb.ResourceDatabase(),

internal/provider/provider.go

@@ -54,10 +54,23 @@ func ResourceInstance() *schema.Resource {
 			},
 			"engine": {
 				Type:             schema.TypeString,
-				Required:         true,
+				Optional:         true,
+				Computed:         true,
 				ForceNew:         true,
 				Description:      "Database's engine version id",
 				DiffSuppressFunc: dsf.IgnoreCase,
+				ConflictsWith: []string{
+					"snapshot_id",
+				},
+			},
+			"snapshot_id": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				ForceNew:    true,
+				Description: "ID of an existing snapshot to create a new instance from. This allows restoring a database instance to the state captured in the specified snapshot. Conflicts with the `engine` attribute.",
+				ConflictsWith: []string{
+					"engine",
+				},
 			},
 			"is_ha_cluster": {
 				Type:        schema.TypeBool,
@@ -323,66 +336,110 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m in
 	if err != nil {
 		return diag.FromErr(err)
 	}
+	id := ""
 
-	createReq := &rdb.CreateInstanceRequest{
-		Region:        region,
-		ProjectID:     types.ExpandStringPtr(d.Get("project_id")),
-		Name:          types.ExpandOrGenerateString(d.Get("name"), "rdb"),
-		NodeType:      d.Get("node_type").(string),
-		Engine:        d.Get("engine").(string),
-		IsHaCluster:   d.Get("is_ha_cluster").(bool),
-		DisableBackup: d.Get("disable_backup").(bool),
-		UserName:      d.Get("user_name").(string),
-		Password:      d.Get("password").(string),
-		VolumeType:    rdb.VolumeType(d.Get("volume_type").(string)),
-		Encryption: &rdb.EncryptionAtRest{
-			Enabled: d.Get("encryption_at_rest").(bool),
-		},
-	}
+	if regionalSnapshotID, ok := d.GetOk("snapshot_id"); ok {
+		haCluster := d.Get("is_ha_cluster").(bool)
+		nodeType := d.Get("node_type").(string)
+		_, snapshotID, err := regional.ParseID(regionalSnapshotID.(string))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		createReqFromSnapshot := &rdb.CreateInstanceFromSnapshotRequest{
+			SnapshotID:   snapshotID,
+			Region:       region,
+			InstanceName: types.ExpandOrGenerateString(d.Get("name"), "rdb"),
+			IsHaCluster:  &haCluster,
+			NodeType:     &nodeType,
+		}
+		res, err := rdbAPI.CreateInstanceFromSnapshot(createReqFromSnapshot, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		_, err = waitForRDBInstance(ctx, rdbAPI, region, res.ID, d.Timeout(schema.TimeoutCreate))
+		if err != nil {
+			return diag.FromErr(err)
+		}
 
-	if initSettings, ok := d.GetOk("init_settings"); ok {
-		createReq.InitSettings = expandInstanceSettings(initSettings)
-	}
+		rawTag, tagExist := d.GetOk("tags")
+		if tagExist {
+			updateReq := &rdb.UpdateInstanceRequest{
+				Region:     region,
+				InstanceID: res.ID,
+			}
+			tags := types.ExpandStrings(rawTag)
+			updateReq.Tags = &tags
+			_, err = rdbAPI.UpdateInstance(updateReq, scw.WithContext(ctx))
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+		d.SetId(regional.NewIDString(region, res.ID))
+		id = res.ID
 
-	rawTag, tagExist := d.GetOk("tags")
-	if tagExist {
-		createReq.Tags = types.ExpandStrings(rawTag)
-	}
+	} else {
 
-	// Init Endpoints
-	if pn, pnExist := d.GetOk("private_network"); pnExist {
-		ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
-		var diags diag.Diagnostics
-		createReq.InitEndpoints, diags = expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
-		if diags.HasError() {
-			return diags
+		createReq := &rdb.CreateInstanceRequest{
+			Region:        region,
+			ProjectID:     types.ExpandStringPtr(d.Get("project_id")),
+			Name:          types.ExpandOrGenerateString(d.Get("name"), "rdb"),
+			NodeType:      d.Get("node_type").(string),
+			Engine:        d.Get("engine").(string),
+			IsHaCluster:   d.Get("is_ha_cluster").(bool),
+			DisableBackup: d.Get("disable_backup").(bool),
+			UserName:      d.Get("user_name").(string),
+			Password:      d.Get("password").(string),
+			VolumeType:    rdb.VolumeType(d.Get("volume_type").(string)),
+			Encryption: &rdb.EncryptionAtRest{
+				Enabled: d.Get("encryption_at_rest").(bool),
+			},
 		}
-		for _, warning := range diags {
-			tflog.Warn(ctx, warning.Detail)
+
+		if initSettings, ok := d.GetOk("init_settings"); ok {
+			createReq.InitSettings = expandInstanceSettings(initSettings)
 		}
-	}
-	if _, lbExists := d.GetOk("load_balancer"); lbExists {
-		createReq.InitEndpoints = append(createReq.InitEndpoints, expandLoadBalancer())
-	}
 
-	if size, ok := d.GetOk("volume_size_in_gb"); ok {
-		if createReq.VolumeType == rdb.VolumeTypeLssd {
-			return diag.FromErr(fmt.Errorf("volume_size_in_gb should not be used with volume_type %s", rdb.VolumeTypeLssd.String()))
+		rawTag, tagExist := d.GetOk("tags")
+		if tagExist {
+			createReq.Tags = types.ExpandStrings(rawTag)
 		}
-		createReq.VolumeSize = scw.Size(uint64(size.(int)) * uint64(scw.GB))
-	}
 
-	res, err := rdbAPI.CreateInstance(createReq, scw.WithContext(ctx))
-	if err != nil {
-		return diag.FromErr(err)
-	}
+		// Init Endpoints
+		if pn, pnExist := d.GetOk("private_network"); pnExist {
+			ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
+			var diags diag.Diagnostics
+			createReq.InitEndpoints, diags = expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
+			if diags.HasError() {
+				return diags
+			}
+			for _, warning := range diags {
+				tflog.Warn(ctx, warning.Detail)
+			}
+		}
+		if _, lbExists := d.GetOk("load_balancer"); lbExists {
+			createReq.InitEndpoints = append(createReq.InitEndpoints, expandLoadBalancer())
+		}
+
+		if size, ok := d.GetOk("volume_size_in_gb"); ok {
+			if createReq.VolumeType == rdb.VolumeTypeLssd {
+				return diag.FromErr(fmt.Errorf("volume_size_in_gb should not be used with volume_type %s", rdb.VolumeTypeLssd.String()))
+			}
+			createReq.VolumeSize = scw.Size(uint64(size.(int)) * uint64(scw.GB))
+		}
+
+		res, err := rdbAPI.CreateInstance(createReq, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
 
-	d.SetId(regional.NewIDString(region, res.ID))
+		d.SetId(regional.NewIDString(region, res.ID))
+		id = res.ID
+	}
 
 	mustUpdate := false
 	updateReq := &rdb.UpdateInstanceRequest{
 		Region:     region,
-		InstanceID: res.ID,
+		InstanceID: id,
 	}
 	// Configure Schedule Backup
 	// BackupScheduleFrequency and BackupScheduleRetention can only configure after instance creation
@@ -403,9 +460,8 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m in
 		updateReq.LogsPolicy = expandInstanceLogsPolicy(policyRaw)
 		mustUpdate = true
 	}
-
 	if mustUpdate {
-		_, err = waitForRDBInstance(ctx, rdbAPI, region, res.ID, d.Timeout(schema.TimeoutCreate))
+		_, err = waitForRDBInstance(ctx, rdbAPI, region, id, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
 			return diag.FromErr(err)
 		}
@@ -416,12 +472,12 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m in
 	}
 	// Configure Instance settings
 	if settings, ok := d.GetOk("settings"); ok {
-		res, err = waitForRDBInstance(ctx, rdbAPI, region, res.ID, d.Timeout(schema.TimeoutCreate))
+		res, err := waitForRDBInstance(ctx, rdbAPI, region, id, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
 			return diag.FromErr(err)
 		}
 
-		_, err := rdbAPI.SetInstanceSettings(&rdb.SetInstanceSettingsRequest{
+		_, err = rdbAPI.SetInstanceSettings(&rdb.SetInstanceSettingsRequest{
 			InstanceID: res.ID,
 			Region:     region,
 			Settings:   expandInstanceSettings(settings),
@@ -430,7 +486,6 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m in
 			return diag.FromErr(err)
 		}
 	}
-
 	return ResourceRdbInstanceRead(ctx, d, m)
 }
 

internal/services/rdb/instance.go

@@ -1383,6 +1383,103 @@ func TestAccInstance_UpdateEncryptionAtRest(t *testing.T) {
 	})
 }
 
+func TestAccRdbInstance_CompleteWorkflow(t *testing.T) {
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	latestEngineVersion := rdbchecks.GetLatestEngineVersion(tt, postgreSQLEngineName)
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { acctest.PreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      IsSnapshotDestroyed(tt),
+		Steps: []resource.TestStep{
+			// Step 1: Create an instance and a snapshot
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_rdb_instance" "main" {
+						name           = "test-rdb-instance"
+						node_type      = "db-dev-s"
+						engine         = %q
+						is_ha_cluster  = false
+						disable_backup = true
+						user_name      = "my_initial_user"
+						password       = "thiZ_is_v&ry_s3cret"
+						tags           = ["terraform-test", "scaleway_rdb_instance"]
+						volume_type    = "bssd"
+						volume_size_in_gb = 10
+					}
+
+					resource "scaleway_rdb_snapshot" "test" {
+						name        = "test-snapshot"
+						instance_id = scaleway_rdb_instance.main.id
+						depends_on  = [scaleway_rdb_instance.main]
+					}
+
+					resource "scaleway_rdb_instance" "from_snapshot" {
+						name           = "test-instance-from-snapshot"
+						node_type      = "db-dev-s"
+						is_ha_cluster  = false
+						disable_backup = true
+						snapshot_id    = scaleway_rdb_snapshot.test.id
+						volume_type    = "bssd"
+						tags           = ["terraform-test", "restored_instance"]
+						depends_on     = [scaleway_rdb_snapshot.test]
+					}
+				`, latestEngineVersion),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "name", "test-instance-from-snapshot"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "user_name", "my_initial_user"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.0", "terraform-test"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.1", "restored_instance"),
+				),
+			},
+			// Step 2: Update the instance created from the snapshot
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_rdb_instance" "main" {
+						name           = "test-rdb-instance"
+						node_type      = "db-dev-s"
+						engine         = %q
+						is_ha_cluster  = false
+						disable_backup = true
+						user_name      = "my_initial_user"
+						password       = "thiZ_is_v&ry_s3cret"
+						tags           = ["terraform-test", "scaleway_rdb_instance"]
+						volume_type    = "bssd"
+						volume_size_in_gb = 10
+					}
+
+					resource "scaleway_rdb_snapshot" "test" {
+						name        = "test-snapshot"
+						instance_id = scaleway_rdb_instance.main.id
+						depends_on  = [scaleway_rdb_instance.main]
+					}
+
+					resource "scaleway_rdb_instance" "from_snapshot" {
+						name           = "test-instance-from-snapshot-updated"
+						node_type      = "db-dev-s"
+						is_ha_cluster  = false
+						disable_backup = true
+						snapshot_id    = scaleway_rdb_snapshot.test.id
+						volume_type    = "bssd"
+						user_name      = "updated_user"
+						password       = "thiZ_is_v&ry_s3cret2"
+						tags           = ["terraform-test", "updated_instance"]
+						depends_on     = [scaleway_rdb_snapshot.test]
+					}
+				`, latestEngineVersion),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "name", "test-instance-from-snapshot-updated"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "user_name", "updated_user"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.0", "terraform-test"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.1", "updated_instance"),
+				),
+			},
+		},
+	})
+}
+
 func isInstancePresent(tt *acctest.TestTools, n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]