Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/chat.$id.action.test.ts
T

180 lines
7.4 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
loadChatContext: vi.fn(),
loadMemberChatChannel: vi.fn(),
validateCSRFToken: vi.fn(),
sendMemberChatMessage: vi.fn(),
loadTasksContext: vi.fn(),
requireTasksPermission: vi.fn(),
markChatMessageAsTask: vi.fn(),
editMemberChatMessage: vi.fn(),
removeMemberChatMessage: vi.fn(),
getTranslations: vi.fn(),
}));
vi.mock("~/modules/chat/routes/chatAccess.server", () => ({ loadChatContext: mocks.loadChatContext }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: mocks.validateCSRFToken }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: mocks.getTranslations }));
vi.mock("~/modules/chat/services/ChatService.server", () => ({
loadMemberChatChannel: mocks.loadMemberChatChannel,
sendMemberChatMessage: mocks.sendMemberChatMessage,
}));
vi.mock("~/modules/chat/services/ChatMessageFeaturesService.server", () => ({
changeChatMessagePin: vi.fn(),
changeChatReaction: vi.fn(),
}));
vi.mock("~/modules/chat/services/ChatMessageTaskService.server", () => ({ markChatMessageAsTask: mocks.markChatMessageAsTask }));
vi.mock("~/modules/chat/services/ChatMessageMutationsService.server", () => ({
editMemberChatMessage: mocks.editMemberChatMessage,
removeMemberChatMessage: mocks.removeMemberChatMessage,
}));
vi.mock("~/utils/integrations/taskAccess.server", () => ({
loadTasksContext: mocks.loadTasksContext,
requireTasksPermission: mocks.requireTasksPermission,
}));
import { action, loader, parseAttachmentFileIds } from "./chat.$id";
describe("chat channel attachment and task actions", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.loadChatContext.mockResolvedValue({
tenantId: "tenant_1",
userId: "user_current",
tenantUserId: "tenant_user_1",
permissions: ["chat.read_own_channels", "chat.write", "tasks.write"],
hasModule: true,
});
mocks.validateCSRFToken.mockResolvedValue(undefined);
mocks.getTranslations.mockResolvedValue({ t: (key: string) => key });
mocks.loadMemberChatChannel.mockResolvedValue({
vm: { status: "empty", data: null, error: null },
eventCursor: "stream_1:1",
authors: [],
});
mocks.loadTasksContext.mockResolvedValue({
tenantId: "tenant_1",
userId: "user_current",
permissions: ["tasks.write"],
hasModule: true,
});
mocks.requireTasksPermission.mockImplementation((context) => context);
});
it("sends an attachment-only message through the member and CSRF boundaries", async () => {
mocks.sendMemberChatMessage.mockResolvedValue({ message: { id: "message_attachment" }, replayed: false });
const response = await actionRequest([
["intent", "send_attachment_message"],
["requestId", "request_attachment"],
["clientMessageId", "client_attachment"],
["body", ""],
["attachmentFileIds", JSON.stringify(["file_1"])],
]);
expect(response.status).toBe(200);
expect(mocks.validateCSRFToken).toHaveBeenCalled();
expect(mocks.sendMemberChatMessage).toHaveBeenCalledWith(
expect.objectContaining({
chatId: "chat_1",
requestId: "request_attachment",
clientMessageId: "client_attachment",
body: "",
attachmentFileIds: ["file_1"],
})
);
await expect(response.json()).resolves.toMatchObject({ ok: true, intent: "send_attachment_message", messageId: "message_attachment" });
});
it("creates a task idempotently from a visible chat message", async () => {
mocks.markChatMessageAsTask.mockResolvedValue({ taskId: "task_1", replayed: false });
const response = await actionRequest([
["intent", "mark_task"],
["requestId", "request_task"],
["messageId", "message_1"],
]);
expect(mocks.requireTasksPermission).toHaveBeenCalledWith(expect.objectContaining({ tenantId: "tenant_1" }), "tasks.write");
expect(mocks.markChatMessageAsTask).toHaveBeenCalledWith(
expect.objectContaining({ chatId: "chat_1", messageId: "message_1", fallbackTitle: "chat.task.fallbackTitle" })
);
await expect(response.json()).resolves.toMatchObject({ ok: true, intent: "mark_task", taskId: "task_1", replayed: false });
});
it("rejects duplicate and oversized attachment payloads before the repository", async () => {
expect(parseAttachmentFileIds(JSON.stringify(["file_1", "file_1"]))).toBeNull();
expect(parseAttachmentFileIds(JSON.stringify(Array.from({ length: 21 }, (_, index) => `file_${index}`)))).toBeNull();
});
it("edits a message through the member mutation service", async () => {
mocks.editMemberChatMessage.mockResolvedValue({ message: { id: "message_1" }, replayed: false });
const response = await actionRequest([
["intent", "edit_message"],
["requestId", "request_edit"],
["messageId", "message_1"],
["body", "Aktualisiert"],
]);
expect(mocks.editMemberChatMessage).toHaveBeenCalledWith(
expect.objectContaining({ chatId: "chat_1", requestId: "request_edit", messageId: "message_1", body: "Aktualisiert" })
);
await expect(response.json()).resolves.toMatchObject({ ok: true, intent: "edit_message", messageId: "message_1", replayed: false });
});
it("deletes a message through the member mutation service", async () => {
mocks.removeMemberChatMessage.mockResolvedValue({ messageId: "message_1", replayed: false });
const response = await actionRequest([
["intent", "delete_message"],
["requestId", "request_delete"],
["messageId", "message_1"],
]);
expect(mocks.removeMemberChatMessage).toHaveBeenCalledWith(
expect.objectContaining({ chatId: "chat_1", requestId: "request_delete", messageId: "message_1" })
);
await expect(response.json()).resolves.toMatchObject({ ok: true, intent: "delete_message", messageId: "message_1", replayed: false });
});
it("passes a top-level message deep-link target into the member-scoped loader", async () => {
await loader({
request: new Request("http://app.localhost/demo/chat/chat_1?message=message_old#message-message_old"),
params: { tenant: "demo", id: "chat_1" },
context: {},
});
expect(mocks.loadMemberChatChannel).toHaveBeenCalledWith(
expect.objectContaining({ tenantSlug: "demo", chatId: "chat_1", focusMessageId: "message_old" })
);
});
it("uses explicit history pagination instead of a simultaneous focus target", async () => {
await loader({
request: new Request("http://app.localhost/demo/chat/chat_1?before=opaque_cursor&message=message_old"),
params: { tenant: "demo", id: "chat_1" },
context: {},
});
expect(mocks.loadMemberChatChannel).toHaveBeenCalledWith(
expect.objectContaining({ tenantSlug: "demo", chatId: "chat_1", beforeMessageCursor: "opaque_cursor" })
);
expect(mocks.loadMemberChatChannel).not.toHaveBeenCalledWith(expect.objectContaining({ focusMessageId: expect.anything() }));
});
});
async function actionRequest(entries: readonly (readonly [string, string])[]): Promise<Response> {
const formData = new URLSearchParams();
formData.set("csrf", "csrf");
for (const [key, value] of entries) formData.set(key, value);
return action({
request: new Request("http://app.localhost/demo/chat/chat_1", {
method: "POST",
headers: { "content-type": "application/x-www-form-urlencoded" },
body: formData,
}),
params: { tenant: "demo", id: "chat_1" },
context: {},
});
}