Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
+445
@@ -0,0 +1,445 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
getMemberChannelDetail: vi.fn(),
|
||||
runChatRepositoryTransaction: vi.fn(),
|
||||
publishWakeup: vi.fn(),
|
||||
publishLinkPreviewRequest: vi.fn(),
|
||||
publishAudit: vi.fn(),
|
||||
logActivity: vi.fn(),
|
||||
}));
|
||||
|
||||
vi.mock("./repository.server.js", () => ({
|
||||
getMemberChannelDetail: mocks.getMemberChannelDetail,
|
||||
runChatRepositoryTransaction: mocks.runChatRepositoryTransaction,
|
||||
}));
|
||||
vi.mock("./realtime-wakeup.server.js", () => ({ publishChatPersistentRealtimeWakeup: mocks.publishWakeup }));
|
||||
vi.mock("./link-preview.server.js", async (importOriginal) => {
|
||||
const actual = await importOriginal<typeof import("./link-preview.server.js")>();
|
||||
return { ...actual, publishChatLinkPreviewRequest: (...args: unknown[]) => mocks.publishLinkPreviewRequest(...args) };
|
||||
});
|
||||
vi.mock("@hivegrid/db/audit-events.server", () => ({ publishAuditEventViaOutbox: mocks.publishAudit }));
|
||||
vi.mock("@hivegrid/activity", () => ({ logActivity: mocks.logActivity }));
|
||||
|
||||
import { CHAT_PERMISSIONS } from "./permissions.js";
|
||||
import { sendChatThreadReply, setChatMessagePin, setChatReaction } from "./message-features.server.js";
|
||||
|
||||
const context = {
|
||||
tenantId: "tenant_1",
|
||||
userId: "user_1",
|
||||
permissions: [CHAT_PERMISSIONS.readOwnChannels, CHAT_PERMISSIONS.write],
|
||||
} as const;
|
||||
|
||||
function eventRow(input: {
|
||||
type: "message_pin_changed" | "reaction_added" | "reaction_removed" | "thread_reply";
|
||||
requestId: string;
|
||||
data: unknown;
|
||||
entityId?: string;
|
||||
}) {
|
||||
return {
|
||||
sequence: 12n,
|
||||
occurredAt: new Date("2026-07-16T09:00:00.000Z"),
|
||||
tenantId: context.tenantId,
|
||||
chatId: "chat_1",
|
||||
type: input.type,
|
||||
actorUserId: context.userId,
|
||||
entityId: input.entityId ?? "message_1",
|
||||
requestId: input.requestId,
|
||||
data: input.data,
|
||||
};
|
||||
}
|
||||
|
||||
function messageRow(overrides: Record<string, unknown> = {}) {
|
||||
return {
|
||||
id: "message_1",
|
||||
createdAt: new Date("2026-07-16T08:00:00.000Z"),
|
||||
updatedAt: new Date("2026-07-16T08:00:00.000Z"),
|
||||
tenantId: context.tenantId,
|
||||
chatId: "chat_1",
|
||||
authorUserId: context.userId,
|
||||
clientMessageId: "client_parent",
|
||||
body: "Parent",
|
||||
bodyFormat: "markdown",
|
||||
parentMessageId: null,
|
||||
mentions: [],
|
||||
linkPreviews: [],
|
||||
editedAt: null,
|
||||
deletedAt: null,
|
||||
systemEventKind: null,
|
||||
systemEventMetadata: null,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function txFixture() {
|
||||
return {
|
||||
$executeRaw: vi.fn().mockResolvedValue(1),
|
||||
$queryRaw: vi.fn().mockResolvedValue([{ id: "membership_1", roleInChat: "member" }]),
|
||||
teamChat: {
|
||||
findFirst: vi.fn().mockResolvedValue({
|
||||
id: "chat_1",
|
||||
kind: "group",
|
||||
name: "Team",
|
||||
isPrivate: false,
|
||||
eventStreamId: "stream_1",
|
||||
projektId: null,
|
||||
}),
|
||||
update: vi.fn().mockResolvedValue({ id: "chat_1" }),
|
||||
},
|
||||
tenant: { findUnique: vi.fn().mockResolvedValue({ slug: "demo" }) },
|
||||
teamChatMember: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
tenantUser: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
userRole: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
groupUser: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
notificationDelivery: { upsert: vi.fn(), create: vi.fn() },
|
||||
teamChatMessage: {
|
||||
findFirst: vi.fn().mockResolvedValue({ id: "message_1", authorUserId: context.userId }),
|
||||
create: vi.fn(),
|
||||
findMany: vi.fn().mockResolvedValue([]),
|
||||
},
|
||||
teamChatEvent: { findFirst: vi.fn().mockResolvedValue(null), create: vi.fn() },
|
||||
teamChatPinnedMessage: { findFirst: vi.fn().mockResolvedValue(null), create: vi.fn(), delete: vi.fn(), findMany: vi.fn() },
|
||||
teamChatReaction: { findFirst: vi.fn().mockResolvedValue(null), create: vi.fn(), delete: vi.fn(), findMany: vi.fn(), count: vi.fn().mockResolvedValue(0) },
|
||||
teamChatThread: { findFirst: vi.fn(), create: vi.fn(), update: vi.fn(), findMany: vi.fn() },
|
||||
};
|
||||
}
|
||||
|
||||
describe("chat message feature mutations", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
mocks.publishWakeup.mockResolvedValue(undefined);
|
||||
mocks.publishLinkPreviewRequest.mockResolvedValue(undefined);
|
||||
mocks.publishAudit.mockResolvedValue(undefined);
|
||||
mocks.logActivity.mockResolvedValue(undefined);
|
||||
});
|
||||
|
||||
it("rechecks chat.write through the shared atomic repository gate", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatEvent.create.mockResolvedValue(
|
||||
eventRow({
|
||||
type: "reaction_added",
|
||||
requestId: "request_reaction",
|
||||
data: {
|
||||
reaction: { id: "reaction_1", messageId: "message_1", userId: context.userId, emoji: "👍", reactedAt: "2026-07-16T09:00:00.000Z" },
|
||||
},
|
||||
})
|
||||
);
|
||||
tx.teamChatReaction.create.mockResolvedValue({ id: "reaction_1", reactedAt: new Date("2026-07-16T09:00:00.000Z") });
|
||||
mocks.runChatRepositoryTransaction.mockImplementation(async (_input, permission, operation) => {
|
||||
expect(permission).toBe(CHAT_PERMISSIONS.write);
|
||||
return operation(tx, [CHAT_PERMISSIONS.write]);
|
||||
});
|
||||
|
||||
const result = await setChatReaction({ ...context, requestId: "request_reaction", chatId: "chat_1", messageId: "message_1", emoji: "👍", active: true });
|
||||
|
||||
expect(result).toMatchObject({ changed: true, replayed: false, active: true });
|
||||
expect(mocks.publishWakeup).toHaveBeenCalledWith(tx, { event: result.event });
|
||||
expect(mocks.publishAudit).toHaveBeenCalledWith(
|
||||
tx,
|
||||
expect.objectContaining({
|
||||
action: "chat.message.reaction_added",
|
||||
targetId: "message_1",
|
||||
requestId: "request_reaction",
|
||||
metadata: { chatId: "chat_1", emoji: "👍" },
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects text disguised as an emoji before opening the repository transaction", async () => {
|
||||
await expect(
|
||||
setChatReaction({ ...context, requestId: "request_reaction", chatId: "chat_1", messageId: "message_1", emoji: "👍oops", active: true })
|
||||
).rejects.toMatchObject({ code: "chat.invalid_input" });
|
||||
expect(mocks.runChatRepositoryTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("strictly rejects pins in direct messages before touching a message", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChat.findFirst.mockResolvedValue({ kind: "dm", eventStreamId: "stream_1" });
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await expect(setChatMessagePin({ ...context, requestId: "request_pin", chatId: "chat_1", messageId: "message_1", pinned: true })).rejects.toMatchObject({
|
||||
code: "chat.pins_not_allowed_in_direct_messages",
|
||||
});
|
||||
expect(tx.teamChatMessage.findFirst).not.toHaveBeenCalled();
|
||||
expect(tx.teamChatPinnedMessage.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects a ninth distinct reaction for one user and message", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatReaction.count.mockResolvedValue(8);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await expect(
|
||||
setChatReaction({ ...context, requestId: "request_reaction", chatId: "chat_1", messageId: "message_1", emoji: "👍", active: true })
|
||||
).rejects.toMatchObject({ code: "chat.reaction_limit_reached" });
|
||||
expect(tx.teamChatReaction.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("hides pinning from members who neither authored the message nor administer the channel", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatMessage.findFirst.mockResolvedValue({ id: "message_1", authorUserId: "user_2" });
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await expect(setChatMessagePin({ ...context, requestId: "request_pin", chatId: "chat_1", messageId: "message_1", pinned: true })).rejects.toMatchObject({
|
||||
code: "foundation.not_found",
|
||||
});
|
||||
expect(tx.teamChatPinnedMessage.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("enforces the 50-pin channel limit while holding row locks", async () => {
|
||||
const tx = txFixture();
|
||||
tx.$queryRaw.mockResolvedValueOnce([{ id: "membership_1" }]).mockResolvedValueOnce(Array.from({ length: 50 }, (_, index) => ({ id: `pin_${index}` })));
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await expect(setChatMessagePin({ ...context, requestId: "request_pin", chatId: "chat_1", messageId: "message_1", pinned: true })).rejects.toMatchObject({
|
||||
code: "chat.pin_limit_reached",
|
||||
});
|
||||
expect(tx.teamChatPinnedMessage.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("replays an identical pin request without a second write or audit", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatEvent.findFirst.mockResolvedValue(
|
||||
eventRow({
|
||||
type: "message_pin_changed",
|
||||
requestId: "request_pin",
|
||||
data: { messageId: "message_1", pinned: true, changedByUserId: context.userId },
|
||||
})
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
const result = await setChatMessagePin({ ...context, requestId: "request_pin", chatId: "chat_1", messageId: "message_1", pinned: true });
|
||||
|
||||
expect(result).toMatchObject({ pinned: true, replayed: true, changed: false });
|
||||
expect(tx.teamChatPinnedMessage.create).not.toHaveBeenCalled();
|
||||
expect(mocks.publishAudit).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects request-id payload drift", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatEvent.findFirst.mockResolvedValue(
|
||||
eventRow({
|
||||
type: "message_pin_changed",
|
||||
requestId: "request_pin",
|
||||
data: { messageId: "message_other", pinned: true, changedByUserId: context.userId },
|
||||
})
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await expect(setChatMessagePin({ ...context, requestId: "request_pin", chatId: "chat_1", messageId: "message_1", pinned: true })).rejects.toMatchObject({
|
||||
code: "foundation.idempotency_conflict",
|
||||
});
|
||||
});
|
||||
|
||||
it("creates exactly one level of replies and publishes the durable thread event atomically", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChatMessage.findFirst.mockResolvedValueOnce(messageRow()).mockResolvedValueOnce(null);
|
||||
tx.teamChatMessage.create.mockResolvedValue(messageRow({ id: "reply_1", clientMessageId: "client_reply", body: "Reply", parentMessageId: "message_1" }));
|
||||
tx.teamChatThread.findFirst.mockResolvedValue(null);
|
||||
tx.teamChatThread.create.mockResolvedValue({
|
||||
id: "message_1",
|
||||
parentMessageId: "message_1",
|
||||
replyCount: 1,
|
||||
lastReplyAt: new Date("2026-07-16T08:00:00.000Z"),
|
||||
participantUserIds: [context.userId],
|
||||
});
|
||||
tx.teamChatEvent.create.mockImplementation(({ data }) =>
|
||||
eventRow({ type: "thread_reply", requestId: "request_reply", data: data.data, entityId: "reply_1" })
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
const result = await sendChatThreadReply({
|
||||
...context,
|
||||
requestId: "request_reply",
|
||||
chatId: "chat_1",
|
||||
threadId: "message_1",
|
||||
clientMessageId: "client_reply",
|
||||
body: "Reply",
|
||||
});
|
||||
|
||||
expect(tx.teamChatMessage.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ parentMessageId: "message_1" }) }));
|
||||
expect(result).toMatchObject({ threadId: "message_1", replayed: false });
|
||||
expect(mocks.publishWakeup).toHaveBeenCalledWith(tx, { event: result.event });
|
||||
expect(mocks.publishAudit).toHaveBeenCalledWith(
|
||||
tx,
|
||||
expect.objectContaining({ action: "chat.thread.reply_created", targetId: "reply_1", requestId: "request_reply" })
|
||||
);
|
||||
});
|
||||
|
||||
it("keeps a deleted thread starter readable as a tombstone and accepts new replies", async () => {
|
||||
const tx = txFixture();
|
||||
const deletedAt = new Date("2026-07-16T08:30:00.000Z");
|
||||
tx.teamChatMessage.findFirst
|
||||
.mockResolvedValueOnce(messageRow({ body: "", deletedAt, authorUserId: "user_parent" }))
|
||||
.mockResolvedValueOnce(null);
|
||||
tx.teamChatMessage.create.mockResolvedValue(
|
||||
messageRow({ id: "reply_after_delete", clientMessageId: "client_after_delete", body: "Weiter im Thread", parentMessageId: "message_1" })
|
||||
);
|
||||
tx.teamChatThread.findFirst.mockResolvedValue({ id: "message_1", participantUserIds: ["user_parent"] });
|
||||
tx.teamChatThread.update.mockResolvedValue({
|
||||
id: "message_1",
|
||||
parentMessageId: "message_1",
|
||||
replyCount: 2,
|
||||
lastReplyAt: new Date("2026-07-16T09:00:00.000Z"),
|
||||
participantUserIds: [context.userId, "user_parent"],
|
||||
});
|
||||
tx.teamChatEvent.create.mockImplementation(({ data }) =>
|
||||
eventRow({ type: "thread_reply", requestId: "request_after_delete", data: data.data, entityId: "reply_after_delete" })
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
const result = await sendChatThreadReply({
|
||||
...context,
|
||||
requestId: "request_after_delete",
|
||||
chatId: "chat_1",
|
||||
threadId: "message_1",
|
||||
clientMessageId: "client_after_delete",
|
||||
body: "Weiter im Thread",
|
||||
});
|
||||
|
||||
const parentLookup = tx.teamChatMessage.findFirst.mock.calls[0]?.[0];
|
||||
expect(parentLookup).toEqual(
|
||||
expect.objectContaining({
|
||||
where: expect.objectContaining({ chatId: "chat_1", parentMessageId: null, OR: [{ id: "message_1" }, { thread: { id: "message_1" } }] }),
|
||||
})
|
||||
);
|
||||
expect(parentLookup.where).not.toHaveProperty("deletedAt");
|
||||
expect(tx.teamChatMessage.create).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ data: expect.objectContaining({ parentMessageId: "message_1", body: "Weiter im Thread" }) })
|
||||
);
|
||||
expect(result).toMatchObject({ threadId: "message_1", replayed: false, message: { id: "reply_after_delete" } });
|
||||
});
|
||||
|
||||
it("persists mentioned followers and lets direct mentions, but not ordinary replies, bypass mute", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChat.findFirst.mockResolvedValue({
|
||||
id: "chat_1",
|
||||
kind: "project",
|
||||
name: "P-100",
|
||||
isPrivate: true,
|
||||
eventStreamId: "stream_1",
|
||||
projektId: "project_1",
|
||||
});
|
||||
tx.teamChatMessage.findFirst.mockResolvedValueOnce(messageRow({ authorUserId: "user_parent" })).mockResolvedValueOnce(null);
|
||||
tx.teamChatMessage.create.mockResolvedValue(
|
||||
messageRow({ id: "reply_1", clientMessageId: "client_reply", body: "Hallo <@user:user_mentioned>", parentMessageId: "message_1" })
|
||||
);
|
||||
tx.teamChatThread.findFirst.mockResolvedValue({ id: "message_1", participantUserIds: ["user_previous", "user_hidden"] });
|
||||
tx.teamChatThread.update.mockResolvedValue({
|
||||
id: "message_1",
|
||||
parentMessageId: "message_1",
|
||||
replyCount: 2,
|
||||
lastReplyAt: new Date("2026-07-16T08:00:00.000Z"),
|
||||
participantUserIds: [context.userId, "user_hidden", "user_mentioned", "user_parent", "user_previous"],
|
||||
});
|
||||
tx.teamChatMember.findMany
|
||||
.mockResolvedValueOnce([{ userId: "user_mentioned" }])
|
||||
.mockResolvedValueOnce([
|
||||
{ userId: "user_parent", notificationPref: "all_messages" },
|
||||
{ userId: "user_previous", notificationPref: "muted" },
|
||||
{ userId: "user_mentioned", notificationPref: "muted" },
|
||||
]);
|
||||
tx.tenantUser.findMany.mockResolvedValue([
|
||||
{ userId: "user_mentioned", user: { firstName: "Mia", lastName: "Mention", email: "mia@example.test" } },
|
||||
]);
|
||||
tx.teamChatEvent.create.mockImplementation(({ data }) =>
|
||||
eventRow({ type: "thread_reply", requestId: "request_reply", data: data.data, entityId: "reply_1" })
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await sendChatThreadReply({
|
||||
...context,
|
||||
requestId: "request_reply",
|
||||
chatId: "chat_1",
|
||||
threadId: "message_1",
|
||||
clientMessageId: "client_reply",
|
||||
body: "Hallo <@user:user_mentioned>",
|
||||
});
|
||||
|
||||
expect(tx.teamChatThread.update).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
data: expect.objectContaining({ participantUserIds: [context.userId, "user_hidden", "user_mentioned", "user_parent", "user_previous"] }),
|
||||
})
|
||||
);
|
||||
expect(tx.teamChatMember.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: expect.objectContaining({ tenantId: context.tenantId, chatId: "chat_1", leftAt: null }),
|
||||
})
|
||||
);
|
||||
expect(tx.notificationDelivery.upsert).toHaveBeenCalledTimes(2);
|
||||
expect(tx.notificationDelivery.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
create: expect.objectContaining({
|
||||
userId: "user_parent",
|
||||
channel: "IN_APP",
|
||||
messageKey: "chat.notifications.threadReply",
|
||||
payloadMetadata: {
|
||||
deeplink: "/demo/chat/chat_1/thread/message_1?message=reply_1#message-reply_1",
|
||||
chatId: "chat_1",
|
||||
threadId: "message_1",
|
||||
messageId: "reply_1",
|
||||
},
|
||||
}),
|
||||
})
|
||||
);
|
||||
expect(tx.notificationDelivery.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
create: expect.objectContaining({
|
||||
userId: "user_mentioned",
|
||||
messageKey: "chat.notifications.mentioned",
|
||||
}),
|
||||
})
|
||||
);
|
||||
expect(tx.notificationDelivery.upsert).not.toHaveBeenCalledWith(expect.objectContaining({ create: expect.objectContaining({ userId: context.userId }) }));
|
||||
expect(tx.notificationDelivery.upsert).not.toHaveBeenCalledWith(expect.objectContaining({ create: expect.objectContaining({ userId: "user_hidden" }) }));
|
||||
expect(tx.notificationDelivery.upsert).not.toHaveBeenCalledWith(expect.objectContaining({ create: expect.objectContaining({ userId: "user_previous" }) }));
|
||||
expect(mocks.logActivity).toHaveBeenCalledWith(expect.objectContaining({ activityType: "chat_message", subjectType: "project", subjectId: "project_1" }), {
|
||||
client: tx,
|
||||
});
|
||||
});
|
||||
|
||||
it("lets direct-message thread replies bypass a muted channel preference", async () => {
|
||||
const tx = txFixture();
|
||||
tx.teamChat.findFirst.mockResolvedValue({
|
||||
id: "chat_1",
|
||||
kind: "dm",
|
||||
name: null,
|
||||
isPrivate: true,
|
||||
eventStreamId: "stream_1",
|
||||
projektId: null,
|
||||
});
|
||||
tx.teamChatMessage.findFirst.mockResolvedValueOnce(messageRow({ authorUserId: "user_parent" })).mockResolvedValueOnce(null);
|
||||
tx.teamChatMessage.create.mockResolvedValue(
|
||||
messageRow({ id: "reply_dm", clientMessageId: "client_reply_dm", body: "Reply", parentMessageId: "message_1" })
|
||||
);
|
||||
tx.teamChatThread.findFirst.mockResolvedValue({ id: "message_1", participantUserIds: ["user_parent"] });
|
||||
tx.teamChatThread.update.mockResolvedValue({
|
||||
id: "message_1",
|
||||
parentMessageId: "message_1",
|
||||
replyCount: 2,
|
||||
lastReplyAt: new Date("2026-07-16T08:00:00.000Z"),
|
||||
participantUserIds: [context.userId, "user_parent"],
|
||||
});
|
||||
tx.teamChatMember.findMany.mockResolvedValue([{ userId: "user_parent", notificationPref: "muted" }]);
|
||||
tx.teamChatEvent.create.mockImplementation(({ data }) =>
|
||||
eventRow({ type: "thread_reply", requestId: "request_dm_reply", data: data.data, entityId: "reply_dm" })
|
||||
);
|
||||
mocks.runChatRepositoryTransaction.mockImplementation((_input, _permission, operation) => operation(tx, [CHAT_PERMISSIONS.write]));
|
||||
|
||||
await sendChatThreadReply({
|
||||
...context,
|
||||
requestId: "request_dm_reply",
|
||||
chatId: "chat_1",
|
||||
threadId: "message_1",
|
||||
clientMessageId: "client_reply_dm",
|
||||
body: "Reply",
|
||||
});
|
||||
|
||||
expect(tx.notificationDelivery.upsert).toHaveBeenCalledOnce();
|
||||
expect(tx.notificationDelivery.upsert).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
create: expect.objectContaining({ userId: "user_parent", messageKey: "chat.notifications.directMessage" }),
|
||||
})
|
||||
);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user