import { CHAT_PERMISSIONS } from "@hivegrid/chat"; import { CatalogError } from "@hivegrid/foundation"; import { beforeEach, describe, expect, it, vi } from "vitest"; import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus"; const mocks = vi.hoisted(() => ({ requireAuth: vi.fn(), getTenantIdFromUrl: vi.fn(), getUserInfo: vi.fn(), tenantHasModule: vi.fn(), getPermissionsByUser: vi.fn(), membership: { id: "tenant-user-1" } as { id: string } | null, tx: { tenantUser: { findFirst: vi.fn(), }, }, })); vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: (...args: unknown[]) => mocks.requireAuth(...args) })); vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: (...args: unknown[]) => mocks.getTenantIdFromUrl(...args) })); vi.mock("~/utils/session.server", () => ({ getUserInfo: (...args: unknown[]) => mocks.getUserInfo(...args) })); vi.mock("~/utils/connector/tenantConnector.server", () => ({ tenantHasModule: (...args: unknown[]) => mocks.tenantHasModule(...args) })); vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({ getPermissionsByUser: (...args: unknown[]) => mocks.getPermissionsByUser(...args) })); vi.mock("~/utils/db/.server/tenantRls.server", () => ({ withTenantRLS: (_tenantId: string, callback: (tx: typeof mocks.tx) => Promise) => callback(mocks.tx), })); import { chatHasPermission, loadChatContext, requireChatChannelAdminAccess, requireChatChannelReadAccess, requireChatChannelWriteAccess, requireChatPermission, type ChatChannelAccessSnapshot, type ChatRouteContext, } from "./chatAccess.server"; const activeMember: ChatChannelAccessSnapshot = { isActiveMember: true, isChannelAdmin: false, isArchived: false, }; function context(permissions: readonly string[]): ChatRouteContext { return { tenantId: "tenant-1", userId: "user-1", tenantUserId: "tenant-user-1", permissions, hasModule: true, }; } describe("chat access", () => { beforeEach(() => { vi.clearAllMocks(); mocks.requireAuth.mockResolvedValue(undefined); mocks.getTenantIdFromUrl.mockResolvedValue("tenant-1"); mocks.getUserInfo.mockResolvedValue({ userId: "user-1" }); mocks.tenantHasModule.mockResolvedValue(true); mocks.getPermissionsByUser.mockResolvedValue([CHAT_PERMISSIONS.readOwnChannels]); mocks.tx.tenantUser.findFirst.mockImplementation(async () => mocks.membership); mocks.membership = { id: "tenant-user-1" }; }); it("loads an authenticated, tenant-scoped module context", async () => { const request = new Request("http://app.localhost/acme/chat"); await expect(loadChatContext({ request, params: { tenant: "acme" } })).resolves.toEqual({ tenantId: "tenant-1", userId: "user-1", tenantUserId: "tenant-user-1", permissions: [CHAT_PERMISSIONS.readOwnChannels], hasModule: true, }); expect(mocks.tenantHasModule).toHaveBeenCalledWith({ tenantId: "tenant-1", userId: "user-1", moduleKey: "chat" }); expect(mocks.tx.tenantUser.findFirst).toHaveBeenCalledWith({ where: { tenantId: "tenant-1", userId: "user-1", status: TenantUserStatus.ACTIVE, user: { active: true }, tenant: { active: true }, }, select: { id: true }, }); }); it("fails closed when the chat module is disabled", async () => { mocks.tenantHasModule.mockResolvedValue(false); const request = new Request("http://app.localhost/acme/chat"); await expect(loadChatContext({ request, params: { tenant: "acme" } })).rejects.toBeInstanceOf(CatalogError); }); it("rejects a session without an active tenant membership", async () => { mocks.membership = null; await expect(loadChatContext({ request: new Request("http://app.localhost/acme/chat"), params: { tenant: "acme" } })).rejects.toBeInstanceOf(CatalogError); }); it("requires exact permissions without making chat.admin an audit capability", () => { const admin = context([CHAT_PERMISSIONS.admin]); expect(chatHasPermission(admin, CHAT_PERMISSIONS.admin)).toBe(true); expect(chatHasPermission(admin, CHAT_PERMISSIONS.readAllChannels)).toBe(false); expect(() => requireChatPermission(admin, CHAT_PERMISSIONS.readAllChannels)).toThrow(CatalogError); }); it("allows active members to read and keeps audit reads behind the dedicated audit-session service", () => { expect(requireChatChannelReadAccess(context([CHAT_PERMISSIONS.readOwnChannels]), activeMember)).toBe("member"); const outsider = { ...activeMember, isActiveMember: false }; expect(() => requireChatChannelReadAccess(context([CHAT_PERMISSIONS.readAllChannels]), outsider)).toThrow(CatalogError); expect(() => requireChatChannelReadAccess(context([CHAT_PERMISSIONS.admin]), outsider)).toThrow(CatalogError); }); it("never lets audit mode or archived membership write", () => { const auditOnly = context([CHAT_PERMISSIONS.readAllChannels]); expect(() => requireChatChannelWriteAccess(auditOnly, { ...activeMember, isActiveMember: false })).toThrow(CatalogError); expect(() => requireChatChannelWriteAccess(context([CHAT_PERMISSIONS.write]), { ...activeMember, isArchived: true })).toThrow(CatalogError); expect(requireChatChannelWriteAccess(context([CHAT_PERMISSIONS.write]), activeMember)).toMatchObject({ userId: "user-1" }); }); it("allows channel admins only as members while global chat admins override membership", () => { expect(requireChatChannelAdminAccess(context([CHAT_PERMISSIONS.readOwnChannels]), { ...activeMember, isChannelAdmin: true })).toMatchObject({ userId: "user-1", }); expect(requireChatChannelAdminAccess(context([CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.admin]), activeMember)).toMatchObject({ userId: "user-1", }); expect( requireChatChannelAdminAccess(context([CHAT_PERMISSIONS.admin]), { ...activeMember, isActiveMember: false, }) ).toMatchObject({ userId: "user-1" }); expect(() => requireChatChannelAdminAccess(context([CHAT_PERMISSIONS.readOwnChannels]), activeMember)).toThrow(CatalogError); }); });