Skip to content

armgit / crm

Public Imported from GitHub
0

Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.

TypeScript
7.1 KB
Raw Blame
import { afterAll, beforeAll, describe, expect, it } from "bun:test";
import { db } from "@crm/db";
import { AgentTriggerService } from "../src/agent/agent-trigger.service";
import { ActivityStampService } from "../src/crm/activity-stamp.service";
import { ConversionService } from "../src/currency/conversion.service";
import { DealsService } from "../src/deals/deals.service";
import { FieldsService } from "../src/fields/fields.service";

const suffix = crypto.randomUUID();
const dealId = `event-deal-${suffix}`;
const contactId = `event-contact-${suffix}`;
const companyId = `event-company-${suffix}`;
const service = new AgentTriggerService(db);
const stamp = new ActivityStampService(db);
const conversion = new ConversionService(db);
const fields = new FieldsService(db, service);
const deals = new DealsService(db, service, stamp, conversion, fields);
const channelId = `event-channel-${suffix}`;
const ownerId = `event-owner-${suffix}`;
const domain = `event-${suffix}.example.test`;
let persistedCompanyId = "";
let persistedDealId = "";
let previousBridgeSecret: string | undefined;

beforeAll(async () => {
	previousBridgeSecret = process.env.AGENT_BRIDGE_SECRET;
	delete process.env.AGENT_BRIDGE_SECRET;
	await db.agentTask.deleteMany({
		where: { OR: [{ dealId }, { contactId }] },
	});
	await db.user.create({
		data: {
			id: ownerId,
			name: "Event Test Owner",
			email: `${ownerId}@example.test`,
		},
	});
	const company = await db.company.create({
		data: { name: "Event Test Company", domain },
		select: { id: true },
	});
	persistedCompanyId = company.id;
});

afterAll(async () => {
	await db.agentTask.deleteMany({
		where: {
			OR: [
				{ dealId: { in: [dealId, persistedDealId].filter(Boolean) } },
				{ contactId },
			],
		},
	});
	await db.agentTask.deleteMany({
		where: {
			kind: "slack-channel-join",
			payload: { path: ["channelId"], equals: channelId },
		},
	});
	if (persistedDealId) {
		await db.activity.deleteMany({ where: { dealId: persistedDealId } });
		await db.deal.deleteMany({ where: { id: persistedDealId } });
	}
	if (persistedCompanyId) {
		await db.company.deleteMany({ where: { id: persistedCompanyId } });
	}
	await db.user.deleteMany({ where: { id: ownerId } });
	if (previousBridgeSecret === undefined) {
		delete process.env.AGENT_BRIDGE_SECRET;
	} else {
		process.env.AGENT_BRIDGE_SECRET = previousBridgeSecret;
	}
});

