fix: change fork to TypeString and add conditional ForceNew (#2959)

* fix: change "fork" to TypeString

* lint + computed on source_owner and source_repo

Signed-off-by: Diogenes Fernandes <[email protected]>

* adding automated test

Signed-off-by: Diogenes Fernandes <[email protected]>

* source_repo and source_owner logic added

Signed-off-by: Diogenes Fernandes <[email protected]>

* lint

Signed-off-by: Diogenes Fernandes <[email protected]>

---------

Signed-off-by: Diogenes Fernandes <[email protected]>

Author: diofeher

github/resource_github_repository.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/google/go-github/v67/github"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 )
@@ -63,22 +64,24 @@ func resourceGithubRepository() *schema.Resource {
 				ValidateDiagFunc: toDiagFunc(validation.StringInSlice([]string{"public", "private", "internal"}, false), "visibility"),
 				Description:      "Can be 'public' or 'private'. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be 'internal'.",
 			},
+			// terraform-sdk-provider doesn't properly support tristate booleans: https://github.com/hashicorp/terraform-plugin-sdk/issues/817
+			// Using TypeString as the best alternative for now.
 			"fork": {
-				Type:        schema.TypeBool,
+				Type:        schema.TypeString,
 				Optional:    true,
-				ForceNew:    true,
+				Computed:    true,
 				Description: "Set to 'true' to fork an existing repository.",
 			},
 			"source_owner": {
 				Type:        schema.TypeString,
 				Optional:    true,
-				ForceNew:    true,
+				Computed:    true,
 				Description: "The owner of the source repository to fork from.",
 			},
 			"source_repo": {
 				Type:        schema.TypeString,
 				Optional:    true,
-				ForceNew:    true,
+				Computed:    true,
 				Description: "The name of the source repository to fork from.",
 			},
 			"security_and_analysis": {
@@ -479,10 +482,32 @@ func resourceGithubRepository() *schema.Resource {
 				Description: " Set to 'true' to always suggest updating pull request branches.",
 			},
 		},
-		CustomizeDiff: customDiffFunction,
+		CustomizeDiff: customdiff.All(
+			customDiffFunction,
+			customdiff.ForceNewIfChange("fork", valueChangedButNotEmpty),
+			customdiff.ForceNewIfChange("source_repo", valueChangedButNotEmpty),
+			customdiff.ForceNewIfChange("source_owner", valueChangedButNotEmpty),
+		),
 	}
 }
 
