resource_github_repository_test.go

package github

import (
	"fmt"
	"regexp"
	"strings"
	"testing"

	"github.com/hashicorp/go-cty/cty"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
	"github.com/hashicorp/terraform-plugin-testing/terraform"

	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
)

func TestAccGithubRepository(t *testing.T) {
	t.Run("creates and updates repositories without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%screate-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {

				name                        = "%s"
				description                 = "Terraform acceptance tests %[1]s"
				has_discussions             = true
				has_issues                  = true
				has_wiki                    = true
				has_downloads               = true
				allow_merge_commit          = true
				allow_squash_merge          = false
				allow_rebase_merge          = false
				allow_auto_merge            = true
				merge_commit_title          = "MERGE_MESSAGE"
				merge_commit_message        = "PR_TITLE"
				auto_init                   = false
				web_commit_signoff_required = true
			}
		`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.test", "has_issues",
				"true",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "has_discussions",
				"true",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "allow_auto_merge",
				"true",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "merge_commit_title",
				"MERGE_MESSAGE",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "web_commit_signoff_required",
				"true",
			),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("updates a repositories name without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		oldName := fmt.Sprintf(`%srename-%s`, testResourcePrefix, randomID)
		newName := fmt.Sprintf(`%s-renamed`, oldName)

		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name         = "%[1]s"
				description  = "Terraform acceptance tests %[2]s"
			}
		`, oldName, randomID)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "name",
					oldName,
				),
				resource.ComposeTestCheckFunc(
					testCheckResourceAttrContains("github_repository.test", "full_name",
						oldName),
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "name",
					newName,
				),
				resource.ComposeTestCheckFunc(
					testCheckResourceAttrContains("github_repository.test", "full_name",
						newName),
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				{
					// Rename the repo to something else
					Config: strings.Replace(
						config,
						oldName,
						newName, 1),
					Check: checks["after"],
				},
			},
		})
	})

	t.Run("imports repositories without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name         = "%s"
				description  = "Terraform acceptance tests %[1]s"
				auto_init 	 = false
			}
		`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttrSet("github_repository.test", "name"),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
				{
					ResourceName:            "github_repository.test",
					ImportState:             true,
					ImportStateVerify:       true,
					ImportStateVerifyIgnore: []string{"auto_init", "vulnerability_alerts", "ignore_vulnerability_alerts_during_read"},
				},
			},
		})
	})

	t.Run("archives repositories without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := `
resource "github_repository" "test" {
	name         = "%s"
	archived     = %s
}
`

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, "false"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "archived", "false"),
					),
				},
				{
					Config: fmt.Sprintf(config, testRepoName, "true"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "archived", "true"),
					),
				},
			},
		})
	})

	t.Run("manages the project feature for a repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sproject-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name         = "%s"
				description  = "Terraform acceptance tests %[1]s"
				has_projects = false
			}
		`, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "has_projects",
					"false",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "has_projects",
					"true",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				{
					Config: strings.Replace(config,
						`has_projects = false`,
						`has_projects = true`, 1),
					Check: checks["after"],
				},
			},
		})
	})

	t.Run("manages the default branch feature for a repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sbranch-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name           = "%s"
				description    = "Terraform acceptance tests %[1]s"
				default_branch = "main"
				auto_init      = true
			}

			resource "github_branch" "default" {
				repository = github_repository.test.name
				branch     = "default"
			}
		`, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "default_branch",
					"main",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "default_branch",
					"default",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				// Test changing default_branch
				{
					Config: strings.Replace(config,
						`default_branch = "main"`,
						`default_branch = "default"`, 1),
					Check: checks["after"],
				},
				// Test changing default_branch back to main again
				{
					Config: config,
					Check:  checks["before"],
				},
			},
		})
	})

	t.Run("allows setting default_branch on an empty repository", func(t *testing.T) {
		// Although default_branch is deprecated, for backwards compatibility
		// we allow setting it to "main".

		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sempty-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name           = "%s"
				description    = "Terraform acceptance tests %[1]s"
				default_branch = "main"
			}
		`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.test", "default_branch",
				"main",
			),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				// Test creation with default_branch set
				{
					Config: config,
					Check:  check,
				},
				// Test that changing another property does not try to set
				// default_branch (which would crash).
				{
					Config: strings.Replace(config,
						`acceptance tests`,
						`acceptance test`, 1),
					Check: check,
				},
			},
		})
	})

	t.Run("manages the license and gitignore feature for a repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%slicense-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name           = "%s"
				description    = "Terraform acceptance tests %[1]s"
				license_template   = "ms-pl"
				gitignore_template = "C++"
			}
		`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.test", "license_template",
				"ms-pl",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "gitignore_template",
				"C++",
			),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("configures_topics_for_a_repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%stopic-%s", testResourcePrefix, randomID)
		topicsBefore := `["terraform", "testing"]`
		topicsAfter := `["terraform", "testing", "extra-topic"]`
		config := `
			resource "github_repository" "test" {
				name        = "%s"
				description = "Terraform acceptance tests %[1]s"
				topics			= %s
			}
		`

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, topicsBefore),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "topics.#", "2"),
					),
				},
				{
					Config: fmt.Sprintf(config, testRepoName, topicsAfter),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "topics.#", "3"),
					),
				},
			},
		})
	})

	t.Run("creates a repository using a public template", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%stemplate-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name        = "%s"
				description = "Terraform acceptance tests %[1]s"

				template {
					owner = "%s"
					repository = "%s"
				}

			}
		`, testRepoName, testAccConf.testPublicTemplateRepositoryOwner, testAccConf.testPublicTemplateRepository)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "is_template", "false"),
					),
				},
			},
		})
	})

	t.Run("creates a repository using an org template", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%stemplate-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name        = "%s"
				description = "Terraform acceptance tests %[1]s"

				template {
					owner = "%s"
					repository = "%s"
				}

			}
		`, testRepoName, testAccConf.owner, testAccConf.testOrgTemplateRepository)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessHasOrgs(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "is_template", "false"),
					),
				},
			},
		})
	})

	t.Run("archives repositories on destroy", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := `
