141 lines
6.0 KiB
TypeScript
141 lines
6.0 KiB
TypeScript
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<unknown>) => 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);
|
|
});
|
|
});
|