1604 lines
47 KiB
TypeScript
1604 lines
47 KiB
TypeScript
import { SystemRole } from "@capakraken/shared";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { notificationRouter } from "../router/notification.js";
|
|
import {
|
|
emitNotificationCreated,
|
|
emitTaskAssigned,
|
|
emitTaskCompleted,
|
|
emitTaskStatusChanged,
|
|
} from "../sse/event-bus.js";
|
|
import { createCallerFactory } from "../trpc.js";
|
|
|
|
const { resolveRecipientsMock } = vi.hoisted(() => ({
|
|
resolveRecipientsMock: vi.fn(),
|
|
}));
|
|
const { sendEmailMock } = vi.hoisted(() => ({
|
|
sendEmailMock: vi.fn(),
|
|
}));
|
|
|
|
// Mock the SSE event bus — we don't test real event emission here
|
|
vi.mock("../sse/event-bus.js", () => ({
|
|
emitNotificationCreated: vi.fn(),
|
|
emitTaskAssigned: vi.fn(),
|
|
emitTaskCompleted: vi.fn(),
|
|
emitTaskStatusChanged: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../lib/notification-targeting.js", () => ({
|
|
resolveRecipients: resolveRecipientsMock,
|
|
}));
|
|
|
|
vi.mock("../lib/email.js", () => ({
|
|
sendEmail: sendEmailMock,
|
|
}));
|
|
|
|
const createCaller = createCallerFactory(notificationRouter);
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
resolveRecipientsMock.mockReset();
|
|
sendEmailMock.mockReset();
|
|
});
|
|
|
|
// ── Caller factories ─────────────────────────────────────────────────────────
|
|
|
|
function createProtectedCaller(db: Record<string, unknown>) {
|
|
return createCaller({
|
|
session: {
|
|
user: { email: "user@example.com", name: "User", image: null },
|
|
expires: "2099-01-01T00:00:00.000Z",
|
|
},
|
|
db: db as never,
|
|
dbUser: {
|
|
id: "user_1",
|
|
systemRole: SystemRole.USER,
|
|
permissionOverrides: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
function createManagerCaller(db: Record<string, unknown>) {
|
|
return createCaller({
|
|
session: {
|
|
user: { email: "mgr@example.com", name: "Manager", image: null },
|
|
expires: "2099-01-01T00:00:00.000Z",
|
|
},
|
|
db: db as never,
|
|
dbUser: {
|
|
id: "user_mgr",
|
|
systemRole: SystemRole.MANAGER,
|
|
permissionOverrides: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
// ── Sample data ──────────────────────────────────────────────────────────────
|
|
|
|
function sampleNotification(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "notif_1",
|
|
userId: "user_1",
|
|
type: "VACATION_APPROVED",
|
|
title: "Vacation approved",
|
|
body: null,
|
|
entityId: null,
|
|
entityType: null,
|
|
readAt: null,
|
|
createdAt: new Date("2026-01-15T10:00:00Z"),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
/** DB mock that resolves the session user for resolveUserId */
|
|
function withUserLookup(db: Record<string, unknown>, userId = "user_1") {
|
|
return {
|
|
user: {
|
|
findUnique: vi.fn().mockResolvedValue({ id: userId }),
|
|
},
|
|
...db,
|
|
};
|
|
}
|
|
|
|
// ─── list ────────────────────────────────────────────────────────────────────
|
|
|
|
describe("notification.list", () => {
|
|
it("returns notifications for the current user", async () => {
|
|
const notifications = [sampleNotification(), sampleNotification({ id: "notif_2" })];
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findMany: vi.fn().mockResolvedValue(notifications),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.list({ limit: 50 });
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(db.notification.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: expect.objectContaining({ userId: "user_1" }),
|
|
orderBy: { createdAt: "desc" },
|
|
take: 50,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("filters to unread only when unreadOnly is true", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.list({ unreadOnly: true, limit: 10 });
|
|
|
|
expect(db.notification.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: expect.objectContaining({ userId: "user_1", readAt: null }),
|
|
take: 10,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── unreadCount ─────────────────────────────────────────────────────────────
|
|
|
|
describe("notification.unreadCount", () => {
|
|
it("returns count of unread notifications", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
count: vi.fn().mockResolvedValue(5),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.unreadCount();
|
|
|
|
expect(result).toBe(5);
|
|
expect(db.notification.count).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { userId: "user_1", readAt: null },
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── markRead ────────────────────────────────────────────────────────────────
|
|
|
|
describe("notification.markRead", () => {
|
|
it("marks a single notification as read when id is provided", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
update: vi.fn().mockResolvedValue(sampleNotification({ readAt: new Date() })),
|
|
updateMany: vi.fn(),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.markRead({ id: "notif_1" });
|
|
|
|
expect(db.notification.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { id: "notif_1", userId: "user_1" },
|
|
data: expect.objectContaining({ readAt: expect.any(Date) }),
|
|
}),
|
|
);
|
|
expect(db.notification.updateMany).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("marks all unread notifications as read when no id is provided", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
update: vi.fn(),
|
|
updateMany: vi.fn().mockResolvedValue({ count: 3 }),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.markRead({});
|
|
|
|
expect(db.notification.updateMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { userId: "user_1", readAt: null },
|
|
data: expect.objectContaining({ readAt: expect.any(Date) }),
|
|
}),
|
|
);
|
|
expect(db.notification.update).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
// ─── create ──────────────────────────────────────────────────────────────────
|
|
|
|
describe("notification.create", () => {
|
|
it("creates a notification (manager role)", async () => {
|
|
const created = sampleNotification({ userId: "target_user" });
|
|
const db = withUserLookup(
|
|
{
|
|
notification: {
|
|
create: vi.fn().mockResolvedValue(created),
|
|
findUnique: vi.fn().mockResolvedValue(created),
|
|
},
|
|
},
|
|
"user_mgr",
|
|
);
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.create({
|
|
userId: "target_user",
|
|
type: "INFO",
|
|
title: "Test notification",
|
|
});
|
|
|
|
expect(result.id).toBe("notif_1");
|
|
expect(db.notification.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({
|
|
userId: "target_user",
|
|
type: "INFO",
|
|
title: "Test notification",
|
|
}),
|
|
}),
|
|
);
|
|
expect(db.notification.findUnique).toHaveBeenCalledWith({ where: { id: "notif_1" } });
|
|
});
|
|
|
|
it("creates a notification with optional fields", async () => {
|
|
const created = sampleNotification({
|
|
userId: "target_user",
|
|
body: "Details here",
|
|
entityId: "proj_1",
|
|
entityType: "PROJECT",
|
|
});
|
|
const db = withUserLookup(
|
|
{
|
|
notification: {
|
|
create: vi.fn().mockResolvedValue(created),
|
|
findUnique: vi.fn().mockResolvedValue(created),
|
|
},
|
|
},
|
|
"user_mgr",
|
|
);
|
|
|
|
const caller = createManagerCaller(db);
|
|
await caller.create({
|
|
userId: "target_user",
|
|
type: "INFO",
|
|
title: "Test",
|
|
body: "Details here",
|
|
entityId: "proj_1",
|
|
entityType: "PROJECT",
|
|
});
|
|
|
|
expect(db.notification.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({
|
|
body: "Details here",
|
|
entityId: "proj_1",
|
|
entityType: "PROJECT",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("rejects creation by a regular user (FORBIDDEN)", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(
|
|
caller.create({ userId: "target", type: "INFO", title: "Nope" }),
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
// ─── createBroadcast ────────────────────────────────────────────────────────
|
|
|
|
describe("notification.createBroadcast", () => {
|
|
const FUTURE_SCHEDULED_AT = new Date("2099-04-01T10:00:00Z");
|
|
|
|
it("rejects broadcasts when no recipients match the target", async () => {
|
|
resolveRecipientsMock.mockResolvedValue([]);
|
|
|
|
const create = vi.fn().mockResolvedValue({
|
|
id: "broadcast_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const update = vi.fn();
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toMatchObject({
|
|
code: "BAD_REQUEST",
|
|
message: "No recipients matched the broadcast target.",
|
|
});
|
|
|
|
expect(create).not.toHaveBeenCalled();
|
|
expect(update).not.toHaveBeenCalled();
|
|
expect(resolveRecipientsMock).toHaveBeenCalledWith(
|
|
"all",
|
|
undefined,
|
|
db,
|
|
"user_mgr",
|
|
);
|
|
});
|
|
|
|
it("rejects immediate broadcasts when transactional persistence support is unavailable", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const create = vi.fn();
|
|
const update = vi.fn();
|
|
const createNotification = vi.fn();
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update,
|
|
},
|
|
notification: {
|
|
create: createNotification,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toMatchObject({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Immediate broadcasts require transactional persistence support.",
|
|
});
|
|
|
|
expect(resolveRecipientsMock).toHaveBeenCalledWith(
|
|
"all",
|
|
undefined,
|
|
db,
|
|
"user_mgr",
|
|
);
|
|
expect(create).not.toHaveBeenCalled();
|
|
expect(update).not.toHaveBeenCalled();
|
|
expect(createNotification).not.toHaveBeenCalled();
|
|
expect(emitNotificationCreated).not.toHaveBeenCalled();
|
|
expect(emitTaskAssigned).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects broadcasts with no recipients before opening a broadcast transaction", async () => {
|
|
resolveRecipientsMock.mockResolvedValue([]);
|
|
|
|
const txCreateBroadcast = vi.fn();
|
|
const txUpdateBroadcast = vi.fn();
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
};
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx));
|
|
const create = vi.fn();
|
|
const update = vi.fn();
|
|
const db = {
|
|
$transaction: transaction,
|
|
notificationBroadcast: {
|
|
create,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toMatchObject({
|
|
code: "BAD_REQUEST",
|
|
message: "No recipients matched the broadcast target.",
|
|
});
|
|
|
|
expect(transaction).not.toHaveBeenCalled();
|
|
expect(create).not.toHaveBeenCalled();
|
|
expect(update).not.toHaveBeenCalled();
|
|
expect(txCreateBroadcast).not.toHaveBeenCalled();
|
|
expect(txUpdateBroadcast).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects scheduled broadcasts when no recipients match the target", async () => {
|
|
resolveRecipientsMock.mockResolvedValue([]);
|
|
|
|
const create = vi.fn();
|
|
const update = vi.fn();
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
})).rejects.toMatchObject({
|
|
code: "BAD_REQUEST",
|
|
message: "No recipients matched the broadcast target.",
|
|
});
|
|
|
|
expect(create).not.toHaveBeenCalled();
|
|
expect(update).not.toHaveBeenCalled();
|
|
expect(resolveRecipientsMock).toHaveBeenCalledWith(
|
|
"all",
|
|
undefined,
|
|
db,
|
|
"user_mgr",
|
|
);
|
|
});
|
|
|
|
it("rejects scheduled broadcasts with task metadata before persisting anything", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a"]);
|
|
|
|
const create = vi.fn();
|
|
const update = vi.fn();
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Approval later",
|
|
targetType: "all",
|
|
category: "TASK",
|
|
taskAction: "approve_vacation:vac_1",
|
|
dueDate: new Date("2099-04-02T10:00:00Z"),
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
})).rejects.toMatchObject({
|
|
code: "BAD_REQUEST",
|
|
message: "Scheduled broadcasts with task metadata are not supported yet.",
|
|
});
|
|
|
|
expect(resolveRecipientsMock).not.toHaveBeenCalled();
|
|
expect(create).not.toHaveBeenCalled();
|
|
expect(update).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not partially persist an immediate broadcast when recipient fan-out fails", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txUpdateBroadcast = vi.fn();
|
|
const txCreateNotification = vi.fn()
|
|
.mockResolvedValueOnce({ id: "notif_a", userId: "user_a" })
|
|
.mockRejectedValueOnce(new Error("fan-out failed"));
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
const outerCreateBroadcast = vi.fn();
|
|
const outerUpdateBroadcast = vi.fn();
|
|
const outerCreateNotification = vi.fn();
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx));
|
|
const db = {
|
|
$transaction: transaction,
|
|
notificationBroadcast: {
|
|
create: outerCreateBroadcast,
|
|
update: outerUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: outerCreateNotification,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toThrow("fan-out failed");
|
|
|
|
expect(transaction).toHaveBeenCalledTimes(1);
|
|
expect(txCreateBroadcast).toHaveBeenCalledTimes(1);
|
|
expect(txCreateNotification).toHaveBeenCalledTimes(2);
|
|
expect(txUpdateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerCreateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerUpdateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerCreateNotification).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("maps broadcast source reference loss during recipient fan-out to not found errors", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_source_missing",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txUpdateBroadcast = vi.fn();
|
|
const txCreateNotification = vi.fn().mockRejectedValue(
|
|
Object.assign(new Error("Foreign key constraint failed"), {
|
|
code: "P2003",
|
|
meta: { field_name: "Notification_sourceId_fkey" },
|
|
}),
|
|
);
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
const outerCreateBroadcast = vi.fn();
|
|
const outerUpdateBroadcast = vi.fn();
|
|
const outerCreateNotification = vi.fn();
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx));
|
|
const db = {
|
|
$transaction: transaction,
|
|
notificationBroadcast: {
|
|
create: outerCreateBroadcast,
|
|
update: outerUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: outerCreateNotification,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toMatchObject({
|
|
code: "NOT_FOUND",
|
|
message: "Notification broadcast not found",
|
|
});
|
|
|
|
expect(transaction).toHaveBeenCalledTimes(1);
|
|
expect(txCreateBroadcast).toHaveBeenCalledTimes(1);
|
|
expect(txCreateNotification).toHaveBeenCalledTimes(1);
|
|
expect(txUpdateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerCreateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerUpdateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerCreateNotification).not.toHaveBeenCalled();
|
|
expect(emitNotificationCreated).not.toHaveBeenCalled();
|
|
expect(emitTaskAssigned).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("emits recipient SSE only after an immediate broadcast commits", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txCreateNotification = vi.fn()
|
|
.mockResolvedValueOnce({ id: "notif_a", userId: "user_a" })
|
|
.mockResolvedValueOnce({ id: "notif_b", userId: "user_b" });
|
|
const txUpdateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
sentAt: new Date("2026-03-30T10:01:00Z"),
|
|
recipientCount: 2,
|
|
});
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx));
|
|
const db = {
|
|
$transaction: transaction,
|
|
notificationBroadcast: {
|
|
create: vi.fn(),
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.createBroadcast({
|
|
title: "Ops update",
|
|
category: "TASK",
|
|
targetType: "all",
|
|
taskAction: "acknowledge",
|
|
});
|
|
|
|
expect(transaction).toHaveBeenCalledTimes(1);
|
|
expect(txCreateBroadcast).toHaveBeenCalledTimes(1);
|
|
expect(txCreateNotification).toHaveBeenCalledTimes(2);
|
|
expect(txUpdateBroadcast).toHaveBeenCalledWith({
|
|
where: { id: "broadcast_tx_1" },
|
|
data: {
|
|
sentAt: expect.any(Date),
|
|
recipientCount: 2,
|
|
},
|
|
});
|
|
expect(emitNotificationCreated).toHaveBeenNthCalledWith(1, "user_a", "notif_a");
|
|
expect(emitNotificationCreated).toHaveBeenNthCalledWith(2, "user_b", "notif_b");
|
|
expect(emitTaskAssigned).toHaveBeenNthCalledWith(1, "user_a", "notif_a");
|
|
expect(emitTaskAssigned).toHaveBeenNthCalledWith(2, "user_b", "notif_b");
|
|
expect(result).toMatchObject({
|
|
id: "broadcast_tx_1",
|
|
recipientCount: 2,
|
|
});
|
|
});
|
|
|
|
it("does not emit recipient SSE when a broadcast is only scheduled", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const create = vi.fn().mockResolvedValue({
|
|
id: "broadcast_sched_1",
|
|
title: "Scheduled ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
recipientCount: 2,
|
|
});
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.createBroadcast({
|
|
title: "Scheduled ops update",
|
|
targetType: "all",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
});
|
|
|
|
expect(create).toHaveBeenCalledWith({
|
|
data: expect.objectContaining({
|
|
senderId: "user_mgr",
|
|
title: "Scheduled ops update",
|
|
targetType: "all",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
recipientCount: 2,
|
|
}),
|
|
});
|
|
expect(db.notification.create).not.toHaveBeenCalled();
|
|
expect(emitNotificationCreated).not.toHaveBeenCalled();
|
|
expect(emitTaskAssigned).not.toHaveBeenCalled();
|
|
expect(result).toMatchObject({
|
|
id: "broadcast_sched_1",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
recipientCount: 2,
|
|
});
|
|
});
|
|
|
|
it("sends broadcast emails only after an immediate broadcast transaction commits", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_email_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txCreateNotification = vi.fn()
|
|
.mockResolvedValueOnce({ id: "notif_a", userId: "user_a" })
|
|
.mockResolvedValueOnce({ id: "notif_b", userId: "user_b" });
|
|
const txUpdateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_email_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
sentAt: new Date("2026-03-30T10:01:00Z"),
|
|
recipientCount: 2,
|
|
});
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
|
|
let transactionCommitted = false;
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => {
|
|
const result = await callback(tx);
|
|
expect(sendEmailMock).not.toHaveBeenCalled();
|
|
transactionCommitted = true;
|
|
return result;
|
|
});
|
|
const db = {
|
|
$transaction: transaction,
|
|
user: {
|
|
findUnique: vi.fn()
|
|
.mockResolvedValueOnce({ email: "user-a@example.com", name: "User A" })
|
|
.mockResolvedValueOnce({ email: "user-b@example.com", name: "User B" }),
|
|
},
|
|
notificationBroadcast: {
|
|
create: vi.fn(),
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.createBroadcast({
|
|
title: "Ops update",
|
|
body: "Email everyone",
|
|
channel: "both",
|
|
targetType: "all",
|
|
});
|
|
|
|
await vi.waitFor(() => {
|
|
expect(sendEmailMock).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
expect(transactionCommitted).toBe(true);
|
|
expect(sendEmailMock).toHaveBeenNthCalledWith(1, expect.objectContaining({
|
|
to: "user-a@example.com",
|
|
subject: "Ops update",
|
|
text: "Email everyone",
|
|
}));
|
|
expect(sendEmailMock).toHaveBeenNthCalledWith(2, expect.objectContaining({
|
|
to: "user-b@example.com",
|
|
subject: "Ops update",
|
|
text: "Email everyone",
|
|
}));
|
|
expect(result).toMatchObject({
|
|
id: "broadcast_tx_email_1",
|
|
recipientCount: 2,
|
|
});
|
|
});
|
|
|
|
it("does not send emails immediately for scheduled broadcasts", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const create = vi.fn().mockResolvedValue({
|
|
id: "broadcast_sched_email_1",
|
|
title: "Scheduled ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
recipientCount: 2,
|
|
});
|
|
const db = {
|
|
user: {
|
|
findUnique: vi.fn(),
|
|
},
|
|
notificationBroadcast: {
|
|
create,
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.createBroadcast({
|
|
title: "Scheduled ops update",
|
|
body: "Hold until later",
|
|
channel: "email",
|
|
targetType: "all",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
});
|
|
|
|
await Promise.resolve();
|
|
|
|
expect(db.user.findUnique).not.toHaveBeenCalled();
|
|
expect(sendEmailMock).not.toHaveBeenCalled();
|
|
expect(result).toMatchObject({
|
|
id: "broadcast_sched_email_1",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
recipientCount: 2,
|
|
});
|
|
});
|
|
|
|
it("maps scheduled broadcast sender persistence failures to not found errors", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const create = vi.fn().mockRejectedValue(
|
|
Object.assign(new Error("Foreign key constraint failed"), {
|
|
code: "P2003",
|
|
meta: { field_name: "NotificationBroadcast_senderId_fkey" },
|
|
}),
|
|
);
|
|
const db = {
|
|
notificationBroadcast: {
|
|
create,
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Scheduled ops update",
|
|
targetType: "all",
|
|
scheduledAt: FUTURE_SCHEDULED_AT,
|
|
})).rejects.toMatchObject({
|
|
code: "NOT_FOUND",
|
|
message: "Sender user not found",
|
|
});
|
|
|
|
expect(create).toHaveBeenCalledTimes(1);
|
|
expect(db.notificationBroadcast.update).not.toHaveBeenCalled();
|
|
expect(db.notification.create).not.toHaveBeenCalled();
|
|
expect(emitNotificationCreated).not.toHaveBeenCalled();
|
|
expect(emitTaskAssigned).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rolls back an immediate broadcast when the final broadcast update fails", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_2",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txCreateNotification = vi.fn()
|
|
.mockResolvedValueOnce({ id: "notif_a", userId: "user_a" })
|
|
.mockResolvedValueOnce({ id: "notif_b", userId: "user_b" });
|
|
const txUpdateBroadcast = vi.fn().mockRejectedValue(
|
|
Object.assign(new Error("Record to update not found"), {
|
|
code: "P2025",
|
|
meta: { modelName: "NotificationBroadcast" },
|
|
}),
|
|
);
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
const outerCreateBroadcast = vi.fn();
|
|
const outerUpdateBroadcast = vi.fn();
|
|
const outerCreateNotification = vi.fn();
|
|
const transaction = vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx));
|
|
const db = {
|
|
$transaction: transaction,
|
|
notificationBroadcast: {
|
|
create: outerCreateBroadcast,
|
|
update: outerUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: outerCreateNotification,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
targetType: "all",
|
|
})).rejects.toMatchObject({
|
|
code: "NOT_FOUND",
|
|
message: "Notification broadcast not found",
|
|
});
|
|
|
|
expect(transaction).toHaveBeenCalledTimes(1);
|
|
expect(txCreateBroadcast).toHaveBeenCalledTimes(1);
|
|
expect(txCreateNotification).toHaveBeenCalledTimes(2);
|
|
expect(txUpdateBroadcast).toHaveBeenCalledTimes(1);
|
|
expect(outerCreateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerUpdateBroadcast).not.toHaveBeenCalled();
|
|
expect(outerCreateNotification).not.toHaveBeenCalled();
|
|
expect(emitNotificationCreated).not.toHaveBeenCalled();
|
|
expect(emitTaskAssigned).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not send broadcast emails when the immediate transaction fails", async () => {
|
|
resolveRecipientsMock.mockResolvedValue(["user_a", "user_b"]);
|
|
|
|
const txCreateBroadcast = vi.fn().mockResolvedValue({
|
|
id: "broadcast_tx_email_fail_1",
|
|
title: "Ops update",
|
|
createdAt: new Date("2026-03-30T10:00:00Z"),
|
|
});
|
|
const txCreateNotification = vi.fn()
|
|
.mockResolvedValueOnce({ id: "notif_a", userId: "user_a" })
|
|
.mockResolvedValueOnce({ id: "notif_b", userId: "user_b" });
|
|
const txUpdateBroadcast = vi.fn().mockRejectedValue(new Error("commit failed"));
|
|
const tx = {
|
|
notificationBroadcast: {
|
|
create: txCreateBroadcast,
|
|
update: txUpdateBroadcast,
|
|
},
|
|
notification: {
|
|
create: txCreateNotification,
|
|
},
|
|
};
|
|
const db = {
|
|
$transaction: vi.fn(async (callback: (db: typeof tx) => Promise<unknown>) => callback(tx)),
|
|
user: {
|
|
findUnique: vi.fn(),
|
|
},
|
|
notificationBroadcast: {
|
|
create: vi.fn(),
|
|
update: vi.fn(),
|
|
},
|
|
notification: {
|
|
create: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.createBroadcast({
|
|
title: "Ops update",
|
|
body: "Email everyone",
|
|
channel: "email",
|
|
targetType: "all",
|
|
})).rejects.toThrow("commit failed");
|
|
|
|
await Promise.resolve();
|
|
|
|
expect(db.user.findUnique).not.toHaveBeenCalled();
|
|
expect(sendEmailMock).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
// ─── task management ────────────────────────────────────────────────────────
|
|
|
|
describe("notification.listTasks", () => {
|
|
it("lists task and approval notifications for the current user as owner or assignee", async () => {
|
|
const tasks = [
|
|
sampleNotification({ id: "task_1", category: "TASK", taskStatus: "OPEN" }),
|
|
sampleNotification({
|
|
id: "approval_1",
|
|
category: "APPROVAL",
|
|
taskStatus: "IN_PROGRESS",
|
|
assigneeId: "user_1",
|
|
}),
|
|
];
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findMany: vi.fn().mockResolvedValue(tasks),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.listTasks({ status: "OPEN", limit: 15 });
|
|
|
|
expect(result).toEqual(tasks);
|
|
expect(db.notification.findMany).toHaveBeenCalledWith({
|
|
where: {
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
taskStatus: "OPEN",
|
|
},
|
|
orderBy: [{ priority: "desc" }, { dueDate: "asc" }, { createdAt: "desc" }],
|
|
take: 15,
|
|
});
|
|
});
|
|
|
|
it("can restrict tasks to those owned by the current user", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.listTasks({ includeAssigned: false, limit: 10 });
|
|
|
|
expect(db.notification.findMany).toHaveBeenCalledWith({
|
|
where: {
|
|
userId: "user_1",
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
},
|
|
orderBy: [{ priority: "desc" }, { dueDate: "asc" }, { createdAt: "desc" }],
|
|
take: 10,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.taskCounts", () => {
|
|
it("normalizes grouped task counts and calculates overdue work", async () => {
|
|
const groupBy = vi.fn().mockResolvedValue([
|
|
{ taskStatus: "OPEN", _count: 4 },
|
|
{ taskStatus: "DONE", _count: 2 },
|
|
]);
|
|
const count = vi.fn().mockResolvedValue(3);
|
|
const db = withUserLookup({
|
|
notification: {
|
|
groupBy,
|
|
count,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.taskCounts();
|
|
|
|
expect(result).toEqual({
|
|
open: 4,
|
|
inProgress: 0,
|
|
done: 2,
|
|
dismissed: 0,
|
|
overdue: 3,
|
|
});
|
|
expect(groupBy).toHaveBeenCalledWith({
|
|
by: ["taskStatus"],
|
|
where: {
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
},
|
|
_count: true,
|
|
});
|
|
expect(count).toHaveBeenCalledWith({
|
|
where: {
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
taskStatus: { in: ["OPEN", "IN_PROGRESS"] },
|
|
dueDate: { lt: expect.any(Date) },
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.getTaskDetail", () => {
|
|
it("returns the selected task detail payload including sender context", async () => {
|
|
const task = {
|
|
id: "task_1",
|
|
title: "Review allocation",
|
|
body: "Please verify the plan.",
|
|
type: "TASK_CREATED",
|
|
priority: "HIGH",
|
|
category: "TASK",
|
|
taskStatus: "OPEN",
|
|
taskAction: "approve_vacation:vac_1",
|
|
dueDate: new Date("2026-04-10T09:00:00Z"),
|
|
entityId: "vac_1",
|
|
entityType: "VACATION",
|
|
completedAt: null,
|
|
completedBy: null,
|
|
createdAt: new Date("2026-04-01T08:00:00Z"),
|
|
userId: "user_1",
|
|
assigneeId: "user_2",
|
|
sender: { id: "user_mgr", name: "Manager", email: "mgr@example.com" },
|
|
};
|
|
const findFirst = vi.fn().mockResolvedValue(task);
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getTaskDetail({ id: "task_1" });
|
|
|
|
expect(result).toEqual(task);
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: {
|
|
id: "task_1",
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
},
|
|
select: {
|
|
id: true,
|
|
title: true,
|
|
body: true,
|
|
type: true,
|
|
priority: true,
|
|
category: true,
|
|
taskStatus: true,
|
|
taskAction: true,
|
|
dueDate: true,
|
|
entityId: true,
|
|
entityType: true,
|
|
completedAt: true,
|
|
completedBy: true,
|
|
createdAt: true,
|
|
userId: true,
|
|
assigneeId: true,
|
|
sender: { select: { id: true, name: true, email: true } },
|
|
},
|
|
});
|
|
});
|
|
|
|
it("returns NOT_FOUND when the task is not visible to the current user", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst: vi.fn().mockResolvedValue(null),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.getTaskDetail({ id: "task_missing" })).rejects.toMatchObject({
|
|
code: "NOT_FOUND",
|
|
message: "Task not found or you do not have permission",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.updateTaskStatus", () => {
|
|
it("marks a task as done, records completion metadata, and emits completion events", async () => {
|
|
const findFirst = vi.fn().mockResolvedValue({
|
|
id: "task_1",
|
|
userId: "user_1",
|
|
assigneeId: "user_2",
|
|
});
|
|
const update = vi.fn().mockResolvedValue({
|
|
id: "task_1",
|
|
taskStatus: "DONE",
|
|
completedBy: "user_1",
|
|
completedAt: new Date("2026-04-02T10:00:00Z"),
|
|
});
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
update,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.updateTaskStatus({ id: "task_1", status: "DONE" });
|
|
|
|
expect(result).toMatchObject({
|
|
id: "task_1",
|
|
taskStatus: "DONE",
|
|
completedBy: "user_1",
|
|
});
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: {
|
|
id: "task_1",
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
},
|
|
});
|
|
expect(update).toHaveBeenCalledWith({
|
|
where: { id: "task_1" },
|
|
data: {
|
|
taskStatus: "DONE",
|
|
completedAt: expect.any(Date),
|
|
completedBy: "user_1",
|
|
},
|
|
});
|
|
expect(emitTaskCompleted).toHaveBeenNthCalledWith(1, "user_1", "task_1");
|
|
expect(emitTaskCompleted).toHaveBeenNthCalledWith(2, "user_2", "task_1");
|
|
expect(emitTaskStatusChanged).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("emits status-change events for non-terminal task updates", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst: vi.fn().mockResolvedValue({
|
|
id: "task_2",
|
|
userId: "user_1",
|
|
assigneeId: "user_3",
|
|
}),
|
|
update: vi.fn().mockResolvedValue({
|
|
id: "task_2",
|
|
taskStatus: "IN_PROGRESS",
|
|
}),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.updateTaskStatus({ id: "task_2", status: "IN_PROGRESS" });
|
|
|
|
expect(db.notification.update).toHaveBeenCalledWith({
|
|
where: { id: "task_2" },
|
|
data: {
|
|
taskStatus: "IN_PROGRESS",
|
|
completedAt: null,
|
|
completedBy: null,
|
|
},
|
|
});
|
|
expect(emitTaskStatusChanged).toHaveBeenNthCalledWith(1, "user_1", "task_2");
|
|
expect(emitTaskStatusChanged).toHaveBeenNthCalledWith(2, "user_3", "task_2");
|
|
});
|
|
|
|
it("clears completion metadata when reopening a completed task", async () => {
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst: vi.fn().mockResolvedValue({
|
|
id: "task_3",
|
|
userId: "user_1",
|
|
assigneeId: "user_3",
|
|
taskStatus: "DONE",
|
|
completedAt: new Date("2026-04-01T10:00:00Z"),
|
|
completedBy: "user_2",
|
|
}),
|
|
update: vi.fn().mockResolvedValue({
|
|
id: "task_3",
|
|
taskStatus: "OPEN",
|
|
completedAt: null,
|
|
completedBy: null,
|
|
}),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.updateTaskStatus({ id: "task_3", status: "OPEN" });
|
|
|
|
expect(result).toMatchObject({
|
|
id: "task_3",
|
|
taskStatus: "OPEN",
|
|
completedAt: null,
|
|
completedBy: null,
|
|
});
|
|
expect(db.notification.update).toHaveBeenCalledWith({
|
|
where: { id: "task_3" },
|
|
data: {
|
|
taskStatus: "OPEN",
|
|
completedAt: null,
|
|
completedBy: null,
|
|
},
|
|
});
|
|
expect(emitTaskStatusChanged).toHaveBeenNthCalledWith(1, "user_1", "task_3");
|
|
expect(emitTaskStatusChanged).toHaveBeenNthCalledWith(2, "user_3", "task_3");
|
|
expect(emitTaskCompleted).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects task status updates for non-task notifications", async () => {
|
|
const findFirst = vi.fn().mockResolvedValue(null);
|
|
const update = vi.fn();
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
update,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.updateTaskStatus({ id: "notif_info_1", status: "DONE" })).rejects.toMatchObject(
|
|
{
|
|
code: "NOT_FOUND",
|
|
message: "Task not found or you do not have permission",
|
|
},
|
|
);
|
|
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: {
|
|
id: "notif_info_1",
|
|
OR: [{ userId: "user_1" }, { assigneeId: "user_1" }],
|
|
category: { in: ["TASK", "APPROVAL"] },
|
|
},
|
|
});
|
|
expect(update).not.toHaveBeenCalled();
|
|
expect(emitTaskCompleted).not.toHaveBeenCalled();
|
|
expect(emitTaskStatusChanged).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("notification.assignTask", () => {
|
|
it("reassigns a task and emits the assignment event for the new assignee", async () => {
|
|
const findUnique = vi.fn().mockResolvedValue({
|
|
id: "task_9",
|
|
category: "TASK",
|
|
assigneeId: "user_2",
|
|
});
|
|
const update = vi.fn().mockResolvedValue({
|
|
id: "task_9",
|
|
category: "TASK",
|
|
assigneeId: "user_4",
|
|
});
|
|
const db = {
|
|
notification: {
|
|
findUnique,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.assignTask({ id: "task_9", assigneeId: "user_4" });
|
|
|
|
expect(findUnique).toHaveBeenCalledWith({ where: { id: "task_9" } });
|
|
expect(update).toHaveBeenCalledWith({
|
|
where: { id: "task_9" },
|
|
data: { assigneeId: "user_4" },
|
|
});
|
|
expect(result).toMatchObject({
|
|
id: "task_9",
|
|
assigneeId: "user_4",
|
|
});
|
|
expect(emitTaskAssigned).toHaveBeenCalledWith("user_4", "task_9");
|
|
});
|
|
|
|
it("returns NOT_FOUND when assigning a task to a missing assignee", async () => {
|
|
const findUnique = vi.fn().mockResolvedValue({
|
|
id: "task_9",
|
|
category: "TASK",
|
|
assigneeId: "user_2",
|
|
});
|
|
const update = vi.fn().mockRejectedValue({
|
|
code: "P2003",
|
|
message: "Foreign key constraint failed",
|
|
meta: { field_name: "Notification_assigneeId_fkey" },
|
|
});
|
|
const db = {
|
|
notification: {
|
|
findUnique,
|
|
update,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await expect(caller.assignTask({ id: "task_9", assigneeId: "user_missing" })).rejects.toMatchObject({
|
|
code: "NOT_FOUND",
|
|
message: "Assignee user not found",
|
|
});
|
|
|
|
expect(findUnique).toHaveBeenCalledWith({ where: { id: "task_9" } });
|
|
expect(update).toHaveBeenCalledWith({
|
|
where: { id: "task_9" },
|
|
data: { assigneeId: "user_missing" },
|
|
});
|
|
expect(emitTaskAssigned).not.toHaveBeenCalledWith("user_missing", "task_9");
|
|
});
|
|
});
|
|
|
|
// ─── reminders ──────────────────────────────────────────────────────────────
|
|
|
|
describe("notification.createReminder", () => {
|
|
it("creates a reminder for the current user and seeds nextRemindAt", async () => {
|
|
const remindAt = new Date("2026-04-15T08:30:00Z");
|
|
const createdReminder = sampleNotification({
|
|
id: "rem_1",
|
|
type: "REMINDER",
|
|
category: "REMINDER",
|
|
title: "Submit report",
|
|
remindAt,
|
|
nextRemindAt: remindAt,
|
|
recurrence: "weekly",
|
|
});
|
|
const create = vi.fn().mockResolvedValue(createdReminder);
|
|
const db = withUserLookup({
|
|
notification: {
|
|
create,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.createReminder({
|
|
title: "Submit report",
|
|
body: "Finance review",
|
|
remindAt,
|
|
recurrence: "weekly",
|
|
entityId: "project_1",
|
|
entityType: "PROJECT",
|
|
link: "/projects/project_1",
|
|
});
|
|
|
|
expect(result).toEqual(createdReminder);
|
|
expect(create).toHaveBeenCalledWith({
|
|
data: {
|
|
userId: "user_1",
|
|
type: "REMINDER",
|
|
category: "REMINDER",
|
|
title: "Submit report",
|
|
body: "Finance review",
|
|
remindAt,
|
|
nextRemindAt: remindAt,
|
|
recurrence: "weekly",
|
|
entityId: "project_1",
|
|
entityType: "PROJECT",
|
|
link: "/projects/project_1",
|
|
channel: "in_app",
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.updateReminder", () => {
|
|
it("updates an owned reminder and keeps nextRemindAt in sync with remindAt", async () => {
|
|
const remindAt = new Date("2026-05-01T07:00:00Z");
|
|
const findFirst = vi.fn().mockResolvedValue({
|
|
id: "rem_1",
|
|
userId: "user_1",
|
|
category: "REMINDER",
|
|
});
|
|
const update = vi.fn().mockResolvedValue({
|
|
id: "rem_1",
|
|
title: "Updated reminder",
|
|
remindAt,
|
|
nextRemindAt: remindAt,
|
|
recurrence: null,
|
|
});
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
update,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.updateReminder({
|
|
id: "rem_1",
|
|
title: "Updated reminder",
|
|
remindAt,
|
|
recurrence: null,
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
id: "rem_1",
|
|
title: "Updated reminder",
|
|
recurrence: null,
|
|
});
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: { id: "rem_1", userId: "user_1", category: "REMINDER" },
|
|
});
|
|
expect(update).toHaveBeenCalledWith({
|
|
where: { id: "rem_1" },
|
|
data: {
|
|
title: "Updated reminder",
|
|
remindAt,
|
|
nextRemindAt: remindAt,
|
|
recurrence: null,
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.deleteReminder", () => {
|
|
it("deletes an owned reminder", async () => {
|
|
const findFirst = vi.fn().mockResolvedValue({
|
|
id: "rem_1",
|
|
userId: "user_1",
|
|
category: "REMINDER",
|
|
});
|
|
const deleteFn = vi.fn().mockResolvedValue({ id: "rem_1" });
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
delete: deleteFn,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.deleteReminder({ id: "rem_1" });
|
|
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: { id: "rem_1", userId: "user_1", category: "REMINDER" },
|
|
});
|
|
expect(deleteFn).toHaveBeenCalledWith({ where: { id: "rem_1" } });
|
|
});
|
|
});
|
|
|
|
describe("notification.listReminders", () => {
|
|
it("lists reminders for the current user ordered by next reminder date", async () => {
|
|
const reminders = [
|
|
{
|
|
id: "rem_1",
|
|
userId: "user_1",
|
|
category: "REMINDER",
|
|
nextRemindAt: new Date("2026-05-01T07:00:00Z"),
|
|
},
|
|
];
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findMany: vi.fn().mockResolvedValue(reminders),
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.listReminders({ limit: 10 });
|
|
|
|
expect(result).toEqual(reminders);
|
|
expect(db.notification.findMany).toHaveBeenCalledWith({
|
|
where: { userId: "user_1", category: "REMINDER" },
|
|
orderBy: { nextRemindAt: "asc" },
|
|
take: 10,
|
|
});
|
|
});
|
|
});
|
|
|
|
// ─── broadcasts and delete ─────────────────────────────────────────────────
|
|
|
|
describe("notification.getBroadcastById", () => {
|
|
it("returns the broadcast including sender context", async () => {
|
|
const findUnique = vi.fn().mockResolvedValue({
|
|
id: "broadcast_1",
|
|
title: "Office update",
|
|
sender: { id: "user_mgr", name: "Manager", email: "mgr@example.com" },
|
|
});
|
|
const db = withUserLookup({
|
|
notificationBroadcast: {
|
|
findUnique,
|
|
},
|
|
}, "user_mgr");
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.getBroadcastById({ id: "broadcast_1" });
|
|
|
|
expect(result).toEqual({
|
|
id: "broadcast_1",
|
|
title: "Office update",
|
|
sender: { id: "user_mgr", name: "Manager", email: "mgr@example.com" },
|
|
});
|
|
expect(findUnique).toHaveBeenCalledWith({
|
|
where: { id: "broadcast_1" },
|
|
include: {
|
|
sender: { select: { id: true, name: true, email: true } },
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("notification.delete", () => {
|
|
it("deletes a regular notification owned by the current user", async () => {
|
|
const findFirst = vi.fn().mockResolvedValue({
|
|
id: "notif_1",
|
|
userId: "user_1",
|
|
category: "NOTIFICATION",
|
|
senderId: "user_mgr",
|
|
});
|
|
const deleteFn = vi.fn().mockResolvedValue({ id: "notif_1" });
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst,
|
|
delete: deleteFn,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.delete({ id: "notif_1" });
|
|
|
|
expect(findFirst).toHaveBeenCalledWith({
|
|
where: { id: "notif_1", userId: "user_1" },
|
|
});
|
|
expect(deleteFn).toHaveBeenCalledWith({ where: { id: "notif_1" } });
|
|
});
|
|
|
|
it("forbids deleting a task created by another user", async () => {
|
|
const deleteFn = vi.fn();
|
|
const db = withUserLookup({
|
|
notification: {
|
|
findFirst: vi.fn().mockResolvedValue({
|
|
id: "task_1",
|
|
userId: "user_1",
|
|
category: "TASK",
|
|
senderId: "user_mgr",
|
|
}),
|
|
delete: deleteFn,
|
|
},
|
|
});
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.delete({ id: "task_1" })).rejects.toMatchObject({
|
|
code: "FORBIDDEN",
|
|
message: "Cannot delete tasks created by others",
|
|
});
|
|
expect(deleteFn).not.toHaveBeenCalled();
|
|
});
|
|
});
|