Track HiveGrid Cloud planning reference
This commit is contained in:
1 parent
b3d5ea6764
commit
e341c5938a
5784 files changed
+1104929
-3
No files matched your search
@@ -0,0 +1,582 @@
|
||||
// @vitest-environment node
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { TenantUserJoined } from "~/application/enums/tenants/TenantUserJoined";
|
||||
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
|
||||
|
||||
vi.mock("~/utils/db.server", () => ({
|
||||
db: {
|
||||
tenant: {
|
||||
count: vi.fn(),
|
||||
create: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
findUnique: vi.fn(),
|
||||
update: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
},
|
||||
tenantUser: {
|
||||
count: vi.fn(),
|
||||
create: vi.fn(),
|
||||
delete: vi.fn(),
|
||||
deleteMany: vi.fn(),
|
||||
findFirst: vi.fn(),
|
||||
findFirstOrThrow: vi.fn(),
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
userRole: {
|
||||
deleteMany: vi.fn(),
|
||||
},
|
||||
groupUser: {
|
||||
deleteMany: vi.fn(),
|
||||
},
|
||||
$transaction: vi.fn(),
|
||||
},
|
||||
dbRead: {
|
||||
tenant: {
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
vi.mock("../helpers/RowFiltersHelper", () => ({
|
||||
default: {
|
||||
getFiltersCondition: vi.fn(),
|
||||
},
|
||||
}));
|
||||
vi.mock("../cache.server", () => ({
|
||||
cachified: vi.fn((options: { getFreshValue: () => unknown }) => options.getFreshValue()),
|
||||
clearCacheKey: vi.fn(),
|
||||
clearCacheKeyPrefix: vi.fn(),
|
||||
}));
|
||||
vi.mock("../services/emailService", () => ({
|
||||
getAvailableTenantInboundAddress: vi.fn(),
|
||||
}));
|
||||
vi.mock("../services/tenantService", () => ({
|
||||
getAvailableTenantSlug: vi.fn(),
|
||||
}));
|
||||
vi.mock("./permissions/userRoles.db.server", () => ({
|
||||
createUserRole: vi.fn(),
|
||||
}));
|
||||
vi.mock("./tenantSubscriptions.db.server", () => ({
|
||||
createTenantSubscription: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/modules/plugins/services/.server/pluginHookPublisher", () => ({
|
||||
emitPluginHookFireAndForget: vi.fn(),
|
||||
}));
|
||||
|
||||
import { db, dbRead } from "~/utils/db.server";
|
||||
import RowFiltersHelper from "../helpers/RowFiltersHelper";
|
||||
import { cachified, clearCacheKey, clearCacheKeyPrefix } from "../cache.server";
|
||||
import { getAvailableTenantInboundAddress } from "../services/emailService";
|
||||
import { getAvailableTenantSlug } from "../services/tenantService";
|
||||
import { createUserRole } from "./permissions/userRoles.db.server";
|
||||
import { createTenantSubscription } from "./tenantSubscriptions.db.server";
|
||||
import { emitPluginHookFireAndForget } from "~/modules/plugins/services/.server/pluginHookPublisher";
|
||||
import {
|
||||
addTenantTypeToTenant,
|
||||
adminGetAllActiveTenantSimple,
|
||||
adminGetAllTenants,
|
||||
adminGetAllTenantsIdsAndNames,
|
||||
adminGetAllTenantsWithUsage,
|
||||
createTenant,
|
||||
createTenantUser,
|
||||
deleteTenant,
|
||||
deleteTenantUser,
|
||||
getAllTenantUsers,
|
||||
getAllTenantsWithoutTypes,
|
||||
getMyTenants,
|
||||
getTenant,
|
||||
getTenantByIdOrSlug,
|
||||
getTenantBySlug,
|
||||
getTenantMember,
|
||||
getTenantSimple,
|
||||
getTenantUser,
|
||||
getTenantUserByIds,
|
||||
getTenantUserSimple,
|
||||
getTenantUserType,
|
||||
getTenantUsers,
|
||||
getTenantUsersCount,
|
||||
getTenantUsersInTenantIds,
|
||||
getTenantWithProfile,
|
||||
getTenantWithUsers,
|
||||
getTenantsInIds,
|
||||
requireTenant,
|
||||
updateTenant,
|
||||
updateTenantDeactivated,
|
||||
updateTenantTheme,
|
||||
} from "./tenants.db.server";
|
||||
|
||||
const dbMock = vi.mocked(db);
|
||||
const dbReadMock = vi.mocked(dbRead);
|
||||
|
||||
describe("tenants db wrapper", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(cachified).mockImplementation((async (options: { getFreshValue: () => unknown }) =>
|
||||
options.getFreshValue()) as never);
|
||||
dbMock.$transaction.mockImplementation((async (operations: Promise<unknown>[] | ((tx: typeof db) => Promise<unknown>)) => {
|
||||
if (Array.isArray(operations)) {
|
||||
return await Promise.all(operations);
|
||||
}
|
||||
return await operations(db);
|
||||
}) as never);
|
||||
vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue(undefined);
|
||||
});
|
||||
|
||||
it("combines admin tenant usage filters for user membership, empty type, and pagination", async () => {
|
||||
const baseWhere = { name: { contains: "acme" } };
|
||||
vi.mocked(RowFiltersHelper.getFiltersCondition).mockReturnValue(baseWhere as never);
|
||||
vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_1" }] as never);
|
||||
vi.mocked(dbMock.tenant.count).mockResolvedValueOnce(42);
|
||||
|
||||
const result = await adminGetAllTenantsWithUsage(
|
||||
{
|
||||
query: "",
|
||||
properties: [
|
||||
{ name: "userId", value: "user_1" },
|
||||
{ name: "typeId", value: "null" },
|
||||
],
|
||||
} as never,
|
||||
{ page: 3, pageSize: 10 }
|
||||
);
|
||||
|
||||
const userWhere = { OR: [baseWhere, { users: { some: { userId: "user_1" } } }] };
|
||||
const expectedWhere = { OR: [userWhere, { types: { none: {} } }] };
|
||||
expect(dbMock.tenant.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
skip: 20,
|
||||
take: 10,
|
||||
where: expectedWhere,
|
||||
orderBy: { createdAt: "desc" },
|
||||
})
|
||||
);
|
||||
expect(dbMock.tenant.count).toHaveBeenCalledWith({ where: expectedWhere });
|
||||
expect(result.pagination).toEqual({ page: 3, pageSize: 10, totalItems: 42, totalPages: 5 });
|
||||
});
|
||||
|
||||
it("uses read and write clients for the basic tenant listing helpers", async () => {
|
||||
vi.mocked(dbMock.tenant.findMany).mockResolvedValue([] as never);
|
||||
vi.mocked(dbReadMock.tenant.findMany).mockResolvedValue([] as never);
|
||||
|
||||
await getTenantsInIds(["tenant_1", "tenant_2"]);
|
||||
await adminGetAllTenants();
|
||||
await adminGetAllTenantsIdsAndNames();
|
||||
await adminGetAllActiveTenantSimple();
|
||||
|
||||
expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({ where: { id: { in: ["tenant_1", "tenant_2"] } } })
|
||||
);
|
||||
expect(dbMock.tenant.findMany).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({ orderBy: { createdAt: "desc" } })
|
||||
);
|
||||
expect(dbReadMock.tenant.findMany).toHaveBeenNthCalledWith(1, {
|
||||
select: { id: true, name: true, slug: true },
|
||||
});
|
||||
expect(dbReadMock.tenant.findMany).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
where: { active: true },
|
||||
orderBy: { name: "asc" },
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it("wraps cached tenant identity lookups with stable cache keys", async () => {
|
||||
vi.mocked(dbMock.tenant.findUnique).mockResolvedValue({ id: "tenant_1" } as never);
|
||||
vi.mocked(dbMock.tenant.findFirst).mockResolvedValue({ id: "tenant_1" } as never);
|
||||
|
||||
await getTenant("tenant_1");
|
||||
await getTenantSimple("tenant_1");
|
||||
await getTenantByIdOrSlug("acme");
|
||||
|
||||
expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenant:tenant_1" }));
|
||||
expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenantSimple:tenant_1" }));
|
||||
expect(cachified).toHaveBeenCalledWith(expect.objectContaining({ key: "tenantIdOrSlug:acme" }));
|
||||
expect(dbMock.tenant.findFirst).toHaveBeenCalledWith({
|
||||
where: { OR: [{ id: "acme" }, { slug: "acme" }] },
|
||||
include: { subscription: true },
|
||||
});
|
||||
});
|
||||
|
||||
it("queries direct tenant identity variants without cache wrappers", async () => {
|
||||
vi.mocked(dbMock.tenant.findUnique).mockResolvedValue({ id: "tenant_1" } as never);
|
||||
|
||||
await getTenantBySlug("acme");
|
||||
await getTenantWithProfile("tenant_1");
|
||||
await getTenantWithUsers("tenant_1");
|
||||
|
||||
expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(1, { where: { slug: "acme" } });
|
||||
expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(2, { where: { id: "tenant_1" }, include: { types: true } });
|
||||
expect(dbMock.tenant.findUnique).toHaveBeenNthCalledWith(3, { where: { id: "tenant_1" }, include: { users: true } });
|
||||
});
|
||||
|
||||
it("uses the free-text query as a user filter and concrete tenant type when no base filter exists", async () => {
|
||||
vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([] as never);
|
||||
vi.mocked(dbMock.tenant.count).mockResolvedValueOnce(3);
|
||||
|
||||
const result = await adminGetAllTenantsWithUsage({
|
||||
query: "user_query",
|
||||
properties: [{ name: "typeId", value: "type_pro" }],
|
||||
} as never);
|
||||
|
||||
const expectedWhere = {
|
||||
OR: [{ users: { some: { userId: "user_query" } } }, { types: { some: { id: "type_pro" } } }],
|
||||
};
|
||||
expect(dbMock.tenant.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
skip: undefined,
|
||||
take: undefined,
|
||||
where: expectedWhere,
|
||||
})
|
||||
);
|
||||
expect(result.pagination).toEqual({ page: 1, pageSize: 10, totalItems: 3, totalPages: 1 });
|
||||
});
|
||||
|
||||
it("throws a descriptive error when requireTenant cannot resolve a tenant", async () => {
|
||||
vi.mocked(dbMock.tenant.findUnique).mockResolvedValueOnce(null);
|
||||
|
||||
await expect(requireTenant("tenant_missing")).rejects.toThrow("Tenant not found: tenant_missing");
|
||||
});
|
||||
|
||||
it("returns null early for tenant-with-users and tenant-user lookups without ids", async () => {
|
||||
await expect(getTenantWithUsers()).resolves.toBeNull();
|
||||
await expect(getTenantUser()).resolves.toBeNull();
|
||||
|
||||
expect(dbMock.tenant.findUnique).not.toHaveBeenCalled();
|
||||
expect(dbMock.tenantUser.findFirst).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("returns active member tenants and active tenant-user counts", async () => {
|
||||
vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([{ id: "tenant_1" }] as never);
|
||||
vi.mocked(dbMock.tenantUser.count).mockResolvedValueOnce(7);
|
||||
|
||||
await expect(getMyTenants("user_1")).resolves.toEqual([{ id: "tenant_1" }]);
|
||||
await expect(getTenantUsersCount("tenant_1")).resolves.toBe(7);
|
||||
|
||||
expect(dbMock.tenant.findMany).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
where: { active: true, users: { some: { userId: "user_1", status: TenantUserStatus.ACTIVE } } },
|
||||
orderBy: { name: "asc" },
|
||||
})
|
||||
);
|
||||
expect(dbMock.tenantUser.count).toHaveBeenCalledWith({
|
||||
where: { tenantId: "tenant_1", status: TenantUserStatus.ACTIVE },
|
||||
});
|
||||
});
|
||||
|
||||
it("scopes tenant users to active members and tenant-local role includes by default", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findMany).mockResolvedValueOnce([{ id: "tu_1" }] as never);
|
||||
|
||||
await expect(getTenantUsers("tenant_1")).resolves.toEqual([{ id: "tu_1" }]);
|
||||
|
||||
expect(dbMock.tenantUser.findMany).toHaveBeenCalledWith({
|
||||
where: { tenantId: "tenant_1", status: TenantUserStatus.ACTIVE },
|
||||
include: {
|
||||
user: {
|
||||
include: {
|
||||
roles: { where: { tenantId: "tenant_1" }, include: { role: true } },
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("skips the active-member status filter when inactive members are requested", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await getTenantUsers("tenant_1", { includeInactive: true });
|
||||
|
||||
expect(dbMock.tenantUser.findMany).toHaveBeenCalledWith(expect.objectContaining({ where: { tenantId: "tenant_1" } }));
|
||||
});
|
||||
|
||||
it("returns an empty member list without touching the database when tenant id is blank", async () => {
|
||||
await expect(getTenantUsers(null)).resolves.toEqual([]);
|
||||
|
||||
expect(dbMock.tenantUser.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("adds tenant scope to tenant-user lookup only when a tenant id is provided", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValue({ id: "tu_1" } as never);
|
||||
|
||||
await getTenantUser("tu_1");
|
||||
await getTenantUser("tu_1", "tenant_1");
|
||||
|
||||
expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({ where: { id: "tu_1" } })
|
||||
);
|
||||
expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({ where: { id: "tu_1", tenantId: "tenant_1" } })
|
||||
);
|
||||
});
|
||||
|
||||
it("queries bulk and admin tenant-user projections with tenant-safe includes", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findMany).mockResolvedValue([] as never);
|
||||
|
||||
await getTenantUsersInTenantIds(["tenant_1", "tenant_2"]);
|
||||
await getAllTenantUsers();
|
||||
|
||||
expect(dbMock.tenantUser.findMany).toHaveBeenNthCalledWith(1, {
|
||||
where: { tenantId: { in: ["tenant_1", "tenant_2"] } },
|
||||
include: {
|
||||
tenant: true,
|
||||
user: { select: expect.any(Object) },
|
||||
},
|
||||
});
|
||||
expect(dbMock.tenantUser.findMany).toHaveBeenNthCalledWith(2, {
|
||||
include: {
|
||||
user: {
|
||||
include: {
|
||||
admin: true,
|
||||
roles: { include: { role: true } },
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("queries tenant-user membership by composite identity and active member predicates", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValue({ id: "tu_1" } as never);
|
||||
|
||||
await getTenantUserByIds("tenant_1", "user_1");
|
||||
await getTenantMember("user_1", "tenant_1");
|
||||
await getTenantUserType("user_1", "tenant_1");
|
||||
|
||||
expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({ where: { tenantId: "tenant_1", userId: "user_1" } })
|
||||
);
|
||||
expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
where: { userId: "user_1", tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } },
|
||||
})
|
||||
);
|
||||
expect(dbMock.tenantUser.findFirst).toHaveBeenNthCalledWith(3, {
|
||||
where: { userId: "user_1", tenantId: "tenant_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } },
|
||||
select: { status: true, type: true },
|
||||
});
|
||||
});
|
||||
|
||||
it("caches tenant-user simple lookups and converts missing rows to null", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findFirstOrThrow).mockRejectedValueOnce(new Error("not found"));
|
||||
|
||||
await expect(getTenantUserSimple({ tenantId: "tenant_1", userId: "user_1" })).resolves.toBeNull();
|
||||
|
||||
expect(cachified).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
key: "tenantUserSimple:tenant_1:user_1",
|
||||
ttl: 1000 * 60 * 60 * 24,
|
||||
})
|
||||
);
|
||||
expect(dbMock.tenantUser.findFirstOrThrow).toHaveBeenCalledWith({
|
||||
where: { tenantId: "tenant_1", userId: "user_1", status: TenantUserStatus.ACTIVE, tenant: { active: true } },
|
||||
select: { id: true, type: true },
|
||||
});
|
||||
});
|
||||
|
||||
it("updates tenant profile data, tenant types, and all slug/id cache keys", async () => {
|
||||
vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "new-slug" } as never);
|
||||
|
||||
await updateTenant(
|
||||
{ id: "tenant_1", slug: "old-slug" } as never,
|
||||
{ name: "Acme", icon: "icon", slug: "new-slug", typeIds: ["type_1", "type_2"] }
|
||||
);
|
||||
|
||||
expect(dbMock.tenant.update).toHaveBeenCalledWith({
|
||||
where: { id: "tenant_1" },
|
||||
data: {
|
||||
name: "Acme",
|
||||
icon: "icon",
|
||||
slug: "new-slug",
|
||||
types: { set: [{ id: "type_1" }, { id: "type_2" }] },
|
||||
},
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:old-slug");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:old-slug");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1");
|
||||
});
|
||||
|
||||
it("updates tenant theme and invalidates API-key tenant cache prefixes", async () => {
|
||||
vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never);
|
||||
|
||||
await updateTenantTheme("tenant_1", { theme: "dark", themeConfig: "{\"accent\":\"blue\"}" });
|
||||
|
||||
expect(dbMock.tenant.update).toHaveBeenCalledWith({
|
||||
where: { id: "tenant_1" },
|
||||
data: { theme: "dark", themeConfig: "{\"accent\":\"blue\"}" },
|
||||
});
|
||||
expect(clearCacheKeyPrefix).toHaveBeenCalledWith("apiKeyHash:");
|
||||
});
|
||||
|
||||
it("adds a tenant type and clears tenant cache keys", async () => {
|
||||
vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never);
|
||||
|
||||
await addTenantTypeToTenant("tenant_1", { typeId: "type_1" });
|
||||
|
||||
expect(dbMock.tenant.update).toHaveBeenCalledWith({
|
||||
where: { id: "tenant_1" },
|
||||
data: { types: { connect: { id: "type_1" } } },
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:acme");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1");
|
||||
});
|
||||
|
||||
it("creates tenants inactive when requested and emits the tenant-created plugin hook", async () => {
|
||||
const createdAt = new Date("2026-05-25T12:00:00.000Z");
|
||||
vi.mocked(getAvailableTenantSlug).mockResolvedValueOnce("acme");
|
||||
vi.mocked(getAvailableTenantInboundAddress).mockResolvedValueOnce("acme@example.test");
|
||||
vi.mocked(dbMock.tenant.create).mockResolvedValueOnce({ id: "tenant_1", slug: "acme", createdAt } as never);
|
||||
|
||||
await createTenant({ name: "Acme", icon: "icon", active: false, slug: "acme" });
|
||||
|
||||
expect(dbMock.tenant.create).toHaveBeenCalledWith({
|
||||
data: {
|
||||
name: "Acme",
|
||||
slug: "acme",
|
||||
icon: "icon",
|
||||
active: false,
|
||||
inboundAddresses: { create: [{ address: "acme@example.test" }] },
|
||||
},
|
||||
});
|
||||
expect(createTenantSubscription).not.toHaveBeenCalled();
|
||||
expect(emitPluginHookFireAndForget).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ name: "tenant.created" }),
|
||||
{
|
||||
tenantId: "tenant_1",
|
||||
slug: "acme",
|
||||
ownerEmail: null,
|
||||
plan: null,
|
||||
createdAt: "2026-05-25T12:00:00.000Z",
|
||||
},
|
||||
{ tenantId: "tenant_1", dispatchKey: "tenant:tenant_1:created" }
|
||||
);
|
||||
});
|
||||
|
||||
it("defaults new tenants active and creates a subscription when a customer id is present", async () => {
|
||||
vi.mocked(getAvailableTenantSlug).mockResolvedValueOnce("acme");
|
||||
vi.mocked(getAvailableTenantInboundAddress).mockResolvedValueOnce("acme@example.test");
|
||||
vi.mocked(dbMock.tenant.create).mockResolvedValueOnce({
|
||||
id: "tenant_1",
|
||||
slug: "acme",
|
||||
createdAt: new Date("2026-05-25T12:00:00.000Z"),
|
||||
} as never);
|
||||
|
||||
await createTenant({ name: "Acme", subscriptionCustomerId: "cus_1" });
|
||||
|
||||
expect(dbMock.tenant.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ active: true }) }));
|
||||
expect(createTenantSubscription).toHaveBeenCalledWith("tenant_1", "cus_1");
|
||||
});
|
||||
|
||||
it("creates tenant users as active invited members and assigns each requested role", async () => {
|
||||
vi.mocked(dbMock.tenantUser.create).mockResolvedValueOnce({ id: "tu_1", tenantId: "tenant_1", userId: "user_1" } as never);
|
||||
|
||||
await createTenantUser(
|
||||
{ tenantId: "tenant_1", userId: "user_1", type: 0 },
|
||||
[{ id: "role_admin" }, { id: "role_member" }] as never
|
||||
);
|
||||
|
||||
expect(dbMock.tenantUser.create).toHaveBeenCalledWith({
|
||||
data: {
|
||||
tenantId: "tenant_1",
|
||||
userId: "user_1",
|
||||
type: 0,
|
||||
joined: TenantUserJoined.JOINED_BY_INVITATION,
|
||||
status: TenantUserStatus.ACTIVE,
|
||||
},
|
||||
});
|
||||
expect(createUserRole).toHaveBeenCalledWith("user_1", "role_admin", "tenant_1");
|
||||
expect(createUserRole).toHaveBeenCalledWith("user_1", "role_member", "tenant_1");
|
||||
});
|
||||
|
||||
it("does not delete cross-tenant membership when a tenant-scoped delete misses", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValueOnce(null);
|
||||
|
||||
await expect(deleteTenantUser("tu_1", "tenant_1")).resolves.toEqual({ count: 0 });
|
||||
|
||||
expect(dbMock.tenantUser.deleteMany).not.toHaveBeenCalled();
|
||||
expect(dbMock.$transaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("deletes tenant-scoped membership, roles, groups, and user-role cache together", async () => {
|
||||
vi.mocked(dbMock.tenantUser.findFirst).mockResolvedValueOnce({ tenantId: "tenant_1", userId: "user_1" } as never);
|
||||
vi.mocked(dbMock.tenantUser.deleteMany).mockResolvedValueOnce({ count: 1 } as never);
|
||||
vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 2 } as never);
|
||||
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never);
|
||||
|
||||
await expect(deleteTenantUser("tu_1", "tenant_1")).resolves.toEqual({ count: 1 });
|
||||
|
||||
expect(dbMock.tenantUser.deleteMany).toHaveBeenCalledWith({ where: { id: "tu_1", tenantId: "tenant_1" } });
|
||||
expect(dbMock.userRole.deleteMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", userId: "user_1" } });
|
||||
expect(dbMock.groupUser.deleteMany).toHaveBeenCalledWith({
|
||||
where: { userId: "user_1", group: { tenantId: "tenant_1" } },
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
|
||||
});
|
||||
|
||||
it("cleans role and group links after an unscoped tenant-user delete when the deleted row has a tenant", async () => {
|
||||
vi.mocked(dbMock.tenantUser.delete).mockResolvedValueOnce({ id: "tu_1", tenantId: "tenant_1", userId: "user_1" } as never);
|
||||
vi.mocked(dbMock.userRole.deleteMany).mockResolvedValueOnce({ count: 2 } as never);
|
||||
vi.mocked(dbMock.groupUser.deleteMany).mockResolvedValueOnce({ count: 3 } as never);
|
||||
|
||||
await deleteTenantUser("tu_1");
|
||||
|
||||
expect(dbMock.$transaction).toHaveBeenCalledTimes(1);
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("userRoles:user_1:tenant_1");
|
||||
});
|
||||
|
||||
it("returns an unscoped tenant-user delete without cleanup when the deleted row has no tenant", async () => {
|
||||
vi.mocked(dbMock.tenantUser.delete).mockResolvedValueOnce({ id: "tu_1", tenantId: null, userId: "user_1" } as never);
|
||||
|
||||
await expect(deleteTenantUser("tu_1")).resolves.toEqual({ id: "tu_1", tenantId: null, userId: "user_1" });
|
||||
|
||||
expect(dbMock.$transaction).not.toHaveBeenCalled();
|
||||
expect(clearCacheKey).not.toHaveBeenCalledWith("userRoles:user_1:null");
|
||||
});
|
||||
|
||||
it("deletes tenants with dependent records included", async () => {
|
||||
vi.mocked(dbMock.tenant.delete).mockResolvedValueOnce({ id: "tenant_1" } as never);
|
||||
|
||||
await deleteTenant("tenant_1");
|
||||
|
||||
expect(dbMock.tenant.delete).toHaveBeenCalledWith({
|
||||
where: { id: "tenant_1" },
|
||||
include: {
|
||||
subscription: true,
|
||||
users: true,
|
||||
invitations: true,
|
||||
rows: true,
|
||||
logs: true,
|
||||
apiKeys: true,
|
||||
userRoles: true,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("updates deactivation state and clears tenant identity cache keys", async () => {
|
||||
vi.mocked(dbMock.tenant.update).mockResolvedValueOnce({ id: "tenant_1", slug: "acme" } as never);
|
||||
|
||||
await updateTenantDeactivated("tenant_1", { active: false, deactivatedReason: "billing" });
|
||||
|
||||
expect(dbMock.tenant.update).toHaveBeenCalledWith({
|
||||
where: { id: "tenant_1" },
|
||||
data: { active: false, deactivatedReason: "billing" },
|
||||
});
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:acme");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenant:tenant_1");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenantIdOrSlug:acme");
|
||||
expect(clearCacheKey).toHaveBeenCalledWith("tenantSimple:tenant_1");
|
||||
});
|
||||
|
||||
it("lists tenants without assigned types", async () => {
|
||||
vi.mocked(dbMock.tenant.findMany).mockResolvedValueOnce([] as never);
|
||||
|
||||
await getAllTenantsWithoutTypes();
|
||||
|
||||
expect(dbMock.tenant.findMany).toHaveBeenCalledWith({ where: { types: { none: {} } } });
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user