resource "github_repository" "test" {
	name               = "%s"
	auto_init          = true
	archive_on_destroy = true
	archived           = %s
}
`

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, "false"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "archived", "false"),
					),
				},
				{
					Config: fmt.Sprintf(config, testRepoName, "true"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "archived", "true"),
					),
				},
			},
		})
	})

	t.Run("create_private_with_forking", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
resource "github_repository" "test" {
	name       = "%s"
	visibility = "private"

	allow_forking = true
}
`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessHasOrgs(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "private"),
						resource.TestCheckResourceAttr("github_repository.test", "allow_forking", "true"),
					),
				},
			},
		})
	})

	t.Run("create_private_without_forking", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "private"

			allow_forking = false
		}
		`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessHasOrgs(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "private"),
						resource.TestCheckResourceAttr("github_repository.test", "allow_forking", "false"),
					),
				},
			},
		})
	})

	t.Run("create_private_with_forking_unset", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
resource "github_repository" "test" {
	name       = "%s"
	visibility = "private"
}
`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessHasOrgs(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "private"),
						resource.TestCheckResourceAttrSet("github_repository.test", "allow_forking"),
					),
				},
			},
		})
	})

	t.Run("update_public_to_private_allow_forking", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%svisibility-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name       = "%s"
				visibility = "public"
			}
		`, testRepoName)

		configPrivate := fmt.Sprintf(`
			resource "github_repository" "test" {
				name          = "%s"
				visibility    = "private"
				allow_forking = false
			}
		`, testRepoName)

		configPrivateForking := fmt.Sprintf(`
			resource "github_repository" "test" {
				name          = "%s"
				visibility    = "private"
				allow_forking = true
			}
		`, testRepoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "public"),
						resource.TestCheckResourceAttr("github_repository.test", "allow_forking", "true"),
					),
				},
				{
					Config: configPrivate,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "private"),
						resource.TestCheckResourceAttr("github_repository.test", "allow_forking", "false"),
					),
				},
				{
					Config: configPrivateForking,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "private"),
						resource.TestCheckResourceAttr("github_repository.test", "allow_forking", "true"),
					),
				},
			},
		})
	})

	t.Run("create_with_vulnerability_alerts", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "public"

			vulnerability_alerts = true
		}
		`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "vulnerability_alerts", "true"),
					),
				},
			},
		})
	})

	t.Run("create_without_vulnerability_alerts", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "public"

			vulnerability_alerts = false
		}
		`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "vulnerability_alerts", "false"),
					),
				},
			},
		})
	})

	t.Run("create_with_vulnerability_alerts_unset", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "public"
		}
		`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttrSet("github_repository.test", "vulnerability_alerts"),
					),
				},
			},
		})
	})

	t.Run("update_vulnerability_alerts", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		repoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "public"

			vulnerability_alerts = false
		}
		`, repoName)

		configUpdate := fmt.Sprintf(`
		resource "github_repository" "test" {
			name       = "%s"
			visibility = "public"

			vulnerability_alerts = true
		}
		`, repoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "vulnerability_alerts", "false"),
					),
				},
				{
					Config: configUpdate,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "vulnerability_alerts", "true"),
					),
				},
			},
		})
	})

	t.Run("create and modify merge commit strategy without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%smodify-co-str-%s", testResourcePrefix, randomID)
		mergeCommitTitle := "PR_TITLE"
		mergeCommitMessage := "BLANK"
		updatedMergeCommitTitle := "MERGE_MESSAGE"
		updatedMergeCommitMessage := "PR_TITLE"

		configs := map[string]string{
			"before": fmt.Sprintf(`
										resource "github_repository" "test" {

												name                 = "%[1]s"
												allow_merge_commit   = true
												merge_commit_title   = "%s"
												merge_commit_message = "%s"
										}
						`, testRepoName, mergeCommitTitle, mergeCommitMessage),
			"after": fmt.Sprintf(`
										resource "github_repository" "test" {
												name                 = "%[1]s"
												allow_merge_commit   = true
												merge_commit_title   = "%s"
												merge_commit_message = "%s"
										}
						`, testRepoName, updatedMergeCommitTitle, updatedMergeCommitMessage),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: configs["before"],
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "merge_commit_title", mergeCommitTitle),
						resource.TestCheckResourceAttr("github_repository.test", "merge_commit_message", mergeCommitMessage),
					),
				},
				{
					Config: configs["after"],
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "merge_commit_title", updatedMergeCommitTitle),
						resource.TestCheckResourceAttr("github_repository.test", "merge_commit_message", updatedMergeCommitMessage),
					),
				},
			},
		})
	})

	t.Run("create and modify squash merge commit strategy without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%smodify-sq-str-%s", testResourcePrefix, randomID)
		testRepoNameAfter := fmt.Sprintf("%s-modified", testRepoName)
		squashMergeCommitTitle := "PR_TITLE"
		squashMergeCommitMessage := "PR_BODY"
		updatedSquashMergeCommitTitle := "COMMIT_OR_PR_TITLE"
		updatedSquashMergeCommitMessage := "COMMIT_MESSAGES"

		configs := map[string]string{
			"before": fmt.Sprintf(`
										resource "github_repository" "test" {
												name                        = "%s"
												allow_squash_merge          = true
												squash_merge_commit_title   = "%s"
												squash_merge_commit_message = "%s"
										}
								`, testRepoName, squashMergeCommitTitle, squashMergeCommitMessage),
			"after": fmt.Sprintf(`
										resource "github_repository" "test" {
												name                        = "%s"
												allow_squash_merge          = true
												squash_merge_commit_title   = "%s"
												squash_merge_commit_message = "%s"
										}
								`, testRepoNameAfter, updatedSquashMergeCommitTitle, updatedSquashMergeCommitMessage),
		}

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr("github_repository.test", "squash_merge_commit_title", squashMergeCommitTitle),
				resource.TestCheckResourceAttr("github_repository.test", "squash_merge_commit_message", squashMergeCommitMessage),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr("github_repository.test", "squash_merge_commit_title", updatedSquashMergeCommitTitle),
				resource.TestCheckResourceAttr("github_repository.test", "squash_merge_commit_message", updatedSquashMergeCommitMessage),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: configs["before"],
					Check:  checks["before"],
				},
				{
					Config: configs["after"],
					Check:  checks["after"],
				},
			},
		})
	})

	// t.Run("create a repository with go as primary_language", func(t *testing.T) {
	// 	randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
	// 	testResourceName := fmt.Sprintf("%srepo-%s", testResourcePrefix, randomID)
	// 	config := fmt.Sprintf(`
	// 		resource "github_repository" "test" {
	// 			name = "%s"
	// 			auto_init = true
	// 		}
	// 		resource "github_repository_file" "test" {
	// 			repository     = github_repository.test.name
	// 			file           = "test.go"
	// 			content        = "package main"
	// 		}
	// 	`, testResourceName)

	// 	check := resource.ComposeTestCheckFunc(
	// 		resource.TestCheckResourceAttr("github_repository.test", "primary_language", "Go"),
	// 	)

	// 	resource.Test(t, resource.TestCase{
	// 		PreCheck:          func() { skipUnauthenticated(t) },
	// 		ProviderFactories: providerFactories,
	// 		Steps: []resource.TestStep{
	// 			{
	// 				// Not doing any checks since the file needs to be created before the language can be updated
	// 				Config: config,
	// 			},
	// 			{
	// 				// Re-running the terraform will refresh the language since the go-file has been created
	// 				Config: config,
	// 				Check:  check,
	// 			},
	// 		},
	// 	})
	// })

	t.Run("creates repository and returns owner field", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)

		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name        = "tf-acc-test-owner-%[1]s"
				description = "Terraform acceptance tests %[1]s"
			}
		`, randomID)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttrSet(
				"github_repository.test", "owner",
			),
		)

		testCase := func(t *testing.T, mode string) {
			resource.Test(t, resource.TestCase{
				PreCheck:  func() { skipUnlessMode(t, mode) },
				Providers: testAccProviders,
				Steps: []resource.TestStep{
					{
						Config: config,
						Check:  check,
					},
				},
			})
		}

		t.Run("with an anonymous account", func(t *testing.T) {
			t.Skip("anonymous account not supported for this operation")
		})

		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)
		})
	})

}

func TestAccGithubRepositoryPages(t *testing.T) {
	randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)

	t.Run("manages the legacy pages feature for a repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%slegacy-pages-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name         = "%s"
				auto_init    = true
				pages {
					build_type = "legacy"

					source {
						branch = "main"
					}
				}
			}
			`, testRepoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "pages.0.source.0.branch", "main"),
						resource.TestCheckResourceAttr("github_repository.test", "pages.0.source.0.path", "/"),
					),
				},
			},
		})
	})

	t.Run("manages the pages from workflow feature for a repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sworkflow-pages-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
		resource "github_repository" "test" {
			name         = "%s"
			auto_init    = true
			pages {
				build_type = "workflow"
			}
		}
		`, testRepoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckNoResourceAttr("github_repository.test", "pages.0.source.#"),
					),
				},
			},
		})
	})

	t.Run("manages the security feature for a private repository", func(t *testing.T) {
		if !testAccConf.testAdvancedSecurity {
			t.Skip("Advanced Security is not enabled for this account")
		}

		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%ssecurity-private-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name        = "%s"
				description = "A repository created by Terraform to test security features"
				visibility  = "private"
				security_and_analysis {
					advanced_security {
						status = "enabled"
					}
					code_security {
						status = "enabled"
					}
					secret_scanning {
						status = "enabled"
					}
					secret_scanning_push_protection {
						status = "enabled"
					}
					secret_scanning_ai_detection {
						status = "enabled"
					}
					secret_scanning_non_provider_patterns {
						status = "enabled"
					}
				}
			}
			`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.advanced_security.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.code_security.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning_push_protection.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning_ai_detection.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning_non_provider_patterns.0.status",
				"enabled",
			),
		)
		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("manages the security feature for a public repository", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%ssecurity-public-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name        = "%s"
				description = "A repository created by Terraform to test security features"
				visibility  = "public"
				security_and_analysis {
					secret_scanning {
						status = "enabled"
					}
					# seems like it can only be "enabled" for an organization that has purchased GHAS
					secret_scanning_push_protection {
						 status = "disabled"
					}
				}
			}
			`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning.0.status",
				"enabled",
			),
			resource.TestCheckResourceAttr(
				"github_repository.test", "security_and_analysis.0.secret_scanning_push_protection.0.status",
				"disabled",
			),
		)
		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("creates repos with private visibility", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%svisibility-private-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "private" {
				name       = "%s"
				visibility = "private"
			}
		`, testRepoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, "foo"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.private", "visibility", "private"),
					),
				},
			},
		})
	})

	t.Run("creates repos with internal visibility", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%svisibility-internal-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name       = "%s"
				visibility = "internal"
			}
		`, testRepoName)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessMode(t, enterprise) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "internal"),
					),
				},
			},
		})
	})

	t.Run("updates repos to private visibility", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%svisibility-public-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "public" {
				name       = "%s"
				visibility = "public"
				vulnerability_alerts = false
			}
		`, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.public", "visibility",
					"public",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.public", "visibility",
					"private",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				{
					Config: reconfigureVisibility(config, "private"),
					Check:  checks["after"],
				},
			},
		})
	})

	t.Run("updates repos to public visibility", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%spublic-vuln-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
				resource "github_repository" "test" {
				name       = "%s"
				visibility = "private"
			}
		`, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "vulnerability_alerts",
					"false",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "vulnerability_alerts",
					"true",
				),
				resource.TestCheckResourceAttr(
					"github_repository.test", "visibility",
					"private",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				{
					Config: strings.Replace(config,
						`}`,
						"vulnerability_alerts = true\n}", 1),
					Check: checks["after"],
				},
			},
		})
	})

	t.Run("updates repos to internal visibility", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sinternal-vuln-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "test" {
				name       = "%s"
				visibility = "private"
			}
		`, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "vulnerability_alerts",
					"false",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.test", "vulnerability_alerts",
					"true",
				),
				resource.TestCheckResourceAttr(
					"github_repository.test", "visibility",
					"private",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessMode(t, enterprise) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  checks["before"],
				},
				{
					Config: strings.Replace(config,
						`}`,
						"vulnerability_alerts = true\n}", 1),
					Check: checks["after"],
				},
			},
		})
	})

	t.Run("sets private visibility for repositories created by a template", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%stemplate-visibility-private-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
			resource "github_repository" "private" {
				name       = "%s"
				visibility = "private"
				template {
					owner      = "%s"
					repository = "%s"
				}
			}
		`, testRepoName, testAccConf.testPublicTemplateRepositoryOwner, testAccConf.testPublicTemplateRepository)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.private", "visibility",
				"private",
			),
			resource.TestCheckResourceAttr(
				"github_repository.private", "private",
				"true",
			),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("create_internal_repo_from_template", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
            resource "github_repository" "test" {
				name       = "%s"
				visibility = "internal"
				template {
					owner      = "%s"
					repository = "%s"
				}
			}
		`, testRepoName, testAccConf.testPublicTemplateRepositoryOwner, testAccConf.testPublicTemplateRepository)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnlessMode(t, enterprise) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.test", "visibility", "internal"),
						resource.TestCheckResourceAttr("github_repository.test", "private", "true"),
					),
				},
			},
		})
	})

	t.Run("check_allow_forking_not_set", func(t *testing.T) {
		t.Skip("This test should be run manually after confirming that the test organization has been correctly configured to disable setting forking at the repo level.")

		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := `
resource "github_repository" "private" {
	name        = "%s"
	description = "%s"
	visibility  = "private"
}
`

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, "foo"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.private", "allow_forking", "false"),
					),
				},
				{
					Config: fmt.Sprintf(config, testRepoName, "bar"),
				},
			},
		})
	})

	t.Run("check_vulnerability_alerts_not_set", func(t *testing.T) {
		t.Skip("This test should be run manually after confirming that the test organization has been correctly configured to disable setting vulnerability alerts at the repo level.")

		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%s%s", testResourcePrefix, randomID)

		config := `
resource "github_repository" "private" {
	name        = "%s"
	description = "%s"
	visibility  = "public"
}
`

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: fmt.Sprintf(config, testRepoName, "foo"),
					Check: resource.ComposeTestCheckFunc(
						resource.TestCheckResourceAttr("github_repository.private", "vulnerability_alerts", "true"),
					),
				},
				{
					Config: fmt.Sprintf(config, testRepoName, "bar"),
				},
			},
		})
	})
}

