180 lines
7.4 KiB
TypeScript
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: {},
|
|
});
|
|
}
|