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
+636
@@ -0,0 +1,636 @@
|
||||
import type { DbTransactionClient } from "@hivegrid/db/transactions.server";
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
logActivity: vi.fn(),
|
||||
publishAuditEventViaOutbox: vi.fn(),
|
||||
publishRealtimeWakeup: vi.fn(),
|
||||
tenantHasChatModuleForSystemTx: vi.fn(),
|
||||
writeSystemMessage: vi.fn(),
|
||||
tx: {
|
||||
$executeRaw: vi.fn(),
|
||||
projekt: { findFirst: vi.fn() },
|
||||
projektMitglied: { findMany: vi.fn() },
|
||||
group: { findMany: vi.fn() },
|
||||
tenantUser: { findMany: vi.fn() },
|
||||
teamChat: { findFirst: vi.fn(), create: vi.fn(), updateMany: vi.fn() },
|
||||
teamChatMember: { findMany: vi.fn(), create: vi.fn(), updateMany: vi.fn() },
|
||||
teamChatEvent: { create: vi.fn() },
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock("@hivegrid/activity", () => ({
|
||||
logActivity: mocks.logActivity,
|
||||
}));
|
||||
|
||||
vi.mock("@hivegrid/db/audit-events.server", () => ({
|
||||
publishAuditEventViaOutbox: mocks.publishAuditEventViaOutbox,
|
||||
}));
|
||||
|
||||
vi.mock("./module-access.server.js", () => ({
|
||||
tenantHasChatModuleForSystemTx: (...args: unknown[]) => mocks.tenantHasChatModuleForSystemTx(...args),
|
||||
}));
|
||||
|
||||
vi.mock("./realtime-wakeup.server.js", () => ({
|
||||
publishChatPersistentRealtimeWakeup: (...args: unknown[]) => mocks.publishRealtimeWakeup(...args),
|
||||
}));
|
||||
|
||||
vi.mock("./system-message.server.js", () => ({
|
||||
writeChatSystemMessageWithTx: (...args: unknown[]) => mocks.writeSystemMessage(...args),
|
||||
}));
|
||||
|
||||
import { archiveProjectChannelIfEnabledWithTx, ensureAndSyncProjectChannelWithTx } from "./project-sync.server.js";
|
||||
|
||||
const NOW = new Date("2026-07-16T08:00:00.000Z");
|
||||
const CHANNEL = {
|
||||
id: "chat_project_1",
|
||||
eventStreamId: "stream_project_1",
|
||||
name: "Wärmepumpe Müller",
|
||||
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
|
||||
isDemoData: false,
|
||||
notificationDefault: "all_messages" as const,
|
||||
};
|
||||
const BASE_PROJECT = {
|
||||
id: "project_1",
|
||||
projektname: "Wärmepumpe Müller",
|
||||
projektNummer: "P-2026-0042",
|
||||
projektleiterId: "user_pl",
|
||||
zustaendigePersonId: null,
|
||||
isDemoData: false,
|
||||
};
|
||||
const TX = mocks.tx as unknown as DbTransactionClient;
|
||||
|
||||
describe("project channel synchronization", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.useFakeTimers();
|
||||
vi.setSystemTime(NOW);
|
||||
mocks.tx.$executeRaw.mockResolvedValue(1);
|
||||
mocks.tenantHasChatModuleForSystemTx.mockResolvedValue(true);
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue(BASE_PROJECT);
|
||||
mocks.tx.projektMitglied.findMany.mockResolvedValue([]);
|
||||
mocks.tx.group.findMany.mockResolvedValue([]);
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_pl")]);
|
||||
mocks.tx.teamChat.findFirst.mockResolvedValue(CHANNEL);
|
||||
mocks.tx.teamChat.create.mockResolvedValue(CHANNEL);
|
||||
mocks.tx.teamChat.updateMany.mockResolvedValue({ count: 1 });
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChatMember.create.mockResolvedValue({ id: "chat_member_1" });
|
||||
mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 });
|
||||
mocks.tx.teamChatEvent.create.mockImplementation(async ({ data }: { data: Record<string, unknown> }) => ({
|
||||
...data,
|
||||
sequence: BigInt(mocks.tx.teamChatEvent.create.mock.calls.length),
|
||||
occurredAt: NOW,
|
||||
}));
|
||||
mocks.logActivity.mockResolvedValue({ id: "activity_1" });
|
||||
mocks.publishAuditEventViaOutbox.mockResolvedValue(undefined);
|
||||
mocks.publishRealtimeWakeup.mockResolvedValue(undefined);
|
||||
mocks.writeSystemMessage.mockImplementation(async (_tx: unknown, input: { tenantId: string; chatId: string; requestId: string }) => ({
|
||||
replayed: false,
|
||||
event: realtimeSystemEvent(input),
|
||||
}));
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it("creates one tenant-scoped project channel and unions all active effective members", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({
|
||||
...BASE_PROJECT,
|
||||
zustaendigePersonId: "user_responsible",
|
||||
});
|
||||
mocks.tx.projektMitglied.findMany.mockResolvedValue([
|
||||
{ userId: "user_direct", groupId: null },
|
||||
{ userId: "user_pl", groupId: null },
|
||||
{ userId: "user_inactive", groupId: null },
|
||||
{ userId: null, groupId: "group_1" },
|
||||
]);
|
||||
mocks.tx.group.findMany.mockResolvedValue([{ users: [{ userId: "user_group" }, { userId: "user_direct" }, { userId: "user_outside_tenant" }] }]);
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([
|
||||
tenantUser("user_responsible"),
|
||||
tenantUser("user_group"),
|
||||
tenantUser("user_pl"),
|
||||
tenantUser("user_direct"),
|
||||
]);
|
||||
mocks.tx.teamChat.findFirst.mockResolvedValue(null);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
actorUserId: null,
|
||||
requestId: "request_create",
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
chatId: CHANNEL.id,
|
||||
created: true,
|
||||
reactivated: false,
|
||||
changed: true,
|
||||
effectiveUserIds: ["user_direct", "user_group", "user_pl", "user_responsible"],
|
||||
writeRestoredUserIds: ["user_direct", "user_group", "user_pl", "user_responsible"],
|
||||
});
|
||||
expect(mocks.tx.teamChat.create).toHaveBeenCalledWith({
|
||||
data: expect.objectContaining({
|
||||
tenantId: "tenant_1",
|
||||
createdByUserId: null,
|
||||
kind: "project",
|
||||
projektId: "project_1",
|
||||
isPrivate: true,
|
||||
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
|
||||
isDemoData: false,
|
||||
}),
|
||||
select: { id: true, eventStreamId: true, name: true, description: true, isDemoData: true, notificationDefault: true },
|
||||
});
|
||||
expect(mocks.tx.teamChatMember.create).toHaveBeenCalledTimes(4);
|
||||
const createdMembers = mocks.tx.teamChatMember.create.mock.calls.map((call) => call[0].data);
|
||||
expect(createdMembers).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
userId: "user_pl",
|
||||
roleInChat: "admin",
|
||||
isProjectManaged: true,
|
||||
projectRoleInChat: "admin",
|
||||
isManualMember: false,
|
||||
manualRoleInChat: null,
|
||||
}),
|
||||
expect.objectContaining({
|
||||
userId: "user_direct",
|
||||
roleInChat: "member",
|
||||
isProjectManaged: true,
|
||||
projectRoleInChat: "member",
|
||||
isManualMember: false,
|
||||
}),
|
||||
expect.objectContaining({ userId: "user_group", roleInChat: "member", isProjectManaged: true, projectRoleInChat: "member" }),
|
||||
expect.objectContaining({ userId: "user_responsible", roleInChat: "member", isProjectManaged: true, projectRoleInChat: "member" }),
|
||||
])
|
||||
);
|
||||
expect(mocks.tx.group.findMany).toHaveBeenCalledWith(expect.objectContaining({ where: { tenantId: "tenant_1", id: { in: ["group_1"] } } }));
|
||||
expect(mocks.tx.tenantUser.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: expect.objectContaining({
|
||||
tenantId: "tenant_1",
|
||||
status: 2,
|
||||
user: { active: true, pendingDeletion: false, pseudonymized: false },
|
||||
}),
|
||||
})
|
||||
);
|
||||
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledTimes(4);
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledTimes(5);
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({
|
||||
kind: "project_created",
|
||||
metadata: expect.objectContaining({ projectId: "project_1", projectName: "Wärmepumpe Müller" }),
|
||||
})
|
||||
);
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({ kind: "member_added", metadata: expect.objectContaining({ memberUserId: "user_pl" }) })
|
||||
);
|
||||
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(9);
|
||||
const projectLeaderEvent = mocks.tx.teamChatEvent.create.mock.calls.find((call) => call[0].data.entityId === "user_pl");
|
||||
expect(projectLeaderEvent?.[0].data.data).toEqual({
|
||||
userId: "user_pl",
|
||||
roleInChat: "admin",
|
||||
joinedAt: NOW.toISOString(),
|
||||
});
|
||||
expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce();
|
||||
expect(mocks.logActivity).toHaveBeenCalledOnce();
|
||||
const projectLock = mocks.tx.$executeRaw.mock.calls.find((call) => call.includes("project-channel:tenant_1:project_1"));
|
||||
expect(String(projectLock?.[0])).toContain("pg_advisory_xact_lock");
|
||||
});
|
||||
|
||||
it("is a no-op when the channel and project-derived membership already match", async () => {
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([projectMember({ userId: "user_pl", roleInChat: "admin" })]);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
actorUserId: "user_actor",
|
||||
requestId: "request_noop",
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ created: false, reactivated: false, changed: false });
|
||||
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChatMember.create).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChatEvent.create).not.toHaveBeenCalled();
|
||||
expect(mocks.writeSystemMessage).not.toHaveBeenCalled();
|
||||
expect(mocks.publishRealtimeWakeup).not.toHaveBeenCalled();
|
||||
expect(mocks.publishAuditEventViaOutbox).not.toHaveBeenCalled();
|
||||
expect(mocks.logActivity).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("revokes only pure project write access and leaves manual guests writable", async () => {
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({ userId: "user_pl", roleInChat: "admin" }),
|
||||
projectMember({ id: "member_removed", userId: "user_removed" }),
|
||||
projectMember({ id: "member_overlap", userId: "user_overlap", isManualMember: true }),
|
||||
projectMember({ id: "member_guest", userId: "user_manual_guest", isProjectManaged: false, isManualMember: true }),
|
||||
]);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
actorUserId: "user_actor",
|
||||
requestId: "request_remove",
|
||||
});
|
||||
|
||||
expect(result.projectSourceRemovedUserIds).toEqual(["user_overlap", "user_removed"]);
|
||||
expect(result.writeRevokedUserIds).toEqual(["user_removed"]);
|
||||
const removedUpdate = memberUpdateFor("user_removed");
|
||||
expect(removedUpdate?.data).toEqual({
|
||||
isProjectManaged: false,
|
||||
projectRoleInChat: null,
|
||||
roleInChat: "member",
|
||||
writeRevokedAt: NOW,
|
||||
leftAt: null,
|
||||
});
|
||||
const overlapUpdate = memberUpdateFor("user_overlap");
|
||||
expect(overlapUpdate?.data).toEqual({
|
||||
isProjectManaged: false,
|
||||
projectRoleInChat: null,
|
||||
roleInChat: "member",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
});
|
||||
expect(memberUpdateFor("user_manual_guest")).toBeUndefined();
|
||||
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledOnce();
|
||||
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
data: expect.objectContaining({
|
||||
type: "member_removed",
|
||||
entityId: "user_removed",
|
||||
data: { userId: "user_removed", leftAt: NOW.toISOString() },
|
||||
}),
|
||||
})
|
||||
);
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({
|
||||
kind: "member_write_access_changed",
|
||||
metadata: expect.objectContaining({ memberUserId: "user_removed", canWrite: false }),
|
||||
})
|
||||
);
|
||||
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it("restores a former project member without creating a duplicate membership", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({
|
||||
...BASE_PROJECT,
|
||||
projektleiterId: null,
|
||||
});
|
||||
mocks.tx.projektMitglied.findMany.mockResolvedValue([{ userId: "user_readded", groupId: null }]);
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_readded")]);
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_readded",
|
||||
userId: "user_readded",
|
||||
isProjectManaged: false,
|
||||
isManualMember: false,
|
||||
writeRevokedAt: new Date("2026-07-15T08:00:00.000Z"),
|
||||
}),
|
||||
]);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
actorUserId: "user_actor",
|
||||
requestId: "request_readd",
|
||||
});
|
||||
|
||||
expect(result.projectSourceAddedUserIds).toEqual(["user_readded"]);
|
||||
expect(result.writeRestoredUserIds).toEqual(["user_readded"]);
|
||||
expect(mocks.tx.teamChatMember.create).not.toHaveBeenCalled();
|
||||
expect(memberUpdateFor("user_readded")?.data).toEqual({
|
||||
isProjectManaged: true,
|
||||
projectRoleInChat: "member",
|
||||
roleInChat: "member",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
joinedAt: NOW,
|
||||
joinedViaUserId: "user_actor",
|
||||
});
|
||||
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ data: expect.objectContaining({ type: "member_added", entityId: "user_readded" }) })
|
||||
);
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({
|
||||
kind: "member_write_access_changed",
|
||||
metadata: expect.objectContaining({ memberUserId: "user_readded", canWrite: true }),
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("reactivates the existing archived project channel instead of creating a duplicate", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChat.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce(CHANNEL);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_reactivate",
|
||||
reactivateArchived: true,
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ chatId: CHANNEL.id, created: false, reactivated: true, changed: true });
|
||||
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({
|
||||
where: {
|
||||
id: CHANNEL.id,
|
||||
tenantId: "tenant_1",
|
||||
projektId: "project_1",
|
||||
kind: "project",
|
||||
archivedAt: { not: null },
|
||||
},
|
||||
data: {
|
||||
archivedAt: null,
|
||||
archivedReason: null,
|
||||
name: "Wärmepumpe Müller",
|
||||
description: "Projekt-Chat für Wärmepumpe Müller, P-2026-0042",
|
||||
isDemoData: false,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("does not reopen an archived project channel during an ordinary member sync", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChat.findFirst.mockResolvedValueOnce(null).mockResolvedValueOnce(CHANNEL);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_sync_archived",
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({ chatId: CHANNEL.id, created: false, reactivated: false, changed: false });
|
||||
expect(mocks.tx.teamChat.create).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChat.updateMany).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.projektMitglied.findMany).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChatMember.findMany).not.toHaveBeenCalled();
|
||||
expect(mocks.tx.teamChatMember.updateMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("preserves a manually granted admin role when that user also becomes project-managed", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.projektMitglied.findMany.mockResolvedValue([{ userId: "user_manual_admin", groupId: null }]);
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([tenantUser("user_manual_admin")]);
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_manual_admin",
|
||||
userId: "user_manual_admin",
|
||||
roleInChat: "admin",
|
||||
isProjectManaged: false,
|
||||
isManualMember: true,
|
||||
}),
|
||||
]);
|
||||
|
||||
await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_manual_admin",
|
||||
});
|
||||
|
||||
expect(memberUpdateFor("user_manual_admin")?.data).toEqual({
|
||||
isProjectManaged: true,
|
||||
projectRoleInChat: "member",
|
||||
roleInChat: "admin",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
});
|
||||
});
|
||||
|
||||
it("promotes a manual member while they are project lead and falls back to manual member after project removal", async () => {
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_overlap",
|
||||
userId: "user_pl",
|
||||
roleInChat: "member",
|
||||
isProjectManaged: false,
|
||||
isManualMember: true,
|
||||
manualRoleInChat: "member",
|
||||
projectRoleInChat: null,
|
||||
}),
|
||||
]);
|
||||
|
||||
await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_promote_project_lead",
|
||||
});
|
||||
|
||||
expect(memberUpdateFor("user_pl")?.data).toEqual({
|
||||
isProjectManaged: true,
|
||||
projectRoleInChat: "admin",
|
||||
roleInChat: "admin",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
});
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({ kind: "project_leader_changed", metadata: expect.objectContaining({ newLeaderUserId: "user_pl" }) })
|
||||
);
|
||||
|
||||
vi.clearAllMocks();
|
||||
mocks.tx.$executeRaw.mockResolvedValue(1);
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.projektMitglied.findMany.mockResolvedValue([]);
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChat.findFirst.mockResolvedValue(CHANNEL);
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_overlap",
|
||||
userId: "user_pl",
|
||||
roleInChat: "admin",
|
||||
isManualMember: true,
|
||||
manualRoleInChat: "member",
|
||||
projectRoleInChat: "admin",
|
||||
}),
|
||||
]);
|
||||
mocks.tx.teamChatMember.updateMany.mockResolvedValue({ count: 1 });
|
||||
mocks.publishAuditEventViaOutbox.mockResolvedValue(undefined);
|
||||
mocks.logActivity.mockResolvedValue({ id: "activity_2" });
|
||||
|
||||
const removed = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_remove_project_lead",
|
||||
});
|
||||
|
||||
expect(removed.writeRevokedUserIds).toEqual([]);
|
||||
expect(memberUpdateFor("user_pl")?.data).toEqual({
|
||||
isProjectManaged: false,
|
||||
projectRoleInChat: null,
|
||||
roleInChat: "member",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
});
|
||||
});
|
||||
|
||||
it("keeps a manual admin effective after losing the project-lead source", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_manual_admin",
|
||||
userId: "user_old_pl",
|
||||
roleInChat: "admin",
|
||||
isManualMember: true,
|
||||
manualRoleInChat: "admin",
|
||||
projectRoleInChat: "admin",
|
||||
}),
|
||||
]);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_manual_admin_fallback",
|
||||
});
|
||||
|
||||
expect(result.writeRevokedUserIds).toEqual([]);
|
||||
expect(memberUpdateFor("user_old_pl")?.data).toEqual({
|
||||
isProjectManaged: false,
|
||||
projectRoleInChat: null,
|
||||
roleInChat: "admin",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
});
|
||||
});
|
||||
|
||||
it("demotes and write-revokes a pure former project lead without retaining admin", async () => {
|
||||
mocks.tx.projekt.findFirst.mockResolvedValue({ ...BASE_PROJECT, projektleiterId: null });
|
||||
mocks.tx.tenantUser.findMany.mockResolvedValue([]);
|
||||
mocks.tx.teamChatMember.findMany.mockResolvedValue([
|
||||
projectMember({
|
||||
id: "member_old_pl",
|
||||
userId: "user_old_pl",
|
||||
roleInChat: "admin",
|
||||
projectRoleInChat: "admin",
|
||||
}),
|
||||
]);
|
||||
|
||||
const result = await ensureAndSyncProjectChannelWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
requestId: "request_revoke_old_project_lead",
|
||||
});
|
||||
|
||||
expect(result.writeRevokedUserIds).toEqual(["user_old_pl"]);
|
||||
expect(memberUpdateFor("user_old_pl")?.data).toEqual({
|
||||
isProjectManaged: false,
|
||||
projectRoleInChat: null,
|
||||
roleInChat: "member",
|
||||
writeRevokedAt: NOW,
|
||||
leftAt: null,
|
||||
});
|
||||
});
|
||||
|
||||
it("archives an active project channel with a durable event and audit trail", async () => {
|
||||
const result = await archiveProjectChannelIfEnabledWithTx(TX, {
|
||||
tenantId: "tenant_1",
|
||||
projectId: "project_1",
|
||||
actorUserId: null,
|
||||
requestId: "request_archive",
|
||||
reason: "project_completed",
|
||||
archivedAt: NOW,
|
||||
});
|
||||
|
||||
expect(result).toEqual({ chatId: CHANNEL.id, archived: true });
|
||||
expect(mocks.tx.teamChat.updateMany).toHaveBeenCalledWith({
|
||||
where: { tenantId: "tenant_1", id: CHANNEL.id, projektId: "project_1", kind: "project", archivedAt: null },
|
||||
data: { archivedAt: NOW, archivedReason: "project_completed" },
|
||||
});
|
||||
expect(mocks.tx.teamChatEvent.create).toHaveBeenCalledWith({
|
||||
data: {
|
||||
tenantId: "tenant_1",
|
||||
chatId: CHANNEL.id,
|
||||
type: "channel_archived",
|
||||
actorUserId: null,
|
||||
entityId: "project_1",
|
||||
requestId: "request_archive",
|
||||
data: { archivedAt: NOW.toISOString(), reason: "project_completed" },
|
||||
},
|
||||
select: {
|
||||
sequence: true,
|
||||
occurredAt: true,
|
||||
tenantId: true,
|
||||
chatId: true,
|
||||
type: true,
|
||||
actorUserId: true,
|
||||
entityId: true,
|
||||
requestId: true,
|
||||
data: true,
|
||||
},
|
||||
});
|
||||
expect(mocks.writeSystemMessage).toHaveBeenCalledWith(
|
||||
TX,
|
||||
expect.objectContaining({ kind: "channel_archived", metadata: { projectId: "project_1", reason: "project_completed" } })
|
||||
);
|
||||
expect(mocks.publishRealtimeWakeup).toHaveBeenCalledTimes(2);
|
||||
expect(mocks.publishAuditEventViaOutbox).toHaveBeenCalledOnce();
|
||||
expect(mocks.logActivity).toHaveBeenCalledOnce();
|
||||
});
|
||||
});
|
||||
|
||||
function projectMember(overrides: Record<string, unknown> = {}) {
|
||||
const merged = {
|
||||
id: "member_project",
|
||||
userId: "user_project",
|
||||
roleInChat: "member",
|
||||
isProjectManaged: true,
|
||||
isManualMember: false,
|
||||
isGroupManaged: false,
|
||||
manualRoleInChat: null,
|
||||
projectRoleInChat: "member",
|
||||
writeRevokedAt: null,
|
||||
leftAt: null,
|
||||
...overrides,
|
||||
};
|
||||
return {
|
||||
...merged,
|
||||
manualRoleInChat:
|
||||
Object.prototype.hasOwnProperty.call(overrides, "manualRoleInChat")
|
||||
? merged.manualRoleInChat
|
||||
: merged.isManualMember
|
||||
? merged.roleInChat
|
||||
: null,
|
||||
projectRoleInChat:
|
||||
Object.prototype.hasOwnProperty.call(overrides, "projectRoleInChat")
|
||||
? merged.projectRoleInChat
|
||||
: merged.isProjectManaged
|
||||
? merged.roleInChat
|
||||
: null,
|
||||
};
|
||||
}
|
||||
|
||||
function memberUpdateFor(userId: string): { where: Record<string, unknown>; data: Record<string, unknown> } | undefined {
|
||||
const call = mocks.tx.teamChatMember.updateMany.mock.calls.find((candidate) => candidate[0].where.userId === userId);
|
||||
return call?.[0];
|
||||
}
|
||||
|
||||
function tenantUser(userId: string) {
|
||||
return {
|
||||
userId,
|
||||
user: {
|
||||
firstName: userId,
|
||||
lastName: null,
|
||||
email: `${userId}@example.test`,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function realtimeSystemEvent(input: { tenantId: string; chatId: string; requestId: string }) {
|
||||
return {
|
||||
event: "chat.message.created",
|
||||
cursor: `${CHANNEL.eventStreamId}:99`,
|
||||
requestId: input.requestId,
|
||||
tenantId: input.tenantId,
|
||||
chatId: input.chatId,
|
||||
occurredAt: NOW.toISOString(),
|
||||
data: {},
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user