func Test_expandPages(t *testing.T) {
	t.Run("expand Pages configuration with workflow", func(t *testing.T) {
		input := []any{map[string]any{
			"build_type": "workflow",
			"source":     []any{map[string]any{}},
		}}

		pages := expandPages(input)
		if pages == nil {
			t.Fatal("pages is nil")
		}
		if pages.GetBuildType() != "workflow" {
			t.Errorf("got %q; want %q", pages.GetBuildType(), "workflow")
		}
		if pages.GetSource().GetBranch() != "main" {
			t.Errorf("got %q; want %q", pages.GetSource().GetBranch(), "main")
		}
	})

	t.Run("expand Pages configuration with source", func(t *testing.T) {
		input := []any{map[string]any{
			"build_type": "legacy",
			"source": []any{map[string]any{
				"branch": "main",
				"path":   "/docs",
			}},
		}}

		pages := expandPages(input)
		if pages == nil {
			t.Fatal("pages is nil")
		}
		if pages.GetBuildType() != "legacy" {
			t.Errorf("got %q; want %q", pages.GetBuildType(), "legacy")
		}
		if pages.GetSource().GetBranch() != "main" {
			t.Errorf("got %q; want %q", pages.GetSource().GetBranch(), "main")
		}
		if pages.GetSource().GetPath() != "/docs" {
			t.Errorf("got %q; want %q", pages.GetSource().GetPath(), "/docs")
		}
	})

	t.Run("forks a repository without error", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sfork-%s", testResourcePrefix, randomID)
		config := fmt.Sprintf(`
				resource "github_repository" "forked" {
					name         = "%s"
					description  = "Terraform acceptance test - forked repository %[1]s"
					fork         = true
					source_owner = "integrations"
					source_repo  = "terraform-provider-github"
				}
		 	`, testRepoName)

		check := resource.ComposeTestCheckFunc(
			resource.TestCheckResourceAttr(
				"github_repository.forked", "fork",
				"true",
			),
			resource.TestCheckResourceAttrSet(
				"github_repository.forked", "html_url",
			),
			resource.TestCheckResourceAttrSet(
				"github_repository.forked", "ssh_clone_url",
			),
			resource.TestCheckResourceAttrSet(
				"github_repository.forked", "git_clone_url",
			),
			resource.TestCheckResourceAttrSet(
				"github_repository.forked", "http_clone_url",
			),
		)

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: config,
					Check:  check,
				},
			},
		})
	})

	t.Run("can update forked repository properties", func(t *testing.T) {
		randomID := acctest.RandStringFromCharSet(5, acctest.CharSetAlphaNum)
		testRepoName := fmt.Sprintf("%sfork-update-%s", testResourcePrefix, randomID)
		initialConfig := fmt.Sprintf(`
				resource "github_repository" "forked_update" {
					name         = "%s"
					description  = "Initial description for forked repo"
					fork         = true
					source_owner = "integrations"
					source_repo  = "terraform-provider-github"
					has_wiki     = true
					has_issues   = false
				}
		 `, testRepoName)

		updatedConfig := fmt.Sprintf(`
				resource "github_repository" "forked_update" {
					name         = "%s"
					description  = "Updated description for forked repo"
					fork         = true
					source_owner = "integrations"
					source_repo  = "terraform-provider-github"
					has_wiki     = false
					has_issues   = true
				}
		 `, testRepoName)

		checks := map[string]resource.TestCheckFunc{
			"before": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "description",
					"Initial description for forked repo",
				),
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "has_wiki",
					"true",
				),
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "has_issues",
					"false",
				),
			),
			"after": resource.ComposeTestCheckFunc(
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "description",
					"Updated description for forked repo",
				),
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "has_wiki",
					"false",
				),
				resource.TestCheckResourceAttr(
					"github_repository.forked_update", "has_issues",
					"true",
				),
			),
		}

		resource.Test(t, resource.TestCase{
			PreCheck:          func() { skipUnauthenticated(t) },
			ProviderFactories: providerFactories,
			Steps: []resource.TestStep{
				{
					Config: initialConfig,
					Check:  checks["before"],
				},
				{
					Config: updatedConfig,
					Check:  checks["after"],
				},
				{
					ResourceName:            "github_repository.forked_update",
					ImportState:             true,
					ImportStateVerify:       true,
					ImportStateVerifyIgnore: []string{"auto_init", "vulnerability_alerts", "ignore_vulnerability_alerts_during_read"},
				},
			},
		})
	})
}

