Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/chat/src/audit.server.test.ts
T

398 lines
14 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
import { CHAT_PERMISSIONS } from "./permissions.js";
const mocks = vi.hoisted(() => ({
runTransaction: vi.fn(),
publishAudit: vi.fn(),
publishWakeup: vi.fn(),
logActivity: vi.fn(),
tx: {
teamChat: { findMany: vi.fn(), findFirst: vi.fn(), updateMany: vi.fn() },
teamChatEvent: { findFirst: vi.fn(), create: vi.fn() },
teamChatMember: { findFirst: vi.fn(), updateMany: vi.fn() },
teamChatMessage: { findMany: vi.fn() },
fileEntityLink: { findMany: vi.fn() },
file: { findMany: vi.fn() },
$queryRaw: vi.fn(),
},
}));
vi.mock("./repository.server.js", () => ({
runChatRepositoryTransaction: (...args: unknown[]) => mocks.runTransaction(...args),
parseChatMessageCursor: (value: string | undefined) =>
value
? {
createdAt: new Date("2026-07-16T08:30:00.000Z"),
id: "message-cursor",
}
: null,
encodeChatMessageCursor: (_chatId: string, row: { id: string }) => `cursor-${row.id}`,
}));
vi.mock("@hivegrid/db/audit-events.server", () => ({
publishAuditEventViaOutbox: (...args: unknown[]) => mocks.publishAudit(...args),
}));
vi.mock("./realtime-wakeup.server.js", () => ({
publishChatPersistentRealtimeWakeup: (...args: unknown[]) => mocks.publishWakeup(...args),
}));
vi.mock("@hivegrid/activity", () => ({
logActivity: (...args: unknown[]) => mocks.logActivity(...args),
}));
import {
forceArchiveChatAuditChannel,
forceRemoveChatAuditMember,
forceSetChatAuditMemberRole,
getChatAuditAdministration,
getChatAuditAttachmentDownload,
getChatAuditChannelDetail,
listChatAuditChannels,
recordChatAuditSessionStarted,
} from "./audit.server.js";
const context = {
tenantId: "tenant-a",
userId: "admin-a",
permissions: [CHAT_PERMISSIONS.readAllChannels],
} as const;
const auditSession = {
sessionId: "audit-session-1",
reason: "Kundenreklamation prüfen",
expiresAtIso: "2026-07-16T10:15:00.000Z",
};
describe("AK-P15b chat admin audit repository", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.runTransaction.mockImplementation(
async (_context: unknown, _permission: string, operation: (tx: typeof mocks.tx, permissions: readonly string[]) => Promise<unknown>) =>
operation(mocks.tx, [CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.readAllChannels, CHAT_PERMISSIONS.admin])
);
mocks.tx.teamChat.findMany.mockResolvedValue([]);
mocks.tx.teamChat.findFirst.mockResolvedValue(channel());
mocks.tx.teamChatEvent.findFirst.mockResolvedValue({ sequence: 4n });
mocks.tx.teamChatMessage.findMany.mockResolvedValue([message()]);
mocks.tx.teamChat.updateMany.mockResolvedValue({ count: 1 });
mocks.tx.teamChatMember.findFirst.mockResolvedValue({
id: "membership-a",
roleInChat: "member",
joinedAt: new Date("2026-07-16T08:00:00.000Z"),
manualRoleInChat: "member",
isManualMember: true,
});
mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 });
mocks.tx.teamChatEvent.create.mockResolvedValue({ sequence: 5n, occurredAt: new Date("2026-07-16T09:05:00.000Z") });
mocks.tx.fileEntityLink.findMany.mockResolvedValue([]);
mocks.tx.file.findMany.mockResolvedValue([]);
mocks.tx.$queryRaw.mockResolvedValue([
{ chatId: "chat-a", userId: "member-a", displayName: "Anna Adler", avatarUrl: null },
{ chatId: "chat-a", userId: "member-b", displayName: "Ben Bauer", avatarUrl: null },
]);
});
it("lists all channels only through the fresh read-all gate and explicit tenant scope", async () => {
mocks.tx.teamChat.findMany.mockResolvedValue([channel()]);
const result = await listChatAuditChannels({
...context,
requestId: "list-request-1",
auditSession,
});
expect(mocks.runTransaction).toHaveBeenCalledWith(expect.objectContaining(context), CHAT_PERMISSIONS.readAllChannels, expect.any(Function));
expect(mocks.tx.teamChat.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: { tenantId: "tenant-a" },
select: expect.objectContaining({
_count: { select: { members: { where: { tenantId: "tenant-a", leftAt: null } } } },
}),
})
);
expect(result).toEqual([
expect.objectContaining({
id: "chat-a",
memberCount: 2,
participants: [
{ userId: "member-a", displayName: "Anna Adler", avatarUrl: null },
{ userId: "member-b", displayName: "Ben Bauer", avatarUrl: null },
],
}),
]);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({
action: "chat.audit.channel_listed",
requestId: "list-request-1",
metadata: expect.objectContaining({
auditSessionId: "audit-session-1",
reason: "Kundenreklamation prüfen",
channelCount: 1,
}),
})
);
});
it("writes an immutable audit event for every read-only channel opening", async () => {
const detail = await getChatAuditChannelDetail({
...context,
chatId: "chat-a",
requestId: "open-request-1",
auditSession,
});
expect(mocks.tx.teamChat.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: { tenantId: "tenant-a", id: "chat-a" } }));
expect(detail.channel.member.canWrite).toBe(false);
expect(detail.messages).toHaveLength(1);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({
tenantId: "tenant-a",
actorId: "admin-a",
action: "chat.audit.channel_opened",
targetId: "chat-a",
requestId: "open-request-1",
dataSensitivity: "confidential",
metadata: expect.objectContaining({
auditSessionId: "audit-session-1",
reason: "Kundenreklamation prüfen",
readOnly: true,
}),
})
);
});
it("resolves every attachment download through the reason-bound audit gate and logs the read", async () => {
mocks.tx.fileEntityLink.findMany.mockResolvedValue([{ entityId: "message-a", fileId: "file-a" }]);
mocks.tx.teamChatMessage.findMany.mockResolvedValue([{ id: "message-a" }]);
mocks.tx.file.findMany.mockResolvedValue([
{
id: "file-a",
displayName: "rechnung.pdf",
storageKey: "tenants/tenant-a/files/file-a",
previewStorageKey: null,
thumbnailStorageKey: null,
},
]);
const result = await getChatAuditAttachmentDownload({
...context,
chatId: "chat-a",
fileId: "file-a",
variant: "original",
requestId: "attachment-request-1",
auditSession,
});
expect(mocks.runTransaction).toHaveBeenCalledWith(expect.anything(), CHAT_PERMISSIONS.readAllChannels, expect.any(Function));
expect(mocks.tx.teamChatMessage.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: { tenantId: "tenant-a", id: { in: ["message-a"] }, chatId: "chat-a" },
})
);
expect(mocks.tx.file.findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: { tenantId: "tenant-a", id: "file-a", archivedAt: null, scanStatus: "clean" },
})
);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({
action: "chat.audit.attachment_opened",
targetType: "File",
targetId: "file-a",
requestId: "attachment-request-1",
metadata: expect.objectContaining({
auditSessionId: "audit-session-1",
reason: auditSession.reason,
chatId: "chat-a",
messageId: "message-a",
variant: "original",
}),
})
);
expect(result.storageKey).toBe("tenants/tenant-a/files/file-a");
});
it("rejects a missing attachment variant before recording a successful audit read", async () => {
mocks.tx.fileEntityLink.findMany.mockResolvedValue([{ entityId: "message-a", fileId: "file-a" }]);
mocks.tx.teamChatMessage.findMany.mockResolvedValue([{ id: "message-a" }]);
mocks.tx.file.findMany.mockResolvedValue([
{
id: "file-a",
displayName: "rechnung.pdf",
storageKey: "tenants/tenant-a/files/file-a",
previewStorageKey: null,
thumbnailStorageKey: null,
},
]);
await expect(
getChatAuditAttachmentDownload({
...context,
chatId: "chat-a",
fileId: "file-a",
variant: "preview",
requestId: "attachment-request-missing-preview",
auditSession,
})
).rejects.toMatchObject({ status: 404 });
expect(mocks.publishAudit).not.toHaveBeenCalled();
});
it("does not audit or expose an attachment that is not linked to the requested channel", async () => {
mocks.tx.fileEntityLink.findMany.mockResolvedValue([{ entityId: "other-message", fileId: "file-a" }]);
mocks.tx.teamChatMessage.findMany.mockResolvedValue([]);
await expect(
getChatAuditAttachmentDownload({
...context,
chatId: "chat-a",
fileId: "file-a",
variant: "original",
requestId: "attachment-request-2",
auditSession,
})
).rejects.toMatchObject({ status: 404 });
expect(mocks.tx.file.findMany).not.toHaveBeenCalled();
expect(mocks.publishAudit).not.toHaveBeenCalled();
});
it("logs each justified audit session before any channel is exposed", async () => {
await recordChatAuditSessionStarted({ ...context, requestId: "session-request-1", auditSession });
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({
action: "chat.audit.session_started",
targetType: "Tenant",
targetId: "tenant-a",
metadata: expect.objectContaining({ auditSessionId: "audit-session-1", reason: "Kundenreklamation prüfen" }),
})
);
});
it("loads force-admin capabilities through the read-all boundary", async () => {
const result = await getChatAuditAdministration({ ...context, chatId: "chat-a" });
expect(mocks.runTransaction).toHaveBeenCalledWith(expect.anything(), CHAT_PERMISSIONS.readAllChannels, expect.any(Function));
expect(result).toMatchObject({
channel: { id: "chat-a", kind: "dm" },
canAdminister: true,
members: [
{ userId: "member-a", displayName: "Anna Adler", roleInChat: "admin" },
{ userId: "member-b", displayName: "Ben Bauer", roleInChat: "member" },
],
});
});
it("force-updates a member role only through both fresh admin permissions and logs the reason", async () => {
await forceSetChatAuditMemberRole({
...context,
permissions: [CHAT_PERMISSIONS.readAllChannels, CHAT_PERMISSIONS.admin],
chatId: "chat-a",
memberUserId: "member-a",
roleInChat: "admin",
requestId: "role-request-1",
auditSession,
});
expect(mocks.runTransaction).toHaveBeenCalledWith(expect.anything(), CHAT_PERMISSIONS.admin, expect.any(Function));
expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith(
expect.objectContaining({
where: expect.objectContaining({ tenantId: "tenant-a", chatId: "chat-a", id: "membership-a" }),
data: expect.objectContaining({ roleInChat: "admin", isManualMember: true, manualRoleInChat: "admin" }),
})
);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({
action: "chat.audit.member_role_forced",
requestId: "role-request-1",
metadata: expect.objectContaining({ reason: auditSession.reason, memberUserId: "member-a", roleInChat: "admin" }),
})
);
expect(mocks.publishWakeup).toHaveBeenCalledOnce();
expect(mocks.logActivity).toHaveBeenCalledOnce();
});
it("force-removes a member and audits the destructive action", async () => {
await forceRemoveChatAuditMember({
...context,
permissions: [CHAT_PERMISSIONS.readAllChannels, CHAT_PERMISSIONS.admin],
chatId: "chat-a",
memberUserId: "member-a",
requestId: "remove-request-1",
auditSession,
});
expect(mocks.tx.teamChatMember.updateMany).toHaveBeenCalledWith(
expect.objectContaining({
data: expect.objectContaining({ leftAt: expect.any(Date), isManualMember: false, isProjectManaged: false, isGroupManaged: false }),
})
);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({ action: "chat.audit.member_removed", metadata: expect.objectContaining({ reason: auditSession.reason }) })
);
});
it("archives any tenant channel as an audited cleanup action", async () => {
await forceArchiveChatAuditChannel({
...context,
permissions: [CHAT_PERMISSIONS.readAllChannels, CHAT_PERMISSIONS.admin],
chatId: "chat-a",
requestId: "archive-request-1",
auditSession,
});
expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith(
expect.objectContaining({ where: { tenantId: "tenant-a", id: "chat-a", archivedAt: null }, data: expect.objectContaining({ archivedReason: "manual" }) })
);
expect(mocks.publishAudit).toHaveBeenCalledWith(
mocks.tx,
expect.objectContaining({ action: "chat.audit.channel_archived", metadata: expect.objectContaining({ reason: auditSession.reason }) })
);
});
});
function channel() {
return {
id: "chat-a",
kind: "dm",
name: null,
description: null,
projektId: null,
isPrivate: true,
archivedAt: null,
lastMessageAt: new Date("2026-07-16T09:00:00.000Z"),
eventStreamId: "stream-a",
members: [
{ userId: "member-a", roleInChat: "admin" },
{ userId: "member-b", roleInChat: "member" },
],
_count: { members: 2 },
};
}
function message() {
const timestamp = new Date("2026-07-16T09:00:00.000Z");
return {
id: "message-a",
createdAt: timestamp,
updatedAt: timestamp,
tenantId: "tenant-a",
chatId: "chat-a",
authorUserId: "member-a",
clientMessageId: "client-a",
body: "Vertrauliche Nachricht",
bodyFormat: "markdown",
parentMessageId: null,
mentions: [],
linkPreviews: [],
editedAt: null,
deletedAt: null,
systemEventKind: null,
systemEventMetadata: null,
};
}