@xenterprises/fastify-xstripe 1.0.0

package/test/handlers.test.js

@@ -0,0 +1,959 @@
+// test/handlers.test.js
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+/**
+ * Example tests for webhook handlers
+ * Run with: node --test test/handlers.test.js
+ */
+
+// Mock event data
+const mockSubscriptionCreatedEvent = {
+  type: 'customer.subscription.created',
+  data: {
+    object: {
+      id: 'sub_123',
+      customer: 'cus_123',
+      status: 'active',
+      current_period_start: 1234567890,
+      current_period_end: 1234567890,
+      items: {
+        data: [{
+          price: {
+            id: 'price_123',
+            product: 'prod_123',
+            unit_amount: 2000,
+            currency: 'usd',
+          },
+          quantity: 1,
+        }],
+      },
+    },
+  },
+};
+
+const mockPaymentFailedEvent = {
+  type: 'invoice.payment_failed',
+  data: {
+    object: {
+      id: 'in_123',
+      customer: 'cus_123',
+      subscription: 'sub_123',
+      amount_due: 2000,
+      attempt_count: 2,
+      currency: 'usd',
+    },
+  },
+};
+
+// Test subscription created handler
+test('subscription.created handler should log correctly', async () => {
+  let loggedInfo = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedInfo = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const mockStripe = {};
+
+  // Import and test default handler
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.created'];
+
+  await handler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+
+  assert.ok(loggedInfo, 'Should have logged info');
+  assert.equal(loggedInfo.subscriptionId, 'sub_123');
+  assert.equal(loggedInfo.customerId, 'cus_123');
+  assert.equal(loggedInfo.status, 'active');
+});
+
+// Test custom handler with database update
+test('custom subscription handler should update database', async () => {
+  let updatedData = null;
+
+  const customHandler = async (event, fastify, stripe) => {
+    const subscription = event.data.object;
+
+    await fastify.prisma.user.update({
+      where: { stripeCustomerId: subscription.customer },
+      data: {
+        subscriptionId: subscription.id,
+        subscriptionStatus: subscription.status,
+      },
+    });
+  };
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+    prisma: {
+      user: {
+        update: async (data) => {
+          updatedData = data;
+          return { id: 1 };
+        },
+      },
+    },
+  };
+
+  const mockStripe = {};
+
+  await customHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+
+  assert.ok(updatedData, 'Should have updated database');
+  assert.equal(updatedData.where.stripeCustomerId, 'cus_123');
+  assert.equal(updatedData.data.subscriptionId, 'sub_123');
+  assert.equal(updatedData.data.subscriptionStatus, 'active');
+});
+
+// Test payment failure handler
+test('payment failure handler should send email', async () => {
+  let emailSent = null;
+
+  const customHandler = async (event, fastify, stripe) => {
+    const invoice = event.data.object;
+    const customer = await stripe.customers.retrieve(invoice.customer);
+
+    await fastify.email.send(
+      customer.email,
+      'Payment Failed',
+      '<p>Please update your payment method.</p>'
+    );
+  };
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+    email: {
+      send: async (to, subject, body) => {
+        emailSent = { to, subject, body };
+        return { success: true };
+      },
+    },
+  };
+
+  const mockStripe = {
+    customers: {
+      retrieve: async (id) => ({
+        id,
+        email: 'test@example.com',
+      }),
+    },
+  };
+
+  await customHandler(mockPaymentFailedEvent, mockFastify, mockStripe);
+
+  assert.ok(emailSent, 'Should have sent email');
+  assert.equal(emailSent.to, 'test@example.com');
+  assert.equal(emailSent.subject, 'Payment Failed');
+});
+
+// Test error handling
+test('handler errors should not throw', async () => {
+  const failingHandler = async (event, fastify, stripe) => {
+    throw new Error('Database connection failed');
+  };
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const mockStripe = {};
+
+  // Should not throw - errors are caught by webhook handler
+  try {
+    await failingHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+    assert.fail('Should have thrown an error');
+  } catch (error) {
+    assert.equal(error.message, 'Database connection failed');
+  }
+});
+
+// Test helper functions
+test('helper functions work correctly', async () => {
+  const { formatAmount, getPlanName, isActiveSubscription } = await import('../src/utils/helpers.js');
+
+  // Test formatAmount
+  const formatted = formatAmount(2000, 'USD');
+  assert.equal(formatted, '$20.00');
+
+  // Test getPlanName
+  const subscription = mockSubscriptionCreatedEvent.data.object;
+  const planName = getPlanName(subscription);
+  assert.ok(planName);
+
+  // Test isActiveSubscription
+  assert.equal(isActiveSubscription(subscription), true);
+
+  const canceledSub = { ...subscription, status: 'canceled' };
+  assert.equal(isActiveSubscription(canceledSub), false);
+});
+
+// Test idempotency
+test('handlers should be idempotent', async () => {
+  let callCount = 0;
+
+  const idempotentHandler = async (event, fastify, stripe) => {
+    const subscription = event.data.object;
+
+    // Upsert pattern - safe to call multiple times
+    await fastify.prisma.user.upsert({
+      where: { stripeCustomerId: subscription.customer },
+      update: { subscriptionStatus: subscription.status },
+      create: {
+        stripeCustomerId: subscription.customer,
+        subscriptionStatus: subscription.status,
+      },
+    });
+
+    callCount++;
+  };
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+    prisma: {
+      user: {
+        upsert: async () => ({ id: 1 }),
+      },
+    },
+  };
+
+  const mockStripe = {};
+
+  // Call handler multiple times
+  await idempotentHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+  await idempotentHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+  await idempotentHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+
+  assert.equal(callCount, 3, 'Should have been called 3 times');
+  // In real scenario, database state should be same after each call
+});
+
+// ============================================================================
+// COMPREHENSIVE EVENT HANDLER TESTS
+// ============================================================================
+
+test('customer.updated handler should process customer updates', async () => {
+  const mockEvent = {
+    type: 'customer.updated',
+    data: {
+      object: {
+        id: 'cus_123',
+        email: 'updated@example.com',
+        name: 'John Updated',
+        metadata: { userId: '456' },
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.updated'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.customerId, 'cus_123');
+});
+
+test('customer.deleted handler should process customer deletion', async () => {
+  const mockEvent = {
+    type: 'customer.deleted',
+    data: {
+      object: {
+        id: 'cus_123',
+        email: 'deleted@example.com',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.deleted'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.customerId, 'cus_123');
+});
+
+test('invoice.created handler should process invoice creation', async () => {
+  const mockEvent = {
+    type: 'invoice.created',
+    data: {
+      object: {
+        id: 'in_123',
+        customer: 'cus_123',
+        subscription: 'sub_123',
+        amount_due: 5000,
+        currency: 'usd',
+        status: 'draft',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['invoice.created'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.invoiceId, 'in_123');
+});
+
+test('invoice.finalized handler should process invoice finalization', async () => {
+  const mockEvent = {
+    type: 'invoice.finalized',
+    data: {
+      object: {
+        id: 'in_123',
+        customer: 'cus_123',
+        amount_due: 5000,
+        status: 'open',
+        hosted_invoice_url: 'https://stripe.com/invoice',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['invoice.finalized'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.invoiceId, 'in_123');
+});
+
+test('invoice.paid handler should process successful invoice payments', async () => {
+  const mockEvent = {
+    type: 'invoice.paid',
+    data: {
+      object: {
+        id: 'in_123',
+        customer: 'cus_123',
+        amount_paid: 5000,
+        paid: true,
+        status: 'paid',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['invoice.paid'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.invoiceId, 'in_123');
+});
+
+test('charge.succeeded handler should process successful charges', async () => {
+  const mockEvent = {
+    type: 'charge.succeeded',
+    data: {
+      object: {
+        id: 'ch_123',
+        customer: 'cus_123',
+        amount: 5000,
+        currency: 'usd',
+        status: 'succeeded',
+        payment_method_details: { type: 'card' },
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['charge.succeeded'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.chargeId, 'ch_123');
+});
+
+test('charge.failed handler should process failed charges', async () => {
+  const mockEvent = {
+    type: 'charge.failed',
+    data: {
+      object: {
+        id: 'ch_123',
+        customer: 'cus_123',
+        amount: 5000,
+        currency: 'usd',
+        failure_code: 'card_declined',
+        failure_message: 'Your card was declined',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: (data) => { loggedData = data; },
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['charge.failed'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.chargeId, 'ch_123');
+});
+
+test('charge.refunded handler should process charge refunds', async () => {
+  const mockEvent = {
+    type: 'charge.refunded',
+    data: {
+      object: {
+        id: 'ch_123',
+        customer: 'cus_123',
+        amount_refunded: 5000,
+        refunded: true,
+        refunds: {
+          data: [{ id: 're_123', amount: 5000 }],
+        },
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['charge.refunded'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.chargeId, 'ch_123');
+});
+
+test('payment_method.attached handler should process payment method attachments', async () => {
+  const mockEvent = {
+    type: 'payment_method.attached',
+    data: {
+      object: {
+        id: 'pm_123',
+        customer: 'cus_123',
+        type: 'card',
+        card: {
+          brand: 'visa',
+          last4: '4242',
+          exp_month: 12,
+          exp_year: 2025,
+        },
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['payment_method.attached'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.paymentMethodId, 'pm_123');
+});
+
+test('payment_method.detached handler should process payment method detachments', async () => {
+  const mockEvent = {
+    type: 'payment_method.detached',
+    data: {
+      object: {
+        id: 'pm_123',
+        customer: null,
+        type: 'card',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['payment_method.detached'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.paymentMethodId, 'pm_123');
+});
+
+// ============================================================================
+// SUBSCRIPTION LIFECYCLE TESTS
+// ============================================================================
+
+test('subscription.updated handler should process subscription changes', async () => {
+  const mockEvent = {
+    type: 'customer.subscription.updated',
+    data: {
+      object: {
+        id: 'sub_123',
+        customer: 'cus_123',
+        status: 'active',
+        current_period_end: 1234567890,
+      },
+      previous_attributes: {
+        status: 'trialing',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.updated'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.subscriptionId, 'sub_123');
+});
+
+test('subscription.deleted handler should process subscription cancellations', async () => {
+  const mockEvent = {
+    type: 'customer.subscription.deleted',
+    data: {
+      object: {
+        id: 'sub_123',
+        customer: 'cus_123',
+        status: 'canceled',
+        canceled_at: 1234567890,
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.deleted'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.subscriptionId, 'sub_123');
+});
+
+test('subscription.trial_will_end handler should process upcoming trial endings', async () => {
+  const mockEvent = {
+    type: 'customer.subscription.trial_will_end',
+    data: {
+      object: {
+        id: 'sub_123',
+        customer: 'cus_123',
+        trial_end: 1234567890,
+        status: 'trialing',
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.trial_will_end'];
+
+  await handler(mockEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.subscriptionId, 'sub_123');
+});
+
+// ============================================================================
+// HANDLER REGISTRY AND CUSTOMIZATION TESTS
+// ============================================================================
+
+test('can override default handlers', async () => {
+  let customHandlerCalled = false;
+
+  const customHandler = async () => {
+    customHandlerCalled = true;
+  };
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  // Store original handler, replace with custom
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const originalHandler = defaultHandlers['customer.subscription.created'];
+
+  defaultHandlers['customer.subscription.created'] = customHandler;
+
+  // Call custom handler
+  await defaultHandlers['customer.subscription.created'](mockSubscriptionCreatedEvent, mockFastify, {});
+
+  assert.ok(customHandlerCalled, 'Custom handler should have been called');
+
+  // Restore original handler
+  defaultHandlers['customer.subscription.created'] = originalHandler;
+});
+
+test('unknown event types can be handled with fallback', async () => {
+  const unknownEvent = {
+    type: 'unknown.event.type',
+    data: { object: { id: 'test' } },
+  };
+
+  let loggedInfo = null;
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: (info) => { loggedInfo = info; },
+    },
+  };
+
+  const fallbackHandler = async (event, fastify) => {
+    fastify.log.warn(`Unhandled event type: ${event.type}`);
+  };
+
+  await fallbackHandler(unknownEvent, mockFastify);
+
+  assert.ok(loggedInfo, 'Should have warned about unknown event');
+});
+
+test('handler receives correct Stripe instance', async () => {
+  let stripeInstance = null;
+
+  const mockStripe = {
+    customers: { retrieve: async () => ({ id: 'cus_123' }) },
+    subscriptions: { retrieve: async () => ({ id: 'sub_123' }) },
+  };
+
+  const testHandler = async (event, fastify, stripe) => {
+    stripeInstance = stripe;
+  };
+
+  const mockFastify = {
+    log: { info: () => {}, error: () => {}, warn: () => {} },
+  };
+
+  await testHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe);
+
+  assert.strictEqual(stripeInstance, mockStripe);
+  assert.ok(stripeInstance.customers);
+  assert.ok(stripeInstance.subscriptions);
+});
+
+// ============================================================================
+// EVENT DATA VALIDATION TESTS
+// ============================================================================
+
+test('handler processes events with complex nested data', async () => {
+  const complexEvent = {
+    type: 'customer.subscription.created',
+    data: {
+      object: {
+        id: 'sub_complex',
+        customer: 'cus_complex',
+        status: 'active',
+        items: {
+          data: [
+            {
+              id: 'si_1',
+              price: {
+                id: 'price_1',
+                product: 'prod_1',
+                unit_amount: 1000,
+                currency: 'usd',
+                recurring: { interval: 'month', interval_count: 1 },
+              },
+              quantity: 1,
+            },
+            {
+              id: 'si_2',
+              price: {
+                id: 'price_2',
+                product: 'prod_2',
+                unit_amount: 2000,
+                currency: 'usd',
+                recurring: { interval: 'year', interval_count: 1 },
+              },
+              quantity: 2,
+            },
+          ],
+        },
+        billing_cycle_anchor: 1234567890,
+        current_period_start: 1234567890,
+        current_period_end: 1234567999,
+      },
+    },
+  };
+
+  let loggedData = null;
+
+  const mockFastify = {
+    log: {
+      info: (data) => { loggedData = data; },
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.created'];
+
+  await handler(complexEvent, mockFastify, {});
+
+  assert.ok(loggedData);
+  assert.equal(loggedData.subscriptionId, 'sub_complex');
+});
+
+test('handler tolerates missing optional fields', async () => {
+  const minimalEvent = {
+    type: 'customer.subscription.created',
+    data: {
+      object: {
+        id: 'sub_minimal',
+        customer: 'cus_minimal',
+        status: 'active',
+        items: { data: [{ price: { id: 'price_minimal' } }] },
+      },
+    },
+  };
+
+  let errorThrown = false;
+
+  const mockFastify = {
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+  const handler = defaultHandlers['customer.subscription.created'];
+
+  try {
+    await handler(minimalEvent, mockFastify, {});
+  } catch (error) {
+    errorThrown = true;
+  }
+
+  assert.equal(errorThrown, false, 'Should handle minimal event data');
+});
+
+// ============================================================================
+// CONCURRENCY AND PERFORMANCE TESTS
+// ============================================================================
+
+test('handlers can execute concurrently', async () => {
+  let executionCount = 0;
+
+  const concurrentHandler = async (event, fastify, stripe) => {
+    await new Promise(resolve => setTimeout(resolve, 10));
+    executionCount++;
+  };
+
+  const mockFastify = {
+    log: { info: () => {}, error: () => {}, warn: () => {} },
+  };
+
+  const mockStripe = {};
+
+  // Execute 5 handlers concurrently
+  const promises = Array(5)
+    .fill(null)
+    .map(() => concurrentHandler(mockSubscriptionCreatedEvent, mockFastify, mockStripe));
+
+  await Promise.all(promises);
+
+  assert.equal(executionCount, 5, 'All 5 concurrent handlers should execute');
+});
+
+test('multiple event types can be handled in sequence', async () => {
+  const mockSubscriptionEvent = {
+    type: 'customer.subscription.created',
+    data: {
+      object: {
+        id: 'sub_123',
+        customer: 'cus_123',
+        status: 'active',
+        items: {
+          data: [{
+            price: {
+              id: 'price_123',
+              product: 'prod_123',
+              unit_amount: 2000,
+              currency: 'usd',
+            },
+            quantity: 1,
+          }],
+        },
+      },
+    },
+  };
+
+  const mockChargeSucceededEvent = {
+    type: 'charge.succeeded',
+    data: {
+      object: {
+        id: 'ch_123',
+        customer: 'cus_123',
+        amount: 5000,
+        currency: 'usd',
+        status: 'succeeded',
+        payment_method_details: { type: 'card' },
+      },
+    },
+  };
+
+  const results = [];
+
+  const mockFastify = {
+    log: {
+      info: (data) => { results.push(data); },
+      error: () => {},
+      warn: (data) => { results.push(data); },
+    },
+  };
+
+  const { defaultHandlers } = await import('../src/handlers/defaultHandlers.js');
+
+  const events = [mockSubscriptionEvent, mockChargeSucceededEvent];
+
+  for (const event of events) {
+    const handler = defaultHandlers[event.type];
+    if (handler) {
+      await handler(event, mockFastify, {});
+    }
+  }
+
+  assert.equal(results.length, 2, 'Should have processed 2 events');
+});