From 9e7509aeee4f3d1511eefb938e9f082c69ed72c1 Mon Sep 17 00:00:00 2001 From: Luke Kysow Date: Fri, 29 Jun 2018 19:10:10 +0200 Subject: [PATCH] Test command runner --- server/events/command_runner.go | 122 +++++++++--------- server/events/command_runner_test.go | 118 ++++++++--------- .../matchers/events_projectcommandresult.go | 20 +++ .../mocks/mock_project_command_runner.go | 116 +++++++++++++++++ server/events/project_command_runner.go | 24 ++-- server/events_controller_e2e_test.go | 2 +- server/server.go | 2 +- 7 files changed, 270 insertions(+), 134 deletions(-) create mode 100644 server/events/mocks/matchers/events_projectcommandresult.go create mode 100644 server/events/mocks/mock_project_command_runner.go diff --git a/server/events/command_runner.go b/server/events/command_runner.go index 5297546a7..04fbb7f12 100644 --- a/server/events/command_runner.go +++ b/server/events/command_runner.go @@ -68,7 +68,7 @@ type DefaultCommandRunner struct { // how to enable this functionality. AllowForkPRsFlag string ProjectCommandBuilder ProjectCommandBuilder - ProjectCommandRunner *ProjectCommandRunner + ProjectCommandRunner ProjectCommandRunner } func (c *DefaultCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, user models.User) { @@ -80,23 +80,30 @@ func (c *DefaultCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo HeadRepo: headRepo, BaseRepo: baseRepo, } - runFn := func() ([]ProjectResult, error) { - projectCmds, err := c.ProjectCommandBuilder.BuildAutoplanCommands(ctx) - if err != nil { - return nil, err - } - var results []ProjectResult - for _, cmd := range projectCmds { - res := c.ProjectCommandRunner.Plan(cmd) - results = append(results, ProjectResult{ - ProjectCommandResult: res, - RepoRelDir: cmd.RepoRelDir, - Workspace: cmd.Workspace, - }) - } - return results, nil + defer c.logPanics(ctx) + if !c.validateCtxAndComment(ctx) { + return } - c.run(ctx, AutoplanCommand{}, runFn) + if err := c.CommitStatusUpdater.Update(ctx.BaseRepo, ctx.Pull, vcs.Pending, Plan); err != nil { + ctx.Log.Warn("unable to update commit status: %s", err) + } + + projectCmds, err := c.ProjectCommandBuilder.BuildAutoplanCommands(ctx) + if err != nil { + c.updatePull(ctx, AutoplanCommand{}, CommandResult{Error: err}) + return + } + + var results []ProjectResult + for _, cmd := range projectCmds { + res := c.ProjectCommandRunner.Plan(cmd) + results = append(results, ProjectResult{ + ProjectCommandResult: res, + RepoRelDir: cmd.RepoRelDir, + Workspace: cmd.Workspace, + }) + } + c.updatePull(ctx, AutoplanCommand{}, CommandResult{ProjectResults: results}) } // RunCommentCommand executes the command. @@ -132,33 +139,46 @@ func (c *DefaultCommandRunner) RunCommentCommand(baseRepo models.Repo, maybeHead HeadRepo: headRepo, BaseRepo: baseRepo, } + defer c.logPanics(ctx) - runFn := func() ([]ProjectResult, error) { - var result ProjectCommandResult - switch cmd.Name { - case Plan: - projectCmd, err := c.ProjectCommandBuilder.BuildPlanCommand(ctx, cmd) - if err != nil { - return nil, err - } - result = c.ProjectCommandRunner.Plan(projectCmd) - case Apply: - projectCmd, err := c.ProjectCommandBuilder.BuildApplyCommand(ctx, cmd) - if err != nil { - return nil, err - } - result = c.ProjectCommandRunner.Apply(projectCmd) - default: - ctx.Log.Err("failed to determine desired command, neither plan nor apply") - } - return []ProjectResult{{ - RepoRelDir: cmd.RepoRelDir, - Workspace: cmd.Workspace, - ProjectCommandResult: result, - }}, nil + if !c.validateCtxAndComment(ctx) { + return } - c.run(ctx, cmd, runFn) + if err := c.CommitStatusUpdater.Update(ctx.BaseRepo, ctx.Pull, vcs.Pending, cmd.CommandName()); err != nil { + ctx.Log.Warn("unable to update commit status: %s", err) + } + + var result ProjectCommandResult + switch cmd.Name { + case Plan: + projectCmd, err := c.ProjectCommandBuilder.BuildPlanCommand(ctx, cmd) + if err != nil { + c.updatePull(ctx, cmd, CommandResult{Error: err}) + return + } + result = c.ProjectCommandRunner.Plan(projectCmd) + case Apply: + projectCmd, err := c.ProjectCommandBuilder.BuildApplyCommand(ctx, cmd) + if err != nil { + c.updatePull(ctx, cmd, CommandResult{Error: err}) + return + } + result = c.ProjectCommandRunner.Apply(projectCmd) + default: + ctx.Log.Err("failed to determine desired command, neither plan nor apply") + return + } + + c.updatePull( + ctx, + cmd, + CommandResult{ + ProjectResults: []ProjectResult{{ + RepoRelDir: cmd.RepoRelDir, + Workspace: cmd.Workspace, + ProjectCommandResult: result, + }}}) } func (c *DefaultCommandRunner) getGithubData(baseRepo models.Repo, pullNum int) (models.PullRequest, models.Repo, error) { @@ -208,26 +228,6 @@ func (c *DefaultCommandRunner) validateCtxAndComment(ctx *CommandContext) bool { return true } -func (c *DefaultCommandRunner) run(ctx *CommandContext, command CommandInterface, commandRunner func() ([]ProjectResult, error)) { - defer c.logPanics(ctx) - - if !c.validateCtxAndComment(ctx) { - return - } - - ctx.Log.Debug("updating commit status to pending") - if err := c.CommitStatusUpdater.Update(ctx.BaseRepo, ctx.Pull, vcs.Pending, command.CommandName()); err != nil { - ctx.Log.Warn("unable to update commit status: %s", err) - } - - results, err := commandRunner() - if err != nil { - c.updatePull(ctx, command, CommandResult{Error: err}) - return - } - c.updatePull(ctx, command, CommandResult{ProjectResults: results}) -} - func (c *DefaultCommandRunner) updatePull(ctx *CommandContext, command CommandInterface, res CommandResult) { // Log if we got any errors or failures. if res.Error != nil { diff --git a/server/events/command_runner_test.go b/server/events/command_runner_test.go index 3367806eb..5f0d2ce4c 100644 --- a/server/events/command_runner_test.go +++ b/server/events/command_runner_test.go @@ -39,21 +39,21 @@ var vcsClient *vcsmocks.MockClientProxy var ghStatus *mocks.MockCommitStatusUpdater var githubGetter *mocks.MockGithubPullGetter var gitlabGetter *mocks.MockGitlabMergeRequestGetter -var workspaceLocker *mocks.MockWorkingDirLocker var ch events.DefaultCommandRunner var logBytes *bytes.Buffer +var projectCommandRunner *mocks.MockProjectCommandRunner func setup(t *testing.T) { RegisterMockTestingT(t) projectCommandBuilder = mocks.NewMockProjectCommandBuilder() eventParsing = mocks.NewMockEventParsing() ghStatus = mocks.NewMockCommitStatusUpdater() - workspaceLocker = mocks.NewMockWorkingDirLocker() vcsClient = vcsmocks.NewMockClientProxy() githubGetter = mocks.NewMockGithubPullGetter() gitlabGetter = mocks.NewMockGitlabMergeRequestGetter() logger := logmocks.NewMockSimpleLogging() logBytes = new(bytes.Buffer) + projectCommandRunner := mocks.NewMockProjectCommandRunner() When(logger.Underlying()).ThenReturn(log.New(logBytes, "", 0)) ch = events.DefaultCommandRunner{ VCSClient: vcsClient, @@ -66,6 +66,7 @@ func setup(t *testing.T) { AllowForkPRs: false, AllowForkPRsFlag: "allow-fork-prs-flag", ProjectCommandBuilder: projectCommandBuilder, + ProjectCommandRunner: projectCommandRunner, } } @@ -156,65 +157,56 @@ func TestRunCommentCommand_ClosedPull(t *testing.T) { vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, modelPull.Num, "Atlantis commands can't be run on closed pull requests") } -//func TestRunCommentCommand_FullRun(t *testing.T) { -// t.Log("when running a plan, apply should comment") -// pull := &github.PullRequest{ -// State: github.String("closed"), -// } -// cmdResult := events.CommandResult{} -// for _, c := range []events.CommandName{events.Plan, events.Apply} { -// setup(t) -// cmd := events.CommentCommand{ -// Name: c, -// WorkingDir: "workspace", -// } -// When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(pull, nil) -// When(eventParsing.ParseGithubPull(pull)).ThenReturn(fixtures.Pull, fixtures.GithubRepo, nil) -// When(workspaceLocker.TryLock(fixtures.GithubRepo.FullName, cmd.WorkingDir, fixtures.Pull.Num)).ThenReturn(true) -// switch c { -// case events.Plan: -// When(projectCommandBuilder.PlanViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResult) -// case events.Apply: -// When(projectCommandBuilder.ApplyViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResult) -// } -// -// ch.RunCommentCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, &cmd) -// -// ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, &cmd) -// _, response := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandResult()).GetCapturedArguments() -// Equals(t, cmdResult, response) -// vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()) -// workspaceLocker.VerifyWasCalledOnce().Unlock(fixtures.GithubRepo.FullName, cmd.WorkingDir, fixtures.Pull.Num) -// } -//} +func TestRunCommentCommand_FullRun(t *testing.T) { + pull := &github.PullRequest{ + State: github.String("closed"), + } + expCmdResult := events.CommandResult{ + ProjectResults: []events.ProjectResult{ + { + RepoRelDir: ".", + Workspace: "default", + }, + }, + } + for _, c := range []events.CommandName{events.Plan, events.Apply} { + setup(t) + cmd := events.NewCommentCommand(".", nil, c, false, "default", "") + When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(pull, nil) + When(eventParsing.ParseGithubPull(pull)).ThenReturn(fixtures.Pull, fixtures.GithubRepo, fixtures.GithubRepo, nil) -//func TestRunCommentCommand_ForkPREnabled(t *testing.T) { -// t.Log("when running a plan on a fork PR, it should succeed") -// setup(t) -// -// // Enable forked PRs. -// ch.AllowForkPRs = true -// defer func() { ch.AllowForkPRs = false }() // Reset after test. -// -// var pull github.PullRequest -// cmdResponse := events.CommandResult{} -// cmd := events.CommentCommand{ -// Name: events.Plan, -// WorkingDir: "workspace", -// } -// When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(&pull, nil) -// headRepo := fixtures.GithubRepo -// headRepo.FullName = "forkrepo/atlantis" -// headRepo.Owner = "forkrepo" -// When(eventParsing.ParseGithubPull(&pull)).ThenReturn(fixtures.Pull, headRepo, nil) -// When(workspaceLocker.TryLock(fixtures.GithubRepo.FullName, cmd.WorkingDir, fixtures.Pull.Num)).ThenReturn(true) -// When(projectCommandBuilder.PlanViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResponse) -// -// ch.RunCommentCommand(fixtures.GithubRepo, models.Repo{} /* this isn't used */, fixtures.User, fixtures.Pull.Num, &cmd) -// -// ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, &cmd) -// _, response := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandResult()).GetCapturedArguments() -// Equals(t, cmdResponse, response) -// vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()) -// workspaceLocker.VerifyWasCalledOnce().Unlock(fixtures.GithubRepo.FullName, cmd.WorkingDir, fixtures.Pull.Num) -//} + cmdCtx := models.ProjectCommandContext{RepoRelDir: "."} + switch c { + case events.Plan: + When(projectCommandBuilder.BuildPlanCommand(matchers.AnyPtrToEventsCommandContext(), matchers.AnyPtrToEventsCommentCommand())).ThenReturn(cmdCtx, nil) + case events.Apply: + When(projectCommandBuilder.BuildApplyCommand(matchers.AnyPtrToEventsCommandContext(), matchers.AnyPtrToEventsCommentCommand())).ThenReturn(cmdCtx, nil) + } + + ch.RunCommentCommand(fixtures.GithubRepo, nil, fixtures.User, fixtures.Pull.Num, cmd) + + ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, c) + _, _, response := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandName(), matchers.AnyEventsCommandResult()).GetCapturedArguments() + Equals(t, expCmdResult, response) + vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()) + } +} + +func TestRunAutoplanCommands(t *testing.T) { + expCmdResult := events.CommandResult{ + ProjectResults: []events.ProjectResult{ + { + RepoRelDir: ".", + Workspace: "default", + }, + }, + } + setup(t) + When(projectCommandBuilder.BuildAutoplanCommands(matchers.AnyPtrToEventsCommandContext())).ThenReturn([]models.ProjectCommandContext{{RepoRelDir: ".", Workspace: "default"}}, nil) + ch.RunAutoplanCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.Pull, fixtures.User) + + ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, events.Plan) + _, _, response := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandName(), matchers.AnyEventsCommandResult()).GetCapturedArguments() + Equals(t, expCmdResult, response) + vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()) +} diff --git a/server/events/mocks/matchers/events_projectcommandresult.go b/server/events/mocks/matchers/events_projectcommandresult.go new file mode 100644 index 000000000..522a4ccf8 --- /dev/null +++ b/server/events/mocks/matchers/events_projectcommandresult.go @@ -0,0 +1,20 @@ +package matchers + +import ( + "reflect" + + "github.com/petergtz/pegomock" + events "github.com/runatlantis/atlantis/server/events" +) + +func AnyEventsProjectCommandResult() events.ProjectCommandResult { + pegomock.RegisterMatcher(pegomock.NewAnyMatcher(reflect.TypeOf((*(events.ProjectCommandResult))(nil)).Elem())) + var nullValue events.ProjectCommandResult + return nullValue +} + +func EqEventsProjectCommandResult(value events.ProjectCommandResult) events.ProjectCommandResult { + pegomock.RegisterMatcher(&pegomock.EqMatcher{Value: value}) + var nullValue events.ProjectCommandResult + return nullValue +} diff --git a/server/events/mocks/mock_project_command_runner.go b/server/events/mocks/mock_project_command_runner.go new file mode 100644 index 000000000..cf5555e8d --- /dev/null +++ b/server/events/mocks/mock_project_command_runner.go @@ -0,0 +1,116 @@ +// Automatically generated by pegomock. DO NOT EDIT! +// Source: github.com/runatlantis/atlantis/server/events (interfaces: ProjectCommandRunner) + +package mocks + +import ( + "reflect" + + pegomock "github.com/petergtz/pegomock" + events "github.com/runatlantis/atlantis/server/events" + models "github.com/runatlantis/atlantis/server/events/models" +) + +type MockProjectCommandRunner struct { + fail func(message string, callerSkip ...int) +} + +func NewMockProjectCommandRunner() *MockProjectCommandRunner { + return &MockProjectCommandRunner{fail: pegomock.GlobalFailHandler} +} + +func (mock *MockProjectCommandRunner) Plan(ctx models.ProjectCommandContext) events.ProjectCommandResult { + params := []pegomock.Param{ctx} + result := pegomock.GetGenericMockFrom(mock).Invoke("Plan", params, []reflect.Type{reflect.TypeOf((*events.ProjectCommandResult)(nil)).Elem()}) + var ret0 events.ProjectCommandResult + if len(result) != 0 { + if result[0] != nil { + ret0 = result[0].(events.ProjectCommandResult) + } + } + return ret0 +} + +func (mock *MockProjectCommandRunner) Apply(ctx models.ProjectCommandContext) events.ProjectCommandResult { + params := []pegomock.Param{ctx} + result := pegomock.GetGenericMockFrom(mock).Invoke("Apply", params, []reflect.Type{reflect.TypeOf((*events.ProjectCommandResult)(nil)).Elem()}) + var ret0 events.ProjectCommandResult + if len(result) != 0 { + if result[0] != nil { + ret0 = result[0].(events.ProjectCommandResult) + } + } + return ret0 +} + +func (mock *MockProjectCommandRunner) VerifyWasCalledOnce() *VerifierProjectCommandRunner { + return &VerifierProjectCommandRunner{mock, pegomock.Times(1), nil} +} + +func (mock *MockProjectCommandRunner) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierProjectCommandRunner { + return &VerifierProjectCommandRunner{mock, invocationCountMatcher, nil} +} + +func (mock *MockProjectCommandRunner) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierProjectCommandRunner { + return &VerifierProjectCommandRunner{mock, invocationCountMatcher, inOrderContext} +} + +type VerifierProjectCommandRunner struct { + mock *MockProjectCommandRunner + invocationCountMatcher pegomock.Matcher + inOrderContext *pegomock.InOrderContext +} + +func (verifier *VerifierProjectCommandRunner) Plan(ctx models.ProjectCommandContext) *ProjectCommandRunner_Plan_OngoingVerification { + params := []pegomock.Param{ctx} + methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Plan", params) + return &ProjectCommandRunner_Plan_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} +} + +type ProjectCommandRunner_Plan_OngoingVerification struct { + mock *MockProjectCommandRunner + methodInvocations []pegomock.MethodInvocation +} + +func (c *ProjectCommandRunner_Plan_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext { + ctx := c.GetAllCapturedArguments() + return ctx[len(ctx)-1] +} + +func (c *ProjectCommandRunner_Plan_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext) { + params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) + if len(params) > 0 { + _param0 = make([]models.ProjectCommandContext, len(params[0])) + for u, param := range params[0] { + _param0[u] = param.(models.ProjectCommandContext) + } + } + return +} + +func (verifier *VerifierProjectCommandRunner) Apply(ctx models.ProjectCommandContext) *ProjectCommandRunner_Apply_OngoingVerification { + params := []pegomock.Param{ctx} + methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Apply", params) + return &ProjectCommandRunner_Apply_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations} +} + +type ProjectCommandRunner_Apply_OngoingVerification struct { + mock *MockProjectCommandRunner + methodInvocations []pegomock.MethodInvocation +} + +func (c *ProjectCommandRunner_Apply_OngoingVerification) GetCapturedArguments() models.ProjectCommandContext { + ctx := c.GetAllCapturedArguments() + return ctx[len(ctx)-1] +} + +func (c *ProjectCommandRunner_Apply_OngoingVerification) GetAllCapturedArguments() (_param0 []models.ProjectCommandContext) { + params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations) + if len(params) > 0 { + _param0 = make([]models.ProjectCommandContext, len(params[0])) + for u, param := range params[0] { + _param0[u] = param.(models.ProjectCommandContext) + } + } + return +} diff --git a/server/events/project_command_runner.go b/server/events/project_command_runner.go index f8f39e060..2c77c4fca 100644 --- a/server/events/project_command_runner.go +++ b/server/events/project_command_runner.go @@ -22,6 +22,7 @@ import ( "github.com/runatlantis/atlantis/server/events/models" "github.com/runatlantis/atlantis/server/events/runtime" "github.com/runatlantis/atlantis/server/events/webhooks" + "github.com/runatlantis/atlantis/server/events/yaml/raw" "github.com/runatlantis/atlantis/server/events/yaml/valid" "github.com/runatlantis/atlantis/server/logging" ) @@ -42,7 +43,14 @@ type PlanSuccess struct { LockURL string } -type ProjectCommandRunner struct { +//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_project_command_runner.go ProjectCommandRunner + +type ProjectCommandRunner interface { + Plan(ctx models.ProjectCommandContext) ProjectCommandResult + Apply(ctx models.ProjectCommandContext) ProjectCommandResult +} + +type DefaultProjectCommandRunner struct { Locker ProjectLocker LockURLGenerator LockURLGenerator InitStepRunner runtime.InitStepRunner @@ -55,7 +63,7 @@ type ProjectCommandRunner struct { WorkingDirLocker WorkingDirLocker } -func (p *ProjectCommandRunner) Plan(ctx models.ProjectCommandContext) ProjectCommandResult { +func (p *DefaultProjectCommandRunner) Plan(ctx models.ProjectCommandContext) ProjectCommandResult { // Acquire Atlantis lock for this repo/dir/workspace. lockAttempt, err := p.Locker.TryLock(ctx.Log, ctx.Pull, ctx.User, ctx.Workspace, models.NewProject(ctx.BaseRepo.FullName, ctx.RepoRelDir)) if err != nil { @@ -112,7 +120,7 @@ func (p *ProjectCommandRunner) Plan(ctx models.ProjectCommandContext) ProjectCom } } -func (p *ProjectCommandRunner) runSteps(steps []valid.Step, ctx models.ProjectCommandContext, absPath string) ([]string, error) { +func (p *DefaultProjectCommandRunner) runSteps(steps []valid.Step, ctx models.ProjectCommandContext, absPath string) ([]string, error) { var outputs []string for _, step := range steps { var out string @@ -139,7 +147,7 @@ func (p *ProjectCommandRunner) runSteps(steps []valid.Step, ctx models.ProjectCo return outputs, nil } -func (p *ProjectCommandRunner) Apply(ctx models.ProjectCommandContext) ProjectCommandResult { +func (p *DefaultProjectCommandRunner) Apply(ctx models.ProjectCommandContext) ProjectCommandResult { repoDir, err := p.WorkingDir.GetWorkingDir(ctx.BaseRepo, ctx.Pull, ctx.Workspace) if err != nil { if os.IsNotExist(err) { @@ -154,11 +162,11 @@ func (p *ProjectCommandRunner) Apply(ctx models.ProjectCommandContext) ProjectCo applyRequirements = ctx.ProjectConfig.ApplyRequirements } if ctx.RequireApprovalOverride { - applyRequirements = []string{"approved"} + applyRequirements = []string{raw.ApprovedApplyRequirement} } for _, req := range applyRequirements { switch req { - case "approved": + case raw.ApprovedApplyRequirement: approved, err := p.PullApprovedChecker.PullIsApproved(ctx.BaseRepo, ctx.Pull) // nolint: vetshadow if err != nil { return ProjectCommandResult{Error: errors.Wrap(err, "checking if pull request was approved")} @@ -200,7 +208,7 @@ func (p *ProjectCommandRunner) Apply(ctx models.ProjectCommandContext) ProjectCo } } -func (p ProjectCommandRunner) defaultPlanStage() valid.Stage { +func (p DefaultProjectCommandRunner) defaultPlanStage() valid.Stage { return valid.Stage{ Steps: []valid.Step{ { @@ -213,7 +221,7 @@ func (p ProjectCommandRunner) defaultPlanStage() valid.Stage { } } -func (p ProjectCommandRunner) defaultApplyStage() valid.Stage { +func (p DefaultProjectCommandRunner) defaultApplyStage() valid.Stage { return valid.Stage{ Steps: []valid.Step{ { diff --git a/server/events_controller_e2e_test.go b/server/events_controller_e2e_test.go index a87ab1bb9..be87412bb 100644 --- a/server/events_controller_e2e_test.go +++ b/server/events_controller_e2e_test.go @@ -238,7 +238,7 @@ func setupE2E(t *testing.T) (server.EventsController, *vcsmocks.MockClientProxy, defaultTFVersion := terraformClient.Version() locker := events.NewDefaultAtlantisWorkingDirLocker() commandRunner := &events.DefaultCommandRunner{ - ProjectCommandRunner: &events.ProjectCommandRunner{ + ProjectCommandRunner: &events.DefaultProjectCommandRunner{ Locker: projectLocker, LockURLGenerator: &mockLockURLGenerator{}, InitStepRunner: runtime.InitStepRunner{ diff --git a/server/server.go b/server/server.go index f4db48d89..f122c32fc 100644 --- a/server/server.go +++ b/server/server.go @@ -239,7 +239,7 @@ func NewServer(userConfig UserConfig, config Config) (*Server, error) { WorkingDirLocker: workingDirLocker, RequireApproval: userConfig.RequireApproval, }, - ProjectCommandRunner: &events.ProjectCommandRunner{ + ProjectCommandRunner: &events.DefaultProjectCommandRunner{ Locker: projectLocker, LockURLGenerator: router, InitStepRunner: runtime.InitStepRunner{