func TestGithubRepositoryTopicPassesValidation(t *testing.T) {
	resource := resourceGithubRepository()
	schema := resource.Schema["topics"].Elem.(*schema.Schema)
	diags := schema.ValidateDiagFunc("ef69e1a3-66be-40ca-bb62-4f36186aa292", cty.Path{cty.GetAttrStep{Name: "topic"}})
	if diags.HasError() {
		t.Error(fmt.Errorf("unexpected topic validation failure: %s", diags[0].Summary))
	}
}

func TestGithubRepositoryTopicFailsValidationWhenOverMaxCharacters(t *testing.T) {
	resource := resourceGithubRepository()
	schema := resource.Schema["topics"].Elem.(*schema.Schema)

	diags := schema.ValidateDiagFunc(strings.Repeat("a", 51), cty.Path{cty.GetAttrStep{Name: "topic"}})
	if len(diags) != 1 {
		t.Error(fmt.Errorf("unexpected number of topic validation failures; expected=1; actual=%d", len(diags)))
	}
	expectedFailure := "invalid value for topics (must include only lowercase alphanumeric characters or hyphens and cannot start with a hyphen and consist of 50 characters or less)"
	actualFailure := diags[0].Summary
	if expectedFailure != actualFailure {
		t.Error(fmt.Errorf("unexpected topic validation failure; expected=%s; action=%s", expectedFailure, actualFailure))
	}
}

