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.

add e2e tests

Pedro Ladeira0573f711de9e
diff --git a/apps/web/app/(ee)/api/e2e/trigger-merge-account/route.ts b/apps/web/app/(ee)/api/e2e/trigger-merge-account/route.ts
new file mode 100644
index 0000000000..728c951581
--- /dev/null
+++ b/apps/web/app/(ee)/api/e2e/trigger-merge-account/route.ts
@@ -0,0 +1,74 @@
+import { DubApiError } from "@/lib/api/errors";
+import { parseRequestBody } from "@/lib/api/utils";
+import { withWorkspace } from "@/lib/auth";
+import { triggerQStashWorkflow } from "@/lib/cron/qstash-workflow";
+import { prisma } from "@dub/prisma";
+import { ACME_PROGRAM_ID, nanoid } from "@dub/utils";
+import { NextResponse } from "next/server";
+import * as z from "zod/v4";
+import { assertE2EWorkspace } from "../guard";
+
+const bodySchema = z.object({
+ sourceEmail: z.email(),
+ targetEmail: z.email(),
+});
+
+// POST /api/e2e/trigger-merge-account
+export const POST = withWorkspace(
+ async ({ req, workspace }) => {
+ assertE2EWorkspace(workspace);
+
+ const { sourceEmail, targetEmail } = bodySchema.parse(
+ await parseRequestBody(req),
+ );
+
+ if (sourceEmail.toLowerCase() === targetEmail.toLowerCase()) {
+ throw new DubApiError({
+ code: "bad_request",
+ message: "Source and target emails must be different.",
+ });
+ }
+
+ const partners = await prisma.partner.findMany({
+ where: {
+ email: { in: [sourceEmail, targetEmail] },
+ programs: { some: { programId: ACME_PROGRAM_ID } },
+ },
+ select: { email: true },
+ });
+
+ const enrolledEmails = new Set(partners.map((p) => p.email?.toLowerCase()));
+
+ if (
+ !enrolledEmails.has(sourceEmail.toLowerCase()) ||
+ !enrolledEmails.has(targetEmail.toLowerCase())
+ ) {
+ throw new DubApiError({
+ code: "bad_request",
+ message:
+ "Both partners must exist and be enrolled in the Acme test program.",
+ });
+ }
+
+ const userId = `e2e-merge-${nanoid()}`;
+
+ const res = await triggerQStashWorkflow({
+ workflowType: "merge-partner-account",
+ workflowLabel: userId,
+ body: {
+ userId,
+ sourceEmail,
+ targetEmail,
+ },
+ flowControl: {
+ key: userId,
+ parallelism: 1,
+ },
+ });
+
+ return NextResponse.json(res);
+ },
+ {
+ requiredPermissions: ["workspaces.write"],
+ },
+);
diff --git a/apps/web/tests/workflows/merge-partner-account-workflow.test.ts b/apps/web/tests/workflows/merge-partner-account-workflow.test.ts
new file mode 100644
index 0000000000..80100374df
--- /dev/null
+++ b/apps/web/tests/workflows/merge-partner-account-workflow.test.ts
@@ -0,0 +1,153 @@
+import {
+ VITEST_POLL_INTERVAL_MS,
+ VITEST_TEST_TIMEOUT_MS,
+} from "@/lib/constants/misc";
+import { EnrolledPartnerProps } from "@/lib/types";
+import { describe, expect, test } from "vitest";
+import { randomPartnerEmail } from "../utils/helpers";
+import { IntegrationHarness } from "../utils/integration";
+import { E2E_PARTNER_GROUP } from "../utils/resource";
+import { verifyMergeCompleted } from "./utils/verify-merge-completed";
+
+describe.sequential("Workflow - MergePartnerAccount", async () => {
+ const h = new IntegrationHarness();
+ const { http } = await h.init();
+
+ // Creates a partner enrolled (approved) in the Acme program with a default link.
+ async function createEnrolledPartner(label: string) {
+ const { status, data: partner } = await http.post<EnrolledPartnerProps>({
+ path: "/partners",
+ body: {
+ name: `E2E Merge ${label}`,
+ email: randomPartnerEmail(),
+ groupId: E2E_PARTNER_GROUP.id,
+ },
+ });
+
+ expect(status).toEqual(201);
+ expect(partner.links).not.toBeNull();
+ expect(partner.links!.length).toBeGreaterThan(0);
+
+ return partner;
+ }
+
+ test(
+ "Overlap merge transfers child data and deletes source",
+ { timeout: VITEST_TEST_TIMEOUT_MS },
+ async () => {
+ const source = await createEnrolledPartner("source");
+ const target = await createEnrolledPartner("target");
+ const sourceLinkId = source.links![0].id;
+
+ const { status: triggerStatus, data: triggerRes } = await http.post<{
+ workflowRunId?: string;
+ }>({
+ path: "/e2e/trigger-merge-account",
+ body: { sourceEmail: source.email, targetEmail: target.email },
+ });
+
+ expect(triggerStatus).toEqual(200);
+ expect(triggerRes).not.toBeNull();
+
+ const merged = await verifyMergeCompleted({
+ http,
+ sourcePartnerId: source.id,
+ targetPartnerId: target.id,
+ expectedLinkId: sourceLinkId,
+ });
+
+ expect(merged.links!.map((link) => link.id)).toContain(sourceLinkId);
+ },
+ );
+
+ test(
+ "Overlap merge upgrades target status from pending to approved",
+ { timeout: VITEST_TEST_TIMEOUT_MS },
+ async () => {
+ const source = await createEnrolledPartner("upgrade-source");
+ const target = await createEnrolledPartner("upgrade-target");
+
+ const { status: pendingStatus } = await http.post({
+ path: "/e2e/partners/pending-program-application",
+ body: { partnerId: target.id },
+ });
+ expect(pendingStatus).toEqual(200);
+
+ const { status: triggerStatus } = await http.post({
+ path: "/e2e/trigger-merge-account",
+ body: { sourceEmail: source.email, targetEmail: target.email },
+ });
+ expect(triggerStatus).toEqual(200);
+
+ const startTime = Date.now();
+ let lastTargetStatus: string | undefined;
+
+ while (Date.now() - startTime < VITEST_TEST_TIMEOUT_MS) {
+ const [sourceRes, targetRes] = await Promise.all([
+ http.get({ path: `/partners/${source.id}` }),
+ http.get<EnrolledPartnerProps>({ path: `/partners/${target.id}` }),
+ ]);
+
+ lastTargetStatus =
+ targetRes.status === 200 ? targetRes.data.status : undefined;
+
+ if (sourceRes.status === 404 && lastTargetStatus === "approved") {
+ expect(lastTargetStatus).toBe("approved");
+ return;
+ }
+
+ await new Promise((resolve) =>
+ setTimeout(resolve, VITEST_POLL_INTERVAL_MS),
+ );
+ }
+
+ throw new Error(
+ `Target status was not upgraded to approved within ${VITEST_TEST_TIMEOUT_MS / 1000}s. ` +
+ `Last seen status: ${lastTargetStatus}`,
+ );
+ },
+ );
+
+ test(
+ "Repeat merge is rejected once the source is already merged",
+ { timeout: VITEST_TEST_TIMEOUT_MS },
+ async () => {
+ const source = await createEnrolledPartner("repeat-source");
+ const target = await createEnrolledPartner("repeat-target");
+ const sourceLinkId = source.links![0].id;
+
+ const { status: firstTrigger } = await http.post({
+ path: "/e2e/trigger-merge-account",
+ body: { sourceEmail: source.email, targetEmail: target.email },
+ });
+ expect(firstTrigger).toEqual(200);
+
+ await verifyMergeCompleted({
+ http,
+ sourcePartnerId: source.id,
+ targetPartnerId: target.id,
+ expectedLinkId: sourceLinkId,
+ });
+
+ const { data: afterFirst } = await http.get<EnrolledPartnerProps>({
+ path: `/partners/${target.id}`,
+ });
+ const linkCountAfterFirst = afterFirst.links!.length;
+
+ // The source partner no longer exists, so triggering again is rejected by
+ // the guard (both partners must be enrolled in the Acme program) - the
+ // merge can't be double-processed.
+ const { status: secondTrigger } = await http.post({
+ path: "/e2e/trigger-merge-account",
+ body: { sourceEmail: source.email, targetEmail: target.email },
+ });
+ expect(secondTrigger).toEqual(400);
+
+ const { data: afterSecond } = await http.get<EnrolledPartnerProps>({
+ path: `/partners/${target.id}`,
+ });
+
+ expect(afterSecond.links!.length).toBe(linkCountAfterFirst);
+ },
+ );
+});
diff --git a/apps/web/tests/workflows/utils/verify-merge-completed.ts b/apps/web/tests/workflows/utils/verify-merge-completed.ts
new file mode 100644
index 0000000000..0e61fba5b3
--- /dev/null
+++ b/apps/web/tests/workflows/utils/verify-merge-completed.ts
@@ -0,0 +1,64 @@
+import {
+ VITEST_POLL_INTERVAL_MS,
+ VITEST_TEST_TIMEOUT_MS,
+} from "@/lib/constants/misc";
+import { EnrolledPartnerProps } from "@/lib/types";
+import { expect } from "vitest";
+import { HttpClient } from "../../utils/http";
+
+interface VerifyMergeCompletedProps {
+ http: HttpClient;
+ sourcePartnerId: string;
+ targetPartnerId: string;
+ // A link id that belonged to the source partner and should end up on the target
+ expectedLinkId: string;
+}
+
+/**
+ * Polls until the merge-partner-account workflow has finished:
+ * - the source partner is deleted (GET /partners/:id returns 404), and
+ * - the target partner now owns the source's moved link.
+ */
+export const verifyMergeCompleted = async ({
+ http,
+ sourcePartnerId,
+ targetPartnerId,
+ expectedLinkId,
+}: VerifyMergeCompletedProps) => {
+ const startTime = Date.now();
+
+ let lastSourceStatus: number | null = null;
+ let lastTargetLinkIds: string[] = [];
+
+ while (Date.now() - startTime < VITEST_TEST_TIMEOUT_MS) {
+ const [sourceRes, targetRes] = await Promise.all([
+ http.get<{ error?: unknown }>({ path: `/partners/${sourcePartnerId}` }),
+ http.get<EnrolledPartnerProps>({ path: `/partners/${targetPartnerId}` }),
+ ]);
+
+ lastSourceStatus = sourceRes.status;
+
+ const sourceDeleted = sourceRes.status === 404;
+ const targetLinks =
+ targetRes.status === 200 ? targetRes.data.links ?? [] : [];
+ lastTargetLinkIds = targetLinks.map((link) => link.id);
+ const targetOwnsLink = lastTargetLinkIds.includes(expectedLinkId);
+
+ if (sourceDeleted && targetOwnsLink) {
+ expect(sourceRes.status).toBe(404);
+ expect(lastTargetLinkIds).toContain(expectedLinkId);
+ return targetRes.data;
+ }
+
+ await new Promise((resolve) =>
+ setTimeout(resolve, VITEST_POLL_INTERVAL_MS),
+ );
+ }
+
+ throw new Error(
+ `Merge did not complete within ${VITEST_TEST_TIMEOUT_MS / 1000} seconds. ` +
+ `sourcePartnerId: ${sourcePartnerId} (last status: ${lastSourceStatus}), ` +
+ `targetPartnerId: ${targetPartnerId}, expectedLinkId: ${expectedLinkId}. ` +
+ `Last seen target link ids: [${lastTargetLinkIds.join(", ")}]`,
+ );
+};