Updates the webhook error alerts test

Author: samejr

apps/webapp/test/webhookErrorAlerts.test.ts

@@ -1,71 +1,33 @@
-import { describe, test, expect, beforeAll, afterAll } from "vitest";
-import { DeliverErrorGroupAlertService } from "~/v3/services/alerts/deliverErrorGroupAlert.server";
-import { prisma } from "~/db.server";
-import { getSecretStore } from "~/services/secrets/secretStore.server";
+import { describe, test, expect } from "vitest";
 import { Webhook } from "@trigger.dev/core/v3/schemas";
-
-type ErrorAlertPayload = {
-  channelId: string;
-  projectId: string;
-  classification: "new_issue" | "regression" | "unignored";
-  error: {
-    fingerprint: string;
-    environmentId: string;
-    environmentSlug: string;
-    environmentName: string;
-    taskIdentifier: string;
-    errorType: string;
-    errorMessage: string;
-    sampleStackTrace: string;
-    firstSeen: string;
-    lastSeen: string;
-    occurrenceCount: number;
-  };
+import { generateErrorGroupWebhookPayload } from "~/v3/services/alerts/errorGroupWebhook.server";
+
+type ErrorData = {
+  fingerprint: string;
+  environmentId: string;
+  environmentName: string;
+  taskIdentifier: string;
+  errorType: string;
+  errorMessage: string;
+  sampleStackTrace: string;
+  firstSeen: string;
+  lastSeen: string;
+  occurrenceCount: number;
 };
 
-let testChannelId: string = "";
-let testProjectId: string = "";
-let testOrganizationId: string = "";
-let webhookServer: ReturnType<typeof createWebhookServer> | null = null;
-
-interface WebhookCall {
-  payload: unknown;
-  signature: string;
-}
-
-function createWebhookServer() {
-  const calls: WebhookCall[] = [];
+const TEST_ORG = { id: "org_test_123", slug: "webhook-test-org", name: "Webhook Test Org" };
+const TEST_PROJECT = {
+  id: "proj_test_456",
+  externalRef: "proj_webhook_test",
+  slug: "webhook-test-project",
+  name: "Webhook Test Project",
+};
+const DASHBOARD_URL = "https://cloud.trigger.dev/test";
 
+function createMockError(overrides: Partial<ErrorData> = {}): ErrorData {
   return {
-    calls,
-    handler: async (request: Request) => {
-      const signature = request.headers.get("x-trigger-signature-hmacsha256");
-      const payload = await request.json();
-
-      calls.push({
-        payload,
-        signature: signature || "",
-      });
-
-      return new Response(JSON.stringify({ success: true }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    },
-  };
-}
-
-function createMockErrorPayload(
-  overrides: Partial<Omit<ErrorAlertPayload, "error">> & {
-    error?: Partial<ErrorAlertPayload["error"]>;
-  } = {}
-): ErrorAlertPayload {
-  const { error: errorOverrides, ...payloadOverrides } = overrides;
-
-  const defaultError: ErrorAlertPayload["error"] = {
-    fingerprint: "fp_test_" + Date.now(),
+    fingerprint: "fp_test_default",
     environmentId: "env_test_dev",
-    environmentSlug: "dev",
     environmentName: "Development",
     taskIdentifier: "process-payment",
     errorType: "TypeError",
@@ -77,99 +39,26 @@ function createMockErrorPayload(
     firstSeen: Date.now().toString(),
     lastSeen: Date.now().toString(),
     occurrenceCount: 42,
-    ...errorOverrides,
-  };
-
-  return {
-    channelId: testChannelId,
-    projectId: testProjectId,
-    classification: "new_issue",
-    ...payloadOverrides,
-    error: defaultError,
+    ...overrides,
   };
 }
 
-describe("Webhook Error Alert Tests", () => {
-  beforeAll(async () => {
-    // Create test organization
-    const organization = await prisma.organization.create({
-      data: {
-        title: "Webhook Test Org",
-        slug: "webhook-test-org-" + Date.now(),
-      },
-    });
-    testOrganizationId = organization.id;
-
-    // Create test project
-    const project = await prisma.project.create({
-      data: {
-        name: "Webhook Test Project",
-        slug: "webhook-test-project-" + Date.now(),
-        externalRef: "proj_webhook_test_" + Date.now(),
-        organizationId: organization.id,
-      },
-    });
-    testProjectId = project.id;
-
-    // Create webhook server for testing
-    webhookServer = createWebhookServer();
-
-    // We'll use a mock webhook URL in the tests
-    // In a real integration test, you'd start a local server
-    // For now, we'll just test that the payload is constructed correctly
+function buildPayload(classification: "new_issue" | "regression" | "unignored", error: ErrorData) {
+  return generateErrorGroupWebhookPayload({
+    classification,
+    error,
+    organization: TEST_ORG,
+    project: TEST_PROJECT,
+    dashboardUrl: DASHBOARD_URL,
   });
+}
 
-  afterAll(async () => {
-    // Clean up test data
-    if (testChannelId) {
-      await prisma.projectAlertChannel.deleteMany({
-        where: { id: testChannelId },
-      });
-    }
-    if (testProjectId) {
-      await prisma.project.deleteMany({
-        where: { id: testProjectId },
-      });
-    }
-    if (testOrganizationId) {
-      await prisma.organization.deleteMany({
-        where: { id: testOrganizationId },
-      });
-    }
-  });
-
-  test("webhook payload structure is valid", async () => {
-    // This test verifies the payload structure without actually sending it
-    const mockPayload = createMockErrorPayload({
-      classification: "new_issue",
-    });
-
-    // Import the function to generate the payload
-    const { generateErrorGroupWebhookPayload } = await import(
-      "~/v3/services/alerts/errorGroupWebhook.server"
-    );
-
-    const webhookPayload = generateErrorGroupWebhookPayload({
-      classification: mockPayload.classification,
-      error: mockPayload.error,
-      organization: {
-        id: testOrganizationId,
-        slug: "webhook-test-org",
-        name: "Webhook Test Org",
-      },
-      project: {
-        id: testProjectId,
-        externalRef: "proj_webhook_test",
-        slug: "webhook-test-project",
-        name: "Webhook Test Project",
-      },
-      dashboardUrl: "https://cloud.trigger.dev/test",
-    });
+describe("Webhook Error Alert Payload", () => {
+  test("payload structure is valid and parseable", () => {
+    const payload = buildPayload("new_issue", createMockError());
+    const parsed = Webhook.parse(payload);
 
-    // Verify it can be parsed by the Webhook schema
-    const parsed = Webhook.parse(webhookPayload);
     expect(parsed.type).toBe("alert.error");
-
     if (parsed.type === "alert.error") {
       expect(parsed.object.classification).toBe("new_issue");
       expect(parsed.object.error.type).toBe("TypeError");
@@ -178,114 +67,45 @@ describe("Webhook Error Alert Tests", () => {
     }
   });
 
-  test("webhook payload can be serialized and deserialized", async () => {
-    const mockPayload = createMockErrorPayload({
-      classification: "regression",
-    });
-
-    const { generateErrorGroupWebhookPayload } = await import(
-      "~/v3/services/alerts/errorGroupWebhook.server"
-    );
-
-    const webhookPayload = generateErrorGroupWebhookPayload({
-      classification: mockPayload.classification,
-      error: mockPayload.error,
-      organization: {
-        id: testOrganizationId,
-        slug: "webhook-test-org",
-        name: "Webhook Test Org",
-      },
-      project: {
-        id: testProjectId,
-        externalRef: "proj_webhook_test",
-        slug: "webhook-test-project",
-        name: "Webhook Test Project",
-      },
-      dashboardUrl: "https://cloud.trigger.dev/test",
-    });
-
-    // Serialize to JSON (simulating HTTP transmission)
-    const serialized = JSON.stringify(webhookPayload);
-    const deserialized = JSON.parse(serialized);
+  test("payload survives JSON round-trip", () => {
+    const error = createMockError();
+    const payload = buildPayload("regression", error);
 
-    // Verify it can still be parsed
+    const deserialized = JSON.parse(JSON.stringify(payload));
     const parsed = Webhook.parse(deserialized);
-    expect(parsed.type).toBe("alert.error");
 
+    expect(parsed.type).toBe("alert.error");
     if (parsed.type === "alert.error") {
       expect(parsed.object.classification).toBe("regression");
-      expect(parsed.object.error.fingerprint).toBe(mockPayload.error.fingerprint);
+      expect(parsed.object.error.fingerprint).toBe(error.fingerprint);
     }
   });
 
-  test("webhook payload includes all classifications", async () => {
+  test("all classifications are valid", () => {
     const classifications = ["new_issue", "regression", "unignored"] as const;
 
-    const { generateErrorGroupWebhookPayload } = await import(
-      "~/v3/services/alerts/errorGroupWebhook.server"
-    );
-
     for (const classification of classifications) {
-      const mockPayload = createMockErrorPayload({ classification });
-
-      const webhookPayload = generateErrorGroupWebhookPayload({
-        classification: mockPayload.classification,
-        error: mockPayload.error,
-        organization: {
-          id: testOrganizationId,
-          slug: "webhook-test-org",
-          name: "Webhook Test Org",
-        },
-        project: {
-          id: testProjectId,
-          externalRef: "proj_webhook_test",
-          slug: "webhook-test-project",
-          name: "Webhook Test Project",
-        },
-        dashboardUrl: "https://cloud.trigger.dev/test",
-      });
-
-      const parsed = Webhook.parse(webhookPayload);
+      const payload = buildPayload(classification, createMockError());
+      const parsed = Webhook.parse(payload);
       if (parsed.type === "alert.error") {
         expect(parsed.object.classification).toBe(classification);
       }
     }
   });
 
-  test("webhook payload includes error details", async () => {
-    const mockPayload = createMockErrorPayload({
-      error: {
-        fingerprint: "fp_custom_123",
-        errorType: "CustomError",
-        errorMessage: "Custom error message",
-        sampleStackTrace: "CustomError: at line 42",
-        taskIdentifier: "my-custom-task",
-        occurrenceCount: 999,
-      } as any,
+  test("error details are preserved", () => {
+    const error = createMockError({
+      fingerprint: "fp_custom_123",
+      errorType: "CustomError",
+      errorMessage: "Custom error message",
+      sampleStackTrace: "CustomError: at line 42",
+      taskIdentifier: "my-custom-task",
+      occurrenceCount: 999,
     });
 
-    const { generateErrorGroupWebhookPayload } = await import(
-      "~/v3/services/alerts/errorGroupWebhook.server"
-    );
+    const payload = buildPayload("new_issue", error);
+    const parsed = Webhook.parse(payload);
 
-    const webhookPayload = generateErrorGroupWebhookPayload({
-      classification: mockPayload.classification,
-      error: mockPayload.error,
-      organization: {
-        id: testOrganizationId,
-        slug: "webhook-test-org",
-        name: "Webhook Test Org",
-      },
-      project: {
-        id: testProjectId,
-        externalRef: "proj_webhook_test",
-        slug: "webhook-test-project",
-        name: "Webhook Test Project",
-      },
-      dashboardUrl: "https://cloud.trigger.dev/test",
-    });
-
-    const parsed = Webhook.parse(webhookPayload);
     if (parsed.type === "alert.error") {
       expect(parsed.object.error.fingerprint).toBe("fp_custom_123");
       expect(parsed.object.error.type).toBe("CustomError");
@@ -296,35 +116,11 @@ describe("Webhook Error Alert Tests", () => {
     }
   });
 
-  test("webhook payload handles empty stack trace", async () => {
-    const mockPayload = createMockErrorPayload({
-      error: {
-        sampleStackTrace: "",
-      } as any,
-    });
-
-    const { generateErrorGroupWebhookPayload } = await import(
-      "~/v3/services/alerts/errorGroupWebhook.server"
-    );
-
-    const webhookPayload = generateErrorGroupWebhookPayload({
-      classification: mockPayload.classification,
-      error: mockPayload.error,
-      organization: {
-        id: testOrganizationId,
-        slug: "webhook-test-org",
-        name: "Webhook Test Org",
-      },
-      project: {
-        id: testProjectId,
-        externalRef: "proj_webhook_test",
-        slug: "webhook-test-project",
-        name: "Webhook Test Project",
-      },
-      dashboardUrl: "https://cloud.trigger.dev/test",
-    });
+  test("empty stack trace becomes undefined", () => {
+    const error = createMockError({ sampleStackTrace: "" });
+    const payload = buildPayload("new_issue", error);
+    const parsed = Webhook.parse(payload);
 
-    const parsed = Webhook.parse(webhookPayload);
     if (parsed.type === "alert.error") {
       expect(parsed.object.error.stackTrace).toBeUndefined();
     }