@easyflow/javascript-sdk 2.1.7

package/libs/http.spec.js

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