PR feedback and improvements to the new gitlab_project import_url attribute

Fix import_url not being set in properties

Use StateChangeConf instead of for loop

Make the importURL test less brittle by importing a local repository

Add import_url to docs

Make import_url force new

Author: armsnyder

gitlab/resource_gitlab_project.go

@@ -62,6 +62,11 @@ var resourceGitLabProjectSchema = map[string]*schema.Schema{
 			return old == new
 		},
 	},
+	"import_url": {
+		Type:     schema.TypeString,
+		Optional: true,
+		ForceNew: true,
+	},
 	"request_access_enabled": {
 		Type:     schema.TypeBool,
 		Optional: true,
@@ -113,10 +118,6 @@ var resourceGitLabProjectSchema = map[string]*schema.Schema{
 		ValidateFunc: validation.StringInSlice([]string{"private", "internal", "public"}, true),
 		Default:      "private",
 	},
-	"import_url": {
-		Type:     schema.TypeString,
-		Optional: true,
-	},
 	"merge_method": {
 		Type:         schema.TypeString,
 		Optional:     true,
@@ -315,6 +316,7 @@ func resourceGitlabProjectCreate(d *schema.ResourceData, meta interface{}) error
 
 	if v, ok := d.GetOk("import_url"); ok {
 		options.ImportURL = gitlab.String(v.(string))
+		setProperties = append(setProperties, "import_url")
 	}
 
 	log.Printf("[DEBUG] create gitlab project %q", *options.Name)
@@ -333,6 +335,28 @@ func resourceGitlabProjectCreate(d *schema.ResourceData, meta interface{}) error
 	// is committed to state since we set its ID
 	d.SetId(fmt.Sprintf("%d", project.ID))
 
+	if _, ok := d.GetOk("import_url"); ok {
+		log.Printf("[DEBUG] waiting for project %q import to finish", *options.Name)
+
+		stateConf := &resource.StateChangeConf{
+			Pending: []string{"scheduled", "started"},
+			Target:  []string{"finished"},
+			Timeout: time.Minute,
+			Refresh: func() (interface{}, string, error) {
+				status, _, err := client.ProjectImportExport.ImportStatus(d.Id())
+				if err != nil {
+					return nil, "", err
+				}
+
+				return status, status.ImportStatus, nil
+			},
+		}
+
+		if _, err := stateConf.WaitForState(); err != nil {
+			return fmt.Errorf("error while waiting for project %q import to finish: %w", *options.Name, err)
+		}
+	}
+
 	if v, ok := d.GetOk("shared_with_groups"); ok {
 		for _, option := range expandSharedWithGroupsOptions(v) {
 			if _, err := client.Projects.ShareProjectWithGroup(project.ID, option); err != nil {
@@ -360,7 +384,6 @@ func resourceGitlabProjectCreate(d *schema.ResourceData, meta interface{}) error
 }
 
 func resourceGitlabProjectRead(d *schema.ResourceData, meta interface{}) error {
-	var project *gitlab.Project
 	client := meta.(*gitlab.Client)
 	log.Printf("[DEBUG] read gitlab project %s", d.Id())
 
@@ -374,13 +397,6 @@ func resourceGitlabProjectRead(d *schema.ResourceData, meta interface{}) error {
 		return nil
 	}
 
-	for project.ImportStatus == "started" {
-		project, _, err = client.Projects.GetProject(d.Id(), nil)
-		if err != nil {
-			return err
-		}
-	}
-
 	resourceGitlabProjectSetToState(d, project)
 	return nil
 }

gitlab/resource_gitlab_project_test.go

@@ -2,6 +2,7 @@ package gitlab
 
 import (
 	"fmt"
+	"os"
 	"regexp"
 	"testing"
 
@@ -352,18 +353,55 @@ func TestAccGitlabProject_transfer(t *testing.T) {
 	})
 }
 
-func TestAccImportURL(t *testing.T) {
-	var received gitlab.Project
+func TestAccGitlabProject_importURL(t *testing.T) {
+	// Since we do some manual setup in this test, we need to handle the test skip first.
+	if os.Getenv(resource.TestEnvVar) == "" {
+		t.Skip(fmt.Sprintf("Acceptance tests skipped unless env '%s' set", resource.TestEnvVar))
+	}
+
+	client := testAccProvider.Meta().(*gitlab.Client)
+	rInt := acctest.RandInt()
+
+	// Create a base project for importing.
+	baseProject, _, err := client.Projects.CreateProject(&gitlab.CreateProjectOptions{
+		Name:       gitlab.String(fmt.Sprintf("base-%d", rInt)),
+		Visibility: gitlab.Visibility(gitlab.PublicVisibility),
+	})
+	if err != nil {
+		t.Fatalf("failed to create base project: %v", err)
+	}
+
+	defer client.Projects.DeleteProject(baseProject.ID)
+
+	// Add a file to the base project, for later verifying the import.
+	_, _, err = client.RepositoryFiles.CreateFile(baseProject.ID, "foo.txt", &gitlab.CreateFileOptions{
+		Branch:        gitlab.String("master"),
+		CommitMessage: gitlab.String("add file"),
+		Content:       gitlab.String(""),
+	})
+	if err != nil {
+		t.Fatalf("failed to commit file to base project: %v", err)
+	}
+
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
 		Providers:    testAccProviders,
 		CheckDestroy: testAccCheckGitlabProjectDestroy,
 		Steps: []resource.TestStep{
 			{
-				Config: testImportURLOptions(),
+				Config: testAccGitlabProjectConfigImportURL(rInt, baseProject.HTTPURLToRepo),
 				Check: resource.ComposeTestCheckFunc(
-					testAccCheckGitlabProjectExists("gitlab_project.import_url", &received),
-					testAccCheckImportURL("gitlab/resource_gitlab_project.go", &received),
+					resource.TestCheckResourceAttr("gitlab_project.imported", "import_url", baseProject.HTTPURLToRepo),
+					func(state *terraform.State) error {
+						projectID := state.RootModule().Resources["gitlab_project.imported"].Primary.ID
+
+						_, _, err := client.RepositoryFiles.GetFile(projectID, "foo.txt", &gitlab.GetFileOptions{Ref: gitlab.String("master")}, nil)
+						if err != nil {
+							return fmt.Errorf("failed to get file from imported project: %w", err)
+						}
+
+						return nil
+					},
 				),
 			},
 		},
@@ -686,48 +724,16 @@ resource "gitlab_project" "foo" {
 	`, rInt, rInt)
 }
 
-func testImportURLOptions() string {
+func testAccGitlabProjectConfigImportURL(rInt int, importURL string) string {
 	return fmt.Sprintf(`
-resource "gitlab_project" "import_url" {
-  name = "import"
-  path = "import"
-  description = "Terraform Import URL Acceptance test"
+resource "gitlab_project" "imported" {
+  name = "imported-%d"
+  default_branch = "master"
+  import_url = "%s"
 
   # So that acceptance tests can be run in a gitlab organization
   # with no billing
   visibility_level = "public"
-  merge_method = "ff"
-  only_allow_merge_if_pipeline_succeeds = true
-  only_allow_merge_if_all_discussions_are_resolved = true
-
-  issues_enabled = false
-  merge_requests_enabled = false
-  approvals_before_merge = 0
-  wiki_enabled = false
-  snippets_enabled = false
-  container_registry_enabled = false
-  shared_runners_enabled = false
-  archived = false
-  import_url = "https://github.com/terraform-providers/terraform-provider-gitlab.git"
-  default_branch = "master"
 }
-	`)
-}
-
-func testAccCheckImportURL(fp string, project *gitlab.Project) resource.TestCheckFunc {
-	return func(s *terraform.State) error {
-		conn := testAccProvider.Meta().(*gitlab.Client)
-		ref := &gitlab.GetFileOptions{
-			Ref: gitlab.String("master"),
-		}
-		f, _, err := conn.RepositoryFiles.GetFile(project.ID, fp, ref, nil)
-		if err != nil {
-			return fmt.Errorf("Cannot find file %s, error %s\n", fp, err)
-		}
-		if f == nil {
-			return fmt.Errorf("Did not find file\n")
-		}
-
-		return nil
-	}
+`, rInt, importURL)
 }

website/docs/r/project.html.markdown

@@ -40,6 +40,8 @@ The following arguments are supported:
 
 * `default_branch` - (Optional) The default branch for the project.
 
+* `import_url` - (Optional) Git URL to a repository to be imported.
+
 * `request_access_enabled` - Allow users to request member access.
 
 * `issues_enabled` - (Optional) Enable issue tracking for the project.