972 lines
30 KiB
TypeScript
972 lines
30 KiB
TypeScript
import { listAssignmentBookings } from "@capakraken/application";
|
|
import { PermissionKey, SystemRole } from "@capakraken/shared";
|
|
import { describe, expect, it, vi } from "vitest";
|
|
import { staffingRouter } from "../router/staffing.js";
|
|
import { createCallerFactory } from "../trpc.js";
|
|
|
|
// Mock the pure-logic packages — we focus on the router/DB layer
|
|
vi.mock("@capakraken/staffing", () => ({
|
|
rankResources: vi.fn().mockImplementation((input: { resources: { id: string }[] }) =>
|
|
input.resources.map((r: { id: string }, i: number) => ({
|
|
resourceId: r.id,
|
|
score: 80 - i * 10,
|
|
breakdown: {
|
|
skillScore: 70,
|
|
availabilityScore: 90,
|
|
costScore: 80,
|
|
utilizationScore: 75,
|
|
},
|
|
})),
|
|
),
|
|
}));
|
|
|
|
vi.mock("@capakraken/application", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("@capakraken/application")>();
|
|
return {
|
|
...actual,
|
|
listAssignmentBookings: vi.fn().mockResolvedValue([]),
|
|
};
|
|
});
|
|
|
|
const createCaller = createCallerFactory(staffingRouter);
|
|
|
|
// ── 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: {
|
|
granted: [PermissionKey.VIEW_PLANNING, PermissionKey.VIEW_COSTS],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
function createAuthenticatedCaller(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 createProtectedCallerWithOverrides(
|
|
db: Record<string, unknown>,
|
|
overrides: { granted?: PermissionKey[]; denied?: PermissionKey[] } | null,
|
|
) {
|
|
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: overrides,
|
|
},
|
|
});
|
|
}
|
|
|
|
// ── Sample data ──────────────────────────────────────────────────────────────
|
|
|
|
function sampleResource(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
eid: "alice",
|
|
lcrCents: 7500,
|
|
chargeabilityTarget: 80,
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
skills: [
|
|
{ skill: "Compositing", proficiency: 4, isMainSkill: true },
|
|
{ skill: "Nuke", proficiency: 3, isMainSkill: false, category: "Software" },
|
|
],
|
|
isActive: true,
|
|
valueScore: 85,
|
|
chapter: "VFX",
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("staffing router authorization", () => {
|
|
const planningWindow = {
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-04-01T00:00:00.000Z"),
|
|
endDate: new Date("2026-04-02T00:00:00.000Z"),
|
|
};
|
|
const projectRankingWindow = {
|
|
projectId: "project_1",
|
|
startDate: new Date("2026-04-01T00:00:00.000Z"),
|
|
endDate: new Date("2026-04-02T00:00:00.000Z"),
|
|
};
|
|
|
|
it.each([
|
|
{
|
|
name: "getSuggestions",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
hoursPerDay: 8,
|
|
}),
|
|
},
|
|
{
|
|
name: "getProjectStaffingSuggestions",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.getProjectStaffingSuggestions({
|
|
projectId: projectRankingWindow.projectId,
|
|
}),
|
|
},
|
|
{
|
|
name: "searchCapacity",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.searchCapacity({
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
}),
|
|
},
|
|
{
|
|
name: "analyzeUtilization",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.analyzeUtilization({
|
|
resourceId: planningWindow.resourceId,
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
}),
|
|
},
|
|
{
|
|
name: "findCapacity",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.findCapacity({
|
|
resourceId: planningWindow.resourceId,
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
}),
|
|
},
|
|
{
|
|
name: "findBestProjectResource",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.findBestProjectResource({
|
|
projectId: projectRankingWindow.projectId,
|
|
startDate: projectRankingWindow.startDate,
|
|
endDate: projectRankingWindow.endDate,
|
|
}),
|
|
},
|
|
{
|
|
name: "getBestProjectResourceDetail",
|
|
invoke: (caller: ReturnType<typeof createAuthenticatedCaller>) => caller.getBestProjectResourceDetail({
|
|
projectId: projectRankingWindow.projectId,
|
|
startDate: projectRankingWindow.startDate,
|
|
endDate: projectRankingWindow.endDate,
|
|
}),
|
|
},
|
|
])("requires planning read access for $name", async ({ invoke }) => {
|
|
const caller = createAuthenticatedCaller({});
|
|
|
|
await expect(invoke(caller)).rejects.toMatchObject({
|
|
code: "FORBIDDEN",
|
|
message: "Planning read access required",
|
|
});
|
|
});
|
|
|
|
it("allows explicit viewPlanning overrides to search capacity", async () => {
|
|
vi.mocked(listAssignmentBookings).mockResolvedValueOnce([]);
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCallerWithOverrides(db, {
|
|
granted: [PermissionKey.VIEW_PLANNING],
|
|
});
|
|
const result = await caller.searchCapacity({
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
});
|
|
|
|
expect(result).toEqual({
|
|
period: "2026-04-01 to 2026-04-02",
|
|
minHoursFilter: 4,
|
|
results: [],
|
|
totalFound: 0,
|
|
});
|
|
});
|
|
|
|
it("does not treat viewCosts as a substitute for viewPlanning on staffing reads", async () => {
|
|
const caller = createProtectedCallerWithOverrides({}, {
|
|
granted: [PermissionKey.VIEW_COSTS],
|
|
});
|
|
|
|
await expect(caller.searchCapacity({
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
})).rejects.toMatchObject({
|
|
code: "FORBIDDEN",
|
|
message: "Planning read access required",
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
{
|
|
name: "getSuggestions",
|
|
invoke: (caller: ReturnType<typeof createProtectedCallerWithOverrides>) => caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: planningWindow.startDate,
|
|
endDate: planningWindow.endDate,
|
|
hoursPerDay: 8,
|
|
}),
|
|
},
|
|
{
|
|
name: "getProjectStaffingSuggestions",
|
|
invoke: (caller: ReturnType<typeof createProtectedCallerWithOverrides>) => caller.getProjectStaffingSuggestions({
|
|
projectId: projectRankingWindow.projectId,
|
|
}),
|
|
},
|
|
{
|
|
name: "findBestProjectResource",
|
|
invoke: (caller: ReturnType<typeof createProtectedCallerWithOverrides>) => caller.findBestProjectResource({
|
|
projectId: projectRankingWindow.projectId,
|
|
startDate: projectRankingWindow.startDate,
|
|
endDate: projectRankingWindow.endDate,
|
|
}),
|
|
},
|
|
{
|
|
name: "getBestProjectResourceDetail",
|
|
invoke: (caller: ReturnType<typeof createProtectedCallerWithOverrides>) => caller.getBestProjectResourceDetail({
|
|
projectId: projectRankingWindow.projectId,
|
|
startDate: projectRankingWindow.startDate,
|
|
endDate: projectRankingWindow.endDate,
|
|
}),
|
|
},
|
|
])("requires viewCosts for $name", async ({ invoke }) => {
|
|
const caller = createProtectedCallerWithOverrides({}, {
|
|
granted: [PermissionKey.VIEW_PLANNING],
|
|
});
|
|
|
|
await expect(invoke(caller)).rejects.toMatchObject({
|
|
code: "FORBIDDEN",
|
|
message: `Permission required: ${PermissionKey.VIEW_COSTS}`,
|
|
});
|
|
});
|
|
});
|
|
|
|
// ─── getSuggestions ──────────────────────────────────────────────────────────
|
|
|
|
describe("staffing.getSuggestions", () => {
|
|
it("returns ranked suggestions for a staffing demand", async () => {
|
|
const resources = [
|
|
sampleResource(),
|
|
sampleResource({ id: "res_2", displayName: "Bob", eid: "bob", valueScore: 70 }),
|
|
];
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue(resources),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
hoursPerDay: 8,
|
|
});
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0]).toHaveProperty("resourceId");
|
|
expect(result[0]).toHaveProperty("score");
|
|
expect(result[0]).toMatchObject({
|
|
resourceName: "Alice",
|
|
eid: "alice",
|
|
location: {
|
|
countryCode: "DE",
|
|
federalState: "BY",
|
|
},
|
|
capacity: expect.objectContaining({
|
|
requestedHoursPerDay: 8,
|
|
baseAvailableHours: expect.any(Number),
|
|
effectiveAvailableHours: expect.any(Number),
|
|
remainingHoursPerDay: expect.any(Number),
|
|
holidayHoursDeduction: expect.any(Number),
|
|
}),
|
|
conflicts: {
|
|
count: expect.any(Number),
|
|
conflictDays: expect.any(Array),
|
|
details: expect.any(Array),
|
|
},
|
|
ranking: expect.objectContaining({
|
|
rank: 1,
|
|
components: expect.any(Array),
|
|
}),
|
|
});
|
|
});
|
|
|
|
it("filters resources by chapter when provided", async () => {
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
hoursPerDay: 8,
|
|
chapter: "VFX",
|
|
});
|
|
|
|
expect(db.resource.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: expect.objectContaining({
|
|
isActive: true,
|
|
chapter: "VFX",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("returns empty array when no resources match", async () => {
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
hoursPerDay: 8,
|
|
});
|
|
|
|
expect(result).toHaveLength(0);
|
|
});
|
|
|
|
it("passes budget constraint to ranking", async () => {
|
|
const resources = [sampleResource()];
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue(resources),
|
|
},
|
|
};
|
|
|
|
const { rankResources } = await import("@capakraken/staffing");
|
|
const caller = createProtectedCaller(db);
|
|
await caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
hoursPerDay: 8,
|
|
budgetLcrCentsPerHour: 10000,
|
|
});
|
|
|
|
expect(rankResources).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
budgetLcrCentsPerHour: 10000,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("uses value score as a transparent tiebreaker within two score points", async () => {
|
|
const resources = [
|
|
sampleResource({ id: "res_1", displayName: "Alice", eid: "alice", valueScore: 60 }),
|
|
sampleResource({ id: "res_2", displayName: "Bob", eid: "bob", valueScore: 95 }),
|
|
];
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue(resources),
|
|
},
|
|
};
|
|
|
|
const { rankResources } = await import("@capakraken/staffing");
|
|
vi.mocked(rankResources).mockImplementationOnce((input: { resources: Array<{ id: string }> }) => ([
|
|
{
|
|
resourceId: input.resources[0]!.id,
|
|
score: 80,
|
|
breakdown: {
|
|
skillScore: 80,
|
|
availabilityScore: 80,
|
|
costScore: 80,
|
|
utilizationScore: 80,
|
|
},
|
|
},
|
|
{
|
|
resourceId: input.resources[1]!.id,
|
|
score: 79,
|
|
breakdown: {
|
|
skillScore: 79,
|
|
availabilityScore: 79,
|
|
costScore: 79,
|
|
utilizationScore: 79,
|
|
},
|
|
},
|
|
]));
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getSuggestions({
|
|
requiredSkills: ["Compositing"],
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
hoursPerDay: 8,
|
|
});
|
|
|
|
expect(result[0]?.resourceId).toBe("res_2");
|
|
expect(result[0]?.ranking).toMatchObject({
|
|
rank: 1,
|
|
baseRank: 2,
|
|
tieBreakerApplied: true,
|
|
});
|
|
expect(result[0]?.ranking.tieBreakerReason).toContain("value score");
|
|
});
|
|
});
|
|
|
|
describe("staffing.getProjectStaffingSuggestions", () => {
|
|
it("returns canonical project-scoped staffing suggestions with defaults and role filter", async () => {
|
|
vi.mocked(listAssignmentBookings).mockResolvedValueOnce([]);
|
|
|
|
const db = {
|
|
project: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "project_1",
|
|
shortCode: "GDM",
|
|
name: "Gelddruckmaschine",
|
|
startDate: new Date("2026-01-06T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-06T00:00:00.000Z"),
|
|
}),
|
|
},
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([
|
|
sampleResource({
|
|
id: "res_by",
|
|
displayName: "Bavaria",
|
|
eid: "BY-1",
|
|
areaRole: { name: "Consultant" },
|
|
country: { code: "DE", name: "Germany" },
|
|
}),
|
|
sampleResource({
|
|
id: "res_hh",
|
|
displayName: "Hamburg",
|
|
eid: "HH-1",
|
|
federalState: "HH",
|
|
areaRole: { name: "Artist" },
|
|
country: { code: "DE", name: "Germany" },
|
|
}),
|
|
]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getProjectStaffingSuggestions({
|
|
projectId: "project_1",
|
|
roleName: "artist",
|
|
limit: 5,
|
|
});
|
|
|
|
expect(result).toEqual({
|
|
project: "Gelddruckmaschine (GDM)",
|
|
period: "2026-01-06 to 2026-01-06",
|
|
suggestions: [
|
|
{
|
|
id: "res_hh",
|
|
name: "Hamburg",
|
|
eid: "HH-1",
|
|
role: "Artist",
|
|
chapter: "VFX",
|
|
fte: expect.any(Number),
|
|
lcr: "75,00 EUR",
|
|
workingDays: expect.any(Number),
|
|
availableHours: expect.any(Number),
|
|
bookedHours: 0,
|
|
availableHoursPerDay: expect.any(Number),
|
|
utilization: 0,
|
|
},
|
|
],
|
|
});
|
|
expect(db.project.findUnique).toHaveBeenCalledWith({
|
|
where: { id: "project_1" },
|
|
select: {
|
|
id: true,
|
|
shortCode: true,
|
|
name: true,
|
|
startDate: true,
|
|
endDate: true,
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("staffing.getBestProjectResourceDetail", () => {
|
|
it("returns canonical project resource ranking with holiday-aware capacity details", async () => {
|
|
const assignmentFindMany = vi
|
|
.fn()
|
|
.mockResolvedValueOnce([
|
|
{
|
|
resourceId: "res_carol",
|
|
hoursPerDay: 2,
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-16T00:00:00.000Z"),
|
|
status: "PROPOSED",
|
|
resource: {
|
|
id: "res_carol",
|
|
eid: "carol.danvers",
|
|
displayName: "Carol Danvers",
|
|
chapter: "Delivery",
|
|
lcrCents: 7664,
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "HH",
|
|
metroCityId: "city_hamburg",
|
|
country: { code: "DE", name: "Deutschland" },
|
|
metroCity: { name: "Hamburg" },
|
|
areaRole: { name: "Artist" },
|
|
},
|
|
},
|
|
{
|
|
resourceId: "res_steve",
|
|
hoursPerDay: 4,
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-16T00:00:00.000Z"),
|
|
status: "CONFIRMED",
|
|
resource: {
|
|
id: "res_steve",
|
|
eid: "steve.rogers",
|
|
displayName: "Steve Rogers",
|
|
chapter: "Delivery",
|
|
lcrCents: 13377,
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: "city_augsburg",
|
|
country: { code: "DE", name: "Deutschland" },
|
|
metroCity: { name: "Augsburg" },
|
|
areaRole: { name: "Artist" },
|
|
},
|
|
},
|
|
])
|
|
.mockResolvedValueOnce([
|
|
{
|
|
resourceId: "res_carol",
|
|
projectId: "project_lari",
|
|
hoursPerDay: 2,
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-16T00:00:00.000Z"),
|
|
status: "PROPOSED",
|
|
project: { name: "Gelddruckmaschine", shortCode: "LARI" },
|
|
},
|
|
{
|
|
resourceId: "res_steve",
|
|
projectId: "project_lari",
|
|
hoursPerDay: 4,
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-16T00:00:00.000Z"),
|
|
status: "CONFIRMED",
|
|
project: { name: "Gelddruckmaschine", shortCode: "LARI" },
|
|
},
|
|
]);
|
|
|
|
const db = {
|
|
project: {
|
|
findUnique: vi.fn().mockResolvedValue({
|
|
id: "project_lari",
|
|
name: "Gelddruckmaschine",
|
|
shortCode: "LARI",
|
|
status: "ACTIVE",
|
|
responsiblePerson: "Larissa Joos",
|
|
}),
|
|
},
|
|
assignment: {
|
|
findMany: assignmentFindMany,
|
|
},
|
|
vacation: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.getBestProjectResourceDetail({
|
|
projectId: "project_lari",
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-16T00:00:00.000Z"),
|
|
minHoursPerDay: 3,
|
|
rankingMode: "lowest_lcr",
|
|
});
|
|
|
|
expect(result.project).toEqual({
|
|
id: "project_lari",
|
|
name: "Gelddruckmaschine",
|
|
shortCode: "LARI",
|
|
status: "ACTIVE",
|
|
responsiblePerson: "Larissa Joos",
|
|
});
|
|
expect(result.period).toEqual({
|
|
startDate: "2026-01-05",
|
|
endDate: "2026-01-16",
|
|
minHoursPerDay: 3,
|
|
rankingMode: "lowest_lcr",
|
|
});
|
|
expect(result.filters).toEqual({
|
|
chapter: null,
|
|
roleName: null,
|
|
});
|
|
expect(result.candidateCount).toBe(2);
|
|
expect(result.bestMatch).toEqual(
|
|
expect.objectContaining({
|
|
name: "Carol Danvers",
|
|
remainingHoursPerDay: 6,
|
|
lcrCents: 7664,
|
|
federalState: "HH",
|
|
metroCity: "Hamburg",
|
|
baseAvailableHours: 80,
|
|
holidaySummary: expect.objectContaining({ count: 0 }),
|
|
}),
|
|
);
|
|
expect(result.candidates).toEqual([
|
|
expect.objectContaining({
|
|
name: "Carol Danvers",
|
|
remainingHoursPerDay: 6,
|
|
workingDays: 10,
|
|
baseAvailableHours: 80,
|
|
holidaySummary: expect.objectContaining({ count: 0, hoursDeduction: 0 }),
|
|
capacityBreakdown: expect.objectContaining({ holidayHoursDeduction: 0 }),
|
|
}),
|
|
expect.objectContaining({
|
|
name: "Steve Rogers",
|
|
remainingHoursPerDay: 4,
|
|
workingDays: 9,
|
|
baseAvailableHours: 80,
|
|
holidaySummary: expect.objectContaining({ count: 1, hoursDeduction: 8 }),
|
|
capacityBreakdown: expect.objectContaining({ holidayHoursDeduction: 8 }),
|
|
}),
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("staffing.searchCapacity", () => {
|
|
it("returns holiday-aware capacity across multiple resources", async () => {
|
|
vi.mocked(listAssignmentBookings).mockResolvedValueOnce([]);
|
|
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([
|
|
sampleResource({
|
|
id: "res_by",
|
|
displayName: "Bavaria",
|
|
eid: "BY-1",
|
|
chapter: "CGI",
|
|
areaRole: { name: "Consultant" },
|
|
federalState: "BY",
|
|
}),
|
|
sampleResource({
|
|
id: "res_hh",
|
|
displayName: "Hamburg",
|
|
eid: "HH-1",
|
|
chapter: "CGI",
|
|
areaRole: { name: "Consultant" },
|
|
federalState: "HH",
|
|
}),
|
|
]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.searchCapacity({
|
|
startDate: new Date("2026-01-06"),
|
|
endDate: new Date("2026-01-06"),
|
|
minHoursPerDay: 1,
|
|
});
|
|
|
|
expect(result.results).toHaveLength(1);
|
|
expect(result.results[0]).toEqual(
|
|
expect.objectContaining({
|
|
name: "Hamburg",
|
|
availableHours: 8,
|
|
availableHoursPerDay: 8,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("applies role and chapter filters in the resource query", async () => {
|
|
vi.mocked(listAssignmentBookings).mockResolvedValueOnce([]);
|
|
|
|
const db = {
|
|
resource: {
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await caller.searchCapacity({
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-02"),
|
|
minHoursPerDay: 4,
|
|
roleName: "Consult",
|
|
chapter: "CG",
|
|
limit: 5,
|
|
});
|
|
|
|
expect(db.resource.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: expect.objectContaining({
|
|
isActive: true,
|
|
areaRole: { name: { contains: "Consult", mode: "insensitive" } },
|
|
chapter: { contains: "CG", mode: "insensitive" },
|
|
}),
|
|
take: 100,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── analyzeUtilization ──────────────────────────────────────────────────────
|
|
|
|
describe("staffing.analyzeUtilization", () => {
|
|
it("returns utilization analysis for an existing resource", async () => {
|
|
const resource = {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
chargeabilityTarget: 80,
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
};
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(resource),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.analyzeUtilization({
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
});
|
|
|
|
expect(result).toHaveProperty("currentChargeability");
|
|
expect(result.resourceId).toBe("res_1");
|
|
});
|
|
|
|
it("excludes Bavarian public holidays from chargeability analysis", async () => {
|
|
const resource = {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
chargeabilityTarget: 80,
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
};
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(resource),
|
|
},
|
|
};
|
|
|
|
const { listAssignmentBookings } = await import("@capakraken/application");
|
|
vi.mocked(listAssignmentBookings).mockResolvedValue([
|
|
{
|
|
id: "a1",
|
|
projectId: "project_1",
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-06T00:00:00.000Z"),
|
|
hoursPerDay: 8,
|
|
dailyCostCents: 0,
|
|
status: "CONFIRMED",
|
|
project: { id: "project_1", name: "Chargeable", shortCode: "CHG", status: "ACTIVE", orderType: "CHARGEABLE", clientId: null, dynamicFields: null },
|
|
resource: { id: "res_1", displayName: "Alice", chapter: "VFX" },
|
|
},
|
|
]);
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.analyzeUtilization({
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-06T00:00:00.000Z"),
|
|
});
|
|
|
|
expect(result.currentChargeability).toBe(100);
|
|
expect(result.overallocatedDays).toEqual([]);
|
|
expect(result.underutilizedDays).toEqual([]);
|
|
});
|
|
|
|
it("throws NOT_FOUND when resource does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(
|
|
caller.analyzeUtilization({
|
|
resourceId: "nonexistent",
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
}),
|
|
).rejects.toThrow("Resource not found");
|
|
});
|
|
});
|
|
|
|
// ─── findCapacity ────────────────────────────────────────────────────────────
|
|
|
|
describe("staffing.findCapacity", () => {
|
|
it("returns capacity windows for an existing resource", async () => {
|
|
const resource = {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
};
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(resource),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.findCapacity({
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
});
|
|
|
|
expect(result.length).toBeGreaterThan(0);
|
|
expect(result[0]).toHaveProperty("availableHoursPerDay");
|
|
expect(result.every((window) => window.availableHoursPerDay > 0)).toBe(true);
|
|
expect(result.reduce((sum, window) => sum + window.availableDays, 0)).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("splits capacity windows around Bavarian public holidays", async () => {
|
|
const resource = {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
};
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(resource),
|
|
},
|
|
};
|
|
|
|
const { listAssignmentBookings } = await import("@capakraken/application");
|
|
vi.mocked(listAssignmentBookings).mockResolvedValue([]);
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.findCapacity({
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-07T00:00:00.000Z"),
|
|
minAvailableHoursPerDay: 4,
|
|
});
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0]).toEqual(
|
|
expect.objectContaining({
|
|
startDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-05T00:00:00.000Z"),
|
|
}),
|
|
);
|
|
expect(result[1]).toEqual(
|
|
expect.objectContaining({
|
|
startDate: new Date("2026-01-07T00:00:00.000Z"),
|
|
endDate: new Date("2026-01-07T00:00:00.000Z"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("throws NOT_FOUND when resource does not exist", async () => {
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(null),
|
|
},
|
|
};
|
|
|
|
const caller = createProtectedCaller(db);
|
|
await expect(
|
|
caller.findCapacity({
|
|
resourceId: "nonexistent",
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
}),
|
|
).rejects.toThrow("Resource not found");
|
|
});
|
|
|
|
it("honors minAvailableHoursPerDay when computing holiday-aware windows", async () => {
|
|
const resource = {
|
|
id: "res_1",
|
|
displayName: "Alice",
|
|
availability: { monday: 8, tuesday: 8, wednesday: 8, thursday: 8, friday: 8 },
|
|
countryId: "country_de",
|
|
federalState: "BY",
|
|
metroCityId: null,
|
|
country: { code: "DE" },
|
|
metroCity: null,
|
|
};
|
|
const db = {
|
|
resource: {
|
|
findUnique: vi.fn().mockResolvedValue(resource),
|
|
},
|
|
};
|
|
|
|
const { listAssignmentBookings } = await import("@capakraken/application");
|
|
vi.mocked(listAssignmentBookings).mockResolvedValue([
|
|
{
|
|
id: "a1",
|
|
projectId: "project_1",
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-04-01T00:00:00.000Z"),
|
|
endDate: new Date("2026-04-30T00:00:00.000Z"),
|
|
hoursPerDay: 3,
|
|
dailyCostCents: 0,
|
|
status: "CONFIRMED",
|
|
project: { id: "project_1", name: "Project", shortCode: "PRJ", status: "ACTIVE", orderType: "CHARGEABLE", clientId: null, dynamicFields: null },
|
|
resource: { id: "res_1", displayName: "Alice", chapter: "VFX" },
|
|
},
|
|
]);
|
|
|
|
const caller = createProtectedCaller(db);
|
|
const result = await caller.findCapacity({
|
|
resourceId: "res_1",
|
|
startDate: new Date("2026-04-01"),
|
|
endDate: new Date("2026-04-30"),
|
|
minAvailableHoursPerDay: 6,
|
|
});
|
|
|
|
expect(result.every((window) => window.availableHoursPerDay >= 6)).toBe(true);
|
|
});
|
|
});
|