From dfdccc21e6f6cb0e0c07e58c53d3a79e02532f2a Mon Sep 17 00:00:00 2001
From: sunil-lakshman <104969541+sunil-lakshman@users.noreply.github.com>
Date: Fri, 31 Oct 2025 13:21:26 +0530
Subject: [PATCH] chore: Added unit testcases

---
 test/api-error.spec.ts                        | 209 ++++++++++++++++
 test/contentstack-core.spec.ts                |   5 +
 test/request.spec.ts                          |  30 +++
 .../retryPolicy/delivery-sdk-handlers.spec.ts | 226 ++++++++++++++++++
 4 files changed, 470 insertions(+)
 create mode 100644 test/api-error.spec.ts

diff --git a/test/api-error.spec.ts b/test/api-error.spec.ts
new file mode 100644
index 0000000..5c765a6
--- /dev/null
+++ b/test/api-error.spec.ts
@@ -0,0 +1,209 @@
+import { APIError } from '../src/lib/api-error';
+
+describe('APIError', () => {
+  describe('constructor', () => {
+    it('should create an APIError with all properties', () => {
+      const error = new APIError('Test error', 'ERROR_CODE', 404);
+      
+      expect(error.message).toBe('Test error');
+      expect(error.error_code).toBe('ERROR_CODE');
+      expect(error.status).toBe(404);
+      expect(error.error_message).toBe('Test error');
+      expect(error.name).toBe('APIError');
+      expect(error.stack).toBeUndefined();
+    });
+
+    it('should create an APIError with numeric error_code', () => {
+      const error = new APIError('Test error', 500, 500);
+      
+      expect(error.error_code).toBe(500);
+      expect(error.status).toBe(500);
+    });
+  });
+
+  describe('fromAxiosError', () => {
+    it('should create APIError from axios error with response data', () => {
+      const axiosError = {
+        response: {
+          data: {
+            error_message: 'Not Found',
+            error_code: 404,
+          },
+          status: 404,
+        },
+      };
+
+      const error = APIError.fromAxiosError(axiosError);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Not Found');
+      expect(error.error_code).toBe(404);
+      expect(error.status).toBe(404);
+    });
+
+    it('should create APIError from axios error with message but no response', () => {
+      const axiosError = {
+        message: 'Network Error',
+        code: 'ENOTFOUND',
+      };
+
+      const error = APIError.fromAxiosError(axiosError);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Network Error');
+      expect(error.error_code).toBe('ENOTFOUND');
+      expect(error.status).toBe(0);
+    });
+
+    it('should create APIError from axios error with message but no code', () => {
+      const axiosError = {
+        message: 'Network Error',
+      };
+
+      const error = APIError.fromAxiosError(axiosError);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Network Error');
+      expect(error.error_code).toBe('NETWORK_ERROR');
+      expect(error.status).toBe(0);
+    });
+
+    it('should create APIError with default message for unknown errors', () => {
+      const axiosError = {};
+
+      const error = APIError.fromAxiosError(axiosError);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Unknown error occurred');
+      expect(error.error_code).toBe('UNKNOWN_ERROR');
+      expect(error.status).toBe(0);
+    });
+
+    it('should handle axios error with response.data but no response.status', () => {
+      const axiosError = {
+        response: {
+          data: {
+            error_message: 'Server Error',
+          },
+        },
+      };
+
+      // This should call fromResponseData, which requires status
+      // Let's test with a proper status
+      const axiosErrorWithStatus = {
+        response: {
+          data: {
+            error_message: 'Server Error',
+          },
+          status: 500,
+        },
+      };
+
+      const error = APIError.fromAxiosError(axiosErrorWithStatus);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Server Error');
+      expect(error.status).toBe(500);
+    });
+  });
+
+  describe('fromResponseData', () => {
+    it('should create APIError from response data with error_message', () => {
+      const responseData = {
+        error_message: 'Bad Request',
+        error_code: 400,
+      };
+
+      const error = APIError.fromResponseData(responseData, 400);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Bad Request');
+      expect(error.error_code).toBe(400);
+      expect(error.status).toBe(400);
+    });
+
+    it('should create APIError from response data with message fallback', () => {
+      const responseData = {
+        message: 'Internal Server Error',
+        code: 500,
+      };
+
+      const error = APIError.fromResponseData(responseData, 500);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Internal Server Error');
+      expect(error.error_code).toBe(500);
+      expect(error.status).toBe(500);
+    });
+
+    it('should create APIError from response data with error fallback', () => {
+      const responseData = {
+        error: 'Validation Error',
+        code: 422,
+      };
+
+      const error = APIError.fromResponseData(responseData, 422);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Validation Error');
+      expect(error.error_code).toBe(422);
+      expect(error.status).toBe(422);
+    });
+
+    it('should create APIError from string response data', () => {
+      const responseData = 'Plain text error message';
+
+      const error = APIError.fromResponseData(responseData, 500);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Plain text error message');
+      expect(error.error_code).toBe(500);
+      expect(error.status).toBe(500);
+    });
+
+    it('should create APIError with default message when no error fields present', () => {
+      const responseData = {
+        someOtherField: 'value',
+      };
+
+      const error = APIError.fromResponseData(responseData, 500);
+
+      expect(error).toBeInstanceOf(APIError);
+      expect(error.error_message).toBe('Request failed');
+      expect(error.error_code).toBe(500);
+      expect(error.status).toBe(500);
+    });
+
+    it('should extract error_code from response data', () => {
+      const responseData = {
+        error_message: 'Error',
+        error_code: 999,
+      };
+
+      const error = APIError.fromResponseData(responseData, 500);
+
+      expect(error.error_code).toBe(999);
+    });
+
+    it('should extract code from response data when error_code not present', () => {
+      const responseData = {
+        error_message: 'Error',
+        code: 888,
+      };
+
+      const error = APIError.fromResponseData(responseData, 500);
+
+      expect(error.error_code).toBe(888);
+    });
+
+    it('should use status as error_code fallback', () => {
+      const responseData = {
+        error_message: 'Error',
+      };
+
+      const error = APIError.fromResponseData(responseData, 503);
+
+      expect(error.error_code).toBe(503);
+    });
+  });
+});
diff --git a/test/contentstack-core.spec.ts b/test/contentstack-core.spec.ts
index 3767561..1cfd3ab 100644
--- a/test/contentstack-core.spec.ts
+++ b/test/contentstack-core.spec.ts
@@ -150,6 +150,9 @@ describe('contentstackCore', () => {
 
   describe('config.onError', () => {
     it('should call the onError function when an error occurs', async () => {
+      // Suppress expected console.error from network error
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      
       const onError = jest.fn();
       const options = {
         defaultHostname: 'cdn.contentstack.io',
@@ -163,6 +166,8 @@ describe('contentstackCore', () => {
       } catch (error: unknown) {
         expect(onError).toBeCalledWith(error);
       }
+      
+      consoleErrorSpy.mockRestore();
     });
 
     it('should not call the onError function when no error occurs', async () => {
diff --git a/test/request.spec.ts b/test/request.spec.ts
index 40a9ec2..1214497 100644
--- a/test/request.spec.ts
+++ b/test/request.spec.ts
@@ -344,4 +344,34 @@ describe('Request tests', () => {
     const result = await getData(client, url, requestData);
     expect(result).toEqual(mockResponse);
   });
+
+  it('should use instance.request when URL length exceeds 2000 characters', async () => {
+    const client = httpClient({ defaultHostname: 'example.com' });
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+    
+    // Create a very long query parameter that will exceed 2000 characters when combined with baseURL
+    // baseURL is typically like 'https://example.com:443/v3' (~30 chars), url is '/your-api-endpoint' (~20 chars)
+    // So we need params that serialize to >1950 chars to exceed 2000 total
+    const longParam = 'x'.repeat(2000);
+    const requestData = { params: { longParam, param2: 'y'.repeat(500) } };
+    
+    // Mock instance.request since that's what gets called for long URLs
+    const requestSpy = jest.spyOn(client, 'request').mockResolvedValue({ data: mockResponse } as any);
+
+    const result = await getData(client, url, requestData);
+    
+    expect(result).toEqual(mockResponse);
+    // Verify that request was called (not get) with the full URL
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'get',
+        url: expect.stringMatching(/longParam/),
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+      })
+    );
+    
+    requestSpy.mockRestore();
+  });
 });
diff --git a/test/retryPolicy/delivery-sdk-handlers.spec.ts b/test/retryPolicy/delivery-sdk-handlers.spec.ts
index d0e8599..659cfe8 100644
--- a/test/retryPolicy/delivery-sdk-handlers.spec.ts
+++ b/test/retryPolicy/delivery-sdk-handlers.spec.ts
@@ -335,6 +335,135 @@ describe('retryResponseErrorHandler', () => {
     jest.useRealTimers();
   });
 
+  it('should use default retryDelay (300ms) when retryDelay is explicitly undefined', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1 },
+      response: {
+        status: 429,
+        statusText: 'Rate limit exceeded',
+        headers: {},
+        data: {
+          error_message: 'Rate limit exceeded',
+          error_code: 429,
+          errors: null,
+        },
+      },
+    };
+    const config = { retryLimit: 3, retryDelay: undefined }; // Explicitly undefined
+    const client = axios.create();
+
+    mock.onAny().reply(200, { success: true });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+
+    // Fast-forward time by the default delay (300ms) - fallback from undefined
+    jest.advanceTimersByTime(300);
+
+    const response = (await responsePromise) as AxiosResponse;
+    expect(response.status).toBe(200);
+
+    jest.useRealTimers();
+  });
+
+  it('should use default retryDelay (300ms) when retryDelay is null', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1 },
+      response: {
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: {},
+        data: {
+          error_message: 'Unauthorized',
+          error_code: 401,
+          errors: null,
+        },
+      },
+    };
+    const config = { retryLimit: 3, retryDelay: null as any }; // null retryDelay
+    const client = axios.create();
+
+    mock.onAny().reply(200, { success: true });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+
+    // Fast-forward time by the default delay (300ms) - fallback from null
+    jest.advanceTimersByTime(300);
+
+    const response = (await responsePromise) as AxiosResponse;
+    expect(response.status).toBe(200);
+
+    jest.useRealTimers();
+  });
+
+  it('should use default delay in retry function when retryDelay is 0', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1, method: 'get', url: '/test' },
+      response: {
+        status: 500,
+        headers: {},
+        data: {
+          error_message: 'Server Error',
+          error_code: 500,
+          errors: null,
+        },
+      },
+    };
+    const retryCondition = jest.fn().mockReturnValue(true);
+    const config = { retryLimit: 3, retryCondition, retryDelay: 0 }; // 0 is falsy, should use fallback
+    const client = axios.create();
+
+    mock.onAny().reply(200, { success: true });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+
+    // Fast-forward time by default delay (300ms) - 0 is falsy, should use fallback
+    jest.advanceTimersByTime(300);
+
+    const response = (await responsePromise) as AxiosResponse;
+    expect(response.status).toBe(200);
+    expect(retryCondition).toHaveBeenCalledWith(error);
+
+    jest.useRealTimers();
+  });
+
+  it('should use config.retryDelay when retryDelay parameter is 0 in retry function', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1, method: 'get', url: '/test' },
+      response: {
+        status: 500,
+        headers: {},
+        data: {
+          error_message: 'Server Error',
+          error_code: 500,
+          errors: null,
+        },
+      },
+    };
+    const retryCondition = jest.fn().mockReturnValue(true);
+    const config = { retryLimit: 3, retryCondition, retryDelay: 500 }; // config has retryDelay
+    const client = axios.create();
+
+    mock.onAny().reply(200, { success: true });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+
+    // Fast-forward time by config.retryDelay (500ms)
+    jest.advanceTimersByTime(500);
+
+    const response = (await responsePromise) as AxiosResponse;
+    expect(response.status).toBe(200);
+
+    jest.useRealTimers();
+  });
+
   it('should retry when retryCondition is true', async () => {
     const error = {
       config: { retryOnError: true, retryCount: 1 },
@@ -749,6 +878,103 @@ describe('retryResponseErrorHandler', () => {
     jest.useRealTimers();
   });
 
+  it('should reject promise when retry fails for 429 status with retry-after header', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1, method: 'get', url: '/test' },
+      response: {
+        status: 429,
+        headers: {
+          'x-ratelimit-remaining': '0',
+          'retry-after': '1',
+        },
+        data: {
+          error_message: 'Rate limit exceeded',
+          error_code: 429,
+          errors: null,
+        },
+      },
+    };
+    const config = { retryLimit: 3 };
+    const client = axios.create();
+
+    // Mock the retry request to fail
+    mock.onGet('/test').reply(() => {
+      throw new Error('Retry failed');
+    });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+    jest.advanceTimersByTime(1000);
+
+    await expect(responsePromise).rejects.toThrow('Retry failed');
+
+    jest.useRealTimers();
+  });
+
+  it('should reject promise when retry fails for 401/429 status with retryDelay', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1, method: 'get', url: '/test' },
+      response: {
+        status: 401,
+        headers: {},
+        data: {
+          error_message: 'Unauthorized',
+          error_code: 401,
+          errors: null,
+        },
+      },
+    };
+    const config = { retryLimit: 3, retryDelay: 100 };
+    const client = axios.create();
+
+    // Mock the retry request to fail
+    mock.onGet('/test').reply(() => {
+      throw new Error('Retry authentication failed');
+    });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+    jest.advanceTimersByTime(100);
+
+    await expect(responsePromise).rejects.toThrow('Retry authentication failed');
+
+    jest.useRealTimers();
+  });
+
+  it('should reject promise when retry fails in retryCondition path', async () => {
+    const error = {
+      config: { retryOnError: true, retryCount: 1, method: 'get', url: '/test' },
+      response: {
+        status: 500,
+        headers: {},
+        data: {
+          error_message: 'Server Error',
+          error_code: 500,
+          errors: null,
+        },
+      },
+    };
+    const retryCondition = jest.fn().mockReturnValue(true);
+    const config = { retryLimit: 3, retryCondition, retryDelay: 100 };
+    const client = axios.create();
+
+    // Mock the retry request to fail
+    mock.onGet('/test').reply(() => {
+      throw new Error('Retry server error failed');
+    });
+
+    jest.useFakeTimers();
+
+    const responsePromise = retryResponseErrorHandler(error, config, client);
+    jest.advanceTimersByTime(100);
+
+    await expect(responsePromise).rejects.toThrow('Retry server error failed');
+
+    jest.useRealTimers();
+  });
+
   it('should reject with original error when 429/401 response has no data', async () => {
     const error = {
       config: { retryOnError: true, retryCount: 5 },