fix: API Controller CommentCommand.Name defaults to Apply instead of Plan (#6090)

Signed-off-by: Ricardo Silveira <ricardo.silveira@olx.com>
Co-authored-by: Ricardo Silveira <ricardo.silveira@olx.com>
Co-authored-by: PePe Amengual <2208324+jamengual@users.noreply.github.com>

Author: 3 people

server/controllers/api_controller.go

@@ -56,16 +56,18 @@ type APIRequest struct {
 	}
 }
 
-func (a *APIRequest) getCommands(ctx *command.Context, cmdBuilder func(*command.Context, *events.CommentCommand) ([]command.ProjectContext, error)) ([]command.ProjectContext, []*events.CommentCommand, error) {
+func (a *APIRequest) getCommands(ctx *command.Context, cmdName command.Name, cmdBuilder func(*command.Context, *events.CommentCommand) ([]command.ProjectContext, error)) ([]command.ProjectContext, []*events.CommentCommand, error) {
 	cc := make([]*events.CommentCommand, 0)
 
 	for _, project := range a.Projects {
 		cc = append(cc, &events.CommentCommand{
+			Name:        cmdName,
 			ProjectName: project,
 		})
 	}
 	for _, path := range a.Paths {
 		cc = append(cc, &events.CommentCommand{
+			Name:       cmdName,
 			RepoRelDir: strings.TrimRight(path.Directory, "/"),
 			Workspace:  path.Workspace,
 		})
@@ -236,7 +238,7 @@ func (a *APIController) apiSetup(ctx *command.Context, cmdName command.Name) err
 }
 
 func (a *APIController) apiPlan(request *APIRequest, ctx *command.Context) (*command.Result, error) {
-	cmds, cc, err := request.getCommands(ctx, a.ProjectCommandBuilder.BuildPlanCommands)
+	cmds, cc, err := request.getCommands(ctx, command.Plan, a.ProjectCommandBuilder.BuildPlanCommands)
 	if err != nil {
 		return nil, err
 	}
@@ -284,7 +286,7 @@ func (a *APIController) apiPlan(request *APIRequest, ctx *command.Context) (*com
 }
 
 func (a *APIController) apiApply(request *APIRequest, ctx *command.Context) (*command.Result, error) {
-	cmds, cc, err := request.getCommands(ctx, a.ProjectCommandBuilder.BuildApplyCommands)
+	cmds, cc, err := request.getCommands(ctx, command.Apply, a.ProjectCommandBuilder.BuildApplyCommands)
 	if err != nil {
 		return nil, err
 	}

server/controllers/api_controller_test.go

@@ -203,6 +203,79 @@ func TestAPIController_Apply(t *testing.T) {
 	projectCommandRunner.VerifyWasCalled(Times(expectedCalls)).Apply(Any[command.ProjectContext]())
 }
 
+// TestAPIController_Plan_PreWorkflowHooksReceiveCorrectCommand verifies that when
+// calling the Plan API endpoint, the pre-workflow hooks receive a CommentCommand
+// with Name set to command.Plan (not the zero value which would be command.Apply).
+func TestAPIController_Plan_PreWorkflowHooksReceiveCorrectCommand(t *testing.T) {
+	ac, _, _ := setup(t)
+
+	// Get access to the pre-workflow hooks mock for verification
+	preWorkflowHooksRunner := ac.PreWorkflowHooksCommandRunner.(*MockPreWorkflowHooksCommandRunner)
+
+	body, _ := json.Marshal(controllers.APIRequest{
+		Repository: "Repo",
+		Ref:        "main",
+		Type:       "Gitlab",
+		Projects:   []string{"default"},
+	})
+
+	req, _ := http.NewRequest("POST", "", bytes.NewBuffer(body))
+	req.Header.Set(atlantisTokenHeader, atlantisToken)
+	w := httptest.NewRecorder()
+	ac.Plan(w, req)
+	ResponseContains(t, w, http.StatusOK, "")
+
+	// Capture the CommentCommand passed to RunPreHooks and verify Name is Plan
+	_, capturedCmd := preWorkflowHooksRunner.VerifyWasCalled(Times(1)).
+		RunPreHooks(Any[*command.Context](), Any[*events.CommentCommand]()).
+		GetCapturedArguments()
+
+	Assert(t, capturedCmd.Name == command.Plan,
+		"expected CommentCommand.Name to be Plan (%d), got %s (%d)",
+		command.Plan, capturedCmd.Name.String(), capturedCmd.Name)
+}
+
+// TestAPIController_Apply_PreWorkflowHooksReceiveCorrectCommand verifies that when
+// calling the Apply API endpoint, the pre-workflow hooks receive a CommentCommand
+// with Name set to command.Apply for the apply phase (and command.Plan for the
+// plan phase that runs first).
+func TestAPIController_Apply_PreWorkflowHooksReceiveCorrectCommand(t *testing.T) {
+	ac, _, _ := setup(t)
+
+	// Get access to the pre-workflow hooks mock for verification
+	preWorkflowHooksRunner := ac.PreWorkflowHooksCommandRunner.(*MockPreWorkflowHooksCommandRunner)
+
+	body, _ := json.Marshal(controllers.APIRequest{
+		Repository: "Repo",
+		Ref:        "main",
+		Type:       "Gitlab",
+		Projects:   []string{"default"},
+	})
+
+	req, _ := http.NewRequest("POST", "", bytes.NewBuffer(body))
+	req.Header.Set(atlantisTokenHeader, atlantisToken)
+	w := httptest.NewRecorder()
+	ac.Apply(w, req)
+	ResponseContains(t, w, http.StatusOK, "")
+
+	// Apply calls apiPlan first (which runs pre-hooks with Plan), then apiApply (which runs pre-hooks with Apply)
+	// So we expect 2 calls: first with Plan, second with Apply
+	_, capturedCmds := preWorkflowHooksRunner.VerifyWasCalled(Times(2)).
+		RunPreHooks(Any[*command.Context](), Any[*events.CommentCommand]()).
+		GetAllCapturedArguments()
+
+	Assert(t, len(capturedCmds) == 2,
+		"expected 2 pre-workflow hook calls, got %d", len(capturedCmds))
+
+	Assert(t, capturedCmds[0].Name == command.Plan,
+		"expected first CommentCommand.Name to be Plan (%d), got %s (%d)",
+		command.Plan, capturedCmds[0].Name.String(), capturedCmds[0].Name)
+
+	Assert(t, capturedCmds[1].Name == command.Apply,
+		"expected second CommentCommand.Name to be Apply (%d), got %s (%d)",
+		command.Apply, capturedCmds[1].Name.String(), capturedCmds[1].Name)
+}
+
 func TestAPIController_ListLocks(t *testing.T) {
 	ac, _, _ := setup(t)
 	time := time.Now()