Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

Move send-campaign workflow coverage to Playwright API tests.

Kiran K8075f9fa91be
diff --git a/apps/web/playwright/api/bounties/bounties.spec.ts b/apps/web/playwright/api/bounties/bounties.spec.ts
index f5f5bc3219..c55961419e 100644
--- a/apps/web/playwright/api/bounties/bounties.spec.ts
+++ b/apps/web/playwright/api/bounties/bounties.spec.ts
@@ -784,7 +784,10 @@ test("POST /bounties – invalid partner tag IDs", async ({ api, program }) => {
}),
}),
).toEqual(
- badRequest("Invalid partner tag IDs detected: invalid-partner-tag-id"),
+ apiError({
+ code: "bad_request",
+ message: "Invalid partner tag IDs detected: invalid-partner-tag-id",
+ }),
);
});
@@ -874,7 +877,10 @@ test("PATCH /bounties/{bountyId} – invalid partner tag IDs", async ({
partnerTagIds: ["invalid-partner-tag-id"],
}),
).toEqual(
- badRequest("Invalid partner tag IDs detected: invalid-partner-tag-id"),
+ apiError({
+ code: "bad_request",
+ message: "Invalid partner tag IDs detected: invalid-partner-tag-id",
+ }),
);
} finally {
await deleteBounty(api, id);
diff --git a/apps/web/playwright/api/campaigns/send-campaign-workflow-helpers.ts b/apps/web/playwright/api/campaigns/send-campaign-workflow-helpers.ts
new file mode 100644
index 0000000000..d3a560a3ea
--- /dev/null
+++ b/apps/web/playwright/api/campaigns/send-campaign-workflow-helpers.ts
@@ -0,0 +1,364 @@
+import { createId } from "@/lib/api/create-id";
+import { prisma } from "@/lib/prisma";
+import type { EnrolledPartnerProps } from "@/lib/types";
+import { nanoid } from "@dub/utils";
+import { expect } from "@playwright/test";
+import { subHours } from "date-fns";
+import { randomName, randomPartnerEmail } from "../../utils";
+import type { ApiClient } from "../fixtures";
+import { campaignContent, createCampaign, deleteCampaign } from "./helpers";
+
+export const enrolledDaysCondition = {
+ attribute: "partnerEnrolledDays",
+ operator: "gte",
+ value: 1,
+} as const;
+
+export async function publishTransactionalCampaign(
+ api: ApiClient,
+ overrides: Record<string, unknown> = {},
+) {
+ const { status, data } = await createCampaign(api);
+ expect(status).toEqual(201);
+
+ const patched = await api.patch(`/api/campaigns/${data.id}`, {
+ ...campaignContent({
+ triggerConditions: [enrolledDaysCondition],
+ ...overrides,
+ }),
+ status: "active",
+ ...overrides,
+ });
+
+ expect(patched.status).toEqual(200);
+ return data.id;
+}
+
+export async function getCampaignWorkflow(campaignId: string) {
+ return prisma.workflow.findFirstOrThrow({
+ where: {
+ campaign: {
+ id: campaignId,
+ },
+ },
+ });
+}
+
+export async function runScheduledCampaignWorkflow(
+ api: ApiClient,
+ workflowId: string,
+) {
+ const { status, data } = await api.post<{ message: string }>(
+ `/api/e2e/trigger-workflow/${workflowId}`,
+ {},
+ );
+
+ expect(status).toEqual(200);
+
+ if (data.message.includes("disabled")) {
+ return "disabled";
+ }
+
+ if (data.message.includes("not found")) {
+ return "not found";
+ }
+
+ return "finished";
+}
+
+export async function runPartnerCampaignWorkflow(
+ api: ApiClient,
+ workflowId: string,
+ partnerId: string,
+) {
+ const { status, data } = await api.post<{ message: string }>(
+ `/api/e2e/trigger-workflow/${workflowId}`,
+ { partnerId },
+ );
+
+ expect(status).toEqual(200);
+ return data.message.includes("disabled") ? "disabled" : "finished";
+}
+
+export async function createTestPartner(
+ api: ApiClient,
+ overrides: Record<string, unknown> = {},
+) {
+ const { status, data } = await api.post<EnrolledPartnerProps>(
+ "/api/partners",
+ {
+ name: randomName("partner"),
+ email: randomPartnerEmail(),
+ ...overrides,
+ },
+ );
+
+ expect(status).toEqual(201);
+ return data;
+}
+
+export async function createPartnerMailbox(partnerId: string) {
+ const partner = await prisma.partner.findUniqueOrThrow({
+ where: { id: partnerId },
+ select: { email: true, name: true },
+ });
+
+ const user = await prisma.user.create({
+ data: {
+ id: createId({ prefix: "user_" }),
+ email: partner.email!,
+ name: partner.name,
+ emailVerified: new Date(),
+ defaultPartnerId: partnerId,
+ },
+ });
+
+ await prisma.partnerUser.create({
+ data: {
+ userId: user.id,
+ partnerId,
+ role: "owner",
+ notificationPreferences: {
+ create: {},
+ },
+ },
+ });
+
+ return user.id;
+}
+
+export async function backdateEnrollment({
+ partnerId,
+ programId,
+ hoursAgo,
+}: {
+ partnerId: string;
+ programId: string;
+ hoursAgo: number;
+}) {
+ await prisma.programEnrollment.update({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ data: {
+ createdAt: subHours(new Date(), hoursAgo),
+ },
+ });
+}
+
+export async function setEnrollmentStatus({
+ partnerId,
+ programId,
+ status,
+}: {
+ partnerId: string;
+ programId: string;
+ status: "pending" | "approved" | "banned";
+}) {
+ await prisma.programEnrollment.update({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ data: { status },
+ });
+}
+
+export async function setLinkStats({
+ partnerId,
+ programId,
+ leads,
+ conversions,
+ saleAmount,
+}: {
+ partnerId: string;
+ programId: string;
+ leads?: number;
+ conversions?: number;
+ saleAmount?: number;
+}) {
+ const link = await prisma.link.findFirst({
+ where: { partnerId, programId },
+ orderBy: { id: "asc" },
+ select: { id: true },
+ });
+
+ expect(link).not.toBeNull();
+
+ await prisma.link.update({
+ where: { id: link!.id },
+ data: {
+ ...(leads !== undefined && { leads }),
+ ...(conversions !== undefined && { conversions }),
+ ...(saleAmount !== undefined && { saleAmount }),
+ },
+ });
+}
+
+export async function createTestCommission({
+ programId,
+ partnerId,
+ earnings,
+}: {
+ programId: string;
+ partnerId: string;
+ earnings: number;
+}) {
+ return prisma.commission.create({
+ data: {
+ id: createId({ prefix: "cm_" }),
+ programId,
+ partnerId,
+ type: "sale",
+ amount: earnings,
+ quantity: 1,
+ earnings,
+ status: "pending",
+ },
+ });
+}
+
+export async function tagPartner({
+ programId,
+ partnerId,
+ partnerTagId,
+}: {
+ programId: string;
+ partnerId: string;
+ partnerTagId: string;
+}) {
+ await prisma.programPartnerTag.create({
+ data: {
+ programId,
+ partnerId,
+ partnerTagId,
+ },
+ });
+}
+
+export async function insertCampaignEmail({
+ campaignId,
+ programId,
+ partnerId,
+ recipientUserId,
+}: {
+ campaignId: string;
+ programId: string;
+ partnerId: string;
+ recipientUserId: string;
+}) {
+ return prisma.notificationEmail.create({
+ data: {
+ id: createId({ prefix: "em_" }),
+ type: "Campaign",
+ emailId: `pw_${nanoid()}`,
+ campaignId,
+ programId,
+ partnerId,
+ recipientUserId,
+ },
+ });
+}
+
+export async function campaignEmails(campaignId: string, partnerId?: string) {
+ return prisma.notificationEmail.findMany({
+ where: {
+ campaignId,
+ type: "Campaign",
+ ...(partnerId && { partnerId }),
+ },
+ });
+}
+
+export async function expectCampaignEmailCount({
+ campaignId,
+ partnerId,
+ count,
+}: {
+ campaignId: string;
+ partnerId?: string;
+ count: number;
+}) {
+ const emails = await campaignEmails(campaignId, partnerId);
+ expect(
+ emails,
+ count > 0
+ ? "expected a campaign NotificationEmail (SMTP/MailHog or Resend must be configured)"
+ : "did not expect a campaign NotificationEmail",
+ ).toHaveLength(count);
+ return emails;
+}
+
+export async function createTestGroup(api: ApiClient) {
+ const slug = `g-${nanoid(8).toLowerCase()}`;
+ const { status, data } = await api.post<{ id: string }>("/api/groups", {
+ name: randomName("group"),
+ slug,
+ color: "blue",
+ });
+
+ expect(status).toEqual(201);
+ return data.id;
+}
+
+export async function deleteTestGroup(api: ApiClient, id: string | undefined) {
+ if (!id) return;
+ await api.delete(`/api/groups/${id}`);
+}
+
+export async function deleteTestPartner(partnerId: string | undefined) {
+ if (!partnerId) return;
+
+ const partnerUsers = await prisma.partnerUser.findMany({
+ where: { partnerId },
+ select: { userId: true },
+ });
+
+ await prisma.notificationEmail.deleteMany({
+ where: { partnerId },
+ });
+
+ await prisma.commission.deleteMany({
+ where: { partnerId },
+ });
+
+ await prisma.programPartnerTag.deleteMany({
+ where: { partnerId },
+ });
+
+ if (partnerUsers.length > 0) {
+ await prisma.user.deleteMany({
+ where: {
+ id: {
+ in: partnerUsers.map((row) => row.userId),
+ },
+ },
+ });
+ }
+
+ await prisma.link.deleteMany({
+ where: { partnerId },
+ });
+
+ await prisma.programEnrollment.deleteMany({
+ where: { partnerId },
+ });
+
+ // Prisma partner.delete hits a PlanetScale relation quirk; raw SQL matches
+ // bulkDeletePartners cleanup used by e2e cron. Use Prisma so cleanup hits
+ // DATABASE_URL, not PLANETSCALE_DATABASE_URL.
+ await prisma.$executeRaw`DELETE FROM Partner WHERE id = ${partnerId}`;
+}
+
+export async function cleanupCampaign(api: ApiClient, campaignId?: string) {
+ if (!campaignId) return;
+ await prisma.notificationEmail.deleteMany({
+ where: { campaignId },
+ });
+ await deleteCampaign(api, campaignId);
+}
diff --git a/apps/web/playwright/api/campaigns/send-campaign-workflow.spec.ts b/apps/web/playwright/api/campaigns/send-campaign-workflow.spec.ts
new file mode 100644
index 0000000000..6ae066892d
--- /dev/null
+++ b/apps/web/playwright/api/campaigns/send-campaign-workflow.spec.ts
@@ -0,0 +1,913 @@
+import { prisma } from "@/lib/prisma";
+import { expect } from "@playwright/test";
+import { test } from "../fixtures";
+import { createCampaign, createPartnerTag, deletePartnerTag } from "./helpers";
+import {
+ backdateEnrollment,
+ campaignEmails,
+ cleanupCampaign,
+ createPartnerMailbox,
+ createTestCommission,
+ createTestGroup,
+ createTestPartner,
+ deleteTestGroup,
+ deleteTestPartner,
+ enrolledDaysCondition,
+ expectCampaignEmailCount,
+ getCampaignWorkflow,
+ insertCampaignEmail,
+ publishTransactionalCampaign,
+ runPartnerCampaignWorkflow,
+ runScheduledCampaignWorkflow,
+ setEnrollmentStatus,
+ setLinkStats,
+ tagPartner,
+} from "./send-campaign-workflow-helpers";
+
+test("transactional draft workflow is disabled", async ({ api }) => {
+ let campaignId: string | undefined;
+
+ try {
+ const { status, data } = await createCampaign(api);
+ expect(status).toEqual(201);
+ campaignId = data.id;
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(workflow.disabledAt).not.toBeNull();
+ expect(workflow.actions).toEqual([
+ {
+ type: "sendCampaign",
+ data: { campaignId },
+ },
+ ]);
+ } finally {
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("publishing a transactional campaign enables the workflow", async ({
+ api,
+}) => {
+ let campaignId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const workflow = await getCampaignWorkflow(campaignId);
+
+ expect(workflow.disabledAt).toBeNull();
+ expect(workflow.triggerConditions).toEqual([enrolledDaysCondition]);
+ expect(workflow.actions).toEqual([
+ {
+ type: "sendCampaign",
+ data: { campaignId },
+ },
+ ]);
+ } finally {
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("pausing a campaign disables the workflow", async ({ api }) => {
+ let campaignId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+
+ const paused = await api.patch(`/api/campaigns/${campaignId}`, {
+ status: "paused",
+ });
+ expect(paused.status).toEqual(200);
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(workflow.disabledAt).not.toBeNull();
+ } finally {
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled run skips a disabled workflow", async ({ api, program }) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ await prisma.workflow.update({
+ where: { id: workflow.id },
+ data: { disabledAt: new Date() },
+ });
+
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "disabled",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled window only includes enrollments from 12–24h ago", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ const partnerIds: string[] = [];
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+
+ for (const hoursAgo of [6, 18, 30]) {
+ const partner = await createTestPartner(api);
+ partnerIds.push(partner.id);
+ await createPartnerMailbox(partner.id);
+ await backdateEnrollment({
+ partnerId: partner.id,
+ programId: program.id,
+ hoursAgo,
+ });
+ }
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: partnerIds[0],
+ count: 0,
+ });
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: partnerIds[1],
+ count: 1,
+ });
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: partnerIds[2],
+ count: 0,
+ });
+ } finally {
+ for (const partnerId of partnerIds) {
+ await deleteTestPartner(partnerId);
+ }
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled run skips eligible partners without a partner user", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled run does not send duplicate campaign emails", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+
+ const emails = await expectCampaignEmailCount({
+ campaignId,
+ partnerId,
+ count: 1,
+ });
+ expect(emails[0].type).toEqual("Campaign");
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled run skips partners who already received the campaign", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ const userId = await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const existing = await insertCampaignEmail({
+ campaignId,
+ programId: program.id,
+ partnerId,
+ recipientUserId: userId,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+
+ const emails = await campaignEmails(campaignId, partnerId);
+ expect(emails).toHaveLength(1);
+ expect(emails[0].id).toEqual(existing.id);
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled AND sends when enrollment window and leads match", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ enrolledDaysCondition,
+ { attribute: "totalLeads", operator: "gte", value: 1 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+ await setLinkStats({
+ partnerId,
+ programId: program.id,
+ leads: 1,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled AND does not send when the metric condition fails", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ enrolledDaysCondition,
+ { attribute: "totalLeads", operator: "gte", value: 1 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("scheduled AND sends when totalLeads lte 0", async ({ api, program }) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ enrolledDaysCondition,
+ { attribute: "totalLeads", operator: "lte", value: 0 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+const scheduledMetricCases = [
+ {
+ name: "totalConversions",
+ condition: {
+ attribute: "totalConversions",
+ operator: "gte",
+ value: 1,
+ },
+ stats: { conversions: 1 },
+ },
+ {
+ name: "totalSaleAmount",
+ condition: {
+ attribute: "totalSaleAmount",
+ operator: "gte",
+ value: 100,
+ },
+ stats: { saleAmount: 100 },
+ },
+] as const;
+
+for (const { name, condition, stats } of scheduledMetricCases) {
+ test(`scheduled AND sends when ${name} matches`, async ({ api, program }) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [enrolledDaysCondition, condition],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+ await setLinkStats({
+ partnerId,
+ programId: program.id,
+ ...stats,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+ });
+}
+
+test("scheduled AND sends when totalCommissions matches", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ enrolledDaysCondition,
+ { attribute: "totalCommissions", operator: "gte", value: 1 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+ await createTestCommission({
+ programId: program.id,
+ partnerId,
+ earnings: 500,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("partnerJoined sends on partnerEnrolled and not on the scheduled runner", async ({
+ api,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ { attribute: "partnerJoined", operator: "gte", value: 0 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+
+ expect(
+ await runPartnerCampaignWorkflow(api, workflow.id, partnerId),
+ ).toEqual("finished");
+
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("leadRecorded sends when totalLeads matches and skips when it does not", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let matchId: string | undefined;
+ let missId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ { attribute: "totalLeads", operator: "gte", value: 1 },
+ ],
+ });
+
+ const match = await createTestPartner(api);
+ matchId = match.id;
+ await createPartnerMailbox(matchId);
+ await setLinkStats({
+ partnerId: matchId,
+ programId: program.id,
+ leads: 1,
+ });
+
+ const miss = await createTestPartner(api);
+ missId = miss.id;
+ await createPartnerMailbox(missId);
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runPartnerCampaignWorkflow(api, workflow.id, matchId)).toEqual(
+ "finished",
+ );
+ expect(await runPartnerCampaignWorkflow(api, workflow.id, missId)).toEqual(
+ "finished",
+ );
+
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: matchId,
+ count: 1,
+ });
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: missId,
+ count: 0,
+ });
+ } finally {
+ await deleteTestPartner(matchId);
+ await deleteTestPartner(missId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("saleRecorded sends when totalConversions matches", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ { attribute: "totalConversions", operator: "gte", value: 1 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await setLinkStats({
+ partnerId,
+ programId: program.id,
+ conversions: 1,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(
+ await runPartnerCampaignWorkflow(api, workflow.id, partnerId),
+ ).toEqual("finished");
+
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("commissionRecorded sends when totalCommissions matches", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ { attribute: "totalCommissions", operator: "gte", value: 1 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await createTestCommission({
+ programId: program.id,
+ partnerId,
+ earnings: 250,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(
+ await runPartnerCampaignWorkflow(api, workflow.id, partnerId),
+ ).toEqual("finished");
+
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("event runner skips disabled workflows", async ({ api }) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api, {
+ triggerConditions: [
+ { attribute: "partnerJoined", operator: "gte", value: 0 },
+ ],
+ });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ await prisma.workflow.update({
+ where: { id: workflow.id },
+ data: { disabledAt: new Date() },
+ });
+
+ expect(
+ await runPartnerCampaignWorkflow(api, workflow.id, partnerId),
+ ).toEqual("disabled");
+
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("group filter only sends to partners in selected groups", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let groupId: string | undefined;
+ let inGroupId: string | undefined;
+ let outGroupId: string | undefined;
+
+ try {
+ groupId = await createTestGroup(api);
+ campaignId = await publishTransactionalCampaign(api, {
+ groupIds: [groupId],
+ });
+
+ const inGroup = await createTestPartner(api, { groupId });
+ inGroupId = inGroup.id;
+ await createPartnerMailbox(inGroupId);
+ await backdateEnrollment({
+ partnerId: inGroupId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const outGroup = await createTestPartner(api, {
+ groupId: program.defaultGroupId,
+ });
+ outGroupId = outGroup.id;
+ await createPartnerMailbox(outGroupId);
+ await backdateEnrollment({
+ partnerId: outGroupId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: inGroupId,
+ count: 1,
+ });
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: outGroupId,
+ count: 0,
+ });
+ } finally {
+ await deleteTestPartner(inGroupId);
+ await deleteTestPartner(outGroupId);
+ await cleanupCampaign(api, campaignId);
+ await deleteTestGroup(api, groupId);
+ }
+});
+
+test("partner tag filter only sends to tagged partners", async ({
+ api,
+ program,
+}) => {
+ let campaignId: string | undefined;
+ let partnerTagId: string | undefined;
+ let taggedId: string | undefined;
+ let untaggedId: string | undefined;
+
+ try {
+ const tag = await createPartnerTag(program.id);
+ partnerTagId = tag.id;
+ campaignId = await publishTransactionalCampaign(api, {
+ partnerTagIds: [tag.id],
+ });
+
+ const tagged = await createTestPartner(api);
+ taggedId = tagged.id;
+ await createPartnerMailbox(taggedId);
+ await tagPartner({
+ programId: program.id,
+ partnerId: taggedId,
+ partnerTagId: tag.id,
+ });
+ await backdateEnrollment({
+ partnerId: taggedId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const untagged = await createTestPartner(api);
+ untaggedId = untagged.id;
+ await createPartnerMailbox(untaggedId);
+ await backdateEnrollment({
+ partnerId: untaggedId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: taggedId,
+ count: 1,
+ });
+ await expectCampaignEmailCount({
+ campaignId,
+ partnerId: untaggedId,
+ count: 0,
+ });
+ } finally {
+ await deleteTestPartner(taggedId);
+ await deleteTestPartner(untaggedId);
+ await cleanupCampaign(api, campaignId);
+ await deletePartnerTag(partnerTagId);
+ }
+});
+
+test("group and tag filters both have to match", async ({ api, program }) => {
+ let campaignId: string | undefined;
+ let groupId: string | undefined;
+ let partnerTagId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ groupId = await createTestGroup(api);
+ const tag = await createPartnerTag(program.id);
+ partnerTagId = tag.id;
+ campaignId = await publishTransactionalCampaign(api, {
+ groupIds: [groupId],
+ partnerTagIds: [tag.id],
+ });
+
+ const partner = await createTestPartner(api, { groupId });
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+
+ await tagPartner({
+ programId: program.id,
+ partnerId,
+ partnerTagId: tag.id,
+ });
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 1 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ await deletePartnerTag(partnerTagId);
+ await deleteTestGroup(api, groupId);
+ }
+});
+
+test("non-approved enrollments are not sent", async ({ api, program }) => {
+ let campaignId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ campaignId = await publishTransactionalCampaign(api);
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+ await setEnrollmentStatus({
+ partnerId,
+ programId: program.id,
+ status: "pending",
+ });
+
+ const workflow = await getCampaignWorkflow(campaignId);
+ expect(await runScheduledCampaignWorkflow(api, workflow.id)).toEqual(
+ "finished",
+ );
+ await expectCampaignEmailCount({ campaignId, partnerId, count: 0 });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, campaignId);
+ }
+});
+
+test("draft and paused campaigns do not send", async ({ api, program }) => {
+ let draftId: string | undefined;
+ let pausedId: string | undefined;
+ let partnerId: string | undefined;
+
+ try {
+ const { data: draft } = await createCampaign(api);
+ draftId = draft.id;
+ await api.patch(`/api/campaigns/${draftId}`, {
+ triggerConditions: [enrolledDaysCondition],
+ });
+
+ pausedId = await publishTransactionalCampaign(api);
+ await api.patch(`/api/campaigns/${pausedId}`, { status: "paused" });
+
+ const partner = await createTestPartner(api);
+ partnerId = partner.id;
+ await createPartnerMailbox(partnerId);
+ await backdateEnrollment({
+ partnerId,
+ programId: program.id,
+ hoursAgo: 18,
+ });
+
+ const draftWorkflow = await getCampaignWorkflow(draftId);
+ const pausedWorkflow = await getCampaignWorkflow(pausedId);
+
+ expect(await runScheduledCampaignWorkflow(api, draftWorkflow.id)).toEqual(
+ "disabled",
+ );
+ expect(await runScheduledCampaignWorkflow(api, pausedWorkflow.id)).toEqual(
+ "disabled",
+ );
+
+ await expectCampaignEmailCount({
+ campaignId: draftId,
+ partnerId,
+ count: 0,
+ });
+ await expectCampaignEmailCount({
+ campaignId: pausedId,
+ partnerId,
+ count: 0,
+ });
+ } finally {
+ await deleteTestPartner(partnerId);
+ await cleanupCampaign(api, draftId);
+ await cleanupCampaign(api, pausedId);
+ }
+});
diff --git a/apps/web/playwright/api/setup-test-workspace.ts b/apps/web/playwright/api/setup-test-workspace.ts
index 36cead5225..e044899004 100644
--- a/apps/web/playwright/api/setup-test-workspace.ts
+++ b/apps/web/playwright/api/setup-test-workspace.ts
@@ -71,6 +71,7 @@ export async function setupTestWorkspace() {
foldersLimit: 100,
aiLimit: 1000,
partnersLimit: 1000,
+ groupsLimit: 100,
},
create: {
id: createId({ prefix: "ws_" }),
@@ -86,6 +87,7 @@ export async function setupTestWorkspace() {
foldersLimit: 100,
aiLimit: 1000,
partnersLimit: 1000,
+ groupsLimit: 100,
},
});
diff --git a/apps/web/tests/workflows/send-campaign-workflow.test.ts b/apps/web/tests/workflows/send-campaign-workflow.test.ts
deleted file mode 100644
index e8dcd03132..0000000000
--- a/apps/web/tests/workflows/send-campaign-workflow.test.ts
+++ /dev/null
@@ -1,876 +0,0 @@
-import { EnrolledPartnerProps } from "@/lib/types";
-import { Campaign } from "@prisma/client";
-import { subHours } from "date-fns";
-import { describe, expect, onTestFinished, test } from "vitest";
-import { randomPartnerEmail } from "../utils/helpers";
-import { IntegrationHarness } from "../utils/integration";
-import { E2E_USER_ID } from "../utils/resource";
-import { verifyCampaignSent } from "./utils/verify-campaign-sent";
-
-describe.sequential("Workflow - SendCampaign", async () => {
- const h = new IntegrationHarness();
- const { http } = await h.init();
-
- test("Workflow is created when transactional campaign is published", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
- expect(campaign.id).toBeDefined();
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- const { status: updateStatus } = await http.patch<Campaign>({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Test Campaign",
- subject: "Welcome to our program!",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [
- {
- type: "text",
- text: "Thank you for joining!",
- },
- ],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- },
- });
-
- expect(updateStatus).toEqual(200);
-
- const { status: publishStatus, data: publishedCampaign } =
- await http.patch<Campaign>({
- path: `/campaigns/${campaignId}`,
- body: {
- status: "active",
- },
- });
-
- expect(publishStatus).toEqual(200);
- expect(publishedCampaign.status).toBe("active");
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
- expect(workflow.disabledAt).toBeNull();
-
- const workflowActions = workflow.actions as any[];
- expect(workflowActions[0].type).toBe("sendCampaign");
- expect(workflowActions[0].data.campaignId).toBe(campaignId);
- });
-
- test("Workflow doesn't execute when campaign is in draft", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- const { status: updateStatus, data: updatedCampaign } =
- await http.patch<Campaign>({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Draft Campaign",
- subject: "This should not be sent",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [
- {
- type: "text",
- text: "Draft content",
- },
- ],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- },
- });
-
- expect(updateStatus).toEqual(200);
- expect(updatedCampaign.status).toBe("draft");
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
- expect(workflow.disabledAt).not.toBeNull();
- });
-
- test("Cron executes send campaign workflow", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Cron Campaign",
- subject: "Welcome!",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Test content" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- const { status, data } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(data.message).toContain("Finished executing workflow");
- });
-
- test("Cron skips disabled send campaign workflow", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Disabled Cron Campaign",
- subject: "Should not be sent",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Test" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- // Disable workflow via E2E endpoint
- await http.patch({
- path: `/e2e/workflows/${workflow.id}`,
- body: { disabledAt: new Date().toISOString() },
- });
-
- const { status, data } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(data.message).toContain("disabled");
-
- const { data: emailsSent } = await http.get<any[]>({
- path: "/e2e/notification-emails",
- query: { campaignId },
- });
-
- expect(emailsSent).toHaveLength(0);
- });
-
- test("Cron processes eligible partner enrollment", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Send Campaign",
- subject: "Welcome partner!",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Hello!" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- const { status: partnerStatus, data: partner } =
- await http.post<EnrolledPartnerProps>({
- path: "/partners",
- body: {
- name: "E2E Test Partner - Campaign Send",
- email: randomPartnerEmail(),
- },
- });
-
- expect(partnerStatus).toEqual(201);
-
- // Backdate the enrollment to 18h ago so it falls in the cron window
- await http.patch({
- path: "/e2e/enrollments",
- body: {
- partnerId: partner.id,
- createdAt: subHours(new Date(), 18).toISOString(),
- },
- });
-
- const { status, data } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(data.message).toContain("Finished executing workflow");
- });
-
- test("Cron doesn't send campaign when partner doesn't meet conditions", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E No Match Campaign",
- subject: "Should not be sent",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Test" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- // Create a partner enrolled just now — doesn't match the 12-24h window
- const { status: partnerStatus, data: partner } =
- await http.post<EnrolledPartnerProps>({
- path: "/partners",
- body: {
- name: "E2E Test Partner - No Match",
- email: randomPartnerEmail(),
- },
- });
-
- expect(partnerStatus).toEqual(201);
-
- const { status, data: triggerData } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(triggerData.message).toContain("Finished executing workflow");
-
- const { data: emailsSent } = await http.get<any[]>({
- path: "/e2e/notification-emails",
- query: { campaignId, partnerId: partner.id },
- });
-
- expect(emailsSent).toHaveLength(0);
- });
-
- test("No duplicate campaign sends on multiple cron executions", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await http.delete({
- path: "/e2e/notification-emails",
- query: { campaignId },
- });
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E No Dup Campaign",
- subject: "No duplicates!",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Hello!" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- const { status: partnerStatus, data: partner } =
- await http.post<EnrolledPartnerProps>({
- path: "/partners",
- body: {
- name: "E2E Test Partner - No Dup Campaign",
- email: randomPartnerEmail(),
- },
- });
-
- expect(partnerStatus).toEqual(201);
-
- // Backdate enrollment to match the cron window
- await http.patch({
- path: "/e2e/enrollments",
- body: {
- partnerId: partner.id,
- createdAt: subHours(new Date(), 18).toISOString(),
- },
- });
-
- // Pre-insert a notification email to simulate a previous send
- const { data: existingEmail } = await http.post<any>({
- path: "/e2e/notification-emails",
- body: {
- campaignId,
- partnerId: partner.id,
- recipientUserId: E2E_USER_ID,
- },
- });
-
- expect(existingEmail).not.toBeNull();
-
- // Trigger the workflow — should skip this partner (already sent)
- const { status, data: triggerData } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(triggerData.message).toContain("Finished executing workflow");
-
- // Verify still only 1 notification email (no duplicate)
- const { data: emails } = await http.get<any[]>({
- path: "/e2e/notification-emails",
- query: { campaignId, partnerId: partner.id },
- });
-
- expect(emails).toHaveLength(1);
- expect(emails[0].id).toBe(existingEmail.id);
- });
-
- test("Campaign workflow configuration can be updated", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Campaign Config Test",
- subject: "Test",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Test" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
- const conditions1 = workflow.triggerConditions as any[];
- expect(conditions1[0].value).toBe(1);
-
- const { status: pauseStatus, data: pausedCampaign } =
- await http.patch<Campaign>({
- path: `/campaigns/${campaignId}`,
- body: {
- status: "paused",
- },
- });
-
- expect(pauseStatus).toEqual(200);
- expect(pausedCampaign.status).toBe("paused");
-
- const { data: pausedWorkflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(pausedWorkflow.disabledAt).not.toBeNull();
- });
-
- test("Campaign supports mixed enrollment and metric conditions", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- const { status: updateStatus, data: updatedCampaign } =
- await http.patch<Campaign>({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E Mixed Conditions Campaign",
- subject: "Still no leads after 30 days",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Let's get those leads!" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 30,
- },
- {
- attribute: "totalLeads",
- operator: "lte",
- value: 0,
- },
- ],
- status: "active",
- },
- });
-
- expect(updateStatus).toEqual(200);
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
- expect(workflow.disabledAt).toBeNull();
-
- const conditions = workflow.triggerConditions as any[];
- expect(conditions).toHaveLength(2);
- expect(conditions[0]).toMatchObject({
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 30,
- });
- expect(conditions[1]).toMatchObject({
- attribute: "totalLeads",
- operator: "lte",
- value: 0,
- });
-
- // Response shape exposes the full conditions array
- expect((updatedCampaign as any).triggerConditions).toEqual(conditions);
- });
-
- test(
- "Cron sends campaign when all conditions are met (AND)",
- { timeout: 90000 },
- async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await http.delete({
- path: "/e2e/notification-emails",
- query: { campaignId },
- });
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E AND Match Campaign",
- subject: "You got a lead!",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Congrats on your first lead!" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- {
- attribute: "totalLeads",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- const { status: partnerStatus, data: partner } =
- await http.post<EnrolledPartnerProps>({
- path: "/partners",
- body: {
- name: "E2E Test Partner - AND Match",
- email: randomPartnerEmail(),
- },
- });
-
- expect(partnerStatus).toEqual(201);
- expect(partner.links).not.toBeNull();
-
- // API-created partners have no PartnerUser, and campaign emails only
- // go to users with an email. Create one and set link.leads directly so
- // the cron AND conditions are met without racing Tinybird waitUntil.
- const { status: enrollmentStatus } = await http.patch({
- path: "/e2e/enrollments",
- body: {
- partnerId: partner.id,
- createdAt: subHours(new Date(), 18).toISOString(),
- leads: 1,
- createUser: true,
- },
- });
-
- expect(enrollmentStatus).toEqual(200);
-
- const { status, data } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(data.message).toContain("Finished executing workflow");
-
- await verifyCampaignSent({
- http,
- campaignId,
- partnerId: partner.id,
- });
- },
- );
-
- test("Cron doesn't send when metric condition fails (AND)", async () => {
- const { status: createStatus, data: campaign } = await http.post<{
- id: string;
- }>({
- path: "/campaigns",
- body: {
- type: "transactional",
- },
- });
-
- expect(createStatus).toEqual(201);
-
- const campaignId = campaign.id;
-
- onTestFinished(async () => {
- await h.deleteCampaign(campaignId);
- });
-
- await http.patch({
- path: `/campaigns/${campaignId}`,
- body: {
- name: "E2E AND Partial Match Campaign",
- subject: "Should not be sent",
- bodyJson: {
- type: "doc",
- content: [
- {
- type: "paragraph",
- content: [{ type: "text", text: "Test" }],
- },
- ],
- },
- triggerConditions: [
- {
- attribute: "partnerEnrolledDays",
- operator: "gte",
- value: 1,
- },
- {
- attribute: "totalLeads",
- operator: "gte",
- value: 1,
- },
- ],
- status: "active",
- },
- });
-
- const { data: workflow } = await http.get<any>({
- path: "/e2e/workflows",
- query: { campaignId },
- });
-
- expect(workflow).not.toBeNull();
-
- const { status: partnerStatus, data: partner } =
- await http.post<EnrolledPartnerProps>({
- path: "/partners",
- body: {
- name: "E2E Test Partner - AND Partial",
- email: randomPartnerEmail(),
- },
- });
-
- expect(partnerStatus).toEqual(201);
-
- // Enrollment window matches, but totalLeads is 0 — AND fails
- await http.patch({
- path: "/e2e/enrollments",
- body: {
- partnerId: partner.id,
- createdAt: subHours(new Date(), 18).toISOString(),
- },
- });
-
- const { status, data: triggerData } = await http.post<{ message: string }>({
- path: `/e2e/trigger-workflow/${workflow.id}`,
- });
-
- expect(status).toEqual(200);
- expect(triggerData.message).toContain("Finished executing workflow");
-
- const { data: emailsSent } = await http.get<any[]>({
- path: "/e2e/notification-emails",
- query: { campaignId, partnerId: partner.id },
- });
-
- expect(emailsSent).toHaveLength(0);
- });
-});
diff --git a/apps/web/tests/workflows/utils/verify-campaign-sent.ts b/apps/web/tests/workflows/utils/verify-campaign-sent.ts
deleted file mode 100644
index aa8a433748..0000000000
--- a/apps/web/tests/workflows/utils/verify-campaign-sent.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import {
- VITEST_POLL_INTERVAL_MS,
- VITEST_TEST_TIMEOUT_MS,
-} from "@/lib/constants/misc";
-import { expect } from "vitest";
-import { HttpClient } from "../../utils/http";
-
-interface VerifyCampaignSentProps {
- http: HttpClient;
- campaignId: string;
- partnerId: string;
-}
-
-export const verifyCampaignSent = async ({
- http,
- campaignId,
- partnerId,
-}: VerifyCampaignSentProps) => {
- const startTime = Date.now();
-
- while (Date.now() - startTime < VITEST_TEST_TIMEOUT_MS) {
- const { data: emails } = await http.get<any[]>({
- path: "/e2e/notification-emails",
- query: { campaignId, partnerId },
- });
-
- const emailSent = emails?.[0];
-
- if (emailSent) {
- expect(emailSent.type).toBe("Campaign");
- expect(emailSent.campaignId).toBe(campaignId);
- expect(emailSent.partnerId).toBe(partnerId);
- return emailSent;
- }
-
- await new Promise((resolve) =>
- setTimeout(resolve, VITEST_POLL_INTERVAL_MS),
- );
- }
-
- throw new Error(
- `Campaign email not found within ${VITEST_TEST_TIMEOUT_MS / 1000} seconds. ` +
- `campaignId: ${campaignId}, partnerId: ${partnerId}`,
- );
-};