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.

test: initial tests for move-group and send-campaign

Pedro Ladeira2708fa78dbbf
diff --git a/apps/web/tests/workflows/move-group-workflow.test.ts b/apps/web/tests/workflows/move-group-workflow.test.ts
new file mode 100644
index 0000000000..015cafcbc6
--- /dev/null
+++ b/apps/web/tests/workflows/move-group-workflow.test.ts
@@ -0,0 +1,346 @@
+import { EnrolledPartnerProps } from "@/lib/types";
+import { RESOURCE_COLORS } from "@/ui/colors";
+import { randomValue } from "@dub/utils";
+import { prisma } from "@dub/prisma";
+import { PartnerGroup } from "@dub/prisma/client";
+import { describe, expect, test, onTestFinished } from "vitest";
+import { randomEmail } from "../utils/helpers";
+import { IntegrationHarness } from "../utils/integration";
+import { E2E_PROGRAM, E2E_TRACK_CLICK_HEADERS } from "../utils/resource";
+import { verifyPartnerGroupMove } from "./utils/verify-partner-group-move";
+
+async function trackLeads(
+ http: any,
+ partnerLink: { domain: string; key: string },
+ count: number,
+) {
+ for (let i = 0; i < count; i++) {
+ const { status: clickStatus, data: clickData } = await http.post({
+ path: "/track/click",
+ headers: E2E_TRACK_CLICK_HEADERS,
+ body: {
+ domain: partnerLink.domain,
+ key: partnerLink.key,
+ },
+ });
+
+ expect(clickStatus).toEqual(200);
+ expect(clickData.clickId).toBeDefined();
+
+ const { status: leadStatus } = await http.post({
+ path: "/track/lead",
+ body: {
+ clickId: clickData.clickId,
+ eventName: `Signup-${i}-${Date.now()}`,
+ customerExternalId: `e2e-customer-${i}-${Date.now()}`,
+ customerEmail: `customer${i}@example.com`,
+ },
+ });
+
+ expect(leadStatus).toEqual(200);
+
+ await new Promise((resolve) => setTimeout(resolve, 200));
+ }
+}
+
+describe.sequential("Workflow - MoveGroup", async () => {
+ const h = new IntegrationHarness();
+ const { http } = await h.init();
+ const programId = E2E_PROGRAM.id;
+
+ test("Workflow is created when move rules are configured", async () => {
+ const { status: targetStatus, data: targetGroup } = await http.post<
+ PartnerGroup
+ >({
+ path: "/groups",
+ body: {
+ name: "E2E Target Group - Config Test",
+ slug: `e2e-target-config-${Date.now()}`,
+ color: randomValue(RESOURCE_COLORS),
+ },
+ });
+
+ expect(targetStatus).toEqual(201);
+
+ onTestFinished(async () => {
+ await http.delete({ path: `/groups/${targetGroup.id}` });
+ });
+
+ const { status: patchStatus } = await http.patch({
+ path: `/groups/${targetGroup.id}`,
+ body: {
+ moveRules: [
+ {
+ attribute: "totalLeads",
+ operator: "gte",
+ value: 10,
+ },
+ ],
+ },
+ });
+
+ expect(patchStatus).toEqual(200);
+
+ const workflow = await prisma.workflow.findFirst({
+ where: {
+ partnerGroup: { id: targetGroup.id },
+ },
+ });
+
+ expect(workflow).not.toBeNull();
+ expect(workflow?.trigger).toBe("partnerMetricsUpdated");
+ expect(workflow?.disabledAt).toBeNull();
+
+ const workflowActions = workflow?.actions as any[];
+ expect(workflowActions).toHaveLength(1);
+ expect(workflowActions[0].type).toBe("moveGroup");
+ expect(workflowActions[0].data.groupId).toBe(targetGroup.id);
+
+ const workflowConditions = workflow?.triggerConditions as any[];
+ expect(workflowConditions).toHaveLength(1);
+ expect(workflowConditions[0].attribute).toBe("totalLeads");
+ expect(workflowConditions[0].operator).toBe("gte");
+ expect(workflowConditions[0].value).toBe(10);
+ });
+
+ test("Workflow is deleted when move rules are removed", async () => {
+ const { status: groupStatus, data: group } = await http.post<PartnerGroup>({
+ path: "/groups",
+ body: {
+ name: "E2E Group - Remove Rules",
+ slug: `e2e-remove-rules-${Date.now()}`,
+ color: randomValue(RESOURCE_COLORS),
+ },
+ });
+
+ expect(groupStatus).toEqual(201);
+
+ onTestFinished(async () => {
+ await http.delete({ path: `/groups/${group.id}` });
+ });
+
+ const { status: addStatus } = await http.patch({
+ path: `/groups/${group.id}`,
+ body: {
+ moveRules: [
+ {
+ attribute: "totalLeads",
+ operator: "gte",
+ value: 5,
+ },
+ ],
+ },
+ });
+
+ expect(addStatus).toEqual(200);
+
+ let workflow = await prisma.workflow.findFirst({
+ where: { partnerGroup: { id: group.id } },
+ });
+
+ expect(workflow).not.toBeNull();
+ const workflowId = workflow!.id;
+
+ const { status: removeStatus } = await http.patch({
+ path: `/groups/${group.id}`,
+ body: {
+ moveRules: [],
+ },
+ });
+
+ expect(removeStatus).toEqual(200);
+
+ workflow = await prisma.workflow.findUnique({
+ where: { id: workflowId },
+ });
+
+ expect(workflow).toBeNull();
+ });
+
+ test("Workflow can be disabled via disabledAt field", async () => {
+ const { status: targetStatus, data: targetGroup } = await http.post<
+ PartnerGroup
+ >({
+ path: "/groups",
+ body: {
+ name: "E2E Target Group - Disable Test",
+ slug: `e2e-target-disable-${Date.now()}`,
+ color: randomValue(RESOURCE_COLORS),
+ },
+ });
+
+ expect(targetStatus).toEqual(201);
+
+ onTestFinished(async () => {
+ await http.delete({ path: `/groups/${targetGroup.id}` });
+ });
+
+ const { status: patchStatus } = await http.patch({
+ path: `/groups/${targetGroup.id}`,
+ body: {
+ moveRules: [
+ {
+ attribute: "totalLeads",
+ operator: "gte",
+ value: 5,
+ },
+ ],
+ },
+ });
+
+ expect(patchStatus).toEqual(200);
+
+ const workflow = await prisma.workflow.findFirst({
+ where: { partnerGroup: { id: targetGroup.id } },
+ });
+
+ expect(workflow).not.toBeNull();
+ expect(workflow?.disabledAt).toBeNull();
+
+ await prisma.workflow.update({
+ where: { id: workflow!.id },
+ data: { disabledAt: new Date() },
+ });
+
+ const disabledWorkflow = await prisma.workflow.findUnique({
+ where: { id: workflow!.id },
+ select: { disabledAt: true },
+ });
+
+ expect(disabledWorkflow?.disabledAt).not.toBeNull();
+ });
+
+ test("Workflow executes when conditions are met - partner moves to target group", { timeout: 90000 }, async () => {
+ const { data: existingGroups } = await http.get<PartnerGroup[]>({
+ path: "/groups",
+ });
+
+ expect(existingGroups.length).toBeGreaterThan(0);
+ const sourceGroup = existingGroups[0];
+
+ const { status: targetStatus, data: targetGroup } = await http.post<
+ PartnerGroup
+ >({
+ path: "/groups",
+ body: {
+ name: "E2E Target Group - Move Execution",
+ slug: `e2e-target-exec-${Date.now()}`,
+ color: randomValue(RESOURCE_COLORS),
+ },
+ });
+
+ expect(targetStatus).toEqual(201);
+
+ onTestFinished(async () => {
+ await http.delete({ path: `/groups/${targetGroup.id}` });
+ });
+
+ const { status: patchStatus } = await http.patch({
+ path: `/groups/${targetGroup.id}`,
+ body: {
+ moveRules: [
+ {
+ attribute: "totalLeads",
+ operator: "gte",
+ value: 10,
+ },
+ ],
+ },
+ });
+
+ expect(patchStatus).toEqual(200);
+
+ const { status: partnerStatus, data: partner } = await http.post<
+ EnrolledPartnerProps
+ >({
+ path: "/partners",
+ body: {
+ name: "E2E Test Partner - Move Execution",
+ email: randomEmail(),
+ groupId: sourceGroup.id,
+ },
+ });
+
+ expect(partnerStatus).toEqual(201);
+ expect(partner.links).not.toBeNull();
+
+ const enrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId: partner.id,
+ programId,
+ },
+ },
+ select: { id: true, groupId: true },
+ });
+
+ if (!enrollment) {
+ console.warn(
+ `Skipping test: Partner ${partner.id} not enrolled in program ${programId}. This may indicate an E2E seed configuration issue.`,
+ );
+ return;
+ }
+
+ expect(enrollment.groupId).toBe(sourceGroup.id);
+
+ const partnerLink = partner.links![0];
+
+ await trackLeads(http, partnerLink, 11);
+
+ await verifyPartnerGroupMove({
+ partnerId: partner.id,
+ programId,
+ expectedGroupId: targetGroup.id,
+ });
+ });
+
+ test("Multiple move rules can be configured (AND operator)", async () => {
+ const { status: groupStatus, data: group } = await http.post<PartnerGroup>({
+ path: "/groups",
+ body: {
+ name: "E2E Group - Multiple Rules",
+ slug: `e2e-multi-rules-${Date.now()}`,
+ color: randomValue(RESOURCE_COLORS),
+ },
+ });
+
+ expect(groupStatus).toEqual(201);
+
+ onTestFinished(async () => {
+ await http.delete({ path: `/groups/${group.id}` });
+ });
+
+ const { status: patchStatus } = await http.patch({
+ path: `/groups/${group.id}`,
+ body: {
+ moveRules: [
+ {
+ attribute: "totalLeads",
+ operator: "gte",
+ value: 10,
+ },
+ {
+ attribute: "totalConversions",
+ operator: "gte",
+ value: 5,
+ },
+ ],
+ },
+ });
+
+ expect(patchStatus).toEqual(200);
+
+ const workflow = await prisma.workflow.findFirst({
+ where: { partnerGroup: { id: group.id } },
+ });
+
+ expect(workflow).not.toBeNull();
+
+ const workflowConditions = workflow?.triggerConditions as any[];
+ expect(workflowConditions).toHaveLength(2);
+ expect(workflowConditions[0].attribute).toBe("totalLeads");
+ expect(workflowConditions[0].value).toBe(10);
+ expect(workflowConditions[1].attribute).toBe("totalConversions");
+ expect(workflowConditions[1].value).toBe(5);
+ });
+});
diff --git a/apps/web/tests/workflows/send-campaign-workflow.test.ts b/apps/web/tests/workflows/send-campaign-workflow.test.ts
new file mode 100644
index 0000000000..10e684769f
--- /dev/null
+++ b/apps/web/tests/workflows/send-campaign-workflow.test.ts
@@ -0,0 +1,366 @@
+import { EnrolledPartnerProps } from "@/lib/types";
+import { Campaign } from "@dub/prisma/client";
+import { prisma } from "@dub/prisma";
+import { describe, expect, test, onTestFinished } from "vitest";
+import { randomEmail } from "../utils/helpers";
+import { IntegrationHarness } from "../utils/integration";
+import { E2E_PARTNER, E2E_PROGRAM } from "../utils/resource";
+import { verifyCampaignSent } from "./utils/verify-campaign-sent";
+
+describe.sequential("Workflow - SendCampaign", async () => {
+ const h = new IntegrationHarness();
+ const { http } = await h.init();
+ const programId = E2E_PROGRAM.id;
+
+ const testPartner = E2E_PARTNER;
+
+ test("Workflow executes when partner enrolled - campaign sent", 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!",
+ },
+ ],
+ },
+ ],
+ },
+ triggerCondition: {
+ attribute: "partnerJoined",
+ operator: "gte",
+ value: 0,
+ },
+ },
+ });
+
+ expect(updateStatus).toEqual(200);
+
+ const { status: publishStatus } = await http.patch<Campaign>({
+ path: `/campaigns/${campaignId}`,
+ body: {
+ status: "active",
+ },
+ });
+
+ expect(publishStatus).toEqual(200);
+
+ const partnerId = testPartner.id;
+
+ const enrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ });
+
+ if (!enrollment) {
+ console.warn(
+ `Skipping test: E2E partner ${partnerId} not enrolled in program ${programId}. E2E seed may need updating.`,
+ );
+ return;
+ }
+
+ const workflow = await prisma.workflow.findFirst({
+ where: { campaign: { id: campaignId } },
+ });
+
+ expect(workflow).not.toBeNull();
+
+ const cronResponse = await fetch(
+ `${http.baseUrl.replace("/api", "")}/api/cron/workflows/${workflow!.id}`,
+ {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: "{}",
+ },
+ );
+
+ expect(cronResponse.status).toBe(200);
+
+ await verifyCampaignSent({
+ campaignId,
+ partnerId,
+ });
+ });
+
+ 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 } = 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",
+ },
+ ],
+ },
+ ],
+ },
+ triggerCondition: {
+ attribute: "partnerJoined",
+ operator: "gte",
+ value: 0,
+ },
+ },
+ });
+
+ expect(updateStatus).toEqual(200);
+
+ const { status: partnerStatus, data: partner } = await http.post<
+ EnrolledPartnerProps
+ >({
+ path: "/partners",
+ body: {
+ name: "E2E Draft Campaign Partner",
+ email: randomEmail(),
+ },
+ });
+
+ expect(partnerStatus).toEqual(201);
+
+ await new Promise((resolve) => setTimeout(resolve, 10000));
+
+ const emailSent = await prisma.notificationEmail.findFirst({
+ where: {
+ campaignId,
+ type: "Campaign",
+ partnerId: partner.id,
+ },
+ });
+
+ expect(emailSent).toBeNull();
+ });
+
+ test("Disabled workflow doesn't send campaign", 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 Campaign",
+ subject: "This should not be sent",
+ bodyJson: {
+ type: "doc",
+ content: [
+ {
+ type: "paragraph",
+ content: [{ type: "text", text: "Test" }],
+ },
+ ],
+ },
+ triggerCondition: {
+ attribute: "partnerJoined",
+ operator: "gte",
+ value: 0,
+ },
+ status: "active",
+ },
+ });
+
+ const workflow = await prisma.workflow.findFirst({
+ where: { campaign: { id: campaignId } },
+ });
+
+ expect(workflow).not.toBeNull();
+
+ await prisma.workflow.update({
+ where: { id: workflow!.id },
+ data: { disabledAt: new Date() },
+ });
+
+ const { status: partnerStatus, data: partner } = await http.post<
+ EnrolledPartnerProps
+ >({
+ path: "/partners",
+ body: {
+ name: "E2E Disabled Campaign Partner",
+ email: randomEmail(),
+ },
+ });
+
+ expect(partnerStatus).toEqual(201);
+
+ await new Promise((resolve) => setTimeout(resolve, 10000));
+
+ const emailSent = await prisma.notificationEmail.findFirst({
+ where: {
+ campaignId,
+ type: "Campaign",
+ partnerId: partner.id,
+ },
+ });
+
+ expect(emailSent).toBeNull();
+ });
+
+ test("No duplicate emails to same partner", 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 Duplicate Campaign",
+ subject: "Welcome!",
+ bodyJson: {
+ type: "doc",
+ content: [
+ {
+ type: "paragraph",
+ content: [{ type: "text", text: "Welcome message" }],
+ },
+ ],
+ },
+ triggerCondition: {
+ attribute: "partnerJoined",
+ operator: "gte",
+ value: 0,
+ },
+ status: "active",
+ },
+ });
+
+ const partnerId = testPartner.id;
+
+ const enrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ });
+
+ if (!enrollment) {
+ console.warn(`Skipping test: Partner not enrolled in program`);
+ return;
+ }
+
+ const workflow = await prisma.workflow.findFirst({
+ where: { campaign: { id: campaignId } },
+ });
+
+ expect(workflow).not.toBeNull();
+
+ const cronResponse = await fetch(
+ `${http.baseUrl.replace("/api", "")}/api/cron/workflows/${workflow!.id}`,
+ {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: "{}",
+ },
+ );
+
+ expect(cronResponse.status).toBe(200);
+
+ await verifyCampaignSent({
+ campaignId,
+ partnerId,
+ });
+
+ const cronResponse2 = await fetch(
+ `${http.baseUrl.replace("/api", "")}/api/cron/workflows/${workflow!.id}`,
+ {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: "{}",
+ },
+ );
+
+ expect(cronResponse2.status).toBe(200);
+
+ await new Promise((resolve) => setTimeout(resolve, 5000));
+
+ const allEmails = await prisma.notificationEmail.findMany({
+ where: {
+ campaignId,
+ type: "Campaign",
+ partnerId,
+ },
+ });
+
+ expect(allEmails).toHaveLength(1);
+ });
+});
diff --git a/apps/web/tests/workflows/utils/verify-campaign-sent.ts b/apps/web/tests/workflows/utils/verify-campaign-sent.ts
new file mode 100644
index 0000000000..2daefb30f4
--- /dev/null
+++ b/apps/web/tests/workflows/utils/verify-campaign-sent.ts
@@ -0,0 +1,42 @@
+import { prisma } from "@dub/prisma";
+import { expect } from "vitest";
+
+interface VerifyCampaignSentProps {
+ campaignId: string;
+ partnerId: string;
+}
+
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 30000; // 30 seconds
+
+export const verifyCampaignSent = async ({
+ campaignId,
+ partnerId,
+}: VerifyCampaignSentProps) => {
+ const startTime = Date.now();
+
+ while (Date.now() - startTime < TIMEOUT_MS) {
+ const emailSent = await prisma.notificationEmail.findFirst({
+ where: {
+ campaignId,
+ type: "Campaign",
+ partnerId,
+ },
+ });
+
+ if (emailSent) {
+ expect(emailSent).toBeDefined();
+ expect(emailSent.type).toBe("Campaign");
+ expect(emailSent.campaignId).toBe(campaignId);
+ expect(emailSent.partnerId).toBe(partnerId);
+ return emailSent;
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+ }
+
+ throw new Error(
+ `Campaign email not found within ${TIMEOUT_MS / 1000} seconds. ` +
+ `campaignId: ${campaignId}, partnerId: ${partnerId}`,
+ );
+};
diff --git a/apps/web/tests/workflows/utils/verify-partner-group-move.ts b/apps/web/tests/workflows/utils/verify-partner-group-move.ts
new file mode 100644
index 0000000000..d17e87ddce
--- /dev/null
+++ b/apps/web/tests/workflows/utils/verify-partner-group-move.ts
@@ -0,0 +1,49 @@
+import { prisma } from "@dub/prisma";
+import { expect } from "vitest";
+
+interface VerifyPartnerGroupMoveProps {
+ partnerId: string;
+ programId: string;
+ expectedGroupId: string;
+}
+
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 30000; // 30 seconds
+
+export const verifyPartnerGroupMove = async ({
+ partnerId,
+ programId,
+ expectedGroupId,
+}: VerifyPartnerGroupMoveProps) => {
+ const startTime = Date.now();
+
+ while (Date.now() - startTime < TIMEOUT_MS) {
+ const enrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ select: {
+ groupId: true,
+ clickRewardId: true,
+ leadRewardId: true,
+ saleRewardId: true,
+ discountId: true,
+ },
+ });
+
+ if (enrollment?.groupId === expectedGroupId) {
+ expect(enrollment.groupId).toBe(expectedGroupId);
+ return enrollment;
+ }
+
+ await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+ }
+
+ throw new Error(
+ `Partner group move not found within ${TIMEOUT_MS / 1000} seconds. ` +
+ `partnerId: ${partnerId}, expectedGroupId: ${expectedGroupId}`,
+ );
+};