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 partner application API tests to Playwright. (#4470)

Kiran K86a784ac3aae
diff --git a/apps/web/playwright/api/partner-applications/partner-applications.spec.ts b/apps/web/playwright/api/partner-applications/partner-applications.spec.ts
new file mode 100644
index 0000000000..7c5059b5de
--- /dev/null
+++ b/apps/web/playwright/api/partner-applications/partner-applications.spec.ts
@@ -0,0 +1,442 @@
+import { createId } from "@/lib/api/create-id";
+import { prisma } from "@/lib/prisma";
+import type { GroupProps, PartnerApplicationProps } from "@/lib/types";
+import { expect } from "@playwright/test";
+import {
+ ProgramApplicationRejectionReason,
+ ProgramEnrollmentStatus,
+} from "@prisma/client";
+import {
+ apiError,
+ expectNoOverlap,
+ randomName,
+ randomPartnerEmail,
+} from "../../utils";
+import { test } from "../fixtures";
+import { createGroup, deleteGroup } from "../groups/helpers";
+import { deletePartner } from "../partners/helpers";
+
+type SeededApplication = {
+ applicationId: string;
+ partnerId: string;
+ name: string;
+ email: string;
+ country: "US" | "GB";
+ groupId: string;
+};
+
+const REJECTION_NOTE =
+ "Your audience doesn't align with our target customers. Please reapply if that changes.";
+
+function expectApplication(
+ application: PartnerApplicationProps,
+ expected: SeededApplication,
+ status: ProgramEnrollmentStatus = "pending",
+) {
+ expect(application).toMatchObject({
+ id: expected.applicationId,
+ createdAt: expect.any(String),
+ applicationFormData: [],
+ partner: {
+ id: expected.partnerId,
+ name: expected.name,
+ email: expected.email,
+ country: expected.country,
+ groupId: expected.groupId,
+ status,
+ },
+ });
+}
+
+async function expectApplicationState(
+ application: SeededApplication,
+ {
+ enrollmentStatus,
+ rejectionReason,
+ }: {
+ enrollmentStatus: ProgramEnrollmentStatus;
+ rejectionReason: ProgramApplicationRejectionReason | null;
+ },
+) {
+ const enrollment = await prisma.programEnrollment.findUniqueOrThrow({
+ where: {
+ applicationId: application.applicationId,
+ },
+ include: {
+ application: true,
+ },
+ });
+
+ expect(enrollment.status).toBe(enrollmentStatus);
+ expect(enrollment.partnerId).toBe(application.partnerId);
+ expect(enrollment.application?.rejectionReason ?? null).toBe(rejectionReason);
+ expect(enrollment.application?.rejectionNote ?? null).toBe(
+ rejectionReason ? REJECTION_NOTE : null,
+ );
+ expect(enrollment.application?.reviewedAt).toEqual(expect.any(Date));
+}
+
+test.describe("partner applications", () => {
+ test.describe.configure({
+ mode: "serial",
+ });
+
+ let programId: string;
+ let extraGroup: GroupProps;
+ let applications: SeededApplication[] = [];
+
+ test.beforeAll(async ({ api, program }) => {
+ programId = program.id;
+ extraGroup = await createGroup(api);
+
+ const now = Date.now();
+ const rows: {
+ name: string;
+ email: string;
+ country: "US" | "GB";
+ groupId: string;
+ }[] = [
+ {
+ name: randomName("application"),
+ email: randomPartnerEmail(),
+ country: "US",
+ groupId: extraGroup.id,
+ },
+ {
+ name: randomName("application"),
+ email: randomPartnerEmail(),
+ country: "US",
+ groupId: extraGroup.id,
+ },
+ {
+ name: randomName("application"),
+ email: randomPartnerEmail(),
+ country: "GB",
+ groupId: extraGroup.id,
+ },
+ {
+ name: randomName("application"),
+ email: randomPartnerEmail(),
+ country: "US",
+ groupId: program.defaultGroupId,
+ },
+ {
+ name: randomName("application"),
+ email: randomPartnerEmail(),
+ country: "GB",
+ groupId: program.defaultGroupId,
+ },
+ ];
+
+ for (const [i, row] of rows.entries()) {
+ const partnerId = createId({ prefix: "pn_" });
+ const applicationId = createId({ prefix: "pga_" });
+ const createdAt = new Date(now - i * 1000);
+
+ await prisma.partner.create({
+ data: {
+ id: partnerId,
+ name: row.name,
+ email: row.email,
+ country: row.country,
+ },
+ });
+
+ await prisma.programApplication.create({
+ data: {
+ id: applicationId,
+ programId,
+ groupId: row.groupId,
+ name: row.name,
+ email: row.email,
+ country: row.country,
+ formData: { fields: [] },
+ createdAt,
+ },
+ });
+
+ await prisma.programEnrollment.create({
+ data: {
+ id: createId({ prefix: "pge_" }),
+ partnerId,
+ programId,
+ groupId: row.groupId,
+ applicationId,
+ status: "pending",
+ createdAt,
+ },
+ });
+
+ applications.push({
+ applicationId,
+ partnerId,
+ name: row.name,
+ email: row.email,
+ country: row.country,
+ groupId: row.groupId,
+ });
+ }
+ });
+
+ test.afterAll(async ({ api }) => {
+ for (const application of applications) {
+ await deletePartner(application.partnerId);
+ }
+
+ if (applications.length > 0) {
+ await prisma.programApplication.deleteMany({
+ where: {
+ id: {
+ in: applications.map((application) => application.applicationId),
+ },
+ },
+ });
+ }
+
+ await deleteGroup(api, extraGroup?.id);
+ });
+
+ test("GET /partners/applications", async ({ api }) => {
+ const { status, data } = await api.get<PartnerApplicationProps[]>(
+ `/api/partners/applications?${new URLSearchParams({
+ pageSize: "100",
+ })}`,
+ );
+
+ expect(status).toEqual(200);
+
+ const byId = new Map(
+ data.map((application) => [application.id, application]),
+ );
+
+ for (const expected of applications) {
+ const application = byId.get(expected.applicationId);
+ expect(application).toBeDefined();
+ expectApplication(application!, expected);
+ }
+ });
+
+ test("GET /partners/applications – filters by country", async ({ api }) => {
+ const expected = applications.filter(
+ (application) =>
+ application.groupId === extraGroup.id && application.country === "US",
+ );
+
+ const { status, data } = await api.get<PartnerApplicationProps[]>(
+ `/api/partners/applications?${new URLSearchParams({
+ pageSize: "100",
+ country: "US",
+ groupId: extraGroup.id,
+ })}`,
+ );
+
+ expect(status).toEqual(200);
+ expect(data.map((application) => application.id).sort()).toEqual(
+ expected.map((application) => application.applicationId).sort(),
+ );
+
+ for (const expectedApplication of expected) {
+ const application = data.find(
+ (item) => item.id === expectedApplication.applicationId,
+ );
+
+ expect(application).toBeDefined();
+ expectApplication(application!, expectedApplication);
+ }
+ });
+
+ test("GET /partners/applications – filters by groupId", async ({ api }) => {
+ const expected = applications.filter(
+ (application) => application.groupId === extraGroup.id,
+ );
+
+ const { status, data } = await api.get<PartnerApplicationProps[]>(
+ `/api/partners/applications?${new URLSearchParams({
+ pageSize: "100",
+ groupId: extraGroup.id,
+ })}`,
+ );
+
+ expect(status).toEqual(200);
+ expect(data.map((application) => application.id).sort()).toEqual(
+ expected.map((application) => application.applicationId).sort(),
+ );
+
+ for (const expectedApplication of expected) {
+ const application = data.find(
+ (item) => item.id === expectedApplication.applicationId,
+ );
+
+ expect(application).toBeDefined();
+ expectApplication(application!, expectedApplication);
+ }
+ });
+
+ test("GET /partners/applications – respects pageSize", async ({ api }) => {
+ const expected = applications.filter(
+ (application) => application.groupId === extraGroup.id,
+ );
+
+ const page1 = await api.get<PartnerApplicationProps[]>(
+ `/api/partners/applications?${new URLSearchParams({
+ groupId: extraGroup.id,
+ page: "1",
+ pageSize: "1",
+ })}`,
+ );
+ const page2 = await api.get<PartnerApplicationProps[]>(
+ `/api/partners/applications?${new URLSearchParams({
+ groupId: extraGroup.id,
+ page: "2",
+ pageSize: "1",
+ })}`,
+ );
+
+ expect(page1.status).toEqual(200);
+ expect(page2.status).toEqual(200);
+ expect(page1.data).toHaveLength(1);
+ expect(page2.data).toHaveLength(1);
+ expect(page1.data[0]?.id).toBe(expected[0]?.applicationId);
+ expect(page2.data[0]?.id).toBe(expected[1]?.applicationId);
+ expectNoOverlap(page1.data, page2.data);
+ expectApplication(page1.data[0]!, expected[0]!);
+ expectApplication(page2.data[0]!, expected[1]!);
+ });
+
+ test("POST /partners/applications/approve", async ({ api }) => {
+ const application = applications[0]!;
+
+ const { status, data } = await api.post<{ partnerId: string }>(
+ "/api/partners/applications/approve",
+ {
+ partnerId: application.partnerId,
+ groupId: application.groupId,
+ },
+ );
+
+ expect(status).toEqual(200);
+ expect(data).toStrictEqual({ partnerId: application.partnerId });
+ await expectApplicationState(application, {
+ enrollmentStatus: "approved",
+ rejectionReason: null,
+ });
+ });
+
+ test("POST /partners/applications/reject", async ({ api }) => {
+ const application = applications[1]!;
+
+ const { status, data } = await api.post<{ partnerId: string }>(
+ "/api/partners/applications/reject",
+ {
+ partnerId: application.partnerId,
+ rejectionReason: "other",
+ rejectionNote: REJECTION_NOTE,
+ reapplicationTimeframe: "standard",
+ },
+ );
+
+ expect(status).toEqual(200);
+ expect(data).toStrictEqual({ partnerId: application.partnerId });
+ await expectApplicationState(application, {
+ enrollmentStatus: "rejected",
+ rejectionReason: "other",
+ });
+ });
+
+ test("POST /partners/applications/approve – already approved", async ({
+ api,
+ }) => {
+ const application = applications[0]!;
+
+ const response = await api.post("/api/partners/applications/approve", {
+ partnerId: application.partnerId,
+ groupId: application.groupId,
+ });
+
+ expect(response).toEqual(
+ apiError({
+ code: "bad_request",
+ message:
+ "This enrollment cannot be approved because it is already approved.",
+ }),
+ );
+
+ await expectApplicationState(application, {
+ enrollmentStatus: "approved",
+ rejectionReason: null,
+ });
+ });
+
+ test("POST /partners/applications/reject – already rejected", async ({
+ api,
+ }) => {
+ const application = applications[1]!;
+
+ const response = await api.post("/api/partners/applications/reject", {
+ partnerId: application.partnerId,
+ rejectionReason: "other",
+ rejectionNote: REJECTION_NOTE,
+ reapplicationTimeframe: "standard",
+ });
+
+ expect(response).toEqual(
+ apiError({
+ code: "bad_request",
+ message:
+ "This enrollment cannot be rejected because it is no longer pending.",
+ }),
+ );
+
+ await expectApplicationState(application, {
+ enrollmentStatus: "rejected",
+ rejectionReason: "other",
+ });
+ });
+
+ test("POST /partners/applications/approve – rejected partner", async ({
+ api,
+ }) => {
+ const application = applications[1]!;
+
+ const { status, data } = await api.post<{ partnerId: string }>(
+ "/api/partners/applications/approve",
+ {
+ partnerId: application.partnerId,
+ groupId: application.groupId,
+ },
+ );
+
+ expect(status).toEqual(200);
+ expect(data).toStrictEqual({ partnerId: application.partnerId });
+ await expectApplicationState(application, {
+ enrollmentStatus: "approved",
+ rejectionReason: null,
+ });
+ });
+
+ test("POST /partners/applications/reject – approved partner", async ({
+ api,
+ }) => {
+ const application = applications[0]!;
+
+ const response = await api.post("/api/partners/applications/reject", {
+ partnerId: application.partnerId,
+ rejectionReason: "other",
+ rejectionNote: REJECTION_NOTE,
+ reapplicationTimeframe: "standard",
+ });
+
+ expect(response).toEqual(
+ apiError({
+ code: "bad_request",
+ message:
+ "This enrollment cannot be rejected because it is no longer pending.",
+ }),
+ );
+
+ await expectApplicationState(application, {
+ enrollmentStatus: "approved",
+ rejectionReason: null,
+ });
+ });
+});
diff --git a/apps/web/tests/partner-applications/approve-reject-partner-application.test.ts b/apps/web/tests/partner-applications/approve-reject-partner-application.test.ts
deleted file mode 100644
index 21e47d4cf6..0000000000
--- a/apps/web/tests/partner-applications/approve-reject-partner-application.test.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { generateRandomName } from "@/lib/names";
-import { Partner } from "@prisma/client";
-import { describe, expect, test } from "vitest";
-import { randomPartnerEmail } from "../utils/helpers";
-import { IntegrationHarness } from "../utils/integration";
-import { E2E_PARTNER_GROUP } from "../utils/resource";
-
-describe.sequential(
- "POST /partners/applications/reject and /approve",
- async () => {
- const h = new IntegrationHarness();
- const { http } = await h.init();
-
- test("reject then approve the same partner after E2E pending reset", async () => {
- const partner = {
- name: generateRandomName(),
- email: randomPartnerEmail(),
- groupId: E2E_PARTNER_GROUP.id,
- country: "US" as const,
- };
-
- const { data: created, status: createStatus } = await http.post<Partner>({
- path: "/partners",
- body: partner,
- });
-
- expect(createStatus).toEqual(201);
- const partnerId = created.id;
-
- const { status: seedStatus } = await http.post<{
- partnerId: string;
- programApplicationId: string;
- reset: boolean;
- }>({
- path: "/e2e/partners/pending-program-application",
- body: { partnerId, groupId: E2E_PARTNER_GROUP.id },
- });
- expect(seedStatus).toEqual(200);
-
- const { data: rejectData, status: rejectStatus } = await http.post<{
- partnerId: string;
- }>({
- path: "/partners/applications/reject",
- body: {
- partnerId,
- rejectionReason: "other",
- rejectionNote: "e2e: first rejection",
- reapplicationTimeframe: "standard" as const,
- },
- });
- expect(rejectStatus).toEqual(200);
- expect(rejectData.partnerId).toBe(partnerId);
-
- const { status: duplicateRejectStatus } = await http.post({
- path: "/partners/applications/reject",
- body: {
- partnerId,
- rejectionReason: "other",
- rejectionNote: "e2e: should fail",
- reapplicationTimeframe: "standard" as const,
- },
- });
- expect(duplicateRejectStatus).toEqual(400);
-
- const { status: resetStatus } = await http.post({
- path: "/e2e/partners/pending-program-application",
- body: { partnerId, groupId: E2E_PARTNER_GROUP.id },
- });
- expect(resetStatus).toEqual(200);
-
- const { data: approveData, status: approveStatus } = await http.post<{
- partnerId: string;
- }>({
- path: "/partners/applications/approve",
- body: {
- partnerId,
- groupId: E2E_PARTNER_GROUP.id,
- },
- });
- expect(approveStatus).toEqual(200);
- expect(approveData.partnerId).toBe(partnerId);
-
- const { data: enrolled, status: getStatus } = await http.get<{
- id: string;
- status: string;
- }>({
- path: `/partners/${partnerId}`,
- });
- expect(getStatus).toEqual(200);
- expect(enrolled.id).toBe(partnerId);
- expect(enrolled.status).toBe("approved");
- });
- },
-);
diff --git a/apps/web/tests/partner-applications/list-partner-applications.test.ts b/apps/web/tests/partner-applications/list-partner-applications.test.ts
deleted file mode 100644
index aefd43338c..0000000000
--- a/apps/web/tests/partner-applications/list-partner-applications.test.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { PartnerApplicationProps } from "@/lib/types";
-import { PartnerApplicationSchema } from "@/lib/zod/schemas/program-application";
-import { describe, expect, test } from "vitest";
-import { IntegrationHarness } from "../utils/integration";
-import { E2E_PARTNER_GROUP, E2E_PARTNERS } from "../utils/resource";
-
-describe.sequential("GET /partners/applications", async () => {
- const h = new IntegrationHarness();
- const { http } = await h.init();
-
- test("returns a list of pending partner applications", async () => {
- const { data, status } = await http.get<PartnerApplicationProps[]>({
- path: "/partners/applications",
- });
-
- expect(status).toEqual(200);
- expect(Array.isArray(data)).toBe(true);
-
- data.forEach((application) => {
- const parsed = PartnerApplicationSchema.parse(application);
- expect(parsed.partner.status).toBe("pending");
- });
- });
-
- test("filters applications by country", async () => {
- const country = E2E_PARTNERS[0]!.country;
-
- const { data, status } = await http.get<PartnerApplicationProps[]>({
- path: "/partners/applications",
- query: { country },
- });
-
- expect(status).toEqual(200);
- expect(Array.isArray(data)).toBe(true);
-
- data.forEach((application) => {
- const parsed = PartnerApplicationSchema.parse(application);
- expect(parsed.partner.country).toBe(country);
- expect(parsed.partner.status).toBe("pending");
- });
- });
-
- test("filters applications by groupId", async () => {
- const { data, status } = await http.get<PartnerApplicationProps[]>({
- path: "/partners/applications",
- query: { groupId: E2E_PARTNER_GROUP.id },
- });
-
- expect(status).toEqual(200);
- expect(Array.isArray(data)).toBe(true);
-
- data.forEach((application) => {
- const parsed = PartnerApplicationSchema.parse(application);
- expect(parsed.partner.groupId).toBe(E2E_PARTNER_GROUP.id);
- expect(parsed.partner.status).toBe("pending");
- });
- });
-
- test("respects pageSize pagination", async () => {
- const { data, status } = await http.get<PartnerApplicationProps[]>({
- path: "/partners/applications",
- query: { page: "1", pageSize: "1" },
- });
-
- expect(status).toEqual(200);
- expect(Array.isArray(data)).toBe(true);
- expect(data.length).toBeLessThanOrEqual(1);
-
- data.forEach((application) => {
- PartnerApplicationSchema.parse(application);
- });
- });
-});