test(billing): add unit tests for isValidPaymentMethod and filterValidPaymentMethods

- 25 new tests covering card expiration validation, link payment methods, and unsupported types
- Tests for filterValidPaymentMethods including edge cases (empty, all valid, all invalid, mixed)
- Verifies order preservation and non-mutation of input array

Author: brandonkachen

packages/billing/src/__tests__/auto-topup-helpers.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  filterValidPaymentMethods,
+  isValidPaymentMethod,
+} from '../auto-topup-helpers'
+
+import type Stripe from 'stripe'
+
+/**
+ * Creates a mock Stripe card payment method for testing.
+ */
+function createCardPaymentMethod(
+  id: string,
+  expYear: number | undefined,
+  expMonth: number | undefined,
+): Stripe.PaymentMethod {
+  return {
+    id,
+    type: 'card',
+    card:
+      expYear !== undefined && expMonth !== undefined
+        ? { exp_year: expYear, exp_month: expMonth }
+        : expYear !== undefined
+          ? { exp_year: expYear }
+          : expMonth !== undefined
+            ? { exp_month: expMonth }
+            : undefined,
+  } as Stripe.PaymentMethod
+}
+
+/**
+ * Creates a mock Stripe link payment method for testing.
+ */
+function createLinkPaymentMethod(id: string): Stripe.PaymentMethod {
+  return {
+    id,
+    type: 'link',
+  } as Stripe.PaymentMethod
+}
+
+/**
+ * Creates a mock Stripe payment method with a specified type.
+ */
+function createPaymentMethodWithType(
+  id: string,
+  type: string,
+): Stripe.PaymentMethod {
+  return {
+    id,
+    type,
+  } as Stripe.PaymentMethod
+}
+
+describe('auto-topup-helpers', () => {
+  describe('isValidPaymentMethod', () => {
+    describe('card payment methods', () => {
+      it('should return true for card with future expiration date', () => {
+        // Card expiring in December 2099 - definitely in the future
+        const card = createCardPaymentMethod('pm_1', 2099, 12)
+        expect(isValidPaymentMethod(card)).toBe(true)
+      })
+
+      it('should return true for card expiring many years in the future', () => {
+        const card = createCardPaymentMethod('pm_1', 2050, 6)
+        expect(isValidPaymentMethod(card)).toBe(true)
+      })
+
+      it('should return false for card that expired in the past', () => {
+        // Card expired in January 2020 - definitely in the past
+        const card = createCardPaymentMethod('pm_1', 2020, 1)
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return false for card that expired years ago', () => {
+        const card = createCardPaymentMethod('pm_1', 2015, 6)
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return false for card expiring in current month', () => {
+        // The logic uses > not >= so cards expiring this month are invalid
+        // as the check creates a date at the START of the expiration month
+        const now = new Date()
+        const card = createCardPaymentMethod(
+          'pm_1',
+          now.getFullYear(),
+          now.getMonth() + 1,
+        )
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return true for card expiring next month', () => {
+        const now = new Date()
+        // Handle year rollover
+        const nextMonth = now.getMonth() + 2 // +2 because getMonth is 0-indexed but exp_month is 1-indexed
+        const year =
+          nextMonth > 12 ? now.getFullYear() + 1 : now.getFullYear()
+        const month = nextMonth > 12 ? nextMonth - 12 : nextMonth
+        const card = createCardPaymentMethod('pm_1', year, month)
+        expect(isValidPaymentMethod(card)).toBe(true)
+      })
+
+      it('should return false for card with missing exp_year', () => {
+        const card = createCardPaymentMethod('pm_1', undefined, 12)
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return false for card with missing exp_month', () => {
+        const card = createCardPaymentMethod('pm_1', 2099, undefined)
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return false for card with missing card object', () => {
+        const card = {
+          id: 'pm_1',
+          type: 'card',
+          card: undefined,
+        } as Stripe.PaymentMethod
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+
+      it('should return false for card with null card object', () => {
+        const card = {
+          id: 'pm_1',
+          type: 'card',
+          card: null,
+        } as unknown as Stripe.PaymentMethod
+        expect(isValidPaymentMethod(card)).toBe(false)
+      })
+    })
+
+    describe('link payment methods', () => {
+      it('should return true for link payment method', () => {
+        const link = createLinkPaymentMethod('pm_link_1')
+        expect(isValidPaymentMethod(link)).toBe(true)
+      })
+
+      it('should return true for any link payment method regardless of other properties', () => {
+        const link = {
+          id: 'pm_link_2',
+          type: 'link',
+          link: { email: 'test@example.com' },
+        } as Stripe.PaymentMethod
+        expect(isValidPaymentMethod(link)).toBe(true)
+      })
+    })
+
+    describe('other payment method types', () => {
+      it('should return false for sepa_debit payment method', () => {
+        const sepa = createPaymentMethodWithType('pm_sepa_1', 'sepa_debit')
+        expect(isValidPaymentMethod(sepa)).toBe(false)
+      })
+
+      it('should return false for us_bank_account payment method', () => {
+        const bank = createPaymentMethodWithType('pm_bank_1', 'us_bank_account')
+        expect(isValidPaymentMethod(bank)).toBe(false)
+      })
+
+      it('should return false for acss_debit payment method', () => {
+        const acss = createPaymentMethodWithType('pm_acss_1', 'acss_debit')
+        expect(isValidPaymentMethod(acss)).toBe(false)
+      })
+
+      it('should return false for unknown payment method type', () => {
+        const unknown = createPaymentMethodWithType('pm_unknown', 'unknown_type')
+        expect(isValidPaymentMethod(unknown)).toBe(false)
+      })
+
+      it('should return false for empty type string', () => {
+        const empty = createPaymentMethodWithType('pm_empty', '')
+        expect(isValidPaymentMethod(empty)).toBe(false)
+      })
+    })
+  })
+
+  describe('filterValidPaymentMethods', () => {
+    it('should return empty array for empty input', () => {
+      const result = filterValidPaymentMethods([])
+      expect(result).toEqual([])
+    })
+
+    it('should return all payment methods when all are valid', () => {
+      const validCard = createCardPaymentMethod('pm_card_1', 2099, 12)
+      const validLink = createLinkPaymentMethod('pm_link_1')
+      const validCard2 = createCardPaymentMethod('pm_card_2', 2050, 6)
+
+      const result = filterValidPaymentMethods([validCard, validLink, validCard2])
+
+      expect(result).toHaveLength(3)
+      expect(result[0].id).toBe('pm_card_1')
+      expect(result[1].id).toBe('pm_link_1')
+      expect(result[2].id).toBe('pm_card_2')
+    })
+
+    it('should return empty array when all payment methods are invalid', () => {
+      const expiredCard1 = createCardPaymentMethod('pm_expired_1', 2020, 1)
+      const expiredCard2 = createCardPaymentMethod('pm_expired_2', 2015, 6)
+      const sepa = createPaymentMethodWithType('pm_sepa_1', 'sepa_debit')
+
+      const result = filterValidPaymentMethods([expiredCard1, expiredCard2, sepa])
+
+      expect(result).toEqual([])
+    })
+
+    it('should filter out invalid payment methods from mixed list', () => {
+      const validCard = createCardPaymentMethod('pm_valid_card', 2099, 12)
+      const expiredCard = createCardPaymentMethod('pm_expired', 2020, 1)
+      const validLink = createLinkPaymentMethod('pm_link')
+      const sepa = createPaymentMethodWithType('pm_sepa', 'sepa_debit')
+      const validCard2 = createCardPaymentMethod('pm_valid_card_2', 2050, 6)
+
+      const result = filterValidPaymentMethods([
+        validCard,
+        expiredCard,
+        validLink,
+        sepa,
+        validCard2,
+      ])
+
+      expect(result).toHaveLength(3)
+      expect(result.map((pm) => pm.id)).toEqual([
+        'pm_valid_card',
+        'pm_link',
+        'pm_valid_card_2',
+      ])
+    })
+
+    it('should preserve the order of valid payment methods', () => {
+      const link1 = createLinkPaymentMethod('pm_link_1')
+      const card1 = createCardPaymentMethod('pm_card_1', 2099, 1)
+      const link2 = createLinkPaymentMethod('pm_link_2')
+      const card2 = createCardPaymentMethod('pm_card_2', 2099, 6)
+
+      const result = filterValidPaymentMethods([link1, card1, link2, card2])
+
+      expect(result.map((pm) => pm.id)).toEqual([
+        'pm_link_1',
+        'pm_card_1',
+        'pm_link_2',
+        'pm_card_2',
+      ])
+    })
+
+    it('should handle single valid payment method', () => {
+      const validCard = createCardPaymentMethod('pm_single', 2099, 12)
+
+      const result = filterValidPaymentMethods([validCard])
+
+      expect(result).toHaveLength(1)
+      expect(result[0].id).toBe('pm_single')
+    })
+
+    it('should handle single invalid payment method', () => {
+      const expiredCard = createCardPaymentMethod('pm_expired', 2020, 1)
+
+      const result = filterValidPaymentMethods([expiredCard])
+
+      expect(result).toEqual([])
+    })
+
+    it('should not mutate the original array', () => {
+      const validCard = createCardPaymentMethod('pm_valid', 2099, 12)
+      const expiredCard = createCardPaymentMethod('pm_expired', 2020, 1)
+      const original = [validCard, expiredCard]
+      const originalLength = original.length
+
+      filterValidPaymentMethods(original)
+
+      expect(original).toHaveLength(originalLength)
+      expect(original[0].id).toBe('pm_valid')
+      expect(original[1].id).toBe('pm_expired')
+    })
+  })
+})