833 lines
26 KiB
TypeScript
833 lines
26 KiB
TypeScript
import { SystemRole } from "@capakraken/shared";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
vi.mock("@capakraken/application", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("@capakraken/application")>();
|
|
return {
|
|
...actual,
|
|
isChargeabilityActualBooking: actual.isChargeabilityActualBooking,
|
|
isChargeabilityRelevantProject: actual.isChargeabilityRelevantProject,
|
|
listAssignmentBookings: vi.fn(),
|
|
recomputeResourceValueScores: vi.fn(),
|
|
};
|
|
});
|
|
|
|
vi.mock("../router/blueprint-validation.js", () => ({
|
|
assertBlueprintDynamicFields: vi.fn().mockResolvedValue(undefined),
|
|
}));
|
|
|
|
vi.mock("../ai-client.js", () => ({
|
|
createAiClient: vi.fn(() => ({
|
|
chat: {
|
|
completions: {
|
|
create: vi.fn().mockResolvedValue({
|
|
choices: [{ message: { content: "Generated summary" } }],
|
|
}),
|
|
},
|
|
},
|
|
responses: {
|
|
create: vi.fn(),
|
|
},
|
|
})),
|
|
isAiConfigured: vi.fn().mockReturnValue(true),
|
|
loggedAiCall: vi.fn(async (_provider, _model, _promptLength, fn) => fn()),
|
|
}));
|
|
|
|
vi.mock("../lib/anonymization.js", () => ({
|
|
anonymizeResource: vi.fn((r: Record<string, unknown>) => r),
|
|
anonymizeResources: vi.fn((rs: unknown[]) => rs),
|
|
anonymizeSearchMatches: vi.fn((rs: unknown[]) => rs),
|
|
getAnonymizationDirectory: vi.fn().mockResolvedValue(null),
|
|
resolveResourceIdsByDisplayedEids: vi.fn().mockResolvedValue(new Map()),
|
|
}));
|
|
|
|
vi.mock("../lib/logger.js", () => ({
|
|
logger: {
|
|
debug: vi.fn(),
|
|
info: vi.fn(),
|
|
warn: vi.fn(),
|
|
error: vi.fn(),
|
|
},
|
|
}));
|
|
|
|
import { resourceRouter } from "../router/resource.js";
|
|
import { createAiClient, isAiConfigured, loggedAiCall } from "../ai-client.js";
|
|
import { getAnonymizationDirectory } from "../lib/anonymization.js";
|
|
import { createCallerFactory } from "../trpc.js";
|
|
|
|
const createCaller = createCallerFactory(resourceRouter);
|
|
|
|
function createManagerCaller(db: Record<string, unknown>) {
|
|
return createCaller({
|
|
session: {
|
|
user: { email: "manager@example.com", name: "Manager", image: null },
|
|
expires: "2099-01-01T00:00:00.000Z",
|
|
},
|
|
db: db as never,
|
|
dbUser: {
|
|
id: "mgr_1",
|
|
systemRole: SystemRole.MANAGER,
|
|
permissionOverrides: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
function createAdminCaller(db: Record<string, unknown>) {
|
|
return createCaller({
|
|
session: {
|
|
user: { email: "admin@example.com", name: "Admin", image: null },
|
|
expires: "2099-01-01T00:00:00.000Z",
|
|
},
|
|
db: db as never,
|
|
dbUser: {
|
|
id: "admin_1",
|
|
systemRole: SystemRole.ADMIN,
|
|
permissionOverrides: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
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,
|
|
},
|
|
});
|
|
}
|
|
|
|
const sampleResource = {
|
|
id: "res_1",
|
|
eid: "E-001",
|
|
displayName: "Alice",
|
|
email: "alice@example.com",
|
|
chapter: "CGI",
|
|
lcrCents: 5000,
|
|
ucrCents: 9000,
|
|
currency: "EUR",
|
|
chargeabilityTarget: 80,
|
|
availability: {
|
|
monday: 8,
|
|
tuesday: 8,
|
|
wednesday: 8,
|
|
thursday: 8,
|
|
friday: 8,
|
|
},
|
|
skills: [],
|
|
dynamicFields: {},
|
|
blueprintId: null,
|
|
blueprint: null,
|
|
isActive: true,
|
|
createdAt: new Date("2026-03-01"),
|
|
updatedAt: new Date("2026-03-01"),
|
|
roleId: null,
|
|
portfolioUrl: null,
|
|
postalCode: null,
|
|
federalState: null,
|
|
valueScore: null,
|
|
valueScoreBreakdown: null,
|
|
valueScoreUpdatedAt: null,
|
|
userId: null,
|
|
resourceRoles: [],
|
|
areaRole: null,
|
|
countryId: null,
|
|
metroCityId: null,
|
|
orgUnitId: null,
|
|
managementLevelGroupId: null,
|
|
managementLevelId: null,
|
|
resourceType: null,
|
|
chgResponsibility: null,
|
|
rolledOff: false,
|
|
departed: false,
|
|
enterpriseId: null,
|
|
clientUnitId: null,
|
|
fte: 1,
|
|
};
|
|
|
|
describe("resource router CRUD", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
// ─── listStaff ────────────────────────────────────────────────────────────
|
|
|
|
describe("listStaff", () => {
|
|
it("returns paginated results with total count for staff callers", async () => {
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([sampleResource]),
|
|
count: vi.fn().mockResolvedValue(1),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.listStaff({ limit: 50 });
|
|
|
|
expect(result.resources).toHaveLength(1);
|
|
expect(result.resources[0]?.displayName).toBe("Alice");
|
|
expect(db.resource.findMany).toHaveBeenCalled();
|
|
});
|
|
|
|
it("applies search filter for staff callers", async () => {
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
count: vi.fn().mockResolvedValue(0),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await caller.listStaff({ search: "Alice", limit: 50 });
|
|
|
|
expect(db.resource.findMany).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
// ─── getById ──────────────────────────────────────────────────────────────
|
|
|
|
describe("getById", () => {
|
|
it("returns correct resource", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_1" }),
|
|
findUnique: vi.fn().mockResolvedValue({ ...sampleResource, userId: "user_1" }),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getById({ id: "res_1" });
|
|
|
|
expect(result.id).toBe("res_1");
|
|
expect(result.displayName).toBe("Alice");
|
|
});
|
|
|
|
it("throws NOT_FOUND when resource does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_1" }),
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.getById({ id: "missing" })).rejects.toThrow(
|
|
expect.objectContaining({ code: "NOT_FOUND" }),
|
|
);
|
|
});
|
|
|
|
it("sets isOwnedByCurrentUser when userId matches", async () => {
|
|
const ownedResource = { ...sampleResource, userId: "user_1" };
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_1" }),
|
|
findUnique: vi.fn().mockResolvedValue(ownedResource),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getById({ id: "res_1" });
|
|
|
|
expect(result.isOwnedByCurrentUser).toBe(true);
|
|
});
|
|
|
|
it("rejects foreign resources for regular users", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_own" }),
|
|
findUnique: vi.fn().mockResolvedValue(sampleResource),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.getById({ id: "res_1" })).rejects.toThrow(
|
|
expect.objectContaining({ code: "FORBIDDEN" }),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("getByEid", () => {
|
|
it("returns the matching resource for staff callers", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(sampleResource),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.getByEid({ eid: "E-001" });
|
|
|
|
expect(result).toMatchObject({
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
eid: "E-001",
|
|
});
|
|
expect(db.resource.findUnique).toHaveBeenCalledWith({ where: { eid: "E-001" } });
|
|
});
|
|
|
|
it("throws NOT_FOUND when the requested eid does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await expect(caller.getByEid({ eid: "E-404" })).rejects.toThrow(
|
|
expect.objectContaining({ code: "NOT_FOUND" }),
|
|
);
|
|
});
|
|
|
|
it("resolves anonymized alias eids through the directory fallback", async () => {
|
|
vi.mocked(getAnonymizationDirectory).mockResolvedValueOnce({
|
|
byAliasEid: new Map([["alias-e-001", "res_1"]]),
|
|
} as Awaited<ReturnType<typeof getAnonymizationDirectory>>);
|
|
|
|
const findUnique = vi
|
|
.fn()
|
|
.mockResolvedValueOnce(null)
|
|
.mockResolvedValueOnce(sampleResource);
|
|
const db = {
|
|
resource: {
|
|
findUnique,
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.getByEid({ eid: "alias-e-001" });
|
|
|
|
expect(result).toMatchObject({
|
|
id: "res_1",
|
|
eid: "E-001",
|
|
});
|
|
expect(findUnique).toHaveBeenNthCalledWith(1, { where: { eid: "alias-e-001" } });
|
|
expect(findUnique).toHaveBeenNthCalledWith(2, { where: { id: "res_1" } });
|
|
});
|
|
});
|
|
|
|
// ─── create ───────────────────────────────────────────────────────────────
|
|
|
|
describe("create", () => {
|
|
it("creates a resource and returns it", async () => {
|
|
const created = { ...sampleResource, id: "res_new", resourceRoles: [] };
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue(null),
|
|
create: vi.fn().mockResolvedValue(created),
|
|
},
|
|
auditLog: { create: vi.fn().mockResolvedValue({}) },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.create({
|
|
eid: "E-NEW",
|
|
displayName: "New Resource",
|
|
email: "new@example.com",
|
|
lcrCents: 4000,
|
|
ucrCents: 8000,
|
|
});
|
|
|
|
expect(result.id).toBe("res_new");
|
|
expect(db.resource.create).toHaveBeenCalled();
|
|
expect(db.auditLog.create).toHaveBeenCalled();
|
|
});
|
|
|
|
it("throws CONFLICT on duplicate eid or email", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue(sampleResource),
|
|
create: vi.fn(),
|
|
},
|
|
auditLog: { create: vi.fn() },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await expect(
|
|
caller.create({
|
|
eid: "E-001",
|
|
displayName: "Duplicate",
|
|
email: "alice@example.com",
|
|
lcrCents: 5000,
|
|
ucrCents: 9000,
|
|
}),
|
|
).rejects.toThrow(
|
|
expect.objectContaining({ code: "CONFLICT" }),
|
|
);
|
|
});
|
|
|
|
it("blocks USER role from creating resources", async () => {
|
|
const db = {
|
|
resource: { findFirst: vi.fn(), create: vi.fn() },
|
|
auditLog: { create: vi.fn() },
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(
|
|
caller.create({
|
|
eid: "E-002",
|
|
displayName: "Blocked",
|
|
email: "blocked@example.com",
|
|
lcrCents: 4000,
|
|
ucrCents: 8000,
|
|
}),
|
|
).rejects.toThrow(
|
|
expect.objectContaining({ code: "FORBIDDEN" }),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── update ───────────────────────────────────────────────────────────────
|
|
|
|
describe("update", () => {
|
|
it("updates resource fields", async () => {
|
|
const updated = { ...sampleResource, displayName: "Alice Updated" };
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(sampleResource),
|
|
update: vi.fn().mockResolvedValue(updated),
|
|
},
|
|
resourceRole: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
|
|
auditLog: { create: vi.fn().mockResolvedValue({}) },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.update({
|
|
id: "res_1",
|
|
data: { displayName: "Alice Updated" },
|
|
});
|
|
|
|
expect(result.displayName).toBe("Alice Updated");
|
|
expect(db.resource.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({ where: { id: "res_1" } }),
|
|
);
|
|
});
|
|
|
|
it("throws NOT_FOUND when resource does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
update: vi.fn(),
|
|
},
|
|
auditLog: { create: vi.fn() },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await expect(
|
|
caller.update({ id: "missing", data: { displayName: "X" } }),
|
|
).rejects.toThrow(
|
|
expect.objectContaining({ code: "NOT_FOUND" }),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── deactivate ───────────────────────────────────────────────────────────
|
|
|
|
describe("deactivate", () => {
|
|
it("sets isActive to false", async () => {
|
|
const deactivated = { ...sampleResource, isActive: false };
|
|
const db = {
|
|
resource: {
|
|
update: vi.fn().mockResolvedValue(deactivated),
|
|
},
|
|
auditLog: { create: vi.fn().mockResolvedValue({}) },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.deactivate({ id: "res_1" });
|
|
|
|
expect(result.isActive).toBe(false);
|
|
expect(db.resource.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { id: "res_1" },
|
|
data: { isActive: false },
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("batchDeactivate", () => {
|
|
it("deactivates all requested resources and records one audit entry", async () => {
|
|
const update = vi
|
|
.fn()
|
|
.mockResolvedValueOnce({ ...sampleResource, id: "res_1", isActive: false })
|
|
.mockResolvedValueOnce({ ...sampleResource, id: "res_2", isActive: false });
|
|
const db = {
|
|
resource: {
|
|
update,
|
|
},
|
|
$transaction: vi.fn(async (operations: Promise<unknown>[]) => Promise.all(operations)),
|
|
auditLog: { create: vi.fn().mockResolvedValue({}) },
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.batchDeactivate({ ids: ["res_1", "res_2"] });
|
|
|
|
expect(result).toEqual({ count: 2 });
|
|
expect(db.$transaction).toHaveBeenCalledTimes(1);
|
|
expect(db.auditLog.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({
|
|
entityType: "Resource",
|
|
action: "UPDATE",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("chapters", () => {
|
|
it("returns active chapter names in ascending order", async () => {
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([
|
|
{ chapter: "Animation" },
|
|
{ chapter: "CGI" },
|
|
]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.chapters();
|
|
|
|
expect(result).toEqual(["Animation", "CGI"]);
|
|
expect(db.resource.findMany).toHaveBeenCalledWith({
|
|
where: { isActive: true, chapter: { not: null } },
|
|
select: { chapter: true },
|
|
distinct: ["chapter"],
|
|
orderBy: { chapter: "asc" },
|
|
});
|
|
});
|
|
});
|
|
|
|
// ─── getHoverCard ─────────────────────────────────────────────────────────
|
|
|
|
describe("getHoverCard", () => {
|
|
it("returns expected shape with key fields", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_1" }),
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
eid: "E-001",
|
|
email: "alice@example.com",
|
|
chapter: "CGI",
|
|
lcrCents: 5000,
|
|
ucrCents: 9000,
|
|
currency: "EUR",
|
|
chargeabilityTarget: 80,
|
|
skills: [],
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
isActive: true,
|
|
areaRole: null,
|
|
country: null,
|
|
managementLevel: null,
|
|
resourceType: null,
|
|
}),
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getHoverCard({ id: "res_1" });
|
|
|
|
expect(result).toMatchObject({
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
chapter: "CGI",
|
|
lcrCents: 5000,
|
|
isActive: true,
|
|
});
|
|
});
|
|
|
|
it("throws NOT_FOUND for missing resource", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_1" }),
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
systemSettings: { findUnique: vi.fn().mockResolvedValue(null) },
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.getHoverCard({ id: "missing" })).rejects.toThrow(
|
|
expect.objectContaining({ code: "NOT_FOUND" }),
|
|
);
|
|
});
|
|
|
|
it("rejects foreign hover-card access for regular users", async () => {
|
|
const db = {
|
|
resource: {
|
|
findFirst: vi.fn().mockResolvedValue({ id: "res_own" }),
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
eid: "E-001",
|
|
email: "alice@example.com",
|
|
chapter: "CGI",
|
|
lcrCents: 5000,
|
|
ucrCents: 9000,
|
|
currency: "EUR",
|
|
chargeabilityTarget: 80,
|
|
skills: [],
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
isActive: true,
|
|
areaRole: null,
|
|
country: null,
|
|
managementLevel: null,
|
|
resourceType: null,
|
|
}),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(caller.getHoverCard({ id: "res_1" })).rejects.toThrow(
|
|
expect.objectContaining({ code: "FORBIDDEN" }),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── importSkillMatrix ────────────────────────────────────────────────────
|
|
|
|
describe("importSkillMatrix", () => {
|
|
it("imports skills for the current user resource", async () => {
|
|
const updatedResource = {
|
|
...sampleResource,
|
|
skills: [{ skill: "Maya", proficiency: 4 }],
|
|
skillMatrixUpdatedAt: new Date(),
|
|
};
|
|
const db = {
|
|
user: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "user_1",
|
|
email: "user@example.com",
|
|
resource: { id: "res_1" },
|
|
}),
|
|
},
|
|
resource: {
|
|
update: vi.fn().mockResolvedValue(updatedResource),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.importSkillMatrix({
|
|
skills: [{ skill: "Maya", proficiency: 4 }],
|
|
});
|
|
|
|
expect(db.user.findUnique).toHaveBeenCalledWith({
|
|
where: { id: "user_1" },
|
|
include: { resource: true },
|
|
});
|
|
expect(db.resource.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { id: "res_1" },
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("throws NOT_FOUND when user has no linked resource", async () => {
|
|
const db = {
|
|
user: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "user_1",
|
|
email: "user@example.com",
|
|
resource: null,
|
|
}),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(
|
|
caller.importSkillMatrix({
|
|
skills: [{ skill: "Nuke", proficiency: 3 }],
|
|
}),
|
|
).rejects.toThrow("No resource linked to your account");
|
|
expect(db.user.findUnique).toHaveBeenCalledWith({
|
|
where: { id: "user_1" },
|
|
include: { resource: true },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("importSkillMatrixForResource", () => {
|
|
it("updates skills for an existing resource", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(sampleResource),
|
|
update: vi.fn().mockResolvedValue(sampleResource),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.importSkillMatrixForResource({
|
|
resourceId: "res_1",
|
|
skills: [{ skill: "Houdini", proficiency: 5 }],
|
|
});
|
|
|
|
expect(result).toEqual({ count: 1 });
|
|
expect(db.resource.findUnique).toHaveBeenCalledWith({ where: { id: "res_1" } });
|
|
expect(db.resource.update).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { id: "res_1" },
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("throws NOT_FOUND when the target resource does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
update: vi.fn(),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
await expect(
|
|
caller.importSkillMatrixForResource({
|
|
resourceId: "missing",
|
|
skills: [{ skill: "Houdini", proficiency: 5 }],
|
|
}),
|
|
).rejects.toThrow(
|
|
expect.objectContaining({ code: "NOT_FOUND" }),
|
|
);
|
|
expect(db.resource.update).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("batchImportSkillMatrices", () => {
|
|
it("updates all matching resources in one transaction and reports missing eids", async () => {
|
|
const update = vi
|
|
.fn()
|
|
.mockResolvedValueOnce({ ...sampleResource, id: "res_1" })
|
|
.mockResolvedValueOnce({ ...sampleResource, id: "res_2", eid: "E-002" });
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([
|
|
{ id: "res_1", eid: "E-001" },
|
|
{ id: "res_2", eid: "E-002" },
|
|
]),
|
|
update,
|
|
},
|
|
$transaction: vi.fn(async (operations: Promise<unknown>[]) => Promise.all(operations)),
|
|
};
|
|
|
|
const caller = createAdminCaller(db);
|
|
const result = await caller.batchImportSkillMatrices({
|
|
entries: [
|
|
{ eid: "E-001", skills: [{ skill: "Houdini", proficiency: 5 }] },
|
|
{ eid: "E-002", skills: [{ skill: "Nuke", proficiency: 4 }] },
|
|
{ eid: "E-404", skills: [{ skill: "Maya", proficiency: 3 }] },
|
|
],
|
|
});
|
|
|
|
expect(result).toEqual({ updated: 2, notFound: 1 });
|
|
expect(db.resource.findMany).toHaveBeenCalledWith({
|
|
where: { eid: { in: ["E-001", "E-002", "E-404"] } },
|
|
select: { id: true, eid: true },
|
|
});
|
|
expect(db.$transaction).toHaveBeenCalledTimes(1);
|
|
expect(db.resource.update).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe("generateAiSummary", () => {
|
|
it("persists the generated summary for the requested resource", async () => {
|
|
const update = vi.fn().mockResolvedValue({
|
|
...sampleResource,
|
|
aiSummary: "Generated summary",
|
|
});
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
...sampleResource,
|
|
skills: [
|
|
{ skill: "Maya", proficiency: 5, isMainSkill: true },
|
|
{ skill: "Nuke", proficiency: 4 },
|
|
],
|
|
areaRole: { name: "3D Artist" },
|
|
}),
|
|
update,
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "singleton",
|
|
aiProvider: "openai",
|
|
azureOpenAiDeployment: "gpt-test",
|
|
aiSummaryPrompt: null,
|
|
aiMaxCompletionTokens: 200,
|
|
aiTemperature: 0.7,
|
|
}),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
const result = await caller.generateAiSummary({ resourceId: "res_1" });
|
|
|
|
expect(isAiConfigured).toHaveBeenCalledWith(expect.objectContaining({
|
|
azureOpenAiDeployment: "gpt-test",
|
|
}));
|
|
expect(createAiClient).toHaveBeenCalledWith(expect.objectContaining({
|
|
azureOpenAiDeployment: "gpt-test",
|
|
}));
|
|
expect(loggedAiCall).toHaveBeenCalledOnce();
|
|
expect(update).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { id: "res_1" },
|
|
data: expect.objectContaining({
|
|
aiSummary: "Generated summary",
|
|
aiSummaryUpdatedAt: expect.any(Date),
|
|
}),
|
|
}),
|
|
);
|
|
expect(result).toEqual({ summary: "Generated summary" });
|
|
});
|
|
|
|
it("fails fast when AI is not configured", async () => {
|
|
vi.mocked(isAiConfigured).mockReturnValueOnce(false);
|
|
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
...sampleResource,
|
|
areaRole: { name: "3D Artist" },
|
|
}),
|
|
},
|
|
systemSettings: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "singleton",
|
|
aiProvider: "openai",
|
|
azureOpenAiDeployment: null,
|
|
}),
|
|
},
|
|
};
|
|
|
|
const caller = createManagerCaller(db);
|
|
|
|
await expect(caller.generateAiSummary({ resourceId: "res_1" })).rejects.toThrow(
|
|
"AI is not configured. Please set credentials in Admin → Settings.",
|
|
);
|
|
expect(createAiClient).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|