func reconfigureVisibility(config, visibility string) string {
	re := regexp.MustCompile(`visibility = "(.*)"`)
	newConfig := re.ReplaceAllString(
		config,
		fmt.Sprintf(`visibility = "%s"`, visibility),
	)
	return newConfig
}

type resourceDataLike map[string]any

func (d resourceDataLike) GetOk(key string) (any, bool) {
	v, ok := d[key]
	return v, ok
}

func TestResourceGithubParseFullName(t *testing.T) {
	t.Run("parses valid full name", func(t *testing.T) {
		o := "moyorg"
		r := "myrepo"

		org, repo, ok := resourceGithubParseFullName(resourceDataLike(map[string]any{"full_name": fmt.Sprintf("%s/%s", o, r)}))
		if !ok {
			t.Error("expected ok to be true, got false")
		}
		if org != o {
			t.Errorf("unexpected org (wanted %s, got %s)", o, org)
		}
		if repo != r {
			t.Errorf("unexpected repo (wanted %s, got %s)", r, repo)
		}
	})

	t.Run("handles missing full name", func(t *testing.T) {
		_, _, ok := resourceGithubParseFullName(resourceDataLike(map[string]any{}))
		if ok {
			t.Fatal("expected ok to be false, got true")
		}
	})

	t.Run("handles malformed full name", func(t *testing.T) {
		_, _, ok := resourceGithubParseFullName(resourceDataLike(map[string]any{"full_name": "malformed"}))
		if ok {
			t.Fatal("expected ok to be false, got true")
		}
	})
}

