@easyflow/javascript-sdk 2.1.7

package/sdk.spec.js

@@ -0,0 +1,796 @@
+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')
+        })
+    })
+})