Files
kandev/apps/backend/internal/task/handlers/task_http_lifecycle_test.go
T
Clément Fiere 01b0dedd6c fix: harden task archive lifecycle recovery (#3651)
Co-authored-by: Carlos Florencio <carlosmflorencio@gmail.com>
2026-09-14 16:34:25 +01:00

455 lines
16 KiB
Go

package handlers
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"testing"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
"github.com/kandev/kandev/internal/auth/authn"
"github.com/kandev/kandev/internal/task/dto"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/service"
)
// httpTaskRepo extends the WS fixture with the paging and counting surfaces
// the HTTP list/count routes need, recording the arguments they receive.
type httpTaskRepo struct {
wsTaskRepo
listedWorkspaceID string
listedPage int
listedPageSize int
listedSort string
listedArchived bool
listTotal int
workflowCount int
workflowCountErr error
stepCount int
stepCountErr error
countedWorkflowID string
countedStepID string
}
func (r *httpTaskRepo) ListTasksByWorkspace(
_ context.Context,
workspaceID, _, _, _ string,
page, pageSize int,
sort string,
includeArchived, _, _, _ bool,
) ([]*models.Task, int, error) {
r.listedWorkspaceID = workspaceID
r.listedPage = page
r.listedPageSize = pageSize
r.listedSort = sort
r.listedArchived = includeArchived
return []*models.Task{{ID: "task-b", WorkspaceID: "ws-b", Title: "Mine"}}, r.listTotal, nil
}
func (r *httpTaskRepo) CountTasksByWorkflow(_ context.Context, workflowID string) (int, error) {
r.countedWorkflowID = workflowID
return r.workflowCount, r.workflowCountErr
}
func (r *httpTaskRepo) CountTasksByWorkflowStep(_ context.Context, stepID string) (int, error) {
r.countedStepID = stepID
return r.stepCount, r.stepCountErr
}
func newHTTPTaskHandlers(t *testing.T, repo *httpTaskRepo) *TaskHandlers {
t.Helper()
log := newTestLogger(t)
svc := service.NewService(service.Repos{
Workspaces: repo, Tasks: repo, TaskRepos: repo,
Workflows: repo, Messages: repo, Turns: repo,
Sessions: repo, GitSnapshots: repo, RepoEntities: repo,
Executors: repo, Environments: repo, TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
return &TaskHandlers{service: svc, logger: log}
}
type httpArchiveOutcomeRepo struct {
mockRepository
task *models.Task
archived bool
failRead bool
sawCancelled bool
}
func (r *httpArchiveOutcomeRepo) GetTask(_ context.Context, _ string) (*models.Task, error) {
if r.archived && r.failRead {
return nil, errors.New("post-archive task read failed")
}
return r.task, nil
}
func (r *httpArchiveOutcomeRepo) ArchiveTask(_ context.Context, _ string) error {
r.archived = true
return nil
}
func (r *httpArchiveOutcomeRepo) ArchiveTaskIfActive(ctx context.Context, _ string, _ string) (bool, error) {
r.sawCancelled = ctx.Err() != nil
if r.archived {
return false, nil
}
r.archived = true
return true, nil
}
func (r *httpArchiveOutcomeRepo) ArchiveTaskIfActiveWithVacatedStep(
ctx context.Context,
id string,
cascadeID string,
) (string, bool, error) {
changed, err := r.ArchiveTaskIfActive(ctx, id, cascadeID)
return "", changed, err
}
// taskRequestAs builds a request for a task route carrying userID's identity.
// An empty userID leaves the context identity-free (an internal caller).
func taskRequestAs(t *testing.T, userID, method, target, id string) (*gin.Context, *httptest.ResponseRecorder) {
t.Helper()
c, rec := newWorkflowRequest(t, method, target, "")
if userID != "" {
c.Request = c.Request.WithContext(authn.WithIdentity(
c.Request.Context(), authn.Identity{UserID: userID, Role: authn.RoleMember}))
}
c.Params = gin.Params{{Key: "id", Value: id}}
return c, rec
}
func TestHTTPGetTaskDeniesForeignTask(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
c, rec := taskRequestAs(t, "user-a", http.MethodGet, "/api/v1/tasks/task-b", "task-b")
h.httpGetTask(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.JSONEq(t, `{"error":"task not found"}`, rec.Body.String())
require.NotContains(t, rec.Body.String(), "Victim")
ownerCtx, ownerRec := taskRequestAs(t, "user-b", http.MethodGet, "/api/v1/tasks/task-b", "task-b")
h.httpGetTask(ownerCtx)
require.Equal(t, http.StatusOK, ownerRec.Code)
require.Contains(t, ownerRec.Body.String(), "Victim", "the owner must still get their task")
}
func TestHTTPGetTaskReturnsNotFoundForUnknownTask(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/tasks/nope", "nope")
h.httpGetTask(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.JSONEq(t, `{"error":"task not found"}`, rec.Body.String())
}
func TestHTTPListTasksFiltersForeignWorkspaceRows(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflows/wf-b/tasks", "wf-b")
h.httpListTasks(c)
require.Equal(t, http.StatusOK, rec.Code)
var resp dto.ListTasksResponse
require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
require.Equal(t, 1, resp.Total, "the row from another workspace must be dropped")
require.Equal(t, "task-b", resp.Tasks[0].ID)
}
func TestHTTPListTasksReturnsNotFoundForUnknownWorkflow(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflows/nope/tasks", "nope")
h.httpListTasks(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.JSONEq(t, `{"error":"tasks not found"}`, rec.Body.String())
}
// TestHTTPListTasksByWorkspaceClampsPaging pins the query-parameter parsing.
// page must be a positive integer and page_size must land in [1, 100];
// anything else — non-positive, out of range, or unparseable — falls back to
// the default rather than to the nearest bound, so page_size=500 yields 50,
// not 100.
func TestHTTPListTasksByWorkspaceClampsPaging(t *testing.T) {
for name, tc := range map[string]struct {
query string
wantPage int
wantPageSize int
}{
"defaults": {query: "", wantPage: 1, wantPageSize: 50},
"explicit": {query: "?page=3&page_size=25", wantPage: 3, wantPageSize: 25},
"page zero": {query: "?page=0", wantPage: 1, wantPageSize: 50},
"page negative": {query: "?page=-2", wantPage: 1, wantPageSize: 50},
"page garbage": {query: "?page=abc", wantPage: 1, wantPageSize: 50},
"page size over cap": {query: "?page_size=500", wantPage: 1, wantPageSize: 50},
"page size at cap": {query: "?page_size=100", wantPage: 1, wantPageSize: 100},
"page size non int": {query: "?page_size=many", wantPage: 1, wantPageSize: 50},
"page size negative": {query: "?page_size=-1", wantPage: 1, wantPageSize: 50},
} {
t.Run(name, func(t *testing.T) {
repo := &httpTaskRepo{listTotal: 7}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "", http.MethodGet,
"/api/v1/workspaces/ws-b/tasks"+tc.query, "ws-b")
h.httpListTasksByWorkspace(c)
require.Equal(t, http.StatusOK, rec.Code)
require.Equal(t, "ws-b", repo.listedWorkspaceID)
require.Equal(t, tc.wantPage, repo.listedPage)
require.Equal(t, tc.wantPageSize, repo.listedPageSize)
var resp dto.ListTasksResponse
require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
require.Equal(t, 7, resp.Total, "Total is the repository's grand total, not the page length")
require.Len(t, resp.Tasks, 1)
})
}
}
func TestHTTPListTasksByWorkspacePassesThroughFilters(t *testing.T) {
repo := &httpTaskRepo{}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "", http.MethodGet,
"/api/v1/workspaces/ws-b/tasks?include_archived=true&sort=created_at", "ws-b")
h.httpListTasksByWorkspace(c)
require.Equal(t, http.StatusOK, rec.Code)
require.True(t, repo.listedArchived)
require.NotEmpty(t, repo.listedSort, "sort is normalized rather than dropped")
}
func TestHTTPListTasksByWorkspaceDeniesForeignWorkspace(t *testing.T) {
repo := &httpTaskRepo{}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "user-a", http.MethodGet, "/api/v1/workspaces/ws-b/tasks", "ws-b")
h.httpListTasksByWorkspace(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.Empty(t, repo.listedWorkspaceID, "a denied list must not reach the repository")
}
func TestHTTPGetWorkflowTaskCount(t *testing.T) {
repo := &httpTaskRepo{workflowCount: 4}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflows/wf-b/task-count", "wf-b")
h.httpGetWorkflowTaskCount(c)
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"task_count":4}`, rec.Body.String())
require.Equal(t, "wf-b", repo.countedWorkflowID)
}
func TestHTTPGetWorkflowTaskCountSurfacesFailure(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{workflowCountErr: errors.New("database unavailable")})
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflows/wf-b/task-count", "wf-b")
h.httpGetWorkflowTaskCount(c)
require.Equal(t, http.StatusInternalServerError, rec.Code)
require.JSONEq(t, `{"error":"failed to count tasks"}`, rec.Body.String())
}
func TestHTTPGetStepTaskCount(t *testing.T) {
repo := &httpTaskRepo{stepCount: 2}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflow-steps/step-1/task-count", "step-1")
h.httpGetStepTaskCount(c)
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"task_count":2}`, rec.Body.String())
require.Equal(t, "step-1", repo.countedStepID)
}
func TestHTTPGetStepTaskCountSurfacesFailure(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{stepCountErr: errors.New("database unavailable")})
c, rec := taskRequestAs(t, "", http.MethodGet, "/api/v1/workflow-steps/step-1/task-count", "step-1")
h.httpGetStepTaskCount(c)
require.Equal(t, http.StatusInternalServerError, rec.Code)
require.JSONEq(t, `{"error":"failed to count tasks"}`, rec.Body.String())
}
func TestHTTPArchiveTaskSurvivesCancelledRequestContext(t *testing.T) {
repo := &httpArchiveOutcomeRepo{task: &models.Task{ID: "task-1", WorkspaceID: "ws-1"}}
h := &TaskHandlers{
handoffSvc: service.NewHandoffService(repo, nil, nil, nil, nil, nil),
logger: newTestLogger(t),
}
c, rec := taskRequestAs(t, "", http.MethodDelete, "/api/v1/tasks/task-1", "task-1")
requestCtx, cancel := context.WithCancel(c.Request.Context())
cancel()
c.Request = c.Request.WithContext(requestCtx)
h.httpArchiveTask(c)
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"success":true}`, rec.Body.String())
require.True(t, repo.archived, "archive mutation must complete after request cancellation")
require.False(t, repo.sawCancelled, "archive must receive a detached context")
}
func TestHTTPArchiveFallbackReportsCommittedProjectionFailureAsPending(t *testing.T) {
repo := &httpArchiveOutcomeRepo{
task: &models.Task{ID: "task-1", WorkspaceID: "ws-1"},
failRead: true,
}
log := newTestLogger(t)
svc := service.NewService(service.Repos{
Workspaces: repo, Tasks: repo, TaskRepos: repo,
Workflows: repo, Messages: repo, Turns: repo,
Sessions: repo, GitSnapshots: repo, RepoEntities: repo,
Executors: repo, Environments: repo, TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := &TaskHandlers{service: svc, logger: log}
c, rec := taskRequestAs(t, "", http.MethodDelete, "/api/v1/tasks/task-1", "task-1")
h.httpArchiveTask(c)
require.Equal(t, http.StatusServiceUnavailable, rec.Code)
require.JSONEq(t, `{"pending":true,"success":false,"task_id":"task-1"}`, rec.Body.String())
require.True(t, repo.archived, "archive mutation must remain committed")
}
func TestHTTPArchiveTaskReportsAlreadyArchivedOutcome(t *testing.T) {
repo := &httpArchiveOutcomeRepo{
task: &models.Task{ID: "task-1", WorkspaceID: "ws-1"},
archived: true,
}
h := &TaskHandlers{
handoffSvc: service.NewHandoffService(repo, nil, nil, nil, nil, nil),
logger: newTestLogger(t),
}
c, rec := taskRequestAs(t, "", http.MethodDelete, "/api/v1/tasks/task-1", "task-1")
h.httpArchiveTask(c)
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"already_archived":true,"success":true}`, rec.Body.String())
}
// TestHTTPArchiveTaskDeniesForeignTask is the highest-value denial on this
// surface: archiving takes work away. The owner witness proves the 404 comes
// from scoping, and the write counter proves nothing was archived on the way
// out.
//
// The sibling delete route is deliberately not covered here: it derives its
// context from context.Background() rather than the request, which drops the
// caller identity before the service's check runs. That is reported separately
// rather than pinned here as if it were intended.
func TestHTTPArchiveTaskDeniesForeignTask(t *testing.T) {
repo := &httpTaskRepo{}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "user-a", http.MethodDelete, "/api/v1/tasks/task-b", "task-b")
h.httpArchiveTask(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.JSONEq(t, `{"error":"task not archived"}`, rec.Body.String())
require.Empty(t, repo.archived, "a denied request must not archive the task")
ownerCtx, ownerRec := taskRequestAs(t, "user-b", http.MethodDelete, "/api/v1/tasks/task-b", "task-b")
h.httpArchiveTask(ownerCtx)
require.Equal(t, http.StatusOK, ownerRec.Code,
"the owner must succeed — otherwise the 404 above proves nothing (body: %s)", ownerRec.Body.String())
require.Equal(t, []string{"task-b"}, repo.archived)
}
func TestHTTPDeleteTaskDeletesAndReportsMissingTasks(t *testing.T) {
repo := &httpTaskRepo{}
h := newHTTPTaskHandlers(t, repo)
c, rec := taskRequestAs(t, "", http.MethodDelete, "/api/v1/tasks/task-b", "task-b")
h.httpDeleteTask(c)
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"success":true}`, rec.Body.String())
require.Equal(t, []string{"task-b"}, repo.deleted)
missingCtx, missingRec := taskRequestAs(t, "", http.MethodDelete, "/api/v1/tasks/nope", "nope")
h.httpDeleteTask(missingCtx)
require.Equal(t, http.StatusNotFound, missingRec.Code)
require.JSONEq(t, `{"error":"task not deleted"}`, missingRec.Body.String())
require.Len(t, repo.deleted, 1, "a missing task must not add a delete")
}
func TestCascadeQueryParam(t *testing.T) {
for query, want := range map[string]bool{
"": false,
"?cascade=true": true,
"?cascade=TRUE": true,
"?cascade=True": true,
"?cascade=false": false,
"?cascade=1": false,
"?cascade=yes": false,
"?cascade": false,
} {
c, _ := newWorkflowRequest(t, http.MethodDelete, "/api/v1/tasks/task-b"+query, "")
require.Equalf(t, want, cascadeQueryParam(c), "cascade query %q", query)
}
}
func TestHTTPBulkMoveTasksRejectsInvalidRequests(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
for name, tc := range map[string]struct {
body string
wantBody string
}{
"malformed json": {
body: `{`,
wantBody: `{"error":"invalid payload"}`,
},
"missing target workflow": {
body: `{"source_workflow_id":"wf-b","target_step_id":"step-1"}`,
wantBody: `{"error":"target_workflow_id and target_step_id are required"}`,
},
"missing target step": {
body: `{"source_workflow_id":"wf-b","target_workflow_id":"wf-b"}`,
wantBody: `{"error":"target_workflow_id and target_step_id are required"}`,
},
"missing source without explicit ids": {
body: `{"target_workflow_id":"wf-b","target_step_id":"step-1"}`,
wantBody: `{"error":"source_workflow_id, target_workflow_id, and target_step_id are required"}`,
},
} {
t.Run(name, func(t *testing.T) {
c, rec := newWorkflowRequest(t, http.MethodPost, "/api/v1/tasks/bulk-move", tc.body)
h.httpBulkMoveTasks(c)
require.Equal(t, http.StatusBadRequest, rec.Code)
require.JSONEq(t, tc.wantBody, rec.Body.String())
})
}
}
// TestHTTPBulkMoveSelectedTasksWithEmptySelectionIsANoOp documents that an
// explicit but empty task list short-circuits instead of falling through to
// the whole-column move, which would move tasks nobody selected.
func TestHTTPBulkMoveSelectedTasksWithEmptySelectionIsANoOp(t *testing.T) {
h := newHTTPTaskHandlers(t, &httpTaskRepo{})
c, rec := newWorkflowRequest(t, http.MethodPost, "/api/v1/tasks/bulk-move", "")
h.httpBulkMoveSelectedTasks(c, httpBulkMoveTasksRequest{
TaskIDs: nil,
TargetWorkflowID: "wf-b",
TargetStepID: "step-1",
})
require.Equal(t, http.StatusOK, rec.Code)
require.JSONEq(t, `{"moved_count":0}`, rec.Body.String())
}