398 lines
14 KiB
TypeScript
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,
|
|
};
|
|
}
|