describe("CRM agent events", () => {
	it("routes every event to its catalog record kind", async () => {
		const occurredAt = new Date("2026-08-10T09:00:00.000Z");
		await service.withCrmEvents(async (_tx, emit) => {
			await emit({
				type: "contact.created",
				record: { kind: "contact", id: contactId },
				occurredAt,
				data: { email: "[email protected]" },
			});
		});

		expect(
			await db.agentTask.findFirstOrThrow({
				where: { contactId, kind: "agent-event" },
				select: {
					contactId: true,
					companyId: true,
					dealId: true,
					payload: true,
				},
			}),
		).toEqual({
			contactId,
			companyId: null,
			dealId: null,
			payload: {
				type: "contact.created",
				record: { kind: "contact", id: contactId },
				occurredAt: occurredAt.toISOString(),
				data: { email: "[email protected]" },
			},
		});
	});

	it("writes durable created and closed events for the agent worker", async () => {
		const createdAt = new Date("2026-08-10T10:00:00.000Z");
		const closedAt = new Date("2026-08-10T11:00:00.000Z");

		await service.withCrmEvents(async (_tx, emit) => {
			await emit({
				type: "deal.created",
				record: { kind: "deal", id: dealId },
				occurredAt: createdAt,
				data: { companyId, stage: "DEMO_BOOKED" },
			});
			await emit({
				type: "deal.closed",
				record: { kind: "deal", id: dealId },
				occurredAt: closedAt,
				data: { companyId, from: "NEGOTIATION", to: "CLOSED_WON" },
			});
		});

		const tasks = await db.agentTask.findMany({
			where: { dealId, kind: "agent-event" },
			select: {
				dealId: true,
				reason: true,
				payload: true,
				finishedAt: true,
			},
		});

		expect(tasks).toHaveLength(2);
		expect(tasks.find((task) => task.reason === "deal.created")).toEqual({
			dealId,
			reason: "deal.created",
			payload: {
				type: "deal.created",
				record: { kind: "deal", id: dealId },
				occurredAt: createdAt.toISOString(),
				data: { companyId, stage: "DEMO_BOOKED" },
			},
			finishedAt: null,
		});
		expect(tasks.find((task) => task.reason === "deal.closed")).toEqual({
			dealId,
			reason: "deal.closed",
			payload: {
				type: "deal.closed",
				record: { kind: "deal", id: dealId },
				occurredAt: closedAt.toISOString(),
				data: { companyId, from: "NEGOTIATION", to: "CLOSED_WON" },
			},
			finishedAt: null,
		});
	});

	it("queues one Slack join for a channel that is renamed", async () => {
		await service.slackChannelJoinRequested(channelId, "deal-room");
		await service.slackChannelJoinRequested(channelId, "deal-room-renamed");

		expect(
			await db.agentTask.findMany({
				where: {
					kind: "slack-channel-join",
					payload: { path: ["channelId"], equals: channelId },
				},
				select: { reason: true },
			}),
		).toEqual([{ reason: "Add Comp AI to #deal-room" }]);
	});

	it("rolls back the record when its event cannot commit", async () => {
		const rollbackCompanyId = `event-rollback-company-${suffix}`;
		let error: Error | null = null;

		try {
			await service.withCrmEvents(async (tx, emit) => {
				const company = await tx.company.create({
					data: {
						id: rollbackCompanyId,
						name: "Rollback Event Company",
					},
					select: { id: true, createdAt: true },
				});
				await emit({
					type: "company.created",
					record: { kind: "company", id: company.id },
					occurredAt: company.createdAt,
					data: { name: "Rollback Event Company", domain: null },
				});
				throw new Error("Rollback the record and outbox together.");
			});
		} catch (caught) {
			error = caught as Error;
		}

		expect(error?.message).toBe("Rollback the record and outbox together.");
		expect(
			await db.company.findUnique({ where: { id: rollbackCompanyId } }),
		).toBeNull();
		expect(
			await db.agentTask.count({
				where: { companyId: rollbackCompanyId, kind: "agent-event" },
			}),
		).toBe(0);
	});

	it("emits each real deal lifecycle transition exactly once", async () => {
		const deal = await deals.create({
			name: "Event-driven deal",
			companyId: persistedCompanyId,
			ownerId,
			amountCents: 25_000,
			currency: "USD",
		});
		persistedDealId = deal.id;

		const transitions = await Promise.all([
			deals.setStage({ id: deal.id, stage: "CLOSED_WON" }, ownerId),
			deals.setStage({ id: deal.id, stage: "CLOSED_WON" }, ownerId),
		]);

		expect(transitions.map((transition) => transition.changed).sort()).toEqual([
			false,
			true,
		]);
		await deals.setStage({ id: deal.id, stage: "QUALIFIED_TO_BUY" }, ownerId);

		const reasons = (
			await db.agentTask.findMany({
				where: { dealId: deal.id, kind: "agent-event" },
				select: { reason: true },
			})
		)
			.map((task) => task.reason)
			.sort();
		expect(reasons).toEqual([
			"deal.closed",
			"deal.created",
			"deal.opened",
			"deal.stage.changed",
			"deal.stage.changed",
		]);
		expect(
			await db.activity.count({
				where: { dealId: deal.id, type: "STAGE_CHANGE" },
			}),
		).toBe(2);
	});
});