Files
kandev/apps/backend/internal/task/service/service_team_access_test.go
T
João Salavisa 481359ddb2 feat(auth): organization units, tenancy, roles and scopes for team access (#2919)
Co-authored-by: Kandev Agent <agent@kandev.dev>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-05 13:40:43 +00:00

351 lines
14 KiB
Go

package service
import (
"context"
"errors"
"testing"
"github.com/kandev/kandev/internal/auth/authn"
"github.com/kandev/kandev/internal/authz"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
// End-to-end team access through the real service and repository. The authz
// package proves the resolver's table; this proves the wiring actually reaches
// it — a correct resolver that nobody calls protects nothing.
func ctxAsRole(userID string, role authn.Role) context.Context {
return authn.WithIdentity(context.Background(), authn.Identity{UserID: userID, Role: role})
}
type teamAccessRepo interface {
CreateWorkspace(context.Context, *models.Workspace) error
CreateWorkflow(context.Context, *models.Workflow) error
CreateTask(context.Context, *models.Task) error
UpsertWorkspaceMember(context.Context, *models.WorkspaceMember) error
}
// seedTeamWorkspace builds the shape a team actually has: a unit that holds
// the board, with the colleague a member of it. `shared` decides whether the
// board sits in that unit or in its owner's personal one, which is the whole
// of the private-versus-shared distinction now.
func seedTeamWorkspace(t *testing.T, repo teamAccessRepo, shared bool) {
t.Helper()
ctx := context.Background()
units := testUnits[t.Name()]
if units == nil {
t.Fatal("no unit service for this test")
}
root, err := units.EnsureRoot(ctx, "", "Test org")
if err != nil {
t.Fatalf("ensure root: %v", err)
}
personal, err := units.EnsurePersonal(ctx, "", "user-ana", "Ana")
if err != nil {
t.Fatalf("ensure personal unit: %v", err)
}
team, err := units.Create(ctx, root.ID, "Platform")
if err != nil {
t.Fatalf("create team unit: %v", err)
}
unitID := personal.ID
if shared {
unitID = team.ID
if err := units.SetMember(ctx, team.ID, "user-bruno", "collaborator", "user-ana"); err != nil {
t.Fatalf("add unit member: %v", err)
}
}
if err := repo.CreateWorkspace(ctx, &models.Workspace{
ID: "ws-team", Name: "Team", OwnerID: "user-ana", UnitID: unitID,
}); err != nil {
t.Fatalf("create workspace: %v", err)
}
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-team", WorkspaceID: "ws-team", Name: "Board"}); err != nil {
t.Fatalf("create workflow: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-team", WorkspaceID: "ws-team", WorkflowID: "wf-team", WorkflowStepID: "step-1",
Title: "Ana's task", State: v1.TaskStateCreated, Priority: "medium",
}); err != nil {
t.Fatalf("create task: %v", err)
}
}
// The golden path: a colleague reaches the board through the unit they are
// in, with no invitation and no per-workspace row.
func TestUnitMemberReachesWorkspaceWithoutInvitation(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
if _, err := svc.GetWorkspace(ctxAsRole("user-bruno", authn.RoleMember), "ws-team"); err != nil {
t.Fatalf("a workspace in a unit the member belongs to must be reachable: %v", err)
}
if _, err := svc.GetTask(ctxAsRole("user-bruno", authn.RoleMember), "task-team"); err != nil {
t.Fatalf("a task on that board must be readable by the same member: %v", err)
}
}
// The privacy case the current design is built around must not regress.
func TestPrivateWorkspaceStaysPrivate(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, false)
bruno := ctxAsRole("user-bruno", authn.RoleMember)
if _, err := svc.GetWorkspace(bruno, "ws-team"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("private workspace leaked to a non-member: %v", err)
}
if _, err := svc.GetTask(bruno, "task-team"); !errors.Is(err, repoerrors.ErrTaskNotFound) {
t.Fatalf("private task leaked to a non-member: %v", err)
}
// An admin is a management role, not a visibility role.
admin := ctxAsRole("user-carla", authn.RoleAdmin)
if _, err := svc.GetWorkspace(admin, "ws-team"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("admin reached a private workspace they are not in: %v", err)
}
}
// A guest is deliberately excluded from org-visible workspaces.
func TestGuestExcludedFromOrgVisibleWorkspace(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
guest := ctxAsRole("user-contractor", authn.RoleGuest)
if _, err := svc.GetWorkspace(guest, "ws-team"); !errors.Is(err, repoerrors.ErrWorkspaceNotFound) {
t.Fatalf("guest reached an org-visible workspace: %v", err)
}
// ...until they hold an explicit row.
if err := repo.UpsertWorkspaceMember(context.Background(), &models.WorkspaceMember{
WorkspaceID: "ws-team", UserID: "user-contractor", Role: string(authz.WorkspaceRoleCollaborator),
}); err != nil {
t.Fatalf("add member: %v", err)
}
if _, err := svc.GetWorkspace(guest, "ws-team"); err != nil {
t.Fatalf("guest with a membership row must reach the workspace: %v", err)
}
}
// A direct grant raises a role; it cannot lower one. Narrowing is done by
// placing a workspace in a unit with fewer members, which is what lets the
// combining rule stay "the strongest wins" with no deny concept to reason
// about. This test pins the direction, because the model it replaced narrowed
// in both.
func TestDirectGrantCannotLowerAnInheritedRole(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
if err := repo.UpsertWorkspaceMember(context.Background(), &models.WorkspaceMember{
WorkspaceID: "ws-team", UserID: "user-bruno", Role: string(authz.WorkspaceRoleViewer),
}); err != nil {
t.Fatalf("add viewer grant: %v", err)
}
bruno := ctxAsRole("user-bruno", authn.RoleMember)
if _, err := svc.GetTask(bruno, "task-team"); err != nil {
t.Fatalf("reading must still work: %v", err)
}
title := "renamed by a colleague"
if _, err := svc.UpdateTask(bruno, "task-team", &UpdateTaskRequest{Title: &title}); err != nil {
t.Fatalf("a viewer grant lowered the collaborator role the unit gives: %v", err)
}
}
// A viewer on the unit is a viewer everywhere beneath it: reading is allowed
// and writing is 403 rather than 404, because existence is already known.
func TestUnitViewerCanReadButNotWrite(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
seedUnitViewer(t, "user-carla")
viewer := ctxAsRole("user-carla", authn.RoleMember)
if _, err := svc.GetTask(viewer, "task-team"); err != nil {
t.Fatalf("viewer must read: %v", err)
}
title := "hijacked"
if _, err := svc.UpdateTask(viewer, "task-team", &UpdateTaskRequest{Title: &title}); !IsForbidden(err) {
t.Fatalf("viewer task write = %v, want ErrForbidden", err)
}
}
// seedUnitViewer adds a viewer member to the seeded team unit.
func seedUnitViewer(t *testing.T, userID string) {
t.Helper()
ctx := context.Background()
units := testUnits[t.Name()]
root, err := units.EnsureRoot(ctx, "", "Test org")
if err != nil {
t.Fatalf("ensure root: %v", err)
}
all, err := units.Store().ListByOrg(ctx, "")
if err != nil {
t.Fatalf("list units: %v", err)
}
for _, u := range all {
if u.ParentID == root.ID && u.Name == "Platform" {
if err := units.SetMember(ctx, u.ID, userID, "viewer", "user-ana"); err != nil {
t.Fatalf("add viewer member: %v", err)
}
return
}
}
t.Fatal("seed did not create the team unit")
}
// A collaborator contributes; it does not administer.
func TestCollaboratorCannotManageWorkspace(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
bruno := ctxAsRole("user-bruno", authn.RoleMember)
title := "renamed by a collaborator"
if _, err := svc.UpdateWorkspace(bruno, "ws-team", &UpdateWorkspaceRequest{Name: &title}); !IsForbidden(err) {
t.Fatalf("collaborator workspace rename = %v, want ErrForbidden", err)
}
if _, err := svc.UpsertWorkspaceMember(bruno, "ws-team", "user-carla", string(authz.WorkspaceRoleCollaborator)); !IsForbidden(err) {
t.Fatalf("collaborator member add = %v, want ErrForbidden", err)
}
// A collaborator CAN do the work: writing a task is the whole point.
if _, err := svc.UpdateTask(bruno, "task-team", &UpdateTaskRequest{Title: &title}); err != nil {
t.Fatalf("collaborator must be able to write a task: %v", err)
}
}
// The owner keeps full control, and the DTO projection agrees with the resolver.
func TestOwnerScopesProjectIntoAccessProjection(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
workspace, err := svc.GetWorkspace(ctxAsRole("user-ana", authn.RoleMember), "ws-team")
if err != nil {
t.Fatalf("owner get: %v", err)
}
projection := svc.ProjectWorkspaceAccess(ctxAsRole("user-ana", authn.RoleMember), []*models.Workspace{workspace})
decision := projection.Decision("ws-team")
if decision.Role != authz.WorkspaceRoleOwner {
t.Fatalf("owner viewer_role = %q", decision.Role)
}
for _, scope := range []authz.Scope{authz.ScopeWorkspaceManage, authz.ScopeMemberManage, authz.ScopeSessionExec} {
if !decision.Has(scope) {
t.Errorf("owner projection missing %q", scope)
}
}
brunoProjection := svc.ProjectWorkspaceAccess(ctxAsRole("user-bruno", authn.RoleMember), []*models.Workspace{workspace})
if got := brunoProjection.Decision("ws-team"); got.Role != authz.WorkspaceRoleCollaborator {
t.Fatalf("member viewer_role = %q, want collaborator", got.Role)
}
}
// Membership management rejects each bad input with its own reason.
func TestMemberManagementValidation(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, false)
ana := ctxAsRole("user-ana", authn.RoleMember)
if _, err := svc.UpsertWorkspaceMember(ana, "ws-team", "user-bruno", "owner"); !errors.Is(err, ErrMemberRoleInvalid) {
t.Fatalf("assigning owner = %v, want ErrMemberRoleInvalid", err)
}
if _, err := svc.UpsertWorkspaceMember(ana, "ws-team", "user-ana", "collaborator"); !errors.Is(err, ErrMemberSelf) {
t.Fatalf("adding the owner = %v, want ErrMemberSelf", err)
}
if err := svc.RemoveWorkspaceMember(ana, "ws-team", "user-ana"); !errors.Is(err, ErrMemberIsOwner) {
t.Fatalf("removing the owner = %v, want ErrMemberIsOwner", err)
}
if err := svc.TransferWorkspaceOwnership(ana, "ws-team", "user-nobody"); !errors.Is(err, ErrTransferTargetNotMember) {
t.Fatalf("transfer to a non-member = %v, want ErrTransferTargetNotMember", err)
}
}
// Ownership transfer must leave owner_id and the owner row in agreement.
func TestTransferOwnershipKeepsOwnerRowConsistent(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, false)
ana := ctxAsRole("user-ana", authn.RoleMember)
if _, err := svc.UpsertWorkspaceMember(ana, "ws-team", "user-bruno", "collaborator"); err != nil {
t.Fatalf("add member: %v", err)
}
if err := svc.TransferWorkspaceOwnership(ana, "ws-team", "user-bruno"); err != nil {
t.Fatalf("transfer: %v", err)
}
workspace, err := svc.GetWorkspace(context.Background(), "ws-team")
if err != nil {
t.Fatalf("get workspace: %v", err)
}
if workspace.OwnerID != "user-bruno" {
t.Fatalf("owner_id = %q, want user-bruno", workspace.OwnerID)
}
member, err := repo.GetWorkspaceMember(context.Background(), "ws-team", "user-bruno")
if err != nil || member == nil {
t.Fatalf("owner membership row missing: %v", err)
}
if member.Role != string(authz.WorkspaceRoleOwner) {
t.Fatalf("new owner row role = %q, want owner", member.Role)
}
// The previous owner is demoted, not removed.
previous, err := repo.GetWorkspaceMember(context.Background(), "ws-team", "user-ana")
if err != nil || previous == nil {
t.Fatalf("previous owner row missing: %v", err)
}
if previous.Role != string(authz.WorkspaceRoleCollaborator) {
t.Fatalf("previous owner role = %q, want collaborator", previous.Role)
}
}
// Attribution comes from the authenticated caller, never the payload.
func TestMessageAuthorIsServerStamped(t *testing.T) {
svc, _, _ := createTestService(t)
stamped := svc.resolveAuthorID(ctxAsRole("user-bruno", authn.RoleMember), models.MessageAuthorUser, "user-ana")
if stamped != "user-bruno" {
t.Fatalf("author = %q, want the authenticated caller user-bruno", stamped)
}
// Agent messages name an execution, not a person, and keep their value.
agent := svc.resolveAuthorID(ctxAsRole("user-bruno", authn.RoleMember), models.MessageAuthorAgent, "exec-123")
if agent != "exec-123" {
t.Fatalf("agent author = %q, want exec-123", agent)
}
// Internal/auth-disabled callers keep today's behavior.
internal := svc.resolveAuthorID(context.Background(), models.MessageAuthorUser, "whatever")
if internal != "whatever" {
t.Fatalf("internal author = %q, want whatever", internal)
}
}
// A viewer may read a task but must not move it, edit its metadata, or change
// a repository's base branch. These are the mutators that stayed on the
// reach-only helper until review caught them.
func TestViewerCannotReachWriteOnlyMutators(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, true)
// A viewer now comes from the tree: a direct grant could only raise the
// collaborator role the unit already gives user-bruno.
seedUnitViewer(t, "user-carla")
viewer := ctxAsRole("user-carla", authn.RoleMember)
if _, err := svc.UpdateTaskMetadata(viewer, "task-team", map[string]interface{}{"x": 1}); !IsForbidden(err) {
t.Errorf("viewer UpdateTaskMetadata = %v, want ErrForbidden", err)
}
if _, err := svc.GetTask(viewer, "task-team"); err != nil {
t.Errorf("viewer must still read the task: %v", err)
}
}
// A lookup failure must never read as "granted".
func TestAuthorizationFailsClosedOnLookupError(t *testing.T) {
svc, _, repo := createTestService(t)
seedTeamWorkspace(t, repo, false)
// A task pointing at a workspace row that does not exist is a dangling
// reference and stays readable; that is the documented exception.
if err := repo.CreateTask(context.Background(), &models.Task{
ID: "task-dangling", WorkspaceID: "ws-missing", WorkflowID: "wf-team",
WorkflowStepID: "step-1", Title: "Dangling", State: v1.TaskStateCreated, Priority: "medium",
}); err != nil {
t.Fatalf("create task: %v", err)
}
if _, err := svc.GetTask(ctxAsRole("user-bruno", authn.RoleMember), "task-dangling"); err != nil {
t.Errorf("a dangling workspace reference should not hide the task: %v", err)
}
}