Merge pull request #230 from diggerhq/rename-pull-request-manager

make DiggerExecutor exportable

Author: veziak

pkg/digger/digger.go

@@ -341,19 +341,19 @@ func parseProjectName(comment string) string {
 }
 
 type DiggerExecutor struct {
-	repoOwner         string
-	repoName          string
-	projectName       string
-	projectPath       string
-	stateEnvVars      map[string]string
-	commandEnvVars    map[string]string
-	applyStage        *configuration.Stage
-	planStage         *configuration.Stage
-	commandRunner     CommandRun
-	terraformExecutor terraform.TerraformExecutor
-	prManager         ci.CIService
-	lock              utils.ProjectLock
-	planStorage       utils.PlanStorage
+	RepoOwner         string
+	RepoName          string
+	ProjectName       string
+	ProjectPath       string
+	StateEnvVars      map[string]string
+	CommandEnvVars    map[string]string
+	ApplyStage        *configuration.Stage
+	PlanStage         *configuration.Stage
+	CommandRunner     CommandRun
+	TerraformExecutor terraform.TerraformExecutor
+	ciService         ci.CIService
+	ProjectLock       utils.ProjectLock
+	PlanStorage       utils.PlanStorage
 }
 
 type CommandRun interface {
@@ -384,28 +384,28 @@ func (c CommandRunner) Run(command string) (string, string, error) {
 }
 
 func (d DiggerExecutor) planFileName() string {
-	return d.repoName + "#" + d.projectName + ".tfplan"
+	return d.RepoName + "#" + d.ProjectName + ".tfplan"
 }
 
 func (d DiggerExecutor) localPlanFilePath() string {
-	return path.Join(d.projectPath, d.planFileName())
+	return path.Join(d.ProjectPath, d.planFileName())
 }
 
 func (d DiggerExecutor) storedPlanFilePath() string {
-	return path.Join(d.repoOwner, d.planFileName())
+	return path.Join(d.RepoOwner, d.planFileName())
 }
 
 func (d DiggerExecutor) Plan(prNumber int) error {
-	res, err := d.lock.Lock(prNumber)
+	res, err := d.ProjectLock.Lock(prNumber)
 	if err != nil {
 		return fmt.Errorf("error locking project: %v", err)
 	}
 	log.Printf("Lock result: %t\n", res)
 	if res {
 		var planSteps []configuration.Step
 
-		if d.planStage != nil {
-			planSteps = d.planStage.Steps
+		if d.PlanStage != nil {
+			planSteps = d.PlanStage.Steps
 		} else {
 			planSteps = []configuration.Step{
 				{
@@ -418,31 +418,31 @@ func (d DiggerExecutor) Plan(prNumber int) error {
 		}
 		for _, step := range planSteps {
 			if step.Action == "init" {
-				_, _, err := d.terraformExecutor.Init(step.ExtraArgs, d.stateEnvVars)
+				_, _, err := d.TerraformExecutor.Init(step.ExtraArgs, d.StateEnvVars)
 				if err != nil {
 					return fmt.Errorf("error running init: %v", err)
 				}
 			}
 			if step.Action == "plan" {
 				planArgs := []string{"-out", d.planFileName()}
 				planArgs = append(planArgs, step.ExtraArgs...)
-				isNonEmptyPlan, stdout, stderr, err := d.terraformExecutor.Plan(planArgs, d.commandEnvVars)
+				isNonEmptyPlan, stdout, stderr, err := d.TerraformExecutor.Plan(planArgs, d.CommandEnvVars)
 				if err != nil {
 					return fmt.Errorf("error executing plan: %v", err)
 				}
-				if d.planStorage != nil {
-					err = d.planStorage.StorePlan(d.localPlanFilePath(), d.storedPlanFilePath())
+				if d.PlanStorage != nil {
+					err = d.PlanStorage.StorePlan(d.localPlanFilePath(), d.storedPlanFilePath())
 					if err != nil {
 						return fmt.Errorf("error storing plan: %v", err)
 					}
 				}
 				plan := cleanupTerraformPlan(isNonEmptyPlan, err, stdout, stderr)
-				comment := utils.GetTerraformOutputAsCollapsibleComment("Plan for **"+d.lock.LockId()+"**", plan)
-				d.prManager.PublishComment(prNumber, comment)
+				comment := utils.GetTerraformOutputAsCollapsibleComment("Plan for **"+d.ProjectLock.LockId()+"**", plan)
+				d.ciService.PublishComment(prNumber, comment)
 			}
 			if step.Action == "run" {
-				stdout, stderr, err := d.commandRunner.Run(step.Value)
-				log.Printf("Running %v for **%v**\n%v%v", step.Value, d.lock.LockId(), stdout, stderr)
+				stdout, stderr, err := d.CommandRunner.Run(step.Value)
+				log.Printf("Running %v for **%v**\n%v%v", step.Value, d.ProjectLock.LockId(), stdout, stderr)
 				if err != nil {
 					return fmt.Errorf("error running command: %v", err)
 				}
@@ -454,29 +454,29 @@ func (d DiggerExecutor) Plan(prNumber int) error {
 
 func (d DiggerExecutor) Apply(prNumber int) error {
 	var plansFilename *string
-	if d.planStorage != nil {
+	if d.PlanStorage != nil {
 		var err error
-		plansFilename, err = d.planStorage.RetrievePlan(d.localPlanFilePath(), d.storedPlanFilePath())
+		plansFilename, err = d.PlanStorage.RetrievePlan(d.localPlanFilePath(), d.storedPlanFilePath())
 		if err != nil {
 			return fmt.Errorf("error retrieving plan: %v", err)
 		}
 	}
 
-	isMergeable, _, err := d.prManager.IsMergeable(prNumber)
+	isMergeable, _, err := d.ciService.IsMergeable(prNumber)
 	if err != nil {
 		return fmt.Errorf("error validating is PR is mergeable: %v", err)
 	}
 
 	if !isMergeable {
 		comment := "Cannot perform Apply since the PR is not currently mergeable."
-		d.prManager.PublishComment(prNumber, comment)
+		d.ciService.PublishComment(prNumber, comment)
 	} else {
 
-		if res, _ := d.lock.Lock(prNumber); res {
+		if res, _ := d.ProjectLock.Lock(prNumber); res {
 			var applySteps []configuration.Step
 
-			if d.applyStage != nil {
-				applySteps = d.applyStage.Steps
+			if d.ApplyStage != nil {
+				applySteps = d.ApplyStage.Steps
 			} else {
 				applySteps = []configuration.Step{
 					{
@@ -490,24 +490,24 @@ func (d DiggerExecutor) Apply(prNumber int) error {
 
 			for _, step := range applySteps {
 				if step.Action == "init" {
-					_, _, err := d.terraformExecutor.Init(step.ExtraArgs, d.stateEnvVars)
+					_, _, err := d.TerraformExecutor.Init(step.ExtraArgs, d.StateEnvVars)
 					if err != nil {
 						return fmt.Errorf("error running init: %v", err)
 					}
 				}
 				if step.Action == "apply" {
-					stdout, stderr, err := d.terraformExecutor.Apply(step.ExtraArgs, plansFilename, d.commandEnvVars)
+					stdout, stderr, err := d.TerraformExecutor.Apply(step.ExtraArgs, plansFilename, d.CommandEnvVars)
 					applyOutput := cleanupTerraformApply(true, err, stdout, stderr)
-					comment := utils.GetTerraformOutputAsCollapsibleComment("Apply for **"+d.lock.LockId()+"**", applyOutput)
-					d.prManager.PublishComment(prNumber, comment)
+					comment := utils.GetTerraformOutputAsCollapsibleComment("Apply for **"+d.ProjectLock.LockId()+"**", applyOutput)
+					d.ciService.PublishComment(prNumber, comment)
 					if err != nil {
-						d.prManager.PublishComment(prNumber, "Error during applying.")
+						d.ciService.PublishComment(prNumber, "Error during applying.")
 						return fmt.Errorf("error executing apply: %v", err)
 					}
 				}
 				if step.Action == "run" {
-					stdout, stderr, err := d.commandRunner.Run(step.Value)
-					log.Printf("Running %v for **%v**\n%v%v", step.Value, d.lock.LockId(), stdout, stderr)
+					stdout, stderr, err := d.CommandRunner.Run(step.Value)
+					log.Printf("Running %v for **%v**\n%v%v", step.Value, d.ProjectLock.LockId(), stdout, stderr)
 					if err != nil {
 						return fmt.Errorf("error running command: %v", err)
 					}
@@ -519,21 +519,21 @@ func (d DiggerExecutor) Apply(prNumber int) error {
 }
 
 func (d DiggerExecutor) Unlock(prNumber int) error {
-	err := d.lock.ForceUnlock(prNumber)
+	err := d.ProjectLock.ForceUnlock(prNumber)
 	if err != nil {
-		return fmt.Errorf("failed to aquire lock: %s, %v", d.lock.LockId(), err)
+		return fmt.Errorf("failed to aquire lock: %s, %v", d.ProjectLock.LockId(), err)
 	}
-	err = d.planStorage.DeleteStoredPlan(d.storedPlanFilePath())
+	err = d.PlanStorage.DeleteStoredPlan(d.storedPlanFilePath())
 	if err != nil {
 		return fmt.Errorf("failed to delete stored plan file '%v':  %v", d.storedPlanFilePath(), err)
 	}
 	return nil
 }
 
 func (d DiggerExecutor) Lock(prNumber int) error {
-	_, err := d.lock.Lock(prNumber)
+	_, err := d.ProjectLock.Lock(prNumber)
 	if err != nil {
-		return fmt.Errorf("failed to aquire lock: %s, %v", d.lock.LockId(), err)
+		return fmt.Errorf("failed to aquire lock: %s, %v", d.ProjectLock.LockId(), err)
 	}
 	return nil
 }

pkg/digger/digger_test.go

@@ -151,7 +151,7 @@ func TestCorrectCommandExecutionWhenApplying(t *testing.T) {
 	lock := &MockProjectLock{}
 	planStorage := &MockPlanStorage{}
 	executor := DiggerExecutor{
-		applyStage: &configuration.Stage{
+		ApplyStage: &configuration.Stage{
 			Steps: []configuration.Step{
 				{
 					Action:    "init",
@@ -170,12 +170,12 @@ func TestCorrectCommandExecutionWhenApplying(t *testing.T) {
 				},
 			},
 		},
-		planStage:         &configuration.Stage{},
-		commandRunner:     commandRunner,
-		terraformExecutor: terraformExecutor,
-		prManager:         prManager,
-		lock:              lock,
-		planStorage:       planStorage,
+		PlanStage:         &configuration.Stage{},
+		CommandRunner:     commandRunner,
+		TerraformExecutor: terraformExecutor,
+		ciService:         prManager,
+		ProjectLock:       lock,
+		PlanStorage:       planStorage,
 	}
 
 	executor.Apply(1)
@@ -193,8 +193,8 @@ func TestCorrectCommandExecutionWhenPlanning(t *testing.T) {
 	planStorage := &MockPlanStorage{}
 
 	executor := DiggerExecutor{
-		applyStage: &configuration.Stage{},
-		planStage: &configuration.Stage{
+		ApplyStage: &configuration.Stage{},
+		PlanStage: &configuration.Stage{
 			Steps: []configuration.Step{
 				{
 					Action:    "init",
@@ -213,11 +213,11 @@ func TestCorrectCommandExecutionWhenPlanning(t *testing.T) {
 				},
 			},
 		},
-		commandRunner:     commandRunner,
-		terraformExecutor: terraformExecutor,
-		prManager:         prManager,
-		lock:              lock,
-		planStorage:       planStorage,
+		CommandRunner:     commandRunner,
+		TerraformExecutor: terraformExecutor,
+		ciService:         prManager,
+		ProjectLock:       lock,
+		PlanStorage:       planStorage,
 	}
 
 	executor.Plan(1)