func testCheckResourceAttrContains(resourceName, attributeName, substring string) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		rs, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Resource not found: %s", resourceName)
		}

		value, ok := rs.Primary.Attributes[attributeName]
		if !ok {
			return fmt.Errorf("Attribute not found: %s", attributeName)
		}

		if !strings.Contains(value, substring) {
			return fmt.Errorf("Attribute '%s' does not contain '%s'", value, substring)
		}

		return nil
	}
}

func TestGithubRepositoryNameFailsValidationWhenOverMaxCharacters(t *testing.T) {
	resource := resourceGithubRepository()
	schema := resource.Schema["name"]

	diags := schema.ValidateDiagFunc(strings.Repeat("a", 101), cty.GetAttrPath("name"))
	if len(diags) != 1 {
		t.Error(fmt.Errorf("unexpected number of name validation failures; expected=1; actual=%d", len(diags)))
	}
	expectedFailure := "invalid value for name (must include only alphanumeric characters, underscores or hyphens and consist of 100 characters or less)"
	actualFailure := diags[0].Summary
	if expectedFailure != actualFailure {
		t.Error(fmt.Errorf("unexpected name validation failure; expected=%s; action=%s", expectedFailure, actualFailure))
	}
}

func TestGithubRepositoryNameFailsValidationWithSpace(t *testing.T) {
	resource := resourceGithubRepository()
	schema := resource.Schema["name"]

	diags := schema.ValidateDiagFunc("test space", cty.GetAttrPath("name"))
	if len(diags) != 1 {
		t.Error(fmt.Errorf("unexpected number of name validation failures; expected=1; actual=%d", len(diags)))
	}
	expectedFailure := "invalid value for name (must include only alphanumeric characters, underscores or hyphens and consist of 100 characters or less)"
	actualFailure := diags[0].Summary
	if expectedFailure != actualFailure {
		t.Error(fmt.Errorf("unexpected name validation failure; expected=%s; action=%s", expectedFailure, actualFailure))
	}
}