Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/admin-sales-leads.server.test.ts
T

721 lines
21 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import {
assignmentRuleMatches,
createAdminSalesLeadService,
createPrismaAdminSalesLeadRepository,
evaluateAdminLeadScore,
selectRoundRobinAssignee,
type AdminSalesLeadRepository,
} from "./admin-sales-leads.server.js";
const actor = {
adminUserId: "admin-1",
email: "sales@example.test",
reason: "Lead qualifizieren und kontrolliert weiterführen",
} as const;
const leadFacts = {
id: "lead-1",
sourceId: "source-web",
sourceKey: "website",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
normalizedEmail: "ada@example.test",
phone: "+4930123456",
normalizedPhone: "+4930123456",
company: "Example GmbH",
assignedToAdminUserId: null,
region: "DACH",
country: "DE",
} as const;
function serviceFixture() {
const repository = {
listAutomationConfig: vi.fn(async () => ({ assignmentRules: [], scoreRules: [] })),
createAssignmentRule: vi.fn(async (input) => input as never),
createScoreRule: vi.fn(async (input) => input as never),
scoreLead: vi.fn(async () => ({}) as never),
enrichLead: vi.fn(async () => ({}) as never),
autoAssignLead: vi.fn(async () => ({
leadId: "lead-1",
assignedToAdminUserId: "admin-1",
ruleId: "rule-1",
})),
detectDuplicates: vi.fn(async () => ({ candidates: [], duplicateHintOfLeadId: null })),
dismissDuplicate: vi.fn(async () => ({}) as never),
mergeLeads: vi.fn(async () => ({
survivorLeadId: "lead-1",
mergedLeadId: "lead-2",
replayed: false,
})),
convertLead: vi.fn(async () => ({
leadId: "lead-1",
companyId: "company-1",
contactId: "contact-1",
dealId: "deal-1",
replayed: false,
})),
} satisfies AdminSalesLeadRepository;
const authorize = vi.fn(async () => undefined);
return {
repository,
authorize,
service: createAdminSalesLeadService({ repository, authorize }),
};
}
describe("admin sales lead qualification domain", () => {
it("evaluates score rules in a deterministic, explainable snapshot", () => {
const result = evaluateAdminLeadScore(leadFacts, [
{
id: "score-source",
field: "source",
operator: "equals",
value: "WEBSITE",
points: 25,
version: 2,
},
{
id: "score-region",
field: "region",
operator: "contains",
value: "dach",
points: 30,
version: 3,
},
{
id: "score-email",
field: "has_email",
operator: "equals",
value: "true",
points: 20,
version: 1,
},
{
id: "score-miss",
field: "country",
operator: "equals",
value: "AT",
points: 100,
version: 1,
},
]);
expect(result).toEqual({
score: 75,
scoreBand: "hot",
scoreVersion: 3,
breakdown: [
{ ruleId: "score-source", points: 25 },
{ ruleId: "score-region", points: 30 },
{ ruleId: "score-email", points: 20 },
],
});
});
it("matches source and region criteria as an AND contract", () => {
expect(assignmentRuleMatches({ sourceId: "source-web", region: "dach" }, leadFacts)).toBe(true);
expect(assignmentRuleMatches({ sourceId: "source-partner", region: "dach" }, leadFacts)).toBe(false);
expect(assignmentRuleMatches({ sourceId: null, region: null }, leadFacts)).toBe(true);
});
it("advances and wraps the round-robin cursor without randomness", () => {
expect(selectRoundRobinAssignee(["admin-a", "admin-b", "admin-c"], 1)).toEqual({
adminUserId: "admin-b",
nextAssigneeIndex: 2,
});
expect(selectRoundRobinAssignee(["admin-a", "admin-b", "admin-c"], 5)).toEqual({
adminUserId: "admin-c",
nextAssigneeIndex: 0,
});
});
});
describe("admin sales lead service", () => {
it("uses assignment permission and normalizes round-robin members", async () => {
const { service, repository, authorize } = serviceFixture();
await service.createAssignmentRule({
name: " DACH Website ",
priority: 10,
sourceId: "source-web",
region: " DACH ",
strategy: "round_robin",
roundRobinAdminUserIds: ["admin-b", "admin-a", "admin-b"],
actor,
});
expect(authorize).toHaveBeenCalledWith("admin_sales.crm.assign");
expect(repository.createAssignmentRule).toHaveBeenCalledWith(
expect.objectContaining({
name: "DACH Website",
region: "DACH",
roundRobinAdminUserIds: ["admin-b", "admin-a"],
})
);
});
it("rejects ambiguous assignment rules before persistence", async () => {
const { service, repository } = serviceFixture();
await expect(
service.createAssignmentRule({
name: "Ungültig",
priority: 10,
strategy: "fixed",
fixedAssigneeAdminUserId: "admin-a",
roundRobinAdminUserIds: ["admin-b"],
actor,
})
).rejects.toThrow("exactly one fixed operator");
expect(repository.createAssignmentRule).not.toHaveBeenCalled();
});
it("requires merge permission and two distinct lead identities", async () => {
const { service, repository } = serviceFixture();
await expect(
service.mergeLeads({
candidateId: "candidate-1",
survivorLeadId: "lead-1",
mergedLeadId: "lead-1",
reason: "Doppelte Anfrage",
actor,
})
).rejects.toThrow("two different records");
expect(repository.mergeLeads).not.toHaveBeenCalled();
});
});
describe("admin sales lead Prisma repository", () => {
it("records rule configuration as shared activity and immutable audit in the same transaction", async () => {
const assignmentRule = {
id: "assignment-1",
createdAt: new Date(),
updatedAt: new Date(),
archivedAt: null,
name: "DACH",
active: true,
priority: 10,
sourceId: "source-web",
region: "DACH",
strategy: "fixed" as const,
fixedAssigneeAdminUserId: "admin-1",
roundRobinAdminUserIds: [],
nextAssigneeIndex: 0,
lastAssignedAt: null,
};
const scoreRule = {
id: "score-1",
createdAt: new Date(),
updatedAt: new Date(),
archivedAt: null,
name: "Website",
active: true,
priority: 10,
field: "source" as const,
operator: "equals" as const,
value: "website",
points: 25,
version: 1,
};
const tx = {
adminLeadSource: {
findUnique: vi.fn(async () => ({ id: "source-web" })),
},
adminUser: {
count: vi.fn(async () => 1),
},
adminLeadAssignmentRule: {
create: vi.fn(async () => assignmentRule),
},
adminLeadScoreRule: {
create: vi.fn(async () => scoreRule),
},
adminActivity: {
create: vi.fn(async () => ({ id: "activity-1" })),
},
};
const client = {
$transaction: vi.fn(
async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)
),
};
const writeAudit = vi.fn(async () => undefined);
const repository = createPrismaAdminSalesLeadRepository(client as never, {
writeAudit,
});
await repository.createAssignmentRule({
name: "DACH",
priority: 10,
sourceId: "source-web",
strategy: "fixed",
fixedAssigneeAdminUserId: "admin-1",
actor,
});
await repository.createScoreRule({
name: "Website",
priority: 10,
field: "source",
operator: "equals",
value: "website",
points: 25,
actor,
});
expect(tx.adminActivity.create).toHaveBeenNthCalledWith(1, {
data: expect.objectContaining({
type: "configuration_changed",
actorAdminUserId: "admin-1",
payload: expect.objectContaining({
configurationType: "lead_assignment_rule",
configurationId: "assignment-1",
}),
}),
});
expect(tx.adminActivity.create).toHaveBeenNthCalledWith(2, {
data: expect.objectContaining({
type: "configuration_changed",
actorAdminUserId: "admin-1",
payload: expect.objectContaining({
configurationType: "lead_score_rule",
configurationId: "score-1",
}),
}),
});
expect(writeAudit).toHaveBeenCalledTimes(2);
});
it("records duplicate detection and dismissal in the lead activity stream", async () => {
const detectedCandidate = {
id: "candidate-1",
primaryLeadId: "lead-1",
duplicateLeadId: "lead-2",
matchKeys: ["email"],
confidenceBasisPoints: 8_000,
status: "open" as const,
};
const tx = {
$queryRaw: vi.fn(async () => [{ id: "lead-1" }]),
adminLead: {
findUnique: vi.fn(async () => ({
id: "lead-1",
archivedAt: null,
capturedAt: new Date("2026-07-20T00:00:00.000Z"),
normalizedEmail: "ada@example.test",
normalizedPhone: null,
})),
findMany: vi.fn(async () => [
{
id: "lead-2",
capturedAt: new Date("2026-07-21T00:00:00.000Z"),
normalizedEmail: "ada@example.test",
normalizedPhone: null,
},
]),
update: vi.fn(),
},
adminDuplicateCandidate: {
upsert: vi.fn(async () => detectedCandidate),
findUnique: vi.fn(async () => ({
...detectedCandidate,
primaryLead: { assignedToAdminUserId: "admin-1" },
duplicateLead: { assignedToAdminUserId: "admin-1" },
})),
update: vi.fn(async () => ({
...detectedCandidate,
status: "dismissed" as const,
})),
},
adminActivity: {
create: vi.fn(async () => ({ id: "activity-1" })),
},
};
const client = {
$transaction: vi.fn(
async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)
),
};
const writeAudit = vi.fn(async () => undefined);
const repository = createPrismaAdminSalesLeadRepository(client as never, {
writeAudit,
});
await repository.detectDuplicates({ leadId: "lead-1", actor });
await repository.dismissDuplicate({
candidateId: "candidate-1",
reason: "Nach manueller Prüfung keine Dublette",
actor,
});
expect(tx.adminActivity.create).toHaveBeenNthCalledWith(1, {
data: expect.objectContaining({
type: "lead_updated",
leadId: "lead-1",
payload: expect.objectContaining({
operation: "duplicates_detected",
candidateIds: ["candidate-1"],
}),
}),
});
expect(tx.adminActivity.create).toHaveBeenNthCalledWith(2, {
data: expect.objectContaining({
type: "lead_updated",
leadId: "lead-1",
payload: expect.objectContaining({
operation: "duplicate_dismissed",
candidateId: "candidate-1",
duplicateLeadId: "lead-2",
}),
}),
});
expect(writeAudit).toHaveBeenCalledTimes(2);
});
it("rejects a merge unless the supplied open candidate proves the exact survivor pair", async () => {
const survivor = {
id: "lead-primary",
status: "qualified",
archivedAt: null,
normalizedEmail: "ada@example.test",
normalizedPhone: null,
convertedCompany: null,
convertedContact: null,
convertedDeal: null,
};
const merged = {
...survivor,
id: "lead-duplicate",
status: "new",
};
const tx = {
$queryRaw: vi.fn(async () => []),
adminLead: {
findUnique: vi.fn(async ({ where }: { where: { id: string } }) =>
where.id === survivor.id ? survivor : merged
),
update: vi.fn(),
},
adminMergeRecord: {
findUnique: vi.fn(async () => null),
create: vi.fn(),
},
adminDuplicateCandidate: {
findUnique: vi.fn(async () => ({
id: "candidate-1",
status: "open",
primaryLeadId: "lead-other",
duplicateLeadId: merged.id,
})),
update: vi.fn(),
},
adminLeadActivity: { create: vi.fn() },
adminActivity: { create: vi.fn() },
};
const client = {
$transaction: vi.fn(async (operation: (transaction: typeof tx) => Promise<unknown>) =>
operation(tx)
),
};
const repository = createPrismaAdminSalesLeadRepository(client as never, {
writeAudit: vi.fn(),
});
await expect(
repository.mergeLeads({
candidateId: "candidate-1",
survivorLeadId: survivor.id,
mergedLeadId: merged.id,
reason: "Doppelte Anfrage kontrolliert zusammenführen",
actor,
})
).rejects.toThrow("matching open duplicate candidate");
expect(tx.adminLead.update).not.toHaveBeenCalled();
expect(tx.adminMergeRecord.create).not.toHaveBeenCalled();
});
it("serializes round-robin selection and persists assignment, notification, activity and audit atomically", async () => {
const rules = [
{
id: "rule-1",
createdAt: new Date(),
updatedAt: new Date(),
archivedAt: null,
name: "Website",
active: true,
priority: 10,
sourceId: "source-web",
region: "DACH",
strategy: "round_robin" as const,
fixedAssigneeAdminUserId: null,
roundRobinAdminUserIds: ["admin-a", "admin-b"],
nextAssigneeIndex: 1,
lastAssignedAt: null,
},
];
const tx = {
$queryRaw: vi.fn(async () => [{ id: "locked" }]),
adminLead: {
findUnique: vi.fn(async () => ({
...leadFacts,
archivedAt: null,
metadata: { region: "DACH" },
source: { key: "website" },
qualification: null,
})),
update: vi.fn(async () => ({ id: "lead-1" })),
},
adminLeadAssignmentRule: {
findMany: vi.fn(async () => rules),
findUnique: vi.fn(async () => rules[0]),
update: vi.fn(async () => rules[0]),
},
adminUser: {
count: vi.fn(async () => 1),
},
adminActivity: {
create: vi.fn(async () => ({ id: "activity-1" })),
},
notificationDelivery: {
findFirst: vi.fn(async () => null),
create: vi.fn(async () => ({ id: "notification-1" })),
},
outboxEvent: {
create: vi.fn(async () => ({ id: "outbox-1" })),
findUnique: vi.fn(async () => null),
},
};
const client = {
$transaction: vi.fn(async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)),
};
const writeAudit = vi.fn(async () => undefined);
const repository = createPrismaAdminSalesLeadRepository(client as never, { writeAudit });
await expect(repository.autoAssignLead({ leadId: "lead-1", actor })).resolves.toEqual({
leadId: "lead-1",
assignedToAdminUserId: "admin-b",
ruleId: "rule-1",
});
expect(tx.$queryRaw).toHaveBeenCalledTimes(2);
expect(tx.adminLead.update).toHaveBeenCalledWith({
where: { id: "lead-1" },
data: expect.objectContaining({
assignedToAdminUserId: "admin-b",
activities: {
create: expect.objectContaining({
type: "assigned",
payload: expect.objectContaining({ assignmentRuleId: "rule-1", to: "admin-b" }),
}),
},
}),
});
expect(tx.adminLeadAssignmentRule.update).toHaveBeenCalledWith({
where: { id: "rule-1" },
data: { nextAssigneeIndex: 0, lastAssignedAt: expect.any(Date) },
});
expect(tx.notificationDelivery.create).toHaveBeenCalledWith({
data: expect.objectContaining({
tenantId: null,
userId: null,
adminUserId: "admin-b",
messageKey: "admin.sales.notifications.leadassigned",
sourceKey: "admin-sales:lead-assigned:lead-1:admin-b",
}),
});
expect(tx.outboxEvent.create).toHaveBeenCalledWith({
data: expect.objectContaining({
eventType: "notification.platform.requested.v1",
dispatchKey: "platform-notification:notification-1",
payload: expect.objectContaining({
adminUserId: "admin-b",
metadata: {
leadId: "lead-1",
deeplink: "/sales/leads/lead-1",
},
}),
}),
});
expect(writeAudit).toHaveBeenCalledWith(
tx,
expect.objectContaining({
action: "admin.sales.lead.autoAssigned",
targetId: "lead-1",
})
);
});
it("converts one qualified lead into company, contact and first-stage deal in one transaction", async () => {
const tx = {
$queryRaw: vi.fn(async () => [{ id: "lead-1" }]),
adminLead: {
findUnique: vi.fn(async () => ({
...leadFacts,
archivedAt: null,
status: "qualified",
convertedCompany: null,
convertedContact: null,
convertedDeal: null,
duplicateCandidatesPrimary: [],
duplicateCandidatesSecondary: [],
})),
update: vi.fn(async () => ({ id: "lead-1" })),
},
adminUser: {
count: vi.fn(async () => 1),
},
adminPipeline: {
findFirst: vi.fn(async () => ({
id: "pipeline-1",
stages: [{ id: "stage-lead", probabilityBasisPoints: 1_000 }],
})),
},
adminCompany: {
create: vi.fn(async () => ({ id: "company-1" })),
},
adminContact: {
create: vi.fn(async () => ({ id: "contact-1" })),
},
adminDeal: {
create: vi.fn(async () => ({ id: "deal-1" })),
},
adminActivity: {
create: vi.fn(async () => ({ id: "activity-1" })),
},
};
const client = {
$transaction: vi.fn(async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)),
};
const writeAudit = vi.fn(async () => undefined);
const repository = createPrismaAdminSalesLeadRepository(client as never, { writeAudit });
await expect(
repository.convertLead({
leadId: "lead-1",
companyName: "Example GmbH",
firstName: "Ada",
lastName: "Lovelace",
dealTitle: "HiveGrid SaaS",
ownerAdminUserId: "admin-1",
amountCents: 120_000,
nextStep: "Demo terminieren",
actor,
})
).resolves.toEqual({
leadId: "lead-1",
companyId: "company-1",
contactId: "contact-1",
dealId: "deal-1",
replayed: false,
});
expect(tx.adminCompany.create).toHaveBeenCalledWith({
data: expect.objectContaining({ sourceLeadId: "lead-1", ownerAdminUserId: "admin-1" }),
});
expect(tx.adminContact.create).toHaveBeenCalledWith({
data: expect.objectContaining({ sourceLeadId: "lead-1", companyId: "company-1" }),
});
expect(tx.adminDeal.create).toHaveBeenCalledWith({
data: expect.objectContaining({
sourceLeadId: "lead-1",
companyId: "company-1",
stageId: "stage-lead",
contacts: { create: { contactId: "contact-1", isPrimary: true } },
history: {
create: expect.objectContaining({ reason: "lead_conversion", actorAdminUserId: "admin-1" }),
},
}),
});
expect(tx.adminActivity.create).toHaveBeenCalledWith({
data: expect.objectContaining({
type: "lead_converted",
leadId: "lead-1",
companyId: "company-1",
contactId: "contact-1",
dealId: "deal-1",
}),
});
});
it("replays an already completed conversion without duplicate writes", async () => {
const tx = {
$queryRaw: vi.fn(async () => [{ id: "lead-1" }]),
adminLead: {
findUnique: vi.fn(async () => ({
...leadFacts,
archivedAt: null,
status: "qualified",
convertedCompany: { id: "company-1" },
convertedContact: { id: "contact-1" },
convertedDeal: { id: "deal-1" },
duplicateCandidatesPrimary: [],
duplicateCandidatesSecondary: [],
})),
},
};
const client = {
$transaction: vi.fn(async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)),
};
const repository = createPrismaAdminSalesLeadRepository(client as never);
await expect(
repository.convertLead({
leadId: "lead-1",
companyName: "Example GmbH",
firstName: "Ada",
lastName: "Lovelace",
dealTitle: "HiveGrid SaaS",
ownerAdminUserId: "admin-1",
actor,
})
).resolves.toEqual({
leadId: "lead-1",
companyId: "company-1",
contactId: "contact-1",
dealId: "deal-1",
replayed: true,
});
});
it("hides another sales owner's lead before qualification writes run", async () => {
const tx = {
$queryRaw: vi.fn(async () => [{ id: "lead-foreign" }]),
adminLead: {
findUnique: vi.fn(async () => ({
...leadFacts,
id: "lead-foreign",
assignedToAdminUserId: "admin-2",
archivedAt: null,
metadata: null,
source: { key: "website" },
qualification: null,
})),
},
adminLeadScoreRule: {
findMany: vi.fn(),
},
};
const client = {
$transaction: vi.fn(
async (run: (transaction: typeof tx) => Promise<unknown>) => run(tx)
),
};
const repository = createPrismaAdminSalesLeadRepository(client as never, {
accessScope: {
adminUserId: "admin-1",
canReadAll: false,
canWriteAll: false,
canReadAllCommunication: false,
},
});
await expect(
repository.scoreLead({ leadId: "lead-foreign", actor })
).rejects.toThrow("not found");
expect(tx.adminLeadScoreRule.findMany).not.toHaveBeenCalled();
});
});