+// valueChangedButNotEmpty is a customdiff function that triggers recreation of the resource
+// if the field's value changes from a non-empty state to a different non-empty value.
+func valueChangedButNotEmpty(ctx context.Context, oldVal, newVal, meta any) bool {
+	oldValStr := oldVal.(string)
+	newValStr := newVal.(string)
+	return oldValStr != "" && oldValStr != newValStr
+}
+
+func customDiffFunction(_ context.Context, diff *schema.ResourceDiff, v any) error {
+	if diff.HasChange("name") {
+		if err := diff.SetNewComputed("full_name"); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func calculateVisibility(d *schema.ResourceData) string {
 	if value, ok := d.GetOk("visibility"); ok {
 		return value.(string)
@@ -658,12 +683,11 @@ func resourceGithubRepositoryCreate(d *schema.ResourceData, meta any) error {
 
 			d.SetId(*repo.Name)
 		}
-	} else if d.Get("fork").(bool) {
+	} else if d.Get("fork").(string) == "true" {
 		// Handle repository forking
 		sourceOwner := d.Get("source_owner").(string)
 		sourceRepo := d.Get("source_repo").(string)
 		requestedName := d.Get("name").(string)
-		owner := meta.(*Owner).name
 		log.Printf("[INFO] Creating fork of %s/%s in %s", sourceOwner, sourceRepo, owner)
 
 		if sourceOwner == "" || sourceRepo == "" {
@@ -838,15 +862,15 @@ func resourceGithubRepositoryRead(d *schema.ResourceData, meta any) error {
 
 	// Set fork information if this is a fork
 	if repo.GetFork() {
-		_ = d.Set("fork", true)
+		_ = d.Set("fork", "true")
 
 		// If the repository has parent information, set the source details
 		if repo.Parent != nil {
 			_ = d.Set("source_owner", repo.Parent.GetOwner().GetLogin())
 			_ = d.Set("source_repo", repo.Parent.GetName())
 		}
 	} else {
-		_ = d.Set("fork", false)
+		_ = d.Set("fork", "false")
 		_ = d.Set("source_owner", "")
 		_ = d.Set("source_repo", "")
 	}
@@ -1218,15 +1242,6 @@ func resourceGithubParseFullName(resourceDataLike interface {
 	return parts[0], parts[1], true
 }
 
-func customDiffFunction(_ context.Context, diff *schema.ResourceDiff, v any) error {
-	if diff.HasChange("name") {
-		if err := diff.SetNewComputed("full_name"); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func updateVulnerabilityAlerts(d *schema.ResourceData, client *github.Client, ctx context.Context, owner, repoName string) error {
 	updateVulnerabilityAlerts := client.Repositories.DisableVulnerabilityAlerts
 	if vulnerabilityAlerts, ok := d.GetOk("vulnerability_alerts"); ok && vulnerabilityAlerts.(bool) {

github/resource_github_repository_test.go

@@ -2,12 +2,14 @@ package github
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"regexp"
 	"strings"
 	"testing"
 
+	"github.com/google/go-github/v67/github"
 	"github.com/hashicorp/go-cty/cty"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
@@ -1933,4 +1935,117 @@ func TestAccGithubRepository_fork(t *testing.T) {
 			t.Skip("anonymous account not supported for this operation")
 		})
 	})
+
+	t.Run("can migrate a forked repository from a previous framework version", func(t *testing.T) {
+		rName := fmt.Sprintf("terraform-provider-github-%s", randomID)
+		olderConfig := fmt.Sprintf(`
+			  import {
+				to = github_repository.forked
+				id = "%[1]s"
+			  }
+			  resource "github_repository" "forked" {
+					name         = "%[1]s"
+					description  = "Terraform acceptance test - forked repository %[1]s"
+			  }
+		 `, rName)
+		newerConfig := fmt.Sprintf(`
+			  resource "github_repository" "forked" {
+					name         = "%[1]s"
+					description  = "Terraform acceptance test - forked repository %[1]s"
+					fork         = true
+					source_owner = "integrations"
+					source_repo  = "terraform-provider-github"
+			  }
+		 `, rName)
+
+		testCase := func(t *testing.T, mode string) {
+			providers := []*schema.Provider{testAccProvider}
+			resource.Test(t, resource.TestCase{
+				PreCheck: func() { skipUnlessMode(t, mode) },
+				Steps: []resource.TestStep{
+					{
+						ExternalProviders: map[string]resource.ExternalProvider{
+							"github": {
+								VersionConstraint: "~> 6.7.0",
+								Source:            "integrations/github",
+							},
+						},
+						PreConfig: func() {
+							err := createForkedRepository(rName)
+							if err != nil {
+								t.Fatalf("failed to create fork of %s: %v", rName, err)
+							}
+						},
+						Config: olderConfig,
+						Check: resource.ComposeTestCheckFunc(
+							resource.TestCheckNoResourceAttr(
+								"github_repository.forked", "fork",
+							),
+							resource.TestCheckNoResourceAttr(
+								"github_repository.forked", "source_owner",
+							),
+							resource.TestCheckNoResourceAttr(
+								"github_repository.forked", "source_repo",
+							),
+						),
+					},
+					{
+						ProviderFactories: testAccProviderFactories(&providers),
+						Config:            newerConfig,
+						Check: resource.ComposeTestCheckFunc(
+							resource.TestCheckResourceAttr(
+								"github_repository.forked", "fork",
+								"true",
+							),
+							resource.TestCheckResourceAttr(
+								"github_repository.forked", "source_owner",
+								"integrations",
+							),
+							resource.TestCheckResourceAttr(
+								"github_repository.forked", "source_repo",
+								"terraform-provider-github",
+							),
+						),
+					},
+				},
+			})
+		}
+
+		t.Run("with an individual account", func(t *testing.T) {
+			testCase(t, individual)
+		})
+
+		t.Run("with an organization account", func(t *testing.T) {
+			testCase(t, organization)
+		})
+
+		t.Run("with an anonymous account", func(t *testing.T) {
+			t.Skip("anonymous account not supported for this operation")
+		})
+	})
+}
+
+func createForkedRepository(repositoryName string) error {
+	config := Config{BaseURL: "https://api.github.com/", Owner: testOrganizationFunc(), Token: testToken}
+	meta, err := config.Meta()
+	if err != nil {
+		return fmt.Errorf("failed to create client: %w", err)
+	}
+	client := meta.(*Owner).v3client
+	orgName := meta.(*Owner).name
+	ctx := context.TODO()
+
+	_, _, err = client.Repositories.CreateFork(ctx, "integrations", "snappydoo", &github.RepositoryCreateForkOptions{
+		Organization: orgName,
+		Name:         repositoryName,
+	})
+
+	acceptedError := &github.AcceptedError{}
+	if err != nil {
+		if errors.As(err, &acceptedError) {
+			return nil
+		}
+		return fmt.Errorf("failed to create fork: %w", err)
+	}
+	return nil
 }