Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,140 @@
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);
});
});