Merge pull request #833 from abayomicornelius/fix/issues-752-753-754-755

test: issues #752, #753, #754, #755 — test runner, webhook/badge unit tests, Playwright scaffold

Author: OlaGreat

.github/workflows/e2e.yml

@@ -0,0 +1,44 @@
+name: E2E (Playwright)
+
+on:
+  pull_request_target:
+    paths:
+      - "frontend/**"
+      - ".github/workflows/e2e.yml"
+  push:
+    branches:
+      - main
+    paths:
+      - "frontend/**"
+      - ".github/workflows/e2e.yml"
+
+jobs:
+  e2e:
+    name: Playwright E2E
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+      - run: npm ci
+      - run: npx playwright install --with-deps chromium
+      - run: npm run build
+      - name: Run Playwright tests
+        run: npm run test:e2e
+        env:
+          CI: true
+      - name: Upload Playwright report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report-${{ github.sha }}
+          path: frontend/playwright-report/
+          retention-days: 14

backend/package.json

@@ -7,11 +7,9 @@
     "dev": "tsx watch src/index.ts",
     "start": "tsx src/index.ts",
     "build": "tsc -p tsconfig.json",
-    "test": "NODE_ENV=test JWT_SECRET=test-secret tsx src/auth.test.ts && NODE_ENV=test JWT_SECRET=test-secret tsx src/index.test.ts && NODE_ENV=test tsx src/services/circuit-breaker.test.ts && NODE_ENV=test tsx src/services/drip-scheduler.test.ts",
-    "test:auth": "NODE_ENV=test JWT_SECRET=test-secret tsx src/auth.test.ts",
-    "test:circuit-breaker": "NODE_ENV=test tsx src/services/circuit-breaker.test.ts",
-    "test:drip-scheduler": "NODE_ENV=test tsx src/services/drip-scheduler.test.ts",
-    "test:pbt": "tsx src/rate-limit.test.ts",
+    "test": "NODE_ENV=test JWT_SECRET=test-secret node --import tsx --test \"src/**/*.test.ts\"",
+    "test:watch": "NODE_ENV=test JWT_SECRET=test-secret node --import tsx --test --watch \"src/**/*.test.ts\"",
+    "test:coverage": "NODE_ENV=test JWT_SECRET=test-secret node --import tsx --test --experimental-test-coverage \"src/**/*.test.ts\"",
     "db:generate": "prisma generate",
     "db:migrate": "prisma migrate dev",
     "db:migrate:deploy": "prisma migrate deploy",

backend/src/services/badge-awarder.test.ts

