@easyflow/javascript-sdk 2.1.8 → 2.1.9

package/libs/http.spec.js

@@ -1,427 +0,0 @@
-import { jest } from '@jest/globals'
-
-// Mock dependencies ESM-safe
-await jest.unstable_mockModule('./utils.mjs', () => ({
-    buildApiUrl: jest.fn(),
-    getBrowserFingerprint: jest.fn(() => 'mock-fingerprint-123'),
-}))
-
-await jest.unstable_mockModule('./exception-handler.mjs', () => ({
-    throwsError: jest.fn((error) => {
-        throw error
-    }),
-}))
-
-await jest.unstable_mockModule('./security.mjs', () => ({
-    SecureFetch: {
-        request: jest.fn(),
-    },
-}))
-
-await jest.unstable_mockModule('./errors.mjs', () => ({
-    NetworkError: jest.fn().mockImplementation((message) => ({
-        name: 'NetworkError',
-        message,
-        code: 'NETWORK_ERROR',
-    })),
-    SecurityError: jest.fn().mockImplementation((message) => ({
-        name: 'SecurityError',
-        message,
-        code: 'SECURITY_VIOLATION',
-    })),
-    ValidationError: jest.fn().mockImplementation((message) => ({
-        name: 'ValidationError',
-        message,
-        code: 'VALIDATION_ERROR',
-    })),
-}))
-
-await jest.unstable_mockModule('./constants.mjs', () => ({
-    DEFAULT_CONFIG: {
-        baseUrl: 'https://api.example.com',
-    },
-    HTTP_REQUEST_METHODS: {
-        POST: 'POST',
-    },
-    TARGETS: {
-        CHARGE: 'charge',
-        PLACE_ORDER: 'place-order',
-        ENCRYPT: 'encrypt',
-        GET_OFFER: 'get-offer',
-        GET_ORDER: 'get-order',
-    },
-}))
-
-const { callSecureApi } = await import('./http.mjs')
-const { buildApiUrl } = await import('./utils.mjs')
-const { SecureFetch } = await import('./security.mjs')
-const { throwsError } = await import('./exception-handler.mjs')
-
-describe('HTTP Module', () => {
-    let mockBuildApiUrl
-    let mockSecureFetchRequest
-    let mockThrowsError
-
-    beforeEach(() => {
-        jest.clearAllMocks()
-        mockBuildApiUrl = buildApiUrl
-        mockSecureFetchRequest = SecureFetch.request
-        mockThrowsError = throwsError
-    })
-
-    describe('callSecureApi', () => {
-        test('should make GET request for get-offer target', async () => {
-            const mockResponse = { data: { id: 'offer-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=get-offer&offerId=123'
-            )
-
-            const result = await callSecureApi('get-offer', { offerId: '123' })
-
-            expect(result).toEqual(mockResponse)
-            expect(mockBuildApiUrl).toHaveBeenCalledWith(
-                'https://api.example.com',
-                'get-offer',
-                { offerId: '123' }
-            )
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=get-offer&offerId=123',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                }
-            )
-        })
-
-        test('should make GET request for get-order target', async () => {
-            const mockResponse = { data: { id: 'order-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=get-order&orderId=123'
-            )
-
-            const result = await callSecureApi('get-order', { orderId: '123' })
-
-            expect(result).toEqual(mockResponse)
-            expect(mockBuildApiUrl).toHaveBeenCalledWith(
-                'https://api.example.com',
-                'get-order',
-                { orderId: '123' }
-            )
-        })
-
-        test('should make POST request for other targets', async () => {
-            const mockResponse = { data: { orderId: 'order-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            const payload = { businessId: '123', amount: 1000 }
-            const result = await callSecureApi('charge', payload, {
-                'Content-Type': 'application/json',
-            })
-
-            expect(result).toEqual(mockResponse)
-            expect(mockBuildApiUrl).toHaveBeenCalledWith(
-                'https://api.example.com',
-                'charge'
-            )
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'x-fingerprint-id': 'mock-fingerprint-123',
-                    },
-                    body: JSON.stringify(payload),
-                }
-            )
-        })
-
-        test('should handle API error responses', async () => {
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue({ error: 'API Error' }),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-            await expect(callSecureApi('charge', {})).resolves.toEqual({
-                error: 'API Error',
-            })
-        })
-
-        test('should handle network errors', async () => {
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue({
-                    error: 'Network error: Network timeout',
-                }),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-            await expect(callSecureApi('charge', {})).resolves.toEqual({
-                error: 'Network error: Network timeout',
-            })
-        })
-
-        test('should handle known SDK errors', async () => {
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest
-                    .fn()
-                    .mockResolvedValue({ error: 'Security violation' }),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-            await expect(callSecureApi('charge', {})).resolves.toEqual({
-                error: 'Security violation',
-            })
-        })
-
-        test('should handle validation errors', async () => {
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue({ error: 'Invalid input' }),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-            await expect(callSecureApi('charge', {})).resolves.toEqual({
-                error: 'Invalid input',
-            })
-        })
-
-        test('should handle network errors from SecureFetch', async () => {
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue({
-                    error: 'HTTP 500: Internal Server Error',
-                }),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-            await expect(callSecureApi('charge', {})).resolves.toEqual({
-                error: 'HTTP 500: Internal Server Error',
-            })
-        })
-
-        test('should pass headers to SecureFetch', async () => {
-            const mockResponse = { data: { orderId: 'order-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            const customHeaders = { 'Content-Type': 'application/json' }
-            const result = await callSecureApi(
-                'charge',
-                { amount: 1000 },
-                customHeaders
-            )
-
-            expect(result).toEqual(mockResponse)
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: {
-                        ...customHeaders,
-                        'x-fingerprint-id': 'mock-fingerprint-123',
-                    },
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-
-        test('should handle empty headers', async () => {
-            const mockResponse = { data: { success: true } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            await callSecureApi('charge', { amount: 1000 }, {})
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-
-        test('should handle undefined headers', async () => {
-            const mockResponse = { data: { success: true } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            await callSecureApi('charge', { amount: 1000 })
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-
-        test('should handle complex payload objects', async () => {
-            const mockResponse = { data: { orderId: 'order-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=place-order'
-            )
-
-            const complexPayload = {
-                businessId: 'business-123',
-                payments: [
-                    {
-                        method: 'credit-card',
-                        creditCard: {
-                            cardNumber: '4111111111111111',
-                            holderName: 'John Doe',
-                            month: '12',
-                            year: '2025',
-                            cvv: '123',
-                        },
-                        numberInstallments: 1,
-                    },
-                ],
-                buyer: {
-                    name: 'John Doe',
-                    email: 'john@example.com',
-                },
-            }
-
-            await callSecureApi('place-order', complexPayload)
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=place-order',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                    body: JSON.stringify(complexPayload),
-                }
-            )
-        })
-
-        test('should handle empty payload for GET requests', async () => {
-            const mockResponse = { data: { id: 'offer-123' } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=get-offer'
-            )
-
-            await callSecureApi('get-offer', {})
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=get-offer',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                }
-            )
-        })
-
-        test('should generate fingerprint when not provided in headers', async () => {
-            const mockResponse = { data: { success: true } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            // Call without fingerprint header
-            await callSecureApi('charge', { amount: 1000 })
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'mock-fingerprint-123' },
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-
-        test('should preserve custom fingerprint when provided', async () => {
-            const mockResponse = { data: { success: true } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            // Call with custom fingerprint header
-            const customHeaders = {
-                'x-fingerprint-id': 'custom-fingerprint-456',
-            }
-            await callSecureApi('charge', { amount: 1000 }, customHeaders)
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: { 'x-fingerprint-id': 'custom-fingerprint-456' },
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-
-        test('should handle fingerprint generation failure gracefully', async () => {
-            // Mock fingerprint generation to fail
-            const mockUtils = await import('./utils.mjs')
-            jest.spyOn(mockUtils, 'getBrowserFingerprint').mockImplementation(
-                () => {
-                    throw new Error('Fingerprint generation failed')
-                }
-            )
-
-            const mockResponse = { data: { success: true } }
-            mockSecureFetchRequest.mockResolvedValue({
-                json: jest.fn().mockResolvedValue(mockResponse),
-            })
-            mockBuildApiUrl.mockReturnValue(
-                'https://api.example.com/api/proxy?target=charge'
-            )
-
-            // Should still work without fingerprint
-            await callSecureApi('charge', { amount: 1000 })
-
-            expect(mockSecureFetchRequest).toHaveBeenCalledWith(
-                'https://api.example.com/api/proxy?target=charge',
-                {
-                    method: 'POST',
-                    headers: {},
-                    body: JSON.stringify({ amount: 1000 }),
-                }
-            )
-        })
-    })
-})