evaldoc 1.0.0

package/tests/unit/payment.test.js

@@ -0,0 +1,889 @@
+/**
+ * Unit tests for payment.js module
+ *
+ * Tests Stripe Connect functions, checkout sessions, payment intents,
+ * subscriptions, access control, revenue analytics, and webhook handling.
+ */
+
+// Mock firebase-admin
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+// Mock Stripe
+const mockStripe = {
+  accounts: {
+    create: jest.fn(),
+    retrieve: jest.fn()
+  },
+  accountLinks: {
+    create: jest.fn()
+  },
+  products: {
+    create: jest.fn()
+  },
+  prices: {
+    create: jest.fn()
+  },
+  customers: {
+    create: jest.fn()
+  },
+  checkout: {
+    sessions: {
+      create: jest.fn()
+    }
+  },
+  paymentIntents: {
+    create: jest.fn()
+  },
+  subscriptions: {
+    create: jest.fn(),
+    update: jest.fn()
+  }
+};
+
+jest.mock('../../functions/src/stripe-config', () => ({ stripe: mockStripe }));
+
+const admin = require('firebase-admin');
+const {
+  createConnectAccount,
+  createAccountLink,
+  refreshAccountStatus,
+  setProviderPricing,
+  createCheckoutSession,
+  createPaymentIntent,
+  createSubscription,
+  cancelSubscription,
+  checkPaymentAccess,
+  getRevenueAnalytics,
+  handleStripeWebhook
+} = require('../../functions/src/payment');
+
+describe('Payment Module', () => {
+  beforeEach(() => {
+    admin.__reset();
+    jest.clearAllMocks();
+  });
+
+  // ============================================
+  // STRIPE CONNECT FUNCTIONS
+  // ============================================
+
+  describe('createConnectAccount', () => {
+    it('should create a Stripe Connect Express account and update Firestore', async () => {
+      admin.__seed('providers', 'doc-1', { displayName: 'Dr. Test' });
+
+      mockStripe.accounts.create.mockResolvedValue({
+        id: 'acct_123',
+        charges_enabled: false,
+        payouts_enabled: false
+      });
+
+      const result = await createConnectAccount({
+        providerId: 'doc-1',
+        email: 'doc@test.com',
+        displayName: 'Dr. Test',
+        country: 'US'
+      });
+
+      expect(result.accountId).toBe('acct_123');
+      expect(result.onboardingStatus).toBe('PENDING');
+
+      expect(mockStripe.accounts.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'express',
+          country: 'US',
+          email: 'doc@test.com',
+          capabilities: {
+            card_payments: { requested: true },
+            transfers: { requested: true }
+          }
+        })
+      );
+
+      // Verify Firestore was updated
+      const provider = admin.__getAll('providers')['doc-1'];
+      expect(provider.stripeAccountId).toBe('acct_123');
+      expect(provider.stripeOnboardingStatus).toBe('PENDING');
+    });
+
+    it('should throw on Stripe API error', async () => {
+      admin.__seed('providers', 'doc-1', { displayName: 'Dr. Test' });
+      mockStripe.accounts.create.mockRejectedValue(new Error('Stripe error'));
+
+      await expect(createConnectAccount({
+        providerId: 'doc-1',
+        email: 'doc@test.com'
+      })).rejects.toThrow('Stripe error');
+    });
+  });
+
+  describe('createAccountLink', () => {
+    it('should create an onboarding link', async () => {
+      mockStripe.accountLinks.create.mockResolvedValue({
+        url: 'https://connect.stripe.com/setup/onboarding',
+        expires_at: 1234567890
+      });
+
+      const result = await createAccountLink({
+        stripeAccountId: 'acct_123',
+        providerId: 'doc-1'
+      });
+
+      expect(result.url).toBe('https://connect.stripe.com/setup/onboarding');
+      expect(result.expiresAt).toBe(1234567890);
+
+      expect(mockStripe.accountLinks.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          account: 'acct_123',
+          type: 'account_onboarding'
+        })
+      );
+    });
+  });
+
+  describe('refreshAccountStatus', () => {
+    it('should update Firestore with current account status', async () => {
+      admin.__seed('providers', 'doc-1', {
+        stripeAccountId: 'acct_123',
+        stripeOnboardingStatus: 'PENDING'
+      });
+
+      mockStripe.accounts.retrieve.mockResolvedValue({
+        charges_enabled: true,
+        payouts_enabled: true
+      });
+
+      const result = await refreshAccountStatus({
+        providerId: 'doc-1',
+        stripeAccountId: 'acct_123'
+      });
+
+      expect(result.chargesEnabled).toBe(true);
+      expect(result.payoutsEnabled).toBe(true);
+      expect(result.onboardingComplete).toBe(true);
+
+      const provider = admin.__getAll('providers')['doc-1'];
+      expect(provider.stripeOnboardingStatus).toBe('COMPLETE');
+    });
+
+    it('should keep PENDING status when not fully enabled', async () => {
+      admin.__seed('providers', 'doc-1', {
+        stripeAccountId: 'acct_123',
+        stripeOnboardingStatus: 'PENDING'
+      });
+
+      mockStripe.accounts.retrieve.mockResolvedValue({
+        charges_enabled: true,
+        payouts_enabled: false
+      });
+
+      const result = await refreshAccountStatus({
+        providerId: 'doc-1',
+        stripeAccountId: 'acct_123'
+      });
+
+      expect(result.onboardingComplete).toBe(false);
+      const provider = admin.__getAll('providers')['doc-1'];
+      expect(provider.stripeOnboardingStatus).toBe('PENDING');
+    });
+  });
+
+  // ============================================
+  // PRICING
+  // ============================================
+
+  describe('setProviderPricing', () => {
+    it('should create product and prices on Stripe', async () => {
+      admin.__seed('providers', 'doc-1', { displayName: 'Dr. Test' });
+
+      mockStripe.products.create.mockResolvedValue({ id: 'prod_123' });
+      mockStripe.prices.create.mockResolvedValue({ id: 'price_month_123' });
+
+      const result = await setProviderPricing({
+        providerId: 'doc-1',
+        stripeAccountId: 'acct_123',
+        currency: 'usd',
+        prices: { month: 29.99 },
+        displayName: 'Dr. Test'
+      });
+
+      expect(result.productId).toBe('prod_123');
+      expect(result.priceIds.month).toBe('price_month_123');
+
+      expect(mockStripe.products.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'EvalDoc AI Access - Dr. Test'
+        }),
+        { stripeAccount: 'acct_123' }
+      );
+
+      expect(mockStripe.prices.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          product: 'prod_123',
+          unit_amount: 2999,
+          currency: 'usd',
+          recurring: { interval: 'month' }
+        }),
+        { stripeAccount: 'acct_123' }
+      );
+    });
+
+    it('should reuse existing product if available', async () => {
+      admin.__seed('providers', 'doc-1', {
+        displayName: 'Dr. Test',
+        stripeProductId: 'prod_existing'
+      });
+
+      mockStripe.prices.create.mockResolvedValue({ id: 'price_123' });
+
+      const result = await setProviderPricing({
+        providerId: 'doc-1',
+        stripeAccountId: 'acct_123',
+        prices: { month: 10 }
+      });
+
+      expect(mockStripe.products.create).not.toHaveBeenCalled();
+      expect(result.productId).toBe('prod_existing');
+    });
+
+    it('should skip intervals with zero or null amounts', async () => {
+      admin.__seed('providers', 'doc-1', { displayName: 'Dr. Test' });
+      mockStripe.products.create.mockResolvedValue({ id: 'prod_123' });
+
+      await setProviderPricing({
+        providerId: 'doc-1',
+        stripeAccountId: 'acct_123',
+        prices: { month: 0, week: null, day: 5 }
+      });
+
+      // Only 'day' should create a price (month=0 and week=null are skipped)
+      expect(mockStripe.prices.create).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  // ============================================
+  // CHECKOUT & PAYMENT
+  // ============================================
+
+  describe('createCheckoutSession', () => {
+    it('should create checkout session with 25% platform fee', async () => {
+      admin.__seed('patients', 'patient-1', {});
+
+      mockStripe.customers.create.mockResolvedValue({ id: 'cus_123' });
+      mockStripe.checkout.sessions.create.mockResolvedValue({
+        id: 'cs_123',
+        url: 'https://checkout.stripe.com/pay/cs_123'
+      });
+
+      const result = await createCheckoutSession({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        interval: 'month',
+        stripeAccountId: 'acct_123',
+        stripePriceId: 'price_123'
+      });
+
+      expect(result.sessionId).toBe('cs_123');
+      expect(result.url).toBe('https://checkout.stripe.com/pay/cs_123');
+
+      expect(mockStripe.checkout.sessions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mode: 'subscription',
+          subscription_data: expect.objectContaining({
+            application_fee_percent: 25
+          })
+        }),
+        { stripeAccount: 'acct_123' }
+      );
+    });
+
+    it('should reuse existing Stripe customer', async () => {
+      admin.__seed('patients', 'patient-1', { stripeCustomerId: 'cus_existing' });
+
+      mockStripe.checkout.sessions.create.mockResolvedValue({
+        id: 'cs_123',
+        url: 'https://checkout.stripe.com/pay/cs_123'
+      });
+
+      await createCheckoutSession({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        interval: 'month',
+        stripeAccountId: 'acct_123',
+        stripePriceId: 'price_123'
+      });
+
+      expect(mockStripe.customers.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('createPaymentIntent', () => {
+    it('should create payment intent with Connect and 25% fee', async () => {
+      mockStripe.paymentIntents.create.mockResolvedValue({
+        id: 'pi_123',
+        client_secret: 'pi_123_secret'
+      });
+
+      const result = await createPaymentIntent({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        amount: 20,
+        currency: 'usd',
+        stripeAccountId: 'acct_123',
+        metadata: { conversationId: 'conv-1' }
+      });
+
+      expect(result.clientSecret).toBe('pi_123_secret');
+      expect(result.paymentIntentId).toBe('pi_123');
+
+      expect(mockStripe.paymentIntents.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          amount: 2000,
+          currency: 'usd',
+          application_fee_amount: 500 // 25% of 2000
+        }),
+        { stripeAccount: 'acct_123' }
+      );
+
+      // Should save transaction record
+      const transactions = admin.__getAll('transactions');
+      const txIds = Object.keys(transactions);
+      expect(txIds.length).toBe(1);
+      expect(transactions[txIds[0]].amount).toBe(2000);
+      expect(transactions[txIds[0]].status).toBe('pending');
+    });
+
+    it('should create payment intent without Connect when no stripeAccountId', async () => {
+      mockStripe.paymentIntents.create.mockResolvedValue({
+        id: 'pi_456',
+        client_secret: 'pi_456_secret'
+      });
+
+      await createPaymentIntent({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        amount: 10
+      });
+
+      expect(mockStripe.paymentIntents.create).toHaveBeenCalledWith(
+        expect.not.objectContaining({ application_fee_amount: expect.anything() }),
+        {} // empty options, no stripeAccount
+      );
+    });
+  });
+
+  // ============================================
+  // SUBSCRIPTIONS
+  // ============================================
+
+  describe('cancelSubscription', () => {
+    it('should cancel at period end by default', async () => {
+      admin.__seed('subscriptions', 'sub-doc-1', {
+        stripeSubscriptionId: 'sub_123',
+        status: 'active'
+      });
+
+      mockStripe.subscriptions.update.mockResolvedValue({
+        id: 'sub_123',
+        status: 'active',
+        cancel_at_period_end: true
+      });
+
+      const result = await cancelSubscription({ subscriptionId: 'sub_123' });
+
+      expect(mockStripe.subscriptions.update).toHaveBeenCalledWith('sub_123', {
+        cancel_at_period_end: true
+      });
+      expect(result.cancel_at_period_end).toBe(true);
+    });
+  });
+
+  // ============================================
+  // ACCESS CONTROL
+  // ============================================
+
+  describe('checkPaymentAccess', () => {
+    it('should grant access via access collection (fast path)', async () => {
+      admin.__seed('access', 'doc-1_patient-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        status: 'ACTIVE',
+        stripeSubscriptionId: 'sub_123'
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1'
+      });
+
+      expect(result.hasAccess).toBe(true);
+      expect(result.type).toBe('subscription');
+    });
+
+    it('should deny access when access doc is INACTIVE', async () => {
+      admin.__seed('access', 'doc-1_patient-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        status: 'INACTIVE'
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1'
+      });
+
+      expect(result.hasAccess).toBe(false);
+      expect(result.type).toBeNull();
+    });
+
+    it('should fallback to subscriptions collection for active subscription', async () => {
+      const futureDate = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+      const futureMs = futureDate.getTime();
+
+      const originalNow = admin.firestore.Timestamp.now;
+      admin.firestore.Timestamp.now = () => ({
+        _seconds: Math.floor(Date.now() / 1000),
+        _nanoseconds: 0,
+        toMillis: () => Date.now()
+      });
+
+      admin.__seed('subscriptions', 'sub-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        status: 'active',
+        currentPeriodEnd: {
+          _seconds: Math.floor(futureMs / 1000),
+          toMillis: () => futureMs
+        }
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1'
+      });
+
+      expect(result.hasAccess).toBe(true);
+      expect(result.type).toBe('subscription');
+
+      admin.firestore.Timestamp.now = originalNow;
+    });
+
+    it('should grant access for past_due subscription within period', async () => {
+      const futureDate = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+      const futureMs = futureDate.getTime();
+
+      const originalNow = admin.firestore.Timestamp.now;
+      admin.firestore.Timestamp.now = () => ({
+        _seconds: Math.floor(Date.now() / 1000),
+        _nanoseconds: 0,
+        toMillis: () => Date.now()
+      });
+
+      admin.__seed('subscriptions', 'sub-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        status: 'past_due',
+        currentPeriodEnd: {
+          _seconds: Math.floor(futureMs / 1000),
+          toMillis: () => futureMs
+        }
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1'
+      });
+
+      expect(result.hasAccess).toBe(true);
+      expect(result.type).toBe('subscription');
+
+      admin.firestore.Timestamp.now = originalNow;
+    });
+
+    it('should deny access when no subscription or payment exists', async () => {
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1'
+      });
+
+      expect(result.hasAccess).toBe(false);
+      expect(result.type).toBeNull();
+    });
+
+    it('should grant access for per-chat payment', async () => {
+      admin.__seed('transactions', 'tx-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        conversationId: 'conv-1',
+        status: 'succeeded'
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        conversationId: 'conv-1'
+      });
+
+      expect(result.hasAccess).toBe(true);
+      expect(result.type).toBe('per-chat');
+    });
+
+    it('should deny access for failed per-chat payment', async () => {
+      admin.__seed('transactions', 'tx-1', {
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        conversationId: 'conv-1',
+        status: 'failed'
+      });
+
+      const result = await checkPaymentAccess({
+        providerId: 'doc-1',
+        patientId: 'patient-1',
+        conversationId: 'conv-1'
+      });
+
+      expect(result.hasAccess).toBe(false);
+    });
+  });
+
+  // ============================================
+  // REVENUE ANALYTICS
+  // ============================================
+
+  describe('getRevenueAnalytics', () => {
+    it('should return revenue summary', async () => {
+      const now = new Date();
+      admin.__seed('transactions', 'tx-1', {
+        providerId: 'doc-1',
+        status: 'succeeded',
+        amount: 2000,
+        createdAt: { toDate: () => now }
+      });
+      admin.__seed('transactions', 'tx-2', {
+        providerId: 'doc-1',
+        status: 'succeeded',
+        amount: 3000,
+        createdAt: { toDate: () => now }
+      });
+      admin.__seed('subscriptions', 'sub-1', {
+        providerId: 'doc-1',
+        status: 'active'
+      });
+
+      const result = await getRevenueAnalytics({ providerId: 'doc-1' });
+
+      expect(result.totalRevenue).toBe(50); // (2000 + 3000) / 100
+      expect(result.transactionCount).toBe(2);
+      expect(result.activeSubscriptions).toBe(1);
+      expect(result.currency).toBe('USD');
+    });
+
+    it('should return zeros when no transactions exist', async () => {
+      const result = await getRevenueAnalytics({ providerId: 'doc-empty' });
+
+      expect(result.totalRevenue).toBe(0);
+      expect(result.transactionCount).toBe(0);
+      expect(result.activeSubscriptions).toBe(0);
+    });
+  });
+
+  // ============================================
+  // WEBHOOK HANDLING
+  // ============================================
+
+  describe('handleStripeWebhook', () => {
+    describe('account.updated', () => {
+      it('should update provider onboarding status to COMPLETE', async () => {
+        admin.__seed('providers', 'doc-1', {
+          stripeAccountId: 'acct_123',
+          stripeOnboardingStatus: 'PENDING'
+        });
+
+        await handleStripeWebhook({
+          type: 'account.updated',
+          data: {
+            object: {
+              id: 'acct_123',
+              charges_enabled: true,
+              payouts_enabled: true,
+              metadata: { providerId: 'doc-1' }
+            }
+          }
+        });
+
+        const provider = admin.__getAll('providers')['doc-1'];
+        expect(provider.stripeOnboardingStatus).toBe('COMPLETE');
+        expect(provider.chargesEnabled).toBe(true);
+        expect(provider.payoutsEnabled).toBe(true);
+      });
+    });
+
+    describe('customer.subscription.created', () => {
+      it('should create subscription and access records', async () => {
+        await handleStripeWebhook({
+          type: 'customer.subscription.created',
+          data: {
+            object: {
+              id: 'sub_123',
+              customer: 'cus_123',
+              status: 'active',
+              items: { data: [{ price: { id: 'price_123' } }] },
+              current_period_start: Math.floor(Date.now() / 1000),
+              current_period_end: Math.floor(Date.now() / 1000) + 30 * 86400,
+              cancel_at_period_end: false,
+              metadata: { providerId: 'doc-1', patientId: 'patient-1' }
+            }
+          }
+        });
+
+        // Check subscription was created with stripeSubscriptionId as doc ID
+        const subs = admin.__getAll('subscriptions');
+        expect(subs['sub_123']).toBeDefined();
+        expect(subs['sub_123'].stripeSubscriptionId).toBe('sub_123');
+        expect(subs['sub_123'].status).toBe('active');
+
+        // Check access was created
+        const access = admin.__getAll('access');
+        expect(access['doc-1_patient-1']).toBeDefined();
+        expect(access['doc-1_patient-1'].status).toBe('ACTIVE');
+      });
+
+      it('should be idempotent on webhook retries', async () => {
+        const webhookEvent = {
+          type: 'customer.subscription.created',
+          data: {
+            object: {
+              id: 'sub_retry',
+              customer: 'cus_123',
+              status: 'active',
+              items: { data: [{ price: { id: 'price_123' } }] },
+              current_period_start: Math.floor(Date.now() / 1000),
+              current_period_end: Math.floor(Date.now() / 1000) + 30 * 86400,
+              cancel_at_period_end: false,
+              metadata: { providerId: 'doc-1', patientId: 'patient-1' }
+            }
+          }
+        };
+
+        // Process same webhook twice (simulating Stripe retry)
+        await handleStripeWebhook(webhookEvent);
+        await handleStripeWebhook(webhookEvent);
+
+        // Should still only have one subscription record
+        const subs = admin.__getAll('subscriptions');
+        const subIds = Object.keys(subs);
+        expect(subIds.length).toBe(1);
+        expect(subs['sub_retry']).toBeDefined();
+      });
+
+      it('should skip when metadata is missing', async () => {
+        await handleStripeWebhook({
+          type: 'customer.subscription.created',
+          data: {
+            object: {
+              id: 'sub_no_meta',
+              customer: 'cus_123',
+              status: 'active',
+              items: { data: [{ price: { id: 'price_123' } }] },
+              current_period_start: Math.floor(Date.now() / 1000),
+              current_period_end: Math.floor(Date.now() / 1000) + 30 * 86400,
+              cancel_at_period_end: false,
+              metadata: {}
+            }
+          }
+        });
+
+        const subs = admin.__getAll('subscriptions');
+        expect(Object.keys(subs).length).toBe(0);
+      });
+
+      it('should skip when subscription items are missing', async () => {
+        await handleStripeWebhook({
+          type: 'customer.subscription.created',
+          data: {
+            object: {
+              id: 'sub_no_items',
+              customer: 'cus_123',
+              status: 'active',
+              items: { data: [] },
+              current_period_start: Math.floor(Date.now() / 1000),
+              current_period_end: Math.floor(Date.now() / 1000) + 30 * 86400,
+              cancel_at_period_end: false,
+              metadata: { providerId: 'doc-1', patientId: 'patient-1' }
+            }
+          }
+        });
+
+        const subs = admin.__getAll('subscriptions');
+        expect(Object.keys(subs).length).toBe(0);
+      });
+    });
+
+    describe('customer.subscription.deleted', () => {
+      it('should cancel subscription and revoke access', async () => {
+        admin.__seed('subscriptions', 'sub-doc-1', {
+          stripeSubscriptionId: 'sub_123',
+          status: 'active'
+        });
+        admin.__seed('access', 'doc-1_patient-1', {
+          status: 'ACTIVE',
+          stripeSubscriptionId: 'sub_123'
+        });
+
+        await handleStripeWebhook({
+          type: 'customer.subscription.deleted',
+          data: {
+            object: {
+              id: 'sub_123',
+              metadata: { providerId: 'doc-1', patientId: 'patient-1' }
+            }
+          }
+        });
+
+        const sub = admin.__getAll('subscriptions')['sub-doc-1'];
+        expect(sub.status).toBe('canceled');
+
+        const access = admin.__getAll('access')['doc-1_patient-1'];
+        expect(access.status).toBe('INACTIVE');
+      });
+
+      it('should not crash when access doc does not exist', async () => {
+        admin.__seed('subscriptions', 'sub-doc-2', {
+          stripeSubscriptionId: 'sub_456',
+          status: 'active'
+        });
+        // Intentionally NOT seeding access doc
+
+        await handleStripeWebhook({
+          type: 'customer.subscription.deleted',
+          data: {
+            object: {
+              id: 'sub_456',
+              metadata: { providerId: 'doc-2', patientId: 'patient-2' }
+            }
+          }
+        });
+
+        // Access doc should be created with INACTIVE status
+        const access = admin.__getAll('access')['doc-2_patient-2'];
+        expect(access).toBeDefined();
+        expect(access.status).toBe('INACTIVE');
+      });
+    });
+
+    describe('payment_intent.succeeded', () => {
+      it('should update transaction status to succeeded', async () => {
+        admin.__seed('transactions', 'tx-1', {
+          stripePaymentIntentId: 'pi_123',
+          status: 'pending'
+        });
+
+        await handleStripeWebhook({
+          type: 'payment_intent.succeeded',
+          data: { object: { id: 'pi_123' } }
+        });
+
+        const tx = admin.__getAll('transactions')['tx-1'];
+        expect(tx.status).toBe('succeeded');
+      });
+    });
+
+    describe('payment_intent.payment_failed', () => {
+      it('should update transaction status to failed', async () => {
+        admin.__seed('transactions', 'tx-1', {
+          stripePaymentIntentId: 'pi_123',
+          status: 'pending'
+        });
+
+        await handleStripeWebhook({
+          type: 'payment_intent.payment_failed',
+          data: { object: { id: 'pi_123' } }
+        });
+
+        const tx = admin.__getAll('transactions')['tx-1'];
+        expect(tx.status).toBe('failed');
+      });
+    });
+
+    describe('invoice.payment_failed', () => {
+      it('should revoke access on failed invoice', async () => {
+        admin.__seed('subscriptions', 'sub-doc-1', {
+          stripeSubscriptionId: 'sub_123',
+          providerId: 'doc-1',
+          patientId: 'patient-1',
+          currentPeriodEnd: { _seconds: Math.floor(Date.now() / 1000) + 86400 }
+        });
+        admin.__seed('access', 'doc-1_patient-1', {
+          status: 'ACTIVE',
+          providerId: 'doc-1',
+          patientId: 'patient-1'
+        });
+
+        await handleStripeWebhook({
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              subscription: 'sub_123'
+            }
+          }
+        });
+
+        const access = admin.__getAll('access')['doc-1_patient-1'];
+        expect(access.status).toBe('INACTIVE');
+      });
+
+      it('should not crash when access doc does not exist', async () => {
+        admin.__seed('subscriptions', 'sub-doc-1', {
+          stripeSubscriptionId: 'sub_789',
+          providerId: 'doc-3',
+          patientId: 'patient-3'
+        });
+        // Intentionally NOT seeding access doc
+
+        await handleStripeWebhook({
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              subscription: 'sub_789'
+            }
+          }
+        });
+
+        // Access doc should be created with INACTIVE status
+        const access = admin.__getAll('access')['doc-3_patient-3'];
+        expect(access).toBeDefined();
+        expect(access.status).toBe('INACTIVE');
+      });
+    });
+
+    describe('invoice.payment_succeeded', () => {
+      it('should ensure access is ACTIVE on successful payment', async () => {
+        admin.__seed('subscriptions', 'sub-doc-1', {
+          stripeSubscriptionId: 'sub_123',
+          providerId: 'doc-1',
+          patientId: 'patient-1',
+          currentPeriodEnd: { _seconds: Math.floor(Date.now() / 1000) + 86400 }
+        });
+
+        await handleStripeWebhook({
+          type: 'invoice.payment_succeeded',
+          data: {
+            object: {
+              subscription: 'sub_123'
+            }
+          }
+        });
+
+        const access = admin.__getAll('access')['doc-1_patient-1'];
+        expect(access.status).toBe('ACTIVE');
+      });
+    });
+
+    it('should handle unrecognized event types gracefully', async () => {
+      // Should not throw
+      await handleStripeWebhook({
+        type: 'some.unknown.event',
+        data: { object: {} }
+      });
+    });
+  });
+});