@@ -0,0 +1,151 @@
+import { test, mock } from "node:test";
+import assert from "node:assert/strict";
+import { checkAndAwardBadges } from "./badge-awarder.js";
+
+const ALL_BADGES = [
+  { id: "b-first", criteria: "first_support", name: "First Supporter" },
+  { id: "b-ten", criteria: "ten_supporters", name: "10 Supporters" },
+  { id: "b-xlm", criteria: "total_100_xlm", name: "100 XLM Club" },
+  { id: "b-milestone", criteria: "milestone_reached", name: "Milestone Maker" },
+];
+
+function buildPrismaMock(overrides: {
+  badges?: unknown[];
+  existingAwards?: { badgeId: string }[];
+  txCount?: number;
+  uniqueSupporters?: { supporterAddress: string }[];
+  totalsByAsset?: { assetCode: string; assetIssuer: string | null; _sum: { amount: unknown } }[];
+  milestonesReached?: number;
+  createImpl?: () => Promise<unknown>;
+} = {}) {
+  const profileBadgeCreate = mock.fn(overrides.createImpl ?? (() => Promise.resolve({})));
+
+  const tx = {
+    $executeRaw: mock.fn(() => Promise.resolve()),
+    badge: {
+      findMany: mock.fn(() => Promise.resolve(overrides.badges ?? ALL_BADGES)),
+    },
+    profileBadge: {
+      findMany: mock.fn(() => Promise.resolve(overrides.existingAwards ?? [])),
+      create: profileBadgeCreate,
+    },
+    supportTransaction: {
+      count: mock.fn(() => Promise.resolve(overrides.txCount ?? 0)),
+      findMany: mock.fn(() => Promise.resolve(overrides.uniqueSupporters ?? [])),
+      groupBy: mock.fn(() => Promise.resolve(overrides.totalsByAsset ?? [])),
+    },
+    milestone: {
+      count: mock.fn(() => Promise.resolve(overrides.milestonesReached ?? 0)),
+    },
+  };
+
+  const $transaction = mock.fn((cb: (tx: unknown) => Promise<void>) => cb(tx));
+
+  return { $transaction, tx, profileBadgeCreate };
+}
+
+function awardedCriteria(profileBadgeCreate: ReturnType<typeof mock.fn>): string[] {
+  return profileBadgeCreate.mock.calls.map((c) => {
+    const badgeId = (c.arguments[0] as { data: { badgeId: string } }).data.badgeId;
+    return ALL_BADGES.find((b) => b.id === badgeId)?.criteria ?? badgeId;
+  });
+}
+
+test("first_support is awarded when txCount >= 1", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[0]],
+    txCount: 1,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.deepEqual(awardedCriteria(profileBadgeCreate), ["first_support"]);
+});
+
+test("first_support is NOT awarded when txCount is 0", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[0]],
+    txCount: 0,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.equal(profileBadgeCreate.mock.calls.length, 0);
+});
+
+test("ten_supporters is awarded when uniqueSupporters.length >= 10", async () => {
+  const supporters = Array.from({ length: 10 }, (_, i) => ({ supporterAddress: `G${i}` }));
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[1]],
+    uniqueSupporters: supporters,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.deepEqual(awardedCriteria(profileBadgeCreate), ["ten_supporters"]);
+});
+
+test("ten_supporters is NOT awarded when uniqueSupporters.length < 10", async () => {
+  const supporters = Array.from({ length: 9 }, (_, i) => ({ supporterAddress: `G${i}` }));
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[1]],
+    uniqueSupporters: supporters,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.equal(profileBadgeCreate.mock.calls.length, 0);
+});
+
+test("total_100_xlm is awarded for XLM totals >= 100, ignoring USDC", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[2]],
+    totalsByAsset: [
+      { assetCode: "XLM", assetIssuer: null, _sum: { amount: 150 } },
+      { assetCode: "USDC", assetIssuer: "GISSUER", _sum: { amount: 100000 } },
+    ],
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.deepEqual(awardedCriteria(profileBadgeCreate), ["total_100_xlm"]);
+});
+
+test("total_100_xlm is NOT awarded from USDC totals alone", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[2]],
+    totalsByAsset: [
+      { assetCode: "USDC", assetIssuer: "GISSUER", _sum: { amount: 100000 } },
+    ],
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.equal(profileBadgeCreate.mock.calls.length, 0);
+});
+
+test("milestone_reached is awarded when at least one milestone is reached", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[3]],
+    milestonesReached: 1,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.deepEqual(awardedCriteria(profileBadgeCreate), ["milestone_reached"]);
+});
+
+test("already-awarded badge is not re-awarded, and a P2002 race is silently ignored", async () => {
+  const { $transaction, profileBadgeCreate } = buildPrismaMock({
+    badges: [ALL_BADGES[0]],
+    existingAwards: [{ badgeId: "b-first" }],
+    txCount: 5,
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.equal(profileBadgeCreate.mock.calls.length, 0);
+
+  const p2002Error = Object.assign(new Error("Unique constraint failed"), { code: "P2002" });
+  const { $transaction: tx2, profileBadgeCreate: create2 } = buildPrismaMock({
+    badges: [ALL_BADGES[0]],
+    txCount: 1,
+    createImpl: () => Promise.reject(p2002Error),
+  });
+  await assert.doesNotReject(() => checkAndAwardBadges("profile-1", { $transaction: tx2 } as any));
+  assert.equal(create2.mock.calls.length, 1);
+});
+
+test("all badges already awarded returns early without checking any criteria", async () => {
+  const { $transaction, tx, profileBadgeCreate } = buildPrismaMock({
+    badges: ALL_BADGES,
+    existingAwards: ALL_BADGES.map((b) => ({ badgeId: b.id })),
+  });
+  await checkAndAwardBadges("profile-1", { $transaction } as any);
+  assert.equal(profileBadgeCreate.mock.calls.length, 0);
+  assert.equal((tx.supportTransaction.count as ReturnType<typeof mock.fn>).mock.calls.length, 0);
+});

backend/src/services/badge-awarder.ts

@@ -19,11 +19,11 @@ function profileLockKey(profileId: string): bigint {
   return h;
 }
 
-export async function checkAndAwardBadges(profileId: string): Promise<void> {
+export async function checkAndAwardBadges(profileId: string, prismaClient = prisma): Promise<void> {
   const lockKey = profileLockKey(profileId);
 
   try {
-    await prisma.$transaction(async (tx) => {
+    await prismaClient.$transaction(async (tx) => {
       // Serialize concurrent badge checks for the same profile using a
       // transaction-scoped advisory lock. Concurrent callers block until the
       // current check commits, then each runs with the latest DB state rather

backend/src/services/webhook-processor.test.ts

@@ -0,0 +1,131 @@
+import { test, mock } from "node:test";
+import assert from "node:assert/strict";
+import { processPendingWebhookDeliveries } from "./webhook-processor.js";
+
+function makeDelivery(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "delivery-1",
+    webhookId: "webhook-1",
+    payload: { event: "support.created" },
+    status: "pending",
+    attemptCount: 0,
+    nextRetryAt: new Date(),
+    webhook: { url: "https://example.com/hook", secret: "s3cret" },
+    ...overrides,
+  };
+}
+
+function buildPrismaMock(overrides: {
+  deliveries?: unknown[];
+  claimCount?: number;
+} = {}) {
+  const findMany = mock.fn(() => Promise.resolve(overrides.deliveries ?? [makeDelivery()]));
+  const updateMany = mock.fn(() => Promise.resolve({ count: overrides.claimCount ?? 1 }));
+  const update = mock.fn(() => Promise.resolve({}));
+
+  return {
+    prismaClient: {
+      webhookDelivery: { findMany, update, updateMany },
+    },
+    findMany,
+    updateMany,
+    update,
+  };
+}
+
+function getUpdateData(update: ReturnType<typeof mock.fn>, callIndex = 0): Record<string, unknown> {
+  return (update.mock.calls[callIndex]!.arguments[0] as { data: Record<string, unknown> }).data;
+}
+
+test("successful delivery updates the record to success and increments attemptCount", async () => {
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery({ attemptCount: 0 })],
+  });
+  const deliver = mock.fn(() => Promise.resolve({ status: "success", statusCode: 200 }));
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  assert.equal(update.mock.calls.length, 1);
+  const data = getUpdateData(update);
+  assert.equal(data.status, "success");
+  assert.equal(data.attemptCount, 1);
+  assert.equal(data.lastError, null);
+});
+
+test("HTTP 500 keeps status pending and sets nextRetryAt to the backoff schedule", async () => {
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery({ attemptCount: 0 })],
+  });
+  const deliver = mock.fn(() =>
+    Promise.resolve({ status: "failed", error: "HTTP 500", willRetry: true }),
+  );
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  const data = getUpdateData(update);
+  assert.equal(data.status, "pending");
+  assert.equal(data.attemptCount, 1);
+  assert.ok(data.nextRetryAt instanceof Date);
+  assert.ok((data.nextRetryAt as Date).getTime() > Date.now());
+});
+
+test("HTTP 4xx permanent failure sets status failed with no further retry scheduled", async () => {
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery({ attemptCount: 0 })],
+  });
+  const deliver = mock.fn(() =>
+    Promise.resolve({ status: "failed", error: "HTTP 404", willRetry: false }),
+  );
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  const data = getUpdateData(update);
+  assert.equal(data.status, "failed");
+  assert.equal(data.nextRetryAt, null);
+});
+
+test("reaching max attempts sets status to failed", async () => {
+  // attemptCount is already at MAX_DELIVERY_ATTEMPTS - 1 (2); the query itself
+  // filters attemptCount < MAX_DELIVERY_ATTEMPTS (3), so this is the last try.
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery({ attemptCount: 2 })],
+  });
+  const deliver = mock.fn(() =>
+    Promise.resolve({ status: "failed", error: "HTTP 500", willRetry: true }),
+  );
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  const data = getUpdateData(update);
+  // nextAttempt = 3, shouldRetry(3) is expected to be false at the max attempt.
+  assert.equal(data.status, "failed");
+  assert.equal(data.attemptCount, 3);
+});
+
+test("a network timeout is treated as a transient failure and scheduled for retry", async () => {
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery({ attemptCount: 0 })],
+  });
+  const deliver = mock.fn(() =>
+    Promise.resolve({ status: "failed", error: "The operation was aborted due to timeout", willRetry: true }),
+  );
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  const data = getUpdateData(update);
+  assert.equal(data.status, "pending");
+  assert.ok(data.nextRetryAt instanceof Date);
+});
+
+test("a row already claimed by a concurrent run is skipped (no delivery attempted)", async () => {
+  const { prismaClient, update } = buildPrismaMock({
+    deliveries: [makeDelivery()],
+    claimCount: 0,
+  });
+  const deliver = mock.fn(() => Promise.resolve({ status: "success", statusCode: 200 }));
+
+  await processPendingWebhookDeliveries(prismaClient as any, deliver as any);
+
+  assert.equal(deliver.mock.calls.length, 0);
+  assert.equal(update.mock.calls.length, 0);
+});