@easyflow/javascript-sdk 2.1.8 → 2.1.9

package/sdk.spec.js

@@ -1,796 +0,0 @@
-import { beforeEach, describe, expect, jest, test } from '@jest/globals'
-
-await jest.unstable_mockModule('./libs/security.mjs', () => ({
-    RateLimiter: jest.fn().mockImplementation(() => ({
-        checkLimit: jest.fn().mockResolvedValue(undefined),
-    })),
-    SECURITY_CONFIG: {
-        PRODUCTION_MODE: false,
-    },
-}))
-
-await jest.unstable_mockModule('./libs/logger.mjs', () => ({
-    SecureLogger: jest.fn().mockImplementation(() => ({
-        info: jest.fn(),
-        error: jest.fn(),
-    })),
-}))
-
-await jest.unstable_mockModule('./libs/http.mjs', () => ({
-    callSecureApi: jest.fn(),
-}))
-
-await jest.unstable_mockModule('./libs/sanitizer.mjs', () => ({
-    Sanitizer: {
-        sanitizeInput: jest.fn((input) => {
-            if (input === '' || input === null || input === undefined) {
-                return ''
-            }
-            return input
-        }),
-        sanitizeCreditCard: jest.fn((card) => card),
-    },
-    sanitizeOrderData: jest.fn((data) => data),
-}))
-
-await jest.unstable_mockModule('./libs/utils.mjs', () => ({
-    findPaymentByMethod: jest.fn(),
-    isValidBankBilletPayment: jest.fn(),
-    isValidPixPayment: jest.fn(),
-    mapCreditCardIfNeeded: jest.fn((data) => data),
-}))
-
-await jest.unstable_mockModule('./libs/validator.mjs', () => ({
-    Validator: {
-        validateOrderData: jest.fn(),
-        validateChargeItemsData: jest.fn(),
-        validateCreditCardData: jest.fn(),
-        validateBusinessId: jest.fn(),
-        validateOfferId: jest.fn(),
-        validateOrderId: jest.fn(),
-        validateCreditCardToken: jest.fn(),
-        validateCustomer: jest.fn(),
-        validatePagination: jest.fn(),
-        validateEmail: jest.fn(),
-        validateCPF: jest.fn(),
-        validateCNPJ: jest.fn(),
-        validateLegalDocument: jest.fn(),
-        validatePhone: jest.fn(),
-        validateAddress: jest.fn(),
-        validateCustomerId: jest.fn(),
-        validateCreditCardId: jest.fn(),
-    },
-}))
-
-const { EasyflowSDK, PAYMENT_METHODS } = await import('./sdk.mjs')
-const { SecurityError, ValidationError, NetworkError } = await import(
-    './libs/errors.mjs'
-)
-const { callSecureApi } = await import('./libs/http.mjs')
-const { Sanitizer } = await import('./libs/sanitizer.mjs')
-const { findPaymentByMethod, isValidBankBilletPayment, isValidPixPayment } =
-    await import('./libs/utils.mjs')
-
-describe('EasyflowSDK', () => {
-    let sdk
-    let mockCallSecureApi
-
-    beforeEach(() => {
-        jest.clearAllMocks()
-        mockCallSecureApi = callSecureApi
-    })
-
-    describe('constructor', () => {
-        test('should create SDK instance with string businessId', () => {
-            sdk = new EasyflowSDK('test-business-id')
-            expect(sdk.config.businessId).toBe('test-business-id')
-        })
-
-        test('should create SDK instance with object config', () => {
-            sdk = new EasyflowSDK({ businessId: 'test-business-id' })
-            expect(sdk.config.businessId).toBe('test-business-id')
-        })
-
-        test('should throw SecurityError when businessId is missing', () => {
-            expect(() => new EasyflowSDK()).toThrow(SecurityError)
-            expect(() => new EasyflowSDK({})).toThrow(SecurityError)
-        })
-
-        test('should have correct static version', () => {
-            expect(EasyflowSDK.version).toBeDefined()
-            expect(EasyflowSDK.version).toMatch(/^\d+\.\d+\.\d+$/)
-        })
-    })
-
-    describe('getOffer', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation(
-                (input) => input || 'offer-123'
-            )
-        })
-
-        test('should successfully get offer', async () => {
-            const mockOffer = { id: 'offer-123', items: [{ id: 'item-1' }] }
-            mockCallSecureApi.mockResolvedValue({ data: mockOffer })
-
-            const result = await sdk.getOffer('offer-123')
-
-            expect(result).toEqual(mockOffer)
-            expect(mockCallSecureApi).toHaveBeenCalledWith(
-                'get-offer',
-                { offerId: 'offer-123' },
-                {}
-            )
-        })
-
-        test('should throw ValidationError for invalid offerId', async () => {
-            Sanitizer.sanitizeInput.mockReturnValue('')
-
-            await expect(sdk.getOffer('')).rejects.toThrow(ValidationError)
-        })
-
-        test('should throw NetworkError when API returns error', async () => {
-            mockCallSecureApi.mockResolvedValue({ error: 'API Error' })
-
-            await expect(sdk.getOffer('offer-123')).rejects.toThrow(
-                NetworkError
-            )
-        })
-
-        test('should throw ValidationError when offer not found', async () => {
-            mockCallSecureApi.mockResolvedValue({ data: null })
-
-            await expect(sdk.getOffer('offer-123')).rejects.toThrow(
-                ValidationError
-            )
-        })
-    })
-
-    describe('placeOrder', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation((input) => input)
-        })
-
-        test('should successfully place order', async () => {
-            const mockOffer = { id: 'offer-123', items: [{ id: 'item-1' }] }
-            const orderData = {
-                payments: [{ method: 'credit-card', numberInstallments: 1 }],
-            }
-            mockCallSecureApi
-                .mockResolvedValueOnce({ data: mockOffer })
-                .mockResolvedValueOnce({ data: { orderId: 'order-123' } })
-            const result = await sdk.placeOrder('offer-123', orderData)
-            expect(result).toBe('order-123')
-            expect(mockCallSecureApi).toHaveBeenCalledTimes(2)
-        })
-
-        test('should throw ValidationError for invalid offerId', async () => {
-            Sanitizer.sanitizeInput.mockReturnValue('')
-
-            await expect(sdk.placeOrder('', { payments: [] })).rejects.toThrow(
-                ValidationError
-            )
-        })
-
-        test('should throw ValidationError when offer has no items', async () => {
-            mockCallSecureApi.mockResolvedValue({ data: { items: [] } })
-
-            await expect(
-                sdk.placeOrder('offer-123', { payments: [] })
-            ).rejects.toThrow(ValidationError)
-        })
-    })
-
-    describe('getOrder', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation((input) => input)
-        })
-
-        test('should successfully get order', async () => {
-            const mockOrder = { id: 'order-123', status: 'pending' }
-            mockCallSecureApi.mockResolvedValue({ data: mockOrder })
-            const result = await sdk.getOrder('order-123', {
-                'x-fingerprint': 'test-fingerprint',
-            })
-            expect(result).toEqual(mockOrder)
-            expect(mockCallSecureApi).toHaveBeenCalledWith(
-                'get-order',
-                {
-                    orderId: 'order-123',
-                },
-                { 'x-fingerprint': 'test-fingerprint' }
-            )
-        })
-    })
-
-    describe('getBankBillet', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation((input) => input)
-        })
-
-        test('should successfully get bank billet', async () => {
-            const mockOrder = {
-                payments: [
-                    {
-                        method: 'bank-billet',
-                        bankBillet: { link: 'test-link' },
-                    },
-                ],
-            }
-
-            mockCallSecureApi.mockResolvedValue({ data: mockOrder })
-            findPaymentByMethod.mockReturnValue({
-                bankBillet: { link: 'test-link' },
-            })
-            isValidBankBilletPayment.mockReturnValue(true)
-
-            const result = await sdk.getBankBillet('order-123')
-
-            expect(result).toEqual({ link: 'test-link' })
-        })
-
-        test('should return null when bank billet not found', async () => {
-            const mockOrder = { payments: [] }
-            mockCallSecureApi.mockResolvedValue({ data: mockOrder })
-            findPaymentByMethod.mockReturnValue(null)
-
-            const result = await sdk.getBankBillet('order-123')
-
-            expect(result).toBeNull()
-        })
-
-        test('should throw ValidationError for invalid orderId', async () => {
-            Sanitizer.sanitizeInput.mockReturnValue('')
-
-            await expect(sdk.getBankBillet('')).rejects.toThrow(ValidationError)
-        })
-    })
-
-    describe('charge', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation(
-                (input) => input || 'test-business-id'
-            )
-        })
-
-        test('should successfully process charge', async () => {
-            const chargeData = {
-                items: [{ name: 'Product', price: 1000 }],
-                payments: [{ method: 'pix', numberInstallments: 1 }],
-            }
-            mockCallSecureApi.mockImplementation((target, payload) => {
-                if (target === 'charge') {
-                    if (!payload.businessId)
-                        payload.businessId = 'test-business-id'
-                    return Promise.resolve({ data: { orderId: 'order-123' } })
-                }
-                return Promise.resolve({})
-            })
-            const result = await sdk.charge(chargeData)
-            expect(result).toBe('order-123')
-            expect(mockCallSecureApi).toHaveBeenCalledWith(
-                'charge',
-                expect.objectContaining({
-                    businessId: 'test-business-id',
-                    items: chargeData.items,
-                    payments: chargeData.payments,
-                }),
-                {}
-            )
-        })
-
-        test('should throw NetworkError when API returns error', async () => {
-            const chargeData = {
-                items: [{ name: 'Product', price: 1000 }],
-                payments: [{ method: 'pix', numberInstallments: 1 }],
-            }
-
-            mockCallSecureApi.mockResolvedValue({ error: 'Charge failed' })
-
-            await expect(sdk.charge(chargeData)).rejects.toThrow(NetworkError)
-        })
-    })
-
-    describe('encrypt', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-        })
-
-        test('should successfully encrypt credit card', async () => {
-            const creditCard = {
-                cardNumber: '4111111111111111',
-                holderName: 'John Doe',
-                month: '12',
-                year: '2025',
-                cvv: '123',
-            }
-
-            mockCallSecureApi.mockResolvedValue({
-                data: { token: 'encrypted-token' },
-            })
-
-            const result = await sdk.encrypt(creditCard)
-
-            expect(result).toBe('encrypted-token')
-            expect(mockCallSecureApi).toHaveBeenCalledWith(
-                'encrypt',
-                creditCard,
-                {}
-            )
-        })
-
-        test('should throw NetworkError when API returns error', async () => {
-            const creditCard = {
-                cardNumber: '4111111111111111',
-                holderName: 'John Doe',
-                month: '12',
-                year: '2025',
-                cvv: '123',
-            }
-
-            mockCallSecureApi.mockResolvedValue({ error: 'Encryption failed' })
-
-            await expect(sdk.encrypt(creditCard)).rejects.toThrow(NetworkError)
-        })
-    })
-
-    describe('getPix', () => {
-        beforeEach(() => {
-            sdk = new EasyflowSDK('test-business-id')
-            Sanitizer.sanitizeInput.mockImplementation((input) => input)
-        })
-
-        it('should get PIX data for order with PIX payment', async () => {
-            const mockOrder = {
-                payments: [
-                    {
-                        method: 'pix',
-                        pix: {
-                            qrCode: 'base64-qr-code',
-                            copyAndPasteCode: 'pix-code',
-                        },
-                    },
-                ],
-            }
-
-            mockCallSecureApi.mockResolvedValue({ data: mockOrder })
-            findPaymentByMethod.mockReturnValue({
-                pix: {
-                    qrCode: 'base64-qr-code',
-                    copyAndPasteCode: 'pix-code',
-                },
-            })
-            isValidPixPayment.mockReturnValue(true)
-
-            const result = await sdk.getPix('order-123')
-
-            expect(result).toEqual({
-                qrCode: 'base64-qr-code',
-                copyAndPasteCode: 'pix-code',
-            })
-            expect(mockCallSecureApi).toHaveBeenCalledWith(
-                'get-order',
-                { orderId: 'order-123' },
-                {}
-            )
-        })
-
-        it('should return null for order without PIX payment', async () => {
-            const mockOrder = {
-                payments: [
-                    {
-                        method: 'credit-card',
-                        creditCard: { number: '4111111111111111' },
-                    },
-                ],
-            }
-
-            mockCallSecureApi.mockResolvedValue({ data: mockOrder })
-            findPaymentByMethod.mockReturnValue(null)
-
-            const result = await sdk.getPix('order-123')
-
-            expect(result).toBeNull()
-        })
-
-        it('should throw error for invalid order ID', async () => {
-            Sanitizer.sanitizeInput.mockReturnValue('')
-
-            await expect(sdk.getPix('')).rejects.toThrow('Invalid order ID')
-        })
-    })
-
-    describe('Customer Management', () => {
-        beforeEach(() => {
-            Sanitizer.sanitizeInput.mockImplementation((input) => {
-                if (input === 'test-business-id') {
-                    return 'test-business-id'
-                }
-                if (input === '' || input === null || input === undefined) {
-                    return ''
-                }
-                return input
-            })
-            sdk = new EasyflowSDK('test-business-id')
-        })
-
-        describe('createCustomer', () => {
-            it('should create a new customer successfully', async () => {
-                const customerData = {
-                    name: 'John Doe',
-                    email: 'john@example.com',
-                    document: { type: 'CPF', number: '12345678901' },
-                    phone: {
-                        areaCode: '+55',
-                        ddd: '11',
-                        number: '999999999',
-                        isMobile: true,
-                    },
-                }
-
-                const mockResponse = {
-                    data: {
-                        customer: {
-                            id: '550e8400-e29b-41d4-a716-446655440000',
-                            ...customerData,
-                            business: {
-                                id: 'business-123',
-                                name: 'Test Business',
-                            },
-                        },
-                    },
-                }
-
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                const result = await sdk.createCustomer(customerData)
-
-                expect(result).toEqual(mockResponse.data.customer)
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'create-customer',
-                    {
-                        ...customerData,
-                        businessId: 'test-business-id',
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error when customer data is missing', async () => {
-                await expect(sdk.createCustomer(null)).rejects.toThrow(
-                    'Customer data is required'
-                )
-                await expect(sdk.createCustomer('')).rejects.toThrow(
-                    'Customer data is required'
-                )
-            })
-
-            it('should throw error when API returns error', async () => {
-                mockCallSecureApi.mockResolvedValue({ error: 'API Error' })
-
-                await expect(
-                    sdk.createCustomer({ name: 'John' })
-                ).rejects.toThrow('API Error')
-            })
-        })
-
-        describe('getCustomer', () => {
-            it('should get customer by ID successfully', async () => {
-                const mockCustomer = {
-                    id: '550e8400-e29b-41d4-a716-446655440000',
-                    name: 'John Doe',
-                    email: 'john@example.com',
-                    document: {
-                        type: 'CPF',
-                        number: '12345678901',
-                    },
-                }
-
-                mockCallSecureApi.mockResolvedValue({
-                    data: { customer: mockCustomer },
-                })
-
-                const result = await sdk.getCustomer(
-                    '550e8400-e29b-41d4-a716-446655440000'
-                )
-
-                expect(result).toEqual(mockCustomer)
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'get-customer',
-                    {
-                        customerId: '550e8400-e29b-41d4-a716-446655440000',
-                        businessId: 'test-business-id',
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error for invalid customer ID', async () => {
-                Sanitizer.sanitizeInput.mockReturnValue('')
-
-                await expect(sdk.getCustomer('')).rejects.toThrow(
-                    'Invalid customer ID'
-                )
-            })
-
-            it('should throw error when customer not found', async () => {
-                mockCallSecureApi.mockResolvedValue({ data: null })
-
-                await expect(
-                    sdk.getCustomer('550e8400-e29b-41d4-a716-446655440000')
-                ).rejects.toThrow('Customer not found')
-            })
-        })
-
-        describe('updateCustomer', () => {
-            it('should update customer successfully', async () => {
-                const updateData = {
-                    name: 'John Updated',
-                    email: 'john.updated@example.com',
-                }
-
-                const mockResponse = { data: { updated: true } }
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                const result = await sdk.updateCustomer(
-                    '550e8400-e29b-41d4-a716-446655440000',
-                    updateData
-                )
-
-                expect(result).toEqual({ updated: true })
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'update-customer',
-                    {
-                        customerId: '550e8400-e29b-41d4-a716-446655440000',
-                        businessId: 'test-business-id',
-                        ...updateData,
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error for invalid customer ID', async () => {
-                Sanitizer.sanitizeInput.mockReturnValue('')
-
-                await expect(
-                    sdk.updateCustomer('', { name: 'John' })
-                ).rejects.toThrow('Invalid customer ID')
-            })
-
-            it('should throw error when update data is missing', async () => {
-                await expect(
-                    sdk.updateCustomer(
-                        '550e8400-e29b-41d4-a716-446655440000',
-                        null
-                    )
-                ).rejects.toThrow('Customer update data is required')
-            })
-        })
-    })
-
-    describe('Credit Card Management', () => {
-        beforeEach(() => {
-            Sanitizer.sanitizeInput.mockImplementation((input) => {
-                if (input === 'test-business-id') {
-                    return 'test-business-id'
-                }
-                if (input === '' || input === null || input === undefined) {
-                    return ''
-                }
-                return input
-            })
-            sdk = new EasyflowSDK('test-business-id')
-        })
-
-        describe('addCreditCard', () => {
-            it('should add credit card successfully', async () => {
-                const mockResponse = {
-                    data: {
-                        creditCardId: 'card-123',
-                        creditCard: { creditCardId: 'card-123' },
-                    },
-                }
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                const result = await sdk.addCreditCard(
-                    'customer-1234567890123456',
-                    'encrypted-token-456'
-                )
-
-                expect(result).toEqual({ creditCardId: 'card-123' })
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'add-credit-card',
-                    {
-                        customerId: 'customer-1234567890123456',
-                        businessId: 'test-business-id',
-                        creditCardToken: 'encrypted-token-456',
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error for invalid customer ID', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(sdk.addCreditCard('', 'token')).rejects.toThrow(
-                    'Invalid customer ID'
-                )
-            })
-
-            it('should throw error for invalid credit card token', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '550e8400-e29b-41d4-a716-446655440000')
-                        return '550e8400-e29b-41d4-a716-446655440000'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(
-                    sdk.addCreditCard(
-                        '550e8400-e29b-41d4-a716-446655440000',
-                        ''
-                    )
-                ).rejects.toThrow('Invalid credit card token')
-            })
-
-            it('should throw error when API returns error', async () => {
-                mockCallSecureApi.mockResolvedValue({ error: 'API Error' })
-
-                await expect(
-                    sdk.addCreditCard(
-                        '550e8400-e29b-41d4-a716-446655440000',
-                        'token'
-                    )
-                ).rejects.toThrow('API Error')
-            })
-        })
-
-        describe('removeCreditCard', () => {
-            it('should remove credit card successfully', async () => {
-                const mockResponse = { data: { removed: true } }
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                const result = await sdk.removeCreditCard(
-                    '550e8400-e29b-41d4-a716-446655440000',
-                    'card-456'
-                )
-
-                expect(result).toEqual({ removed: true })
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'delete-credit-card',
-                    {
-                        customerId: '550e8400-e29b-41d4-a716-446655440000',
-                        businessId: 'test-business-id',
-                        creditCardId: 'card-456',
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error for invalid customer ID', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(
-                    sdk.removeCreditCard('', 'card-456')
-                ).rejects.toThrow('Invalid customer ID')
-            })
-
-            it('should throw error for invalid credit card ID', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '550e8400-e29b-41d4-a716-446655440000')
-                        return '550e8400-e29b-41d4-a716-446655440000'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(
-                    sdk.removeCreditCard(
-                        '550e8400-e29b-41d4-a716-446655440000',
-                        ''
-                    )
-                ).rejects.toThrow('Invalid credit card ID')
-            })
-        })
-
-        describe('getCreditCard', () => {
-            it('should get credit card successfully', async () => {
-                const mockResponse = {
-                    data: {
-                        creditCard: {
-                            creditCardId: 'card-456',
-                            brand: 'Visa',
-                            last4Numbers: '1111',
-                            expiresAtMonth: '12',
-                            expiresAtYear: '2025',
-                        },
-                    },
-                }
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                const result = await sdk.getCreditCard(
-                    '550e8400-e29b-41d4-a716-446655440000',
-                    'card-456'
-                )
-
-                expect(result).toEqual({
-                    creditCardId: 'card-456',
-                    brand: 'Visa',
-                    last4Numbers: '1111',
-                    expiresAtMonth: '12',
-                    expiresAtYear: '2025',
-                })
-                expect(mockCallSecureApi).toHaveBeenCalledWith(
-                    'get-credit-card',
-                    {
-                        customerId: '550e8400-e29b-41d4-a716-446655440000',
-                        businessId: 'test-business-id',
-                        creditCardId: 'card-456',
-                    },
-                    {}
-                )
-            })
-
-            it('should throw error for invalid customer ID', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(sdk.getCreditCard('', 'card-456')).rejects.toThrow(
-                    'Invalid customer ID'
-                )
-            })
-
-            it('should throw error for invalid credit card ID', async () => {
-                Sanitizer.sanitizeInput.mockImplementation((input) => {
-                    if (input === 'test-business-id') return 'test-business-id'
-                    if (input === '550e8400-e29b-41d4-a716-446655440000')
-                        return '550e8400-e29b-41d4-a716-446655440000'
-                    if (input === '') return ''
-                    return input
-                })
-
-                await expect(
-                    sdk.getCreditCard(
-                        '550e8400-e29b-41d4-a716-446655440000',
-                        ''
-                    )
-                ).rejects.toThrow('Invalid credit card ID')
-            })
-
-            it('should throw error when credit card not found', async () => {
-                const mockResponse = { data: null }
-                mockCallSecureApi.mockResolvedValue(mockResponse)
-
-                await expect(
-                    sdk.getCreditCard('customer-1234567890123456', 'card-456')
-                ).rejects.toThrow('Credit card not found')
-            })
-        })
-    })
-
-    describe('PAYMENT_METHODS', () => {
-        test('should export payment methods constants', () => {
-            expect(PAYMENT_METHODS).toBeDefined()
-            expect(PAYMENT_METHODS.CREDIT_CARD).toBe('credit-card')
-            expect(PAYMENT_METHODS.PIX).toBe('pix')
-            expect(PAYMENT_METHODS.BANK_BILLET).toBe('bank-billet')
-        })
-    })
-})