diff --git a/server/events/atlantis_workspace.go b/server/events/atlantis_workspace.go
index 06944bdae..251adb7e3 100644
--- a/server/events/atlantis_workspace.go
+++ b/server/events/atlantis_workspace.go
@@ -35,6 +35,7 @@ type AtlantisWorkspace interface {
// absolute path to the root of the cloned repo.
Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, p models.PullRequest, workspace string) (string, error)
// GetWorkspace returns the path to the workspace for this repo and pull.
+ // If workspace does not exist on disk, error will be of type os.IsNotExist.
GetWorkspace(r models.Repo, p models.PullRequest, workspace string) (string, error)
// Delete deletes the workspace for this repo and pull.
Delete(r models.Repo, p models.PullRequest) error
diff --git a/server/events/atlantis_workspace_locker.go b/server/events/atlantis_workspace_locker.go
index 594ea08ab..cc86db42c 100644
--- a/server/events/atlantis_workspace_locker.go
+++ b/server/events/atlantis_workspace_locker.go
@@ -30,6 +30,8 @@ import (
type AtlantisWorkspaceLocker interface {
// TryLock tries to acquire a lock for this repo, workspace and pull.
TryLock(repoFullName string, workspace string, pullNum int) bool
+ // TryLock2 tries to acquire a lock for this repo, workspace and pull.
+ TryLock2(repoFullName string, workspace string, pullNum int) (func(), error)
// Unlock deletes the lock for this repo, workspace and pull. If there was no
// lock it will do nothing.
Unlock(repoFullName, workspace string, pullNum int)
@@ -48,6 +50,17 @@ func NewDefaultAtlantisWorkspaceLocker() *DefaultAtlantisWorkspaceLocker {
}
}
+func (d *DefaultAtlantisWorkspaceLocker) TryLock2(repoFullName string, workspace string, pullNum int) (func(), error) {
+ if !d.TryLock(repoFullName, workspace, pullNum) {
+ return func() {}, fmt.Errorf("the %s workspace is currently locked by another"+
+ " command that is running for this pull request–"+
+ "wait until the previous command is complete and try again", workspace)
+ }
+ return func() {
+ d.Unlock(repoFullName, workspace, pullNum)
+ }, nil
+}
+
// TryLock returns true if a lock is acquired for this repo, pull and workspace and
// false otherwise.
func (d *DefaultAtlantisWorkspaceLocker) TryLock(repoFullName string, workspace string, pullNum int) bool {
diff --git a/server/events/command_context.go b/server/events/command_context.go
index f986e43cc..49b0f0726 100644
--- a/server/events/command_context.go
+++ b/server/events/command_context.go
@@ -30,7 +30,6 @@ type CommandContext struct {
HeadRepo models.Repo
Pull models.PullRequest
// User is the user that triggered this command.
- User models.User
- Command *Command
- Log *logging.SimpleLogger
+ User models.User
+ Log *logging.SimpleLogger
}
diff --git a/server/events/command_handler_test.go b/server/events/command_handler_test.go
deleted file mode 100644
index 65bcf3c6f..000000000
--- a/server/events/command_handler_test.go
+++ /dev/null
@@ -1,247 +0,0 @@
-// Copyright 2017 HootSuite Media Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// Modified hereafter by contributors to runatlantis/atlantis.
-//
-package events_test
-
-import (
- "bytes"
- "errors"
- "log"
- "strings"
- "testing"
-
- "github.com/google/go-github/github"
- . "github.com/petergtz/pegomock"
- "github.com/runatlantis/atlantis/server/events"
- "github.com/runatlantis/atlantis/server/events/mocks"
- "github.com/runatlantis/atlantis/server/events/mocks/matchers"
- "github.com/runatlantis/atlantis/server/events/models"
- "github.com/runatlantis/atlantis/server/events/models/fixtures"
- "github.com/runatlantis/atlantis/server/events/vcs"
- vcsmocks "github.com/runatlantis/atlantis/server/events/vcs/mocks"
- logmocks "github.com/runatlantis/atlantis/server/logging/mocks"
- . "github.com/runatlantis/atlantis/testing"
-)
-
-var operator *mocks.MockPullRequestOperator
-var eventParsing *mocks.MockEventParsing
-var vcsClient *vcsmocks.MockClientProxy
-var ghStatus *mocks.MockCommitStatusUpdater
-var githubGetter *mocks.MockGithubPullGetter
-var gitlabGetter *mocks.MockGitlabMergeRequestGetter
-var workspaceLocker *mocks.MockAtlantisWorkspaceLocker
-var ch events.CommandHandler
-var logBytes *bytes.Buffer
-
-func setup(t *testing.T) {
- RegisterMockTestingT(t)
- operator = mocks.NewMockPullRequestOperator()
- eventParsing = mocks.NewMockEventParsing()
- ghStatus = mocks.NewMockCommitStatusUpdater()
- workspaceLocker = mocks.NewMockAtlantisWorkspaceLocker()
- vcsClient = vcsmocks.NewMockClientProxy()
- githubGetter = mocks.NewMockGithubPullGetter()
- gitlabGetter = mocks.NewMockGitlabMergeRequestGetter()
- logger := logmocks.NewMockSimpleLogging()
- logBytes = new(bytes.Buffer)
- When(logger.Underlying()).ThenReturn(log.New(logBytes, "", 0))
- ch = events.CommandHandler{
- VCSClient: vcsClient,
- CommitStatusUpdater: ghStatus,
- EventParser: eventParsing,
- AtlantisWorkspaceLocker: workspaceLocker,
- MarkdownRenderer: &events.MarkdownRenderer{},
- GithubPullGetter: githubGetter,
- GitlabMergeRequestGetter: gitlabGetter,
- Logger: logger,
- AllowForkPRs: false,
- AllowForkPRsFlag: "allow-fork-prs-flag",
- PullRequestOperator: operator,
- }
-}
-
-func TestExecuteCommand_LogPanics(t *testing.T) {
- t.Log("if there is a panic it is commented back on the pull request")
- setup(t)
- ch.AllowForkPRs = true // Lets us get to the panic code.
- defer func() { ch.AllowForkPRs = false }()
- When(ghStatus.Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, nil)).ThenPanic("panic")
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, 1, nil)
- _, _, comment := vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()).GetCapturedArguments()
- Assert(t, strings.Contains(comment, "Error: goroutine panic"), "comment should be about a goroutine panic")
-}
-
-func TestExecuteCommand_NoGithubPullGetter(t *testing.T) {
- t.Log("if CommandHandler was constructed with a nil GithubPullGetter an error should be logged")
- setup(t)
- ch.GithubPullGetter = nil
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, 1, nil)
- Equals(t, "[ERROR] runatlantis/atlantis#1: Atlantis not configured to support GitHub\n", logBytes.String())
-}
-
-func TestExecuteCommand_NoGitlabMergeGetter(t *testing.T) {
- t.Log("if CommandHandler was constructed with a nil GitlabMergeRequestGetter an error should be logged")
- setup(t)
- ch.GitlabMergeRequestGetter = nil
- ch.ExecuteCommand(fixtures.GitlabRepo, fixtures.GitlabRepo, fixtures.User, 1, nil)
- Equals(t, "[ERROR] runatlantis/atlantis#1: Atlantis not configured to support GitLab\n", logBytes.String())
-}
-
-func TestExecuteCommand_GithubPullErr(t *testing.T) {
- t.Log("if getting the github pull request fails an error should be logged")
- setup(t)
- When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(nil, errors.New("err"))
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
- Equals(t, "[ERROR] runatlantis/atlantis#1: Making pull request API call to GitHub: err\n", logBytes.String())
-}
-
-func TestExecuteCommand_GitlabMergeRequestErr(t *testing.T) {
- t.Log("if getting the gitlab merge request fails an error should be logged")
- setup(t)
- When(gitlabGetter.GetMergeRequest(fixtures.GithubRepo.FullName, fixtures.Pull.Num)).ThenReturn(nil, errors.New("err"))
- ch.ExecuteCommand(fixtures.GitlabRepo, fixtures.GitlabRepo, fixtures.User, fixtures.Pull.Num, nil)
- Equals(t, "[ERROR] runatlantis/atlantis#1: Making merge request API call to GitLab: err\n", logBytes.String())
-}
-
-func TestExecuteCommand_GithubPullParseErr(t *testing.T) {
- t.Log("if parsing the returned github pull request fails an error should be logged")
- setup(t)
- var pull github.PullRequest
- When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(&pull, nil)
- When(eventParsing.ParseGithubPull(&pull)).ThenReturn(fixtures.Pull, fixtures.GithubRepo, errors.New("err"))
-
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
- Equals(t, "[ERROR] runatlantis/atlantis#1: Extracting required fields from comment data: err\n", logBytes.String())
-}
-
-func TestExecuteCommand_ForkPRDisabled(t *testing.T) {
- t.Log("if a command is run on a forked pull request and this is disabled atlantis should" +
- " comment saying that this is not allowed")
- setup(t)
- ch.AllowForkPRs = false // by default it's false so don't need to reset
- var pull github.PullRequest
- modelPull := models.PullRequest{State: models.Open}
- 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(modelPull, headRepo, nil)
-
- ch.ExecuteCommand(fixtures.GithubRepo, models.Repo{} /* this isn't used */, fixtures.User, fixtures.Pull.Num, nil)
- vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, modelPull.Num, "Atlantis commands can't be run on fork pull requests. To enable, set --"+ch.AllowForkPRsFlag)
-}
-
-func TestExecuteCommand_ClosedPull(t *testing.T) {
- t.Log("if a command is run on a closed pull request atlantis should" +
- " comment saying that this is not allowed")
- setup(t)
- pull := &github.PullRequest{
- State: github.String("closed"),
- }
- modelPull := models.PullRequest{State: models.Closed}
- When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(pull, nil)
- When(eventParsing.ParseGithubPull(pull)).ThenReturn(modelPull, fixtures.GithubRepo, nil)
-
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
- vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, modelPull.Num, "Atlantis commands can't be run on closed pull requests")
-}
-
-func TestExecuteCommand_WorkspaceLocked(t *testing.T) {
- t.Log("if the workspace is locked, should comment back on the pull")
- setup(t)
- pull := &github.PullRequest{
- State: github.String("closed"),
- }
- cmd := events.Command{
- Name: events.Plan,
- Workspace: "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.Workspace, fixtures.Pull.Num)).ThenReturn(false)
- ch.ExecuteCommand(fixtures.GithubRepo, fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, &cmd)
-
- msg := "The workspace workspace is currently locked by another" +
- " command that is running for this pull request." +
- " Wait until the previous command is complete and try again."
- ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, &cmd)
- _, response := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandResponse()).GetCapturedArguments()
- Equals(t, msg, response.Failure)
- vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, fixtures.Pull.Num,
- "**Plan Failed**: "+msg+"\n\n")
-}
-
-func TestExecuteCommand_FullRun(t *testing.T) {
- t.Log("when running a plan, apply should comment")
- pull := &github.PullRequest{
- State: github.String("closed"),
- }
- cmdResponse := events.CommandResponse{}
- for _, c := range []events.CommandName{events.Plan, events.Apply} {
- setup(t)
- cmd := events.Command{
- Name: c,
- Workspace: "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.Workspace, fixtures.Pull.Num)).ThenReturn(true)
- switch c {
- case events.Plan:
- When(operator.PlanViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResponse)
- case events.Apply:
- When(operator.ApplyViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResponse)
- }
-
- ch.ExecuteCommand(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.AnyEventsCommandResponse()).GetCapturedArguments()
- Equals(t, cmdResponse, response)
- vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString())
- workspaceLocker.VerifyWasCalledOnce().Unlock(fixtures.GithubRepo.FullName, cmd.Workspace, fixtures.Pull.Num)
- }
-}
-
-func TestExecuteCommand_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.CommandResponse{}
- cmd := events.Command{
- Name: events.Plan,
- Workspace: "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.Workspace, fixtures.Pull.Num)).ThenReturn(true)
- When(operator.PlanViaComment(matchers.AnyPtrToEventsCommandContext())).ThenReturn(cmdResponse)
-
- ch.ExecuteCommand(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.AnyEventsCommandResponse()).GetCapturedArguments()
- Equals(t, cmdResponse, response)
- vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString())
- workspaceLocker.VerifyWasCalledOnce().Unlock(fixtures.GithubRepo.FullName, cmd.Workspace, fixtures.Pull.Num)
-}
diff --git a/server/events/command_response.go b/server/events/command_result.go
similarity index 89%
rename from server/events/command_response.go
rename to server/events/command_result.go
index abba3897b..ff767ddb5 100644
--- a/server/events/command_response.go
+++ b/server/events/command_result.go
@@ -13,8 +13,8 @@
//
package events
-// CommandResponse is the result of running a Command.
-type CommandResponse struct {
+// CommandResult is the result of running a Command.
+type CommandResult struct {
Error error
Failure string
ProjectResults []ProjectResult
diff --git a/server/events/command_handler.go b/server/events/command_runner.go
similarity index 58%
rename from server/events/command_handler.go
rename to server/events/command_runner.go
index bfd25dd93..c54891e87 100644
--- a/server/events/command_handler.go
+++ b/server/events/command_runner.go
@@ -29,10 +29,11 @@ import (
// CommandRunner is the first step after a command request has been parsed.
type CommandRunner interface {
- // ExecuteCommand is the first step after a command request has been parsed.
+ // RunCommentCommand is the first step after a command request has been parsed.
// It handles gathering additional information needed to execute the command
// and then calling the appropriate services to finish executing the command.
- ExecuteCommand(baseRepo models.Repo, headRepo models.Repo, user models.User, pullNum int, cmd *Command)
+ RunCommentCommand(baseRepo models.Repo, maybeHeadRepo *models.Repo, user models.User, pullNum int, cmd *CommentCommand)
+ RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, user models.User)
}
//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_github_pull_getter.go GithubPullGetter
@@ -51,14 +52,13 @@ type GitlabMergeRequestGetter interface {
GetMergeRequest(repoFullName string, pullNum int) (*gitlab.MergeRequest, error)
}
-// CommandHandler is the first step when processing a comment command.
-type CommandHandler struct {
+// DefaultCommandRunner is the first step when processing a comment command.
+type DefaultCommandRunner struct {
VCSClient vcs.ClientProxy
GithubPullGetter GithubPullGetter
GitlabMergeRequestGetter GitlabMergeRequestGetter
CommitStatusUpdater CommitStatusUpdater
EventParser EventParsing
- AtlantisWorkspaceLocker AtlantisWorkspaceLocker
MarkdownRenderer *MarkdownRenderer
Logger logging.SimpleLogging
// AllowForkPRs controls whether we operate on pull requests from forks.
@@ -66,17 +66,50 @@ type CommandHandler struct {
// AllowForkPRsFlag is the name of the flag that controls fork PR's. We use
// this in our error message back to the user on a forked PR so they know
// how to enable this functionality.
- AllowForkPRsFlag string
- PullRequestOperator PullRequestOperator
+ AllowForkPRsFlag string
+ ProjectCommandBuilder ProjectCommandBuilder
+ ProjectCommandRunner *ProjectCommandRunner
}
-// ExecuteCommand executes the command.
-// If the repo is from GitHub, we don't use headRepo and instead make an API call
-// to get the headRepo. This is because the caller is unable to pass in a
-// headRepo since there's not enough data available on the initial webhook
-// payload.
-func (c *CommandHandler) ExecuteCommand(baseRepo models.Repo, headRepo models.Repo, user models.User, pullNum int, cmd *Command) {
+func (c *DefaultCommandRunner) RunAutoplanCommand(baseRepo models.Repo, headRepo models.Repo, pull models.PullRequest, user models.User) {
+ log := c.buildLogger(baseRepo.FullName, pull.Num)
+ ctx := &CommandContext{
+ User: user,
+ Log: log,
+ Pull: pull,
+ 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,
+ Path: cmd.RepoRelPath,
+ Workspace: cmd.Workspace,
+ })
+ }
+ return results, nil
+ }
+ c.run(ctx, AutoplanCommand{}, runFn)
+}
+
+// RunCommentCommand executes the command.
+// We take in a pointer for maybeHeadRepo because for some events there isn't
+// enough data to construct the Repo model and callers might want to wait until
+// the event is further validated before making an additional (potentially
+// wasteful) call to get the necessary data.
+func (c *DefaultCommandRunner) RunCommentCommand(baseRepo models.Repo, maybeHeadRepo *models.Repo, user models.User, pullNum int, cmd *CommentCommand) {
log := c.buildLogger(baseRepo.FullName, pullNum)
+ var headRepo models.Repo
+ if maybeHeadRepo != nil {
+ headRepo = *maybeHeadRepo
+ }
var err error
var pull models.PullRequest
@@ -97,13 +130,38 @@ func (c *CommandHandler) ExecuteCommand(baseRepo models.Repo, headRepo models.Re
Log: log,
Pull: pull,
HeadRepo: headRepo,
- Command: cmd,
BaseRepo: baseRepo,
}
- c.run(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{{
+ Path: cmd.Dir,
+ Workspace: cmd.Workspace,
+ ProjectCommandResult: result,
+ }}, nil
+ }
+
+ c.run(ctx, cmd, runFn)
}
-func (c *CommandHandler) getGithubData(baseRepo models.Repo, pullNum int) (models.PullRequest, models.Repo, error) {
+func (c *DefaultCommandRunner) getGithubData(baseRepo models.Repo, pullNum int) (models.PullRequest, models.Repo, error) {
if c.GithubPullGetter == nil {
return models.PullRequest{}, models.Repo{}, errors.New("Atlantis not configured to support GitHub")
}
@@ -111,14 +169,14 @@ func (c *CommandHandler) getGithubData(baseRepo models.Repo, pullNum int) (model
if err != nil {
return models.PullRequest{}, models.Repo{}, errors.Wrap(err, "making pull request API call to GitHub")
}
- pull, repo, err := c.EventParser.ParseGithubPull(ghPull)
+ pull, _, headRepo, err := c.EventParser.ParseGithubPull(ghPull)
if err != nil {
- return pull, repo, errors.Wrap(err, "extracting required fields from comment data")
+ return pull, headRepo, errors.Wrap(err, "extracting required fields from comment data")
}
- return pull, repo, nil
+ return pull, headRepo, nil
}
-func (c *CommandHandler) getGitlabData(baseRepo models.Repo, pullNum int) (models.PullRequest, error) {
+func (c *DefaultCommandRunner) getGitlabData(baseRepo models.Repo, pullNum int) (models.PullRequest, error) {
if c.GitlabMergeRequestGetter == nil {
return models.PullRequest{}, errors.New("Atlantis not configured to support GitLab")
}
@@ -130,60 +188,47 @@ func (c *CommandHandler) getGitlabData(baseRepo models.Repo, pullNum int) (model
return pull, nil
}
-func (c *CommandHandler) buildLogger(repoFullName string, pullNum int) *logging.SimpleLogger {
+func (c *DefaultCommandRunner) buildLogger(repoFullName string, pullNum int) *logging.SimpleLogger {
src := fmt.Sprintf("%s#%d", repoFullName, pullNum)
return logging.NewSimpleLogger(src, c.Logger.Underlying(), true, c.Logger.GetLevel())
}
-func (c *CommandHandler) run(ctx *CommandContext) {
- defer c.logPanics(ctx)
-
+func (c *DefaultCommandRunner) validateCtxAndComment(ctx *CommandContext) bool {
if !c.AllowForkPRs && ctx.HeadRepo.Owner != ctx.BaseRepo.Owner {
ctx.Log.Info("command was run on a fork pull request which is disallowed")
c.VCSClient.CreateComment(ctx.BaseRepo, ctx.Pull.Num, fmt.Sprintf("Atlantis commands can't be run on fork pull requests. To enable, set --%s", c.AllowForkPRsFlag)) // nolint: errcheck
- return
+ return false
}
if ctx.Pull.State != models.Open {
ctx.Log.Info("command was run on closed pull request")
c.VCSClient.CreateComment(ctx.BaseRepo, ctx.Pull.Num, "Atlantis commands can't be run on closed pull requests") // nolint: errcheck
+ return false
+ }
+ 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, ctx.Command); err != nil {
+ 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)
}
- if !c.AtlantisWorkspaceLocker.TryLock(ctx.BaseRepo.FullName, ctx.Command.Workspace, ctx.Pull.Num) {
- errMsg := fmt.Sprintf(
- "The %s workspace is currently locked by another"+
- " command that is running for this pull request."+
- " Wait until the previous command is complete and try again.",
- ctx.Command.Workspace)
- ctx.Log.Warn(errMsg)
- c.updatePull(ctx, CommandResponse{Failure: errMsg})
+
+ results, err := commandRunner()
+ if err != nil {
+ c.updatePull(ctx, command, CommandResult{Error: err})
return
}
- ctx.Log.Debug("successfully acquired workspace lock")
- defer c.AtlantisWorkspaceLocker.Unlock(ctx.BaseRepo.FullName, ctx.Command.Workspace, ctx.Pull.Num)
-
- var cr CommandResponse
- switch ctx.Command.Name {
- case Plan:
- if ctx.Command.Autoplan {
- cr = c.PullRequestOperator.Autoplan(ctx)
- } else {
- cr = c.PullRequestOperator.PlanViaComment(ctx)
- }
- case Apply:
- cr = c.PullRequestOperator.ApplyViaComment(ctx)
- default:
- ctx.Log.Err("failed to determine desired command, neither plan nor apply")
- }
- c.updatePull(ctx, cr)
+ c.updatePull(ctx, command, CommandResult{ProjectResults: results})
}
-func (c *CommandHandler) updatePull(ctx *CommandContext, res CommandResponse) {
+func (c *DefaultCommandRunner) updatePull(ctx *CommandContext, command CommandInterface, res CommandResult) {
// Log if we got any errors or failures.
if res.Error != nil {
ctx.Log.Err(res.Error.Error())
@@ -192,15 +237,15 @@ func (c *CommandHandler) updatePull(ctx *CommandContext, res CommandResponse) {
}
// Update the pull request's status icon and comment back.
- if err := c.CommitStatusUpdater.UpdateProjectResult(ctx, res); err != nil {
+ if err := c.CommitStatusUpdater.UpdateProjectResult(ctx, command.CommandName(), res); err != nil {
ctx.Log.Warn("unable to update commit status: %s", err)
}
- comment := c.MarkdownRenderer.Render(res, ctx.Command.Name, ctx.Log.History.String(), ctx.Command.Verbose, ctx.Command.Autoplan)
+ comment := c.MarkdownRenderer.Render(res, command.CommandName(), ctx.Log.History.String(), command.IsVerbose(), command.IsAutoplan())
c.VCSClient.CreateComment(ctx.BaseRepo, ctx.Pull.Num, comment) // nolint: errcheck
}
// logPanics logs and creates a comment on the pull request for panics.
-func (c *CommandHandler) logPanics(ctx *CommandContext) {
+func (c *DefaultCommandRunner) logPanics(ctx *CommandContext) {
if err := recover(); err != nil {
stack := recovery.Stack(3)
c.VCSClient.CreateComment(ctx.BaseRepo, ctx.Pull.Num, // nolint: errcheck
diff --git a/server/events/command_runner_test.go b/server/events/command_runner_test.go
new file mode 100644
index 000000000..a0d636c9a
--- /dev/null
+++ b/server/events/command_runner_test.go
@@ -0,0 +1,239 @@
+// Copyright 2017 HootSuite Media Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an AS IS BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Modified hereafter by contributors to runatlantis/atlantis.
+//
+package events_test
+
+import (
+ "bytes"
+ "log"
+ "testing"
+
+ . "github.com/petergtz/pegomock"
+ "github.com/runatlantis/atlantis/server/events"
+ "github.com/runatlantis/atlantis/server/events/mocks"
+ vcsmocks "github.com/runatlantis/atlantis/server/events/vcs/mocks"
+ logmocks "github.com/runatlantis/atlantis/server/logging/mocks"
+ //. "github.com/runatlantis/atlantis/testing"
+)
+
+var projectCommandBuilder *mocks.MockProjectCommandBuilder
+var eventParsing *mocks.MockEventParsing
+var vcsClient *vcsmocks.MockClientProxy
+var ghStatus *mocks.MockCommitStatusUpdater
+var githubGetter *mocks.MockGithubPullGetter
+var gitlabGetter *mocks.MockGitlabMergeRequestGetter
+var workspaceLocker *mocks.MockAtlantisWorkspaceLocker
+var ch events.DefaultCommandRunner
+var logBytes *bytes.Buffer
+
+func setup(t *testing.T) {
+ RegisterMockTestingT(t)
+ projectCommandBuilder = mocks.NewMockProjectCommandBuilder()
+ eventParsing = mocks.NewMockEventParsing()
+ ghStatus = mocks.NewMockCommitStatusUpdater()
+ workspaceLocker = mocks.NewMockAtlantisWorkspaceLocker()
+ vcsClient = vcsmocks.NewMockClientProxy()
+ githubGetter = mocks.NewMockGithubPullGetter()
+ gitlabGetter = mocks.NewMockGitlabMergeRequestGetter()
+ logger := logmocks.NewMockSimpleLogging()
+ logBytes = new(bytes.Buffer)
+ When(logger.Underlying()).ThenReturn(log.New(logBytes, "", 0))
+ ch = events.DefaultCommandRunner{
+ VCSClient: vcsClient,
+ CommitStatusUpdater: ghStatus,
+ EventParser: eventParsing,
+ MarkdownRenderer: &events.MarkdownRenderer{},
+ GithubPullGetter: githubGetter,
+ GitlabMergeRequestGetter: gitlabGetter,
+ Logger: logger,
+ AllowForkPRs: false,
+ AllowForkPRsFlag: "allow-fork-prs-flag",
+ ProjectCommandBuilder: projectCommandBuilder,
+ }
+}
+
+//func TestExecuteCommand_LogPanics(t *testing.T) {
+// t.Log("if there is a panic it is commented back on the pull request")
+// setup(t)
+// ch.AllowForkPRs = true // Lets us get to the panic code.
+// defer func() { ch.AllowForkPRs = false }()
+// When(ghStatus.Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, events.Plan)).ThenPanic("panic")
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, 1, nil)
+// _, _, comment := vcsClient.VerifyWasCalledOnce().CreateComment(matchers.AnyModelsRepo(), AnyInt(), AnyString()).GetCapturedArguments()
+// Assert(t, strings.Contains(comment, "Error: goroutine panic"), "comment should be about a goroutine panic")
+//}
+//
+//func TestExecuteCommand_NoGithubPullGetter(t *testing.T) {
+// t.Log("if DefaultCommandRunner was constructed with a nil GithubPullGetter an error should be logged")
+// setup(t)
+// ch.GithubPullGetter = nil
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, 1, nil)
+// Equals(t, "[ERROR] runatlantis/atlantis#1: Atlantis not configured to support GitHub\n", logBytes.String())
+//}
+//
+//func TestExecuteCommand_NoGitlabMergeGetter(t *testing.T) {
+// t.Log("if DefaultCommandRunner was constructed with a nil GitlabMergeRequestGetter an error should be logged")
+// setup(t)
+// ch.GitlabMergeRequestGetter = nil
+// ch.RunCommentCommand(fixtures.GitlabRepo, &fixtures.GitlabRepo, fixtures.User, 1, nil)
+// Equals(t, "[ERROR] runatlantis/atlantis#1: Atlantis not configured to support GitLab\n", logBytes.String())
+//}
+//
+//func TestExecuteCommand_GithubPullErr(t *testing.T) {
+// t.Log("if getting the github pull request fails an error should be logged")
+// setup(t)
+// When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(nil, errors.New("err"))
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
+// Equals(t, "[ERROR] runatlantis/atlantis#1: Making pull request API call to GitHub: err\n", logBytes.String())
+//}
+//
+//func TestExecuteCommand_GitlabMergeRequestErr(t *testing.T) {
+// t.Log("if getting the gitlab merge request fails an error should be logged")
+// setup(t)
+// When(gitlabGetter.GetMergeRequest(fixtures.GithubRepo.FullName, fixtures.Pull.Num)).ThenReturn(nil, errors.New("err"))
+// ch.RunCommentCommand(fixtures.GitlabRepo, &fixtures.GitlabRepo, fixtures.User, fixtures.Pull.Num, nil)
+// Equals(t, "[ERROR] runatlantis/atlantis#1: Making merge request API call to GitLab: err\n", logBytes.String())
+//}
+//
+//func TestExecuteCommand_GithubPullParseErr(t *testing.T) {
+// t.Log("if parsing the returned github pull request fails an error should be logged")
+// setup(t)
+// var pull github.PullRequest
+// When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(&pull, nil)
+// When(eventParsing.ParseGithubPull(&pull)).ThenReturn(fixtures.Pull, fixtures.GithubRepo, errors.New("err"))
+//
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
+// Equals(t, "[ERROR] runatlantis/atlantis#1: Extracting required fields from comment data: err\n", logBytes.String())
+//}
+//
+//func TestExecuteCommand_ForkPRDisabled(t *testing.T) {
+// t.Log("if a command is run on a forked pull request and this is disabled atlantis should" +
+// " comment saying that this is not allowed")
+// setup(t)
+// ch.AllowForkPRs = false // by default it's false so don't need to reset
+// var pull github.PullRequest
+// modelPull := models.PullRequest{State: models.Open}
+// 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(modelPull, headRepo, nil)
+//
+// ch.RunCommentCommand(fixtures.GithubRepo, nil, fixtures.User, fixtures.Pull.Num, nil)
+// vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, modelPull.Num, "Atlantis commands can't be run on fork pull requests. To enable, set --"+ch.AllowForkPRsFlag)
+//}
+//
+//func TestExecuteCommand_ClosedPull(t *testing.T) {
+// t.Log("if a command is run on a closed pull request atlantis should" +
+// " comment saying that this is not allowed")
+// setup(t)
+// pull := &github.PullRequest{
+// State: github.String("closed"),
+// }
+// modelPull := models.PullRequest{State: models.Closed}
+// When(githubGetter.GetPullRequest(fixtures.GithubRepo, fixtures.Pull.Num)).ThenReturn(pull, nil)
+// When(eventParsing.ParseGithubPull(pull)).ThenReturn(modelPull, fixtures.GithubRepo, nil)
+//
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, nil)
+// vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, modelPull.Num, "Atlantis commands can't be run on closed pull requests")
+//}
+//
+//func TestExecuteCommand_WorkspaceLocked(t *testing.T) {
+// t.Log("if the workspace is locked, should comment back on the pull")
+// setup(t)
+// pull := &github.PullRequest{
+// State: github.String("closed"),
+// }
+// cmd := events.CommentCommand{
+// Name: events.Plan,
+// Workspace: "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.Workspace, fixtures.Pull.Num)).ThenReturn(false)
+// ch.RunCommentCommand(fixtures.GithubRepo, &fixtures.GithubRepo, fixtures.User, fixtures.Pull.Num, &cmd)
+//
+// msg := "The workspace workspace is currently locked by another" +
+// " command that is running for this pull request." +
+// " Wait until the previous command is complete and try again."
+// ghStatus.VerifyWasCalledOnce().Update(fixtures.GithubRepo, fixtures.Pull, vcs.Pending, cmd.CommandName())
+// _, _, result := ghStatus.VerifyWasCalledOnce().UpdateProjectResult(matchers.AnyPtrToEventsCommandContext(), matchers.AnyEventsCommandName(), matchers.AnyEventsCommandResult()).GetCapturedArguments()
+// Equals(t, msg, result.Failure)
+// vcsClient.VerifyWasCalledOnce().CreateComment(fixtures.GithubRepo, fixtures.Pull.Num,
+// "**Plan Failed**: "+msg+"\n\n")
+//}
+//
+//func TestExecuteCommand_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,
+// Workspace: "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.Workspace, 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.Workspace, fixtures.Pull.Num)
+// }
+//}
+//
+//func TestExecuteCommand_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,
+// Workspace: "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.Workspace, 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.Workspace, fixtures.Pull.Num)
+//}
diff --git a/server/events/comment_parser.go b/server/events/comment_parser.go
index 808d4493a..c6f9f2439 100644
--- a/server/events/comment_parser.go
+++ b/server/events/comment_parser.go
@@ -59,7 +59,7 @@ type CommentParser struct {
type CommentParseResult struct {
// Command is the successfully parsed command. Will be nil if
// CommentResponse or Ignore is set.
- Command *Command
+ Command *CommentCommand
// CommentResponse is set when we should respond immediately to the command
// for example for atlantis help.
CommentResponse string
@@ -215,7 +215,7 @@ func (e *CommentParser) Parse(comment string, vcsHost models.VCSHostType) Commen
}
return CommentParseResult{
- Command: NewCommand(dir, extraArgs, name, verbose, workspace, project, false),
+ Command: NewCommand(dir, extraArgs, name, verbose, workspace, project),
}
}
diff --git a/server/events/commit_status_updater.go b/server/events/commit_status_updater.go
index 3debcd43f..ba5a23503 100644
--- a/server/events/commit_status_updater.go
+++ b/server/events/commit_status_updater.go
@@ -27,10 +27,10 @@ import (
// the status to signify whether the plan/apply succeeds.
type CommitStatusUpdater interface {
// Update updates the status of the head commit of pull.
- Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, cmd *Command) error
+ Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, command CommandName) error
// UpdateProjectResult updates the status of the head commit given the
// state of response.
- UpdateProjectResult(ctx *CommandContext, res CommandResponse) error
+ UpdateProjectResult(ctx *CommandContext, commandName CommandName, res CommandResult) error
}
// DefaultCommitStatusUpdater implements CommitStatusUpdater.
@@ -39,13 +39,13 @@ type DefaultCommitStatusUpdater struct {
}
// Update updates the commit status.
-func (d *DefaultCommitStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, cmd *Command) error {
- description := fmt.Sprintf("%s %s", strings.Title(cmd.Name.String()), strings.Title(status.String()))
+func (d *DefaultCommitStatusUpdater) Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, command CommandName) error {
+ description := fmt.Sprintf("%s %s", strings.Title(command.String()), strings.Title(status.String()))
return d.Client.UpdateStatus(repo, pull, status, description)
}
// UpdateProjectResult updates the commit status based on the status of res.
-func (d *DefaultCommitStatusUpdater) UpdateProjectResult(ctx *CommandContext, res CommandResponse) error {
+func (d *DefaultCommitStatusUpdater) UpdateProjectResult(ctx *CommandContext, commandName CommandName, res CommandResult) error {
var status vcs.CommitStatus
if res.Error != nil || res.Failure != "" {
status = vcs.Failed
@@ -56,7 +56,7 @@ func (d *DefaultCommitStatusUpdater) UpdateProjectResult(ctx *CommandContext, re
}
status = d.worstStatus(statuses)
}
- return d.Update(ctx.BaseRepo, ctx.Pull, status, ctx.Command)
+ return d.Update(ctx.BaseRepo, ctx.Pull, status, commandName)
}
func (d *DefaultCommitStatusUpdater) worstStatus(ss []vcs.CommitStatus) vcs.CommitStatus {
diff --git a/server/events/commit_status_updater_test.go b/server/events/commit_status_updater_test.go
index 7d05264b0..155822dc1 100644
--- a/server/events/commit_status_updater_test.go
+++ b/server/events/commit_status_updater_test.go
@@ -29,26 +29,12 @@ import (
var repoModel = models.Repo{}
var pullModel = models.PullRequest{}
var status = vcs.Success
-var cmd = events.Command{
- Name: events.Plan,
-}
-
-func TestStatus_String(t *testing.T) {
- cases := map[vcs.CommitStatus]string{
- vcs.Pending: "pending",
- vcs.Success: "success",
- vcs.Failed: "failed",
- }
- for k, v := range cases {
- Equals(t, v, k.String())
- }
-}
func TestUpdate(t *testing.T) {
RegisterMockTestingT(t)
client := mocks.NewMockClientProxy()
s := events.DefaultCommitStatusUpdater{Client: client}
- err := s.Update(repoModel, pullModel, status, &cmd)
+ err := s.Update(repoModel, pullModel, status, events.Plan)
Ok(t, err)
client.VerifyWasCalledOnce().UpdateStatus(repoModel, pullModel, status, "Plan Success")
}
@@ -58,11 +44,10 @@ func TestUpdateProjectResult_Error(t *testing.T) {
ctx := &events.CommandContext{
BaseRepo: repoModel,
Pull: pullModel,
- Command: &events.Command{Name: events.Plan},
}
client := mocks.NewMockClientProxy()
s := events.DefaultCommitStatusUpdater{Client: client}
- err := s.UpdateProjectResult(ctx, events.CommandResponse{Error: errors.New("err")})
+ err := s.UpdateProjectResult(ctx, events.Plan, events.CommandResult{Error: errors.New("err")})
Ok(t, err)
client.VerifyWasCalledOnce().UpdateStatus(repoModel, pullModel, vcs.Failed, "Plan Failed")
}
@@ -72,23 +57,20 @@ func TestUpdateProjectResult_Failure(t *testing.T) {
ctx := &events.CommandContext{
BaseRepo: repoModel,
Pull: pullModel,
- Command: &events.Command{Name: events.Plan},
}
client := mocks.NewMockClientProxy()
s := events.DefaultCommitStatusUpdater{Client: client}
- err := s.UpdateProjectResult(ctx, events.CommandResponse{Failure: "failure"})
+ err := s.UpdateProjectResult(ctx, events.Plan, events.CommandResult{Failure: "failure"})
Ok(t, err)
client.VerifyWasCalledOnce().UpdateStatus(repoModel, pullModel, vcs.Failed, "Plan Failed")
}
func TestUpdateProjectResult(t *testing.T) {
- t.Log("should use worst status")
RegisterMockTestingT(t)
ctx := &events.CommandContext{
BaseRepo: repoModel,
Pull: pullModel,
- Command: &events.Command{Name: events.Plan},
}
cases := []struct {
@@ -126,25 +108,31 @@ func TestUpdateProjectResult(t *testing.T) {
}
for _, c := range cases {
- var results []events.ProjectResult
- for _, statusStr := range c.Statuses {
- var result events.ProjectResult
- switch statusStr {
- case "failure":
- result = events.ProjectResult{Failure: "failure"}
- case "error":
- result = events.ProjectResult{Error: errors.New("err")}
- default:
- result = events.ProjectResult{}
+ t.Run(strings.Join(c.Statuses, "-"), func(t *testing.T) {
+ var results []events.ProjectResult
+ for _, statusStr := range c.Statuses {
+ var result events.ProjectResult
+ switch statusStr {
+ case "failure":
+ result = events.ProjectResult{
+ ProjectCommandResult: events.ProjectCommandResult{Failure: "failure"},
+ }
+ case "error":
+ result = events.ProjectResult{
+ ProjectCommandResult: events.ProjectCommandResult{Error: errors.New("err")},
+ }
+ default:
+ result = events.ProjectResult{}
+ }
+ results = append(results, result)
}
- results = append(results, result)
- }
- resp := events.CommandResponse{ProjectResults: results}
+ resp := events.CommandResult{ProjectResults: results}
- client := mocks.NewMockClientProxy()
- s := events.DefaultCommitStatusUpdater{Client: client}
- err := s.UpdateProjectResult(ctx, resp)
- Ok(t, err)
- client.VerifyWasCalledOnce().UpdateStatus(repoModel, pullModel, c.Expected, "Plan "+strings.Title(c.Expected.String()))
+ client := mocks.NewMockClientProxy()
+ s := events.DefaultCommitStatusUpdater{Client: client}
+ err := s.UpdateProjectResult(ctx, events.Plan, resp)
+ Ok(t, err)
+ client.VerifyWasCalledOnce().UpdateStatus(repoModel, pullModel, c.Expected, "Plan "+strings.Title(c.Expected.String()))
+ })
}
}
diff --git a/server/events/event_parser.go b/server/events/event_parser.go
index dbdccc8e5..3bf4e7f15 100644
--- a/server/events/event_parser.go
+++ b/server/events/event_parser.go
@@ -34,7 +34,27 @@ var multiLineRegex = regexp.MustCompile(`.*\r?\n.+`)
//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_event_parsing.go EventParsing
-type Command struct {
+type CommandInterface interface {
+ CommandName() CommandName
+ IsVerbose() bool
+ IsAutoplan() bool
+}
+
+type AutoplanCommand struct{}
+
+func (c AutoplanCommand) CommandName() CommandName {
+ return Plan
+}
+
+func (c AutoplanCommand) IsVerbose() bool {
+ return false
+}
+
+func (c AutoplanCommand) IsAutoplan() bool {
+ return true
+}
+
+type CommentCommand struct {
// Dir is the path relative to the repo root to run the command in.
// Will never be an empty string and will never end in "/".
Dir string
@@ -44,20 +64,29 @@ type Command struct {
Name CommandName
Verbose bool
Workspace string
- // Autoplan is true if the command is a plan command being executed in an
- // attempt to automatically run plan.
- Autoplan bool
// ProjectName is the name of a project to run the command on. It refers to a
// project specified in an atlantis.yaml file.
ProjectName string
}
-func (c Command) String() string {
- return fmt.Sprintf("command=%q verbose=%t dir=%q workspace=%q project=%q autoplan=%t flags=%q", c.Name.String(), c.Verbose, c.Dir, c.Workspace, c.ProjectName, c.Autoplan, strings.Join(c.Flags, ","))
+func (c CommentCommand) CommandName() CommandName {
+ return c.Name
+}
+
+func (c CommentCommand) IsVerbose() bool {
+ return c.Verbose
+}
+
+func (c CommentCommand) IsAutoplan() bool {
+ return false
+}
+
+func (c CommentCommand) String() string {
+ return fmt.Sprintf("command=%q verbose=%t dir=%q workspace=%q project=%q flags=%q", c.Name.String(), c.Verbose, c.Dir, c.Workspace, c.ProjectName, strings.Join(c.Flags, ","))
}
// NewCommand constructs a Command, setting all missing fields to defaults.
-func NewCommand(dir string, flags []string, name CommandName, verbose bool, workspace string, project string, autoplan bool) *Command {
+func NewCommand(dir string, flags []string, name CommandName, verbose bool, workspace string, project string) *CommentCommand {
// If dir was an empty string, this will return '.'.
validDir := path.Clean(dir)
if validDir == "/" {
@@ -66,24 +95,27 @@ func NewCommand(dir string, flags []string, name CommandName, verbose bool, work
if workspace == "" {
workspace = DefaultWorkspace
}
- return &Command{
+ return &CommentCommand{
Dir: validDir,
Flags: flags,
Name: name,
Verbose: verbose,
Workspace: workspace,
- Autoplan: autoplan,
ProjectName: project,
}
}
type EventParsing interface {
ParseGithubIssueCommentEvent(comment *github.IssueCommentEvent) (baseRepo models.Repo, user models.User, pullNum int, err error)
- // ParseGithubPull returns the pull request and head repo.
- ParseGithubPull(pull *github.PullRequest) (models.PullRequest, models.Repo, error)
+ // ParseGithubPull returns the pull request, base repo and head repo.
+ ParseGithubPull(pull *github.PullRequest) (models.PullRequest, models.Repo, models.Repo, error)
+ // ParseGithubPullEvent returns the pull request, head repo and user that
+ // caused the event. Base repo is available as a field on PullRequest.
+ ParseGithubPullEvent(pullEvent *github.PullRequestEvent) (pull models.PullRequest, baseRepo models.Repo, headRepo models.Repo, user models.User, err error)
ParseGithubRepo(ghRepo *github.Repository) (models.Repo, error)
- // ParseGitlabMergeEvent returns the pull request, base repo and head repo.
- ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.PullRequest, models.Repo, models.Repo, error)
+ // ParseGitlabMergeEvent returns the pull request, base repo, head repo and
+ // user that caused the event.
+ ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.PullRequest, models.Repo, models.Repo, models.User, error)
ParseGitlabMergeCommentEvent(event gitlab.MergeCommentEvent) (baseRepo models.Repo, headRepo models.Repo, user models.User, err error)
ParseGitlabMergeRequest(mr *gitlab.MergeRequest, baseRepo models.Repo) models.PullRequest
}
@@ -116,38 +148,58 @@ func (e *EventParser) ParseGithubIssueCommentEvent(comment *github.IssueCommentE
return
}
-func (e *EventParser) ParseGithubPull(pull *github.PullRequest) (models.PullRequest, models.Repo, error) {
- var pullModel models.PullRequest
- var headRepoModel models.Repo
+func (e *EventParser) ParseGithubPullEvent(pullEvent *github.PullRequestEvent) (models.PullRequest, models.Repo, models.Repo, models.User, error) {
+ if pullEvent.PullRequest == nil {
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, errors.New("pull_request is null")
+ }
+ pull, baseRepo, headRepo, err := e.ParseGithubPull(pullEvent.PullRequest)
+ if err != nil {
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, err
+ }
+ if pullEvent.Sender == nil {
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, errors.New("sender is null")
+ }
+ senderUsername := pullEvent.Sender.GetLogin()
+ if senderUsername == "" {
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, errors.New("sender.login is null")
+ }
+ return pull, baseRepo, headRepo, models.User{Username: senderUsername}, nil
+}
+func (e *EventParser) ParseGithubPull(pull *github.PullRequest) (pullModel models.PullRequest, baseRepo models.Repo, headRepo models.Repo, err error) {
commit := pull.Head.GetSHA()
if commit == "" {
- return pullModel, headRepoModel, errors.New("head.sha is null")
+ err = errors.New("head.sha is null")
+ return
}
url := pull.GetHTMLURL()
if url == "" {
- return pullModel, headRepoModel, errors.New("html_url is null")
+ err = errors.New("html_url is null")
+ return
}
branch := pull.Head.GetRef()
if branch == "" {
- return pullModel, headRepoModel, errors.New("head.ref is null")
+ err = errors.New("head.ref is null")
+ return
}
authorUsername := pull.User.GetLogin()
if authorUsername == "" {
- return pullModel, headRepoModel, errors.New("user.login is null")
+ err = errors.New("user.login is null")
+ return
}
num := pull.GetNumber()
if num == 0 {
- return pullModel, headRepoModel, errors.New("number is null")
+ err = errors.New("number is null")
+ return
}
- baseRepoModel, err := e.ParseGithubRepo(pull.Base.Repo)
+ baseRepo, err = e.ParseGithubRepo(pull.Base.Repo)
if err != nil {
- return pullModel, headRepoModel, err
+ return
}
- headRepoModel, err = e.ParseGithubRepo(pull.Head.Repo)
+ headRepo, err = e.ParseGithubRepo(pull.Head.Repo)
if err != nil {
- return pullModel, headRepoModel, err
+ return
}
pullState := models.Closed
@@ -155,22 +207,23 @@ func (e *EventParser) ParseGithubPull(pull *github.PullRequest) (models.PullRequ
pullState = models.Open
}
- return models.PullRequest{
+ pullModel = models.PullRequest{
Author: authorUsername,
Branch: branch,
HeadCommit: commit,
URL: url,
Num: num,
State: pullState,
- BaseRepo: baseRepoModel,
- }, headRepoModel, nil
+ BaseRepo: baseRepo,
+ }
+ return
}
func (e *EventParser) ParseGithubRepo(ghRepo *github.Repository) (models.Repo, error) {
return models.NewRepo(models.Github, ghRepo.GetFullName(), ghRepo.GetCloneURL(), e.GithubUser, e.GithubToken)
}
-func (e *EventParser) ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.PullRequest, models.Repo, models.Repo, error) {
+func (e *EventParser) ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.PullRequest, models.Repo, models.Repo, models.User, error) {
modelState := models.Closed
if event.ObjectAttributes.State == gitlabPullOpened {
modelState = models.Open
@@ -180,11 +233,11 @@ func (e *EventParser) ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.Pul
baseRepo, err := models.NewRepo(models.Gitlab, event.Project.PathWithNamespace, event.Project.GitHTTPURL, e.GitlabUser, e.GitlabToken)
if err != nil {
- return models.PullRequest{}, models.Repo{}, models.Repo{}, err
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, err
}
headRepo, err := models.NewRepo(models.Gitlab, event.ObjectAttributes.Source.PathWithNamespace, event.ObjectAttributes.Source.GitHTTPURL, e.GitlabUser, e.GitlabToken)
if err != nil {
- return models.PullRequest{}, models.Repo{}, models.Repo{}, err
+ return models.PullRequest{}, models.Repo{}, models.Repo{}, models.User{}, err
}
pull := models.PullRequest{
@@ -197,7 +250,11 @@ func (e *EventParser) ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.Pul
BaseRepo: baseRepo,
}
- return pull, baseRepo, headRepo, err
+ user := models.User{
+ Username: event.User.Username,
+ }
+
+ return pull, baseRepo, headRepo, user, err
}
// ParseGitlabMergeCommentEvent creates Atlantis models out of a GitLab event.
diff --git a/server/events/event_parser_test.go b/server/events/event_parser_test.go
index 1415ffba3..d7ef7fce7 100644
--- a/server/events/event_parser_test.go
+++ b/server/events/event_parser_test.go
@@ -102,34 +102,40 @@ func TestParseGithubIssueCommentEvent(t *testing.T) {
Equals(t, *comment.Issue.Number, pullNum)
}
-func TestParseGithubPull(t *testing.T) {
- testPull := deepcopy.Copy(Pull).(github.PullRequest)
- testPull.Head.SHA = nil
- _, _, err := parser.ParseGithubPull(&testPull)
- ErrEquals(t, "head.sha is null", err)
+func TestParseGithubPullEvent(t *testing.T) {
+ _, _, _, _, err := parser.ParseGithubPullEvent(&github.PullRequestEvent{})
+ ErrEquals(t, "pull_request is null", err)
- testPull = deepcopy.Copy(Pull).(github.PullRequest)
- testPull.HTMLURL = nil
- _, _, err = parser.ParseGithubPull(&testPull)
+ testEvent := deepcopy.Copy(PullEvent).(github.PullRequestEvent)
+ testEvent.PullRequest.HTMLURL = nil
+ _, _, _, _, err = parser.ParseGithubPullEvent(&testEvent)
ErrEquals(t, "html_url is null", err)
- testPull = deepcopy.Copy(Pull).(github.PullRequest)
- testPull.Head.Ref = nil
- _, _, err = parser.ParseGithubPull(&testPull)
- ErrEquals(t, "head.ref is null", err)
+ testEvent = deepcopy.Copy(PullEvent).(github.PullRequestEvent)
+ testEvent.Sender = nil
+ _, _, _, _, err = parser.ParseGithubPullEvent(&testEvent)
+ ErrEquals(t, "sender is null", err)
- testPull = deepcopy.Copy(Pull).(github.PullRequest)
- testPull.User.Login = nil
- _, _, err = parser.ParseGithubPull(&testPull)
- ErrEquals(t, "user.login is null", err)
+ testEvent = deepcopy.Copy(PullEvent).(github.PullRequestEvent)
+ testEvent.Sender.Login = nil
+ _, _, _, _, err = parser.ParseGithubPullEvent(&testEvent)
+ ErrEquals(t, "sender.login is null", err)
- testPull = deepcopy.Copy(Pull).(github.PullRequest)
- testPull.Number = nil
- _, _, err = parser.ParseGithubPull(&testPull)
- ErrEquals(t, "number is null", err)
-
- pullRes, _, err := parser.ParseGithubPull(&Pull)
+ actPull, actBaseRepo, actHeadRepo, actUser, err := parser.ParseGithubPullEvent(&PullEvent)
Ok(t, err)
+ expBaseRepo := models.Repo{
+ Owner: "owner",
+ FullName: "owner/repo",
+ CloneURL: "https://github-user:github-token@github.com/owner/repo.git",
+ SanitizedCloneURL: Repo.GetCloneURL(),
+ Name: "repo",
+ VCSHost: models.VCSHost{
+ Hostname: "github.com",
+ Type: models.Github,
+ },
+ }
+ Equals(t, expBaseRepo, actBaseRepo)
+ Equals(t, expBaseRepo, actHeadRepo)
Equals(t, models.PullRequest{
URL: Pull.GetHTMLURL(),
Author: Pull.User.GetLogin(),
@@ -137,18 +143,61 @@ func TestParseGithubPull(t *testing.T) {
HeadCommit: Pull.Head.GetSHA(),
Num: Pull.GetNumber(),
State: models.Open,
- BaseRepo: models.Repo{
- Owner: "owner",
- FullName: "owner/repo",
- CloneURL: "https://github-user:github-token@github.com/owner/repo.git",
- SanitizedCloneURL: Repo.GetCloneURL(),
- Name: "repo",
- VCSHost: models.VCSHost{
- Hostname: "github.com",
- Type: models.Github,
- },
+ BaseRepo: expBaseRepo,
+ }, actPull)
+ Equals(t, models.User{Username: "user"}, actUser)
+}
+
+func TestParseGithubPull(t *testing.T) {
+ testPull := deepcopy.Copy(Pull).(github.PullRequest)
+ testPull.Head.SHA = nil
+ _, _, _, err := parser.ParseGithubPull(&testPull)
+ ErrEquals(t, "head.sha is null", err)
+
+ testPull = deepcopy.Copy(Pull).(github.PullRequest)
+ testPull.HTMLURL = nil
+ _, _, _, err = parser.ParseGithubPull(&testPull)
+ ErrEquals(t, "html_url is null", err)
+
+ testPull = deepcopy.Copy(Pull).(github.PullRequest)
+ testPull.Head.Ref = nil
+ _, _, _, err = parser.ParseGithubPull(&testPull)
+ ErrEquals(t, "head.ref is null", err)
+
+ testPull = deepcopy.Copy(Pull).(github.PullRequest)
+ testPull.User.Login = nil
+ _, _, _, err = parser.ParseGithubPull(&testPull)
+ ErrEquals(t, "user.login is null", err)
+
+ testPull = deepcopy.Copy(Pull).(github.PullRequest)
+ testPull.Number = nil
+ _, _, _, err = parser.ParseGithubPull(&testPull)
+ ErrEquals(t, "number is null", err)
+
+ pullRes, actBaseRepo, actHeadRepo, err := parser.ParseGithubPull(&Pull)
+ Ok(t, err)
+ expBaseRepo := models.Repo{
+ Owner: "owner",
+ FullName: "owner/repo",
+ CloneURL: "https://github-user:github-token@github.com/owner/repo.git",
+ SanitizedCloneURL: Repo.GetCloneURL(),
+ Name: "repo",
+ VCSHost: models.VCSHost{
+ Hostname: "github.com",
+ Type: models.Github,
},
+ }
+ Equals(t, models.PullRequest{
+ URL: Pull.GetHTMLURL(),
+ Author: Pull.User.GetLogin(),
+ Branch: Pull.Head.GetRef(),
+ HeadCommit: Pull.Head.GetSHA(),
+ Num: Pull.GetNumber(),
+ State: models.Open,
+ BaseRepo: expBaseRepo,
}, pullRes)
+ Equals(t, expBaseRepo, actBaseRepo)
+ Equals(t, expBaseRepo, actHeadRepo)
}
func TestParseGitlabMergeEvent(t *testing.T) {
@@ -156,10 +205,10 @@ func TestParseGitlabMergeEvent(t *testing.T) {
var event *gitlab.MergeEvent
err := json.Unmarshal([]byte(mergeEventJSON), &event)
Ok(t, err)
- pull, repo, _, err := parser.ParseGitlabMergeEvent(*event)
+ pull, actBaseRepo, actHeadRepo, actUser, err := parser.ParseGitlabMergeEvent(*event)
Ok(t, err)
- expRepo := models.Repo{
+ expBaseRepo := models.Repo{
FullName: "gitlabhq/gitlab-test",
Name: "gitlab-test",
SanitizedCloneURL: "https://example.com/gitlabhq/gitlab-test.git",
@@ -178,14 +227,26 @@ func TestParseGitlabMergeEvent(t *testing.T) {
HeadCommit: "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
Branch: "ms-viewport",
State: models.Open,
- BaseRepo: expRepo,
+ BaseRepo: expBaseRepo,
}, pull)
- Equals(t, expRepo, repo)
+ Equals(t, expBaseRepo, actBaseRepo)
+ Equals(t, models.Repo{
+ FullName: "awesome_space/awesome_project",
+ Name: "awesome_project",
+ SanitizedCloneURL: "http://example.com/awesome_space/awesome_project.git",
+ Owner: "awesome_space",
+ CloneURL: "http://gitlab-user:gitlab-token@example.com/awesome_space/awesome_project.git",
+ VCSHost: models.VCSHost{
+ Hostname: "example.com",
+ Type: models.Gitlab,
+ },
+ }, actHeadRepo)
+ Equals(t, models.User{Username: "root"}, actUser)
t.Log("If the state is closed, should set field correctly.")
event.ObjectAttributes.State = "closed"
- pull, _, _, err = parser.ParseGitlabMergeEvent(*event)
+ pull, _, _, _, err = parser.ParseGitlabMergeEvent(*event)
Ok(t, err)
Equals(t, models.Closed, pull.State)
}
@@ -283,20 +344,20 @@ func TestNewCommand_CleansDir(t *testing.T) {
for _, c := range cases {
t.Run(c.Dir, func(t *testing.T) {
- cmd := events.NewCommand(c.Dir, nil, events.Plan, false, "workspace", "", false)
+ cmd := events.NewCommand(c.Dir, nil, events.Plan, false, "workspace", "")
Equals(t, c.ExpDir, cmd.Dir)
})
}
}
func TestNewCommand_EmptyWorkspace(t *testing.T) {
- cmd := events.NewCommand("dir", nil, events.Plan, false, "", "", false)
+ cmd := events.NewCommand("dir", nil, events.Plan, false, "", "")
Equals(t, "default", cmd.Workspace)
}
func TestNewCommand_AllFieldsSet(t *testing.T) {
- cmd := events.NewCommand("dir", []string{"a", "b"}, events.Plan, true, "workspace", "project", false)
- Equals(t, events.Command{
+ cmd := events.NewCommand("dir", []string{"a", "b"}, events.Plan, true, "workspace", "project")
+ Equals(t, events.CommentCommand{
Workspace: "workspace",
Dir: "dir",
Verbose: true,
@@ -306,6 +367,52 @@ func TestNewCommand_AllFieldsSet(t *testing.T) {
}, *cmd)
}
+func TestAutoplanCommand_CommandName(t *testing.T) {
+ Equals(t, events.Plan, (events.AutoplanCommand{}).CommandName())
+}
+
+func TestAutoplanCommand_IsVerbose(t *testing.T) {
+ Equals(t, false, (events.AutoplanCommand{}).IsVerbose())
+}
+
+func TestAutoplanCommand_IsAutoplan(t *testing.T) {
+ Equals(t, true, (events.AutoplanCommand{}).IsAutoplan())
+}
+
+func TestCommentCommand_CommandName(t *testing.T) {
+ Equals(t, events.Plan, (events.CommentCommand{
+ Name: events.Plan,
+ }).CommandName())
+ Equals(t, events.Apply, (events.CommentCommand{
+ Name: events.Apply,
+ }).CommandName())
+}
+
+func TestCommentCommand_IsVerbose(t *testing.T) {
+ Equals(t, false, (events.CommentCommand{
+ Verbose: false,
+ }).IsVerbose())
+ Equals(t, true, (events.CommentCommand{
+ Verbose: true,
+ }).IsVerbose())
+}
+
+func TestCommentCommand_IsAutoplan(t *testing.T) {
+ Equals(t, false, (events.CommentCommand{}).IsAutoplan())
+}
+
+func TestCommentCommand_String(t *testing.T) {
+ exp := `command="plan" verbose=true dir="mydir" workspace="myworkspace" project="myproject" flags="flag1,flag2"`
+ Equals(t, exp, (events.CommentCommand{
+ Dir: "mydir",
+ Flags: []string{"flag1", "flag2"},
+ Name: events.Plan,
+ Verbose: true,
+ Workspace: "myworkspace",
+ ProjectName: "myproject",
+ }).String())
+}
+
var mergeEventJSON = `{
"object_kind": "merge_request",
"user": {
diff --git a/server/events/executor.go b/server/events/executor.go
index 10df87a76..b308e9d02 100644
--- a/server/events/executor.go
+++ b/server/events/executor.go
@@ -18,5 +18,5 @@ package events
// Executor is the generic interface implemented by each command type:
// help, plan, and apply.
type Executor interface {
- Execute(ctx *CommandContext) CommandResponse
+ Execute(ctx *CommandContext) CommandResult
}
diff --git a/server/events/markdown_renderer.go b/server/events/markdown_renderer.go
index acb0d8679..eb06c4ead 100644
--- a/server/events/markdown_renderer.go
+++ b/server/events/markdown_renderer.go
@@ -58,7 +58,7 @@ type ProjectResultTmplData struct {
// Render formats the data into a markdown string.
// nolint: interfacer
-func (m *MarkdownRenderer) Render(res CommandResponse, cmdName CommandName, log string, verbose bool, autoplan bool) string {
+func (m *MarkdownRenderer) Render(res CommandResult, cmdName CommandName, log string, verbose bool, autoplan bool) string {
commandStr := strings.Title(cmdName.String())
common := CommonData{commandStr, verbose, log}
if res.Error != nil {
@@ -73,10 +73,10 @@ func (m *MarkdownRenderer) Render(res CommandResponse, cmdName CommandName, log
return m.renderProjectResults(res.ProjectResults, common)
}
-func (m *MarkdownRenderer) renderProjectResults(pathResults []ProjectResult, common CommonData) string {
+func (m *MarkdownRenderer) renderProjectResults(results []ProjectResult, common CommonData) string {
var resultsTmplData []ProjectResultTmplData
- for _, result := range pathResults {
+ for _, result := range results {
resultData := ProjectResultTmplData{
Workspace: result.Workspace,
Dir: result.Path,
diff --git a/server/events/markdown_renderer_test.go b/server/events/markdown_renderer_test.go
index 202097e9b..040c47731 100644
--- a/server/events/markdown_renderer_test.go
+++ b/server/events/markdown_renderer_test.go
@@ -45,18 +45,20 @@ func TestRenderErr(t *testing.T) {
r := events.MarkdownRenderer{}
for _, c := range cases {
- res := events.CommandResponse{
- Error: c.Error,
- }
- for _, verbose := range []bool{true, false} {
- t.Log("testing " + c.Description)
- s := r.Render(res, c.Command, "log", verbose, false)
- if !verbose {
- Equals(t, c.Expected, s)
- } else {
- Equals(t, c.Expected+"Log
\n \n\n```\nlog```\n
Log
\n \n\n```\nlog```\n
Log
\n \n\n```\nlog```\n
Log
\n \n\n```\nlog```\n
Log
\n \n\n```\nlog```\n
Log
\n \n\n```\nlog```\n