199 lines
6.3 KiB
TypeScript
199 lines
6.3 KiB
TypeScript
import { describe, it, expect, vi } from "vitest";
|
|
import {
|
|
startSequenceRun,
|
|
advanceSequenceRun,
|
|
type SequenceEngineStore,
|
|
type SequenceEngineQueue,
|
|
type SequenceRunRow,
|
|
} from "./engine.js";
|
|
import type { SequenceDefinition } from "./types.js";
|
|
|
|
function makeStore(initial: SequenceRunRow | null = null): SequenceEngineStore & {
|
|
createdDeliveries: Array<{ runId: string; stepIndex: number; scheduledAt: Date }>;
|
|
createdRuns: Array<{ sequenceId: string }>;
|
|
statusUpdates: Array<{ runId: string; status: string }>;
|
|
} {
|
|
const createdDeliveries: Array<{ runId: string; stepIndex: number; scheduledAt: Date }> = [];
|
|
const createdRuns: Array<{ sequenceId: string }> = [];
|
|
const statusUpdates: Array<{ runId: string; status: string }> = [];
|
|
return {
|
|
createdDeliveries,
|
|
createdRuns,
|
|
statusUpdates,
|
|
createRun: vi.fn(async ({ sequenceId, leadId, tenantId, triggerEventId }) => {
|
|
createdRuns.push({ sequenceId });
|
|
return {
|
|
id: `run_${createdRuns.length}`,
|
|
sequenceId,
|
|
leadId,
|
|
tenantId,
|
|
triggerEventId,
|
|
status: "running" as const,
|
|
startedAt: new Date("2026-05-17T12:00:00Z"),
|
|
completedAt: null,
|
|
stepStateJson: null,
|
|
};
|
|
}),
|
|
findRunByTrigger: vi.fn(async () => initial),
|
|
updateRunStatus: vi.fn(async (runId, status) => {
|
|
statusUpdates.push({ runId, status });
|
|
}),
|
|
createDelivery: vi.fn(async ({ runId, stepIndex, scheduledAt }) => {
|
|
createdDeliveries.push({ runId, stepIndex, scheduledAt });
|
|
return {
|
|
id: `del_${createdDeliveries.length}`,
|
|
runId,
|
|
stepIndex,
|
|
status: "pending" as const,
|
|
scheduledAt,
|
|
};
|
|
}),
|
|
};
|
|
}
|
|
|
|
function makeQueue(): SequenceEngineQueue & { scheduled: Array<{ runId: string; stepIndex: number; runAt: Date }> } {
|
|
const scheduled: Array<{ runId: string; stepIndex: number; runAt: Date }> = [];
|
|
return {
|
|
scheduled,
|
|
scheduleStep: vi.fn(async (args) => {
|
|
scheduled.push(args);
|
|
}),
|
|
};
|
|
}
|
|
|
|
const BASE_SEQUENCE: SequenceDefinition = {
|
|
id: "seq_1",
|
|
tenantId: null,
|
|
name: "Welcome",
|
|
description: null,
|
|
triggerEvent: "lead.captured",
|
|
isEnabled: true,
|
|
steps: [
|
|
{ stepIndex: 0, delayHours: 0, template: "welcome", subject: "Welcome" },
|
|
{ stepIndex: 1, delayHours: 24, template: "generic-step", subject: "Day 1" },
|
|
{ stepIndex: 2, delayHours: 72, template: "generic-step", subject: "Day 3" },
|
|
],
|
|
};
|
|
|
|
const TRIGGER = {
|
|
triggerEventId: "evt_1",
|
|
leadId: "lead_1",
|
|
tenantId: null,
|
|
email: "alice@example.com",
|
|
recipientName: "Alice",
|
|
payload: { lead: { status: "new" } },
|
|
} as const;
|
|
|
|
const NOW = () => new Date("2026-05-17T12:00:00Z");
|
|
|
|
describe("startSequenceRun", () => {
|
|
it("creates a run and schedules step 0 immediately when delayHours=0", async () => {
|
|
const store = makeStore();
|
|
const queue = makeQueue();
|
|
const result = await startSequenceRun({ sequence: BASE_SEQUENCE, trigger: TRIGGER }, { store, queue, now: NOW });
|
|
expect(result.scheduled).toBe(true);
|
|
expect(result.alreadyExisted).toBe(false);
|
|
expect(store.createdRuns).toHaveLength(1);
|
|
expect(store.createdDeliveries).toHaveLength(1);
|
|
expect(store.createdDeliveries[0]?.scheduledAt.toISOString()).toBe("2026-05-17T12:00:00.000Z");
|
|
expect(queue.scheduled).toHaveLength(1);
|
|
});
|
|
|
|
it("returns the existing run when (sequence, trigger-event-id) already produced one", async () => {
|
|
const existing: SequenceRunRow = {
|
|
id: "run_existing",
|
|
sequenceId: BASE_SEQUENCE.id,
|
|
leadId: "lead_1",
|
|
tenantId: null,
|
|
triggerEventId: "evt_1",
|
|
status: "running",
|
|
startedAt: NOW(),
|
|
completedAt: null,
|
|
stepStateJson: null,
|
|
};
|
|
const store = makeStore(existing);
|
|
const queue = makeQueue();
|
|
const result = await startSequenceRun({ sequence: BASE_SEQUENCE, trigger: TRIGGER }, { store, queue, now: NOW });
|
|
expect(result.alreadyExisted).toBe(true);
|
|
expect(store.createdRuns).toHaveLength(0);
|
|
expect(queue.scheduled).toHaveLength(0);
|
|
});
|
|
|
|
it("skips disabled sequences", async () => {
|
|
const store = makeStore();
|
|
const queue = makeQueue();
|
|
const result = await startSequenceRun(
|
|
{ sequence: { ...BASE_SEQUENCE, isEnabled: false }, trigger: TRIGGER },
|
|
{ store, queue, now: NOW }
|
|
);
|
|
expect(result.scheduled).toBe(false);
|
|
expect(store.createdRuns).toHaveLength(0);
|
|
});
|
|
|
|
it("skips when sequence-level conditions are false", async () => {
|
|
const store = makeStore();
|
|
const queue = makeQueue();
|
|
const result = await startSequenceRun(
|
|
{
|
|
sequence: {
|
|
...BASE_SEQUENCE,
|
|
conditions: [{ path: "lead.status", op: "eq", value: "qualified" }],
|
|
},
|
|
trigger: TRIGGER,
|
|
},
|
|
{ store, queue, now: NOW }
|
|
);
|
|
expect(result.scheduled).toBe(false);
|
|
expect(store.createdRuns).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("advanceSequenceRun", () => {
|
|
it("schedules the next step with its delay-from-now", async () => {
|
|
const store = makeStore();
|
|
const queue = makeQueue();
|
|
const run: SequenceRunRow = {
|
|
id: "run_1",
|
|
sequenceId: "seq_1",
|
|
leadId: "lead_1",
|
|
tenantId: null,
|
|
triggerEventId: "evt_1",
|
|
status: "running",
|
|
startedAt: NOW(),
|
|
completedAt: null,
|
|
stepStateJson: null,
|
|
};
|
|
const result = await advanceSequenceRun(
|
|
{ run, steps: BASE_SEQUENCE.steps, previousStepIndex: 0 },
|
|
{ store, queue, now: NOW }
|
|
);
|
|
expect(result.completed).toBe(false);
|
|
expect(result.scheduledAt?.toISOString()).toBe("2026-05-18T12:00:00.000Z");
|
|
expect(queue.scheduled).toHaveLength(1);
|
|
expect(queue.scheduled[0]?.stepIndex).toBe(1);
|
|
});
|
|
|
|
it("completes the run when no further steps exist", async () => {
|
|
const store = makeStore();
|
|
const queue = makeQueue();
|
|
const run: SequenceRunRow = {
|
|
id: "run_1",
|
|
sequenceId: "seq_1",
|
|
leadId: "lead_1",
|
|
tenantId: null,
|
|
triggerEventId: "evt_1",
|
|
status: "running",
|
|
startedAt: NOW(),
|
|
completedAt: null,
|
|
stepStateJson: null,
|
|
};
|
|
const result = await advanceSequenceRun(
|
|
{ run, steps: BASE_SEQUENCE.steps, previousStepIndex: 2 },
|
|
{ store, queue, now: NOW }
|
|
);
|
|
expect(result.completed).toBe(true);
|
|
expect(store.statusUpdates).toEqual([{ runId: "run_1", status: "completed" }]);
|
|
expect(queue.scheduled).toHaveLength(0);
|
|
});
|
|
});
|