improve coverage reports

Author: harshitha-cstk

test/unit/base-query.spec.ts

@@ -1,4 +1,8 @@
 import { BaseQuery } from '../../src/lib/base-query';
+import { httpClient, AxiosInstance } from '@contentstack/core';
+import { MOCK_CLIENT_OPTIONS } from '../utils/constant';
+import MockAdapter from 'axios-mock-adapter';
+import { entryFindMock } from '../utils/mocks';
 
 describe('BaseQuery class', () => {
   let baseQuery: BaseQuery;
@@ -69,4 +73,95 @@ describe('BaseQuery class', () => {
     baseQuery.removeParam('key2');
     expect(baseQuery._queryParams).toEqual({ key1: 'value1' });
   });
+});
+
+class TestableBaseQuery extends BaseQuery {
+  constructor(client: AxiosInstance, urlPath: string) {
+    super();
+    this._client = client;
+    this._urlPath = urlPath;
+    this._variants = '';
+  }
+
+  setVariants(variants: string) {
+    this._variants = variants;
+  }
+
+  setParameters(params: any) {
+    this._parameters = params;
+  }
+}
+
+describe('BaseQuery find method', () => {
+  let client: AxiosInstance;
+  let mockClient: MockAdapter;
+  let query: TestableBaseQuery;
+
+  beforeAll(() => {
+    client = httpClient(MOCK_CLIENT_OPTIONS);
+    mockClient = new MockAdapter(client as any);
+  });
+
+  beforeEach(() => {
+    query = new TestableBaseQuery(client, '/content_types/test_uid/entries');
+    mockClient.reset();
+  });
+
+  it('should call find with encode parameter true', async () => {
+    mockClient.onGet('/content_types/test_uid/entries').reply(200, entryFindMock);
+    
+    query.setParameters({ title: 'Test' });
+    const result = await query.find(true);
+    
+    expect(result).toEqual(entryFindMock);
+  });
+
+  it('should call find without parameters', async () => {
+    mockClient.onGet('/content_types/test_uid/entries').reply(200, entryFindMock);
+    
+    const result = await query.find();
+    
+    expect(result).toEqual(entryFindMock);
+  });
+
+  it('should call find with variants header when variants are set', async () => {
+    mockClient.onGet('/content_types/test_uid/entries').reply((config) => {
+      expect(config.headers?.['x-cs-variant-uid']).toBe('variant1,variant2');
+      return [200, entryFindMock];
+    });
+    
+    query.setVariants('variant1,variant2');
+    await query.find();
+  });
+
+  it('should extract content type UID from URL path', async () => {
+    mockClient.onGet('/content_types/my_content_type/entries').reply(200, entryFindMock);
+    
+    const queryWithContentType = new TestableBaseQuery(client, '/content_types/my_content_type/entries');
+    const result = await queryWithContentType.find();
+    
+    expect(result).toEqual(entryFindMock);
+  });
+
+  it('should return null for content type UID when URL does not match pattern', async () => {
+    mockClient.onGet('/assets').reply(200, entryFindMock);
+    
+    const queryWithoutContentType = new TestableBaseQuery(client, '/assets');
+    const result = await queryWithoutContentType.find();
+    
+    expect(result).toEqual(entryFindMock);
+  });
+
+  it('should handle find with both encode and variants', async () => {
+    mockClient.onGet('/content_types/test_uid/entries').reply((config) => {
+      expect(config.headers?.['x-cs-variant-uid']).toBe('test-variant');
+      return [200, entryFindMock];
+    });
+    
+    query.setVariants('test-variant');
+    query.setParameters({ status: 'published' });
+    const result = await query.find(true);
+    
+    expect(result).toEqual(entryFindMock);
+  });
 }); 

test/unit/contentstack.spec.ts

@@ -3,6 +3,7 @@ import * as core from "@contentstack/core";
 import * as Contentstack from "../../src/lib/contentstack";
 import { Stack } from "../../src/lib/stack";
 import { Policy, Region, StackConfig } from "../../src/lib/types";
+import { StorageType } from "../../src/persistance/types/storage-type";
 import {
   CUSTOM_HOST,
   DUMMY_URL,
@@ -401,4 +402,261 @@ describe("Contentstack", () => {
       getHostforRegionSpy.mockRestore();
     });
   });
+
+  describe('locale configuration', () => {
+    it('should set locale in params when locale is provided in config', () => {
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        locale: "fr-fr",
+      };
+      
+      const stackInstance = createStackInstance(config);
+      
+      expect(stackInstance).toBeInstanceOf(Stack);
+      expect(stackInstance.config.locale).toEqual("fr-fr");
+    });
+  });
+
+  describe('live preview configuration in browser environment', () => {
+    const originalDocument = global.document;
+    const originalWindow = global.window;
+
+    beforeEach(() => {
+      // Mock browser environment
+      (utils.isBrowser as jest.Mock) = jest.fn();
+      delete (global as any).document;
+      delete (global as any).window;
+    });
+
+    afterEach(() => {
+      global.document = originalDocument;
+      global.window = originalWindow;
+      jest.restoreAllMocks();
+    });
+
+    it('should extract live_preview params from URL in browser environment', () => {
+      const isBrowserSpy = jest.spyOn(utils, 'isBrowser').mockReturnValue(true);
+      
+      // Mock document.location
+      const mockSearchParams = new Map([
+        ['live_preview', 'test_hash'],
+        ['release_id', 'release123'],
+        ['preview_timestamp', '123456789']
+      ]);
+      
+      (global as any).document = {
+        location: {
+          toString: () => 'http://localhost?live_preview=test_hash&release_id=release123&preview_timestamp=123456789'
+        }
+      };
+
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        live_preview: {
+          enable: true,
+          live_preview: 'default_hash'
+        },
+      };
+      
+      const stackInstance = createStackInstance(config);
+      
+      expect(isBrowserSpy).toHaveBeenCalled();
+      expect(stackInstance).toBeInstanceOf(Stack);
+      
+      isBrowserSpy.mockRestore();
+    });
+
+    it('should not extract params when not in browser environment', () => {
+      const isBrowserSpy = jest.spyOn(utils, 'isBrowser').mockReturnValue(false);
+      
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        live_preview: {
+          enable: true,
+        },
+      };
+      
+      const stackInstance = createStackInstance(config);
+      
+      expect(isBrowserSpy).toHaveBeenCalled();
+      expect(stackInstance).toBeInstanceOf(Stack);
+      
+      isBrowserSpy.mockRestore();
+    });
+  });
+
+  describe('cache adapter configuration', () => {
+    it('should set cache adapter when cacheOptions with policy is provided', () => {
+      const mockAdapter = jest.fn();
+      const mockClient = {
+        defaults: {
+          host: HOST_URL,
+          adapter: mockAdapter,
+        },
+        interceptors: {
+          request: {
+            use: reqInterceptor,
+          },
+          response: {
+            use: resInterceptor,
+          },
+        },
+      };
+
+      createHttpClientMock.mockReturnValue(mockClient as any);
+
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        cacheOptions: {
+          policy: Policy.CACHE_THEN_NETWORK,
+          storeType: 'localStorage' as StorageType
+        },
+      };
+      
+      const stackInstance = createStackInstance(config);
+      
+      expect(stackInstance).toBeInstanceOf(Stack);
+      expect(mockClient.defaults.adapter).toBeDefined();
+    });
+  });
+
+  describe('debug mode with logging interceptors', () => {
+    it('should add request and response logging interceptors when debug is enabled', () => {
+      const mockLogHandler = jest.fn();
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        debug: true,
+        logHandler: mockLogHandler,
+      };
+      
+      const stackInstance = createStackInstance(config);
+      
+      expect(stackInstance).toBeInstanceOf(Stack);
+      expect(reqInterceptor).toHaveBeenCalled();
+      expect(resInterceptor).toHaveBeenCalled();
+    });
+  });
+
+  describe('plugin interceptors execution', () => {
+    it('should execute plugin onRequest and onResponse methods', () => {
+      const mockOnRequest = jest.fn((req) => req);
+      const mockOnResponse = jest.fn((req, res, data) => res);
+      let requestInterceptor: any;
+      let responseInterceptor: any;
+
+      const mockClient = {
+        defaults: {
+          host: HOST_URL,
+        },
+        interceptors: {
+          request: {
+            use: jest.fn((interceptor) => {
+              requestInterceptor = interceptor;
+            }),
+          },
+          response: {
+            use: jest.fn((successInterceptor) => {
+              responseInterceptor = successInterceptor;
+            }),
+          },
+        },
+      };
+
+      createHttpClientMock.mockReturnValue(mockClient as any);
+
+      const mockPlugin = {
+        onRequest: mockOnRequest,
+        onResponse: mockOnResponse,
+      };
+
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        plugins: [mockPlugin],
+      };
+      
+      createStackInstance(config);
+
+      // Test that interceptors were registered
+      expect(mockClient.interceptors.request.use).toHaveBeenCalled();
+      expect(mockClient.interceptors.response.use).toHaveBeenCalled();
+
+      // Test request interceptor execution
+      const mockRequest = { url: '/test' };
+      requestInterceptor(mockRequest);
+      expect(mockOnRequest).toHaveBeenCalledWith(mockRequest);
+
+      // Test response interceptor execution
+      const mockResponse = {
+        request: {},
+        data: {},
+      };
+      responseInterceptor(mockResponse);
+      expect(mockOnResponse).toHaveBeenCalledWith(mockResponse.request, mockResponse, mockResponse.data);
+    });
+
+    it('should handle multiple plugins in order', () => {
+      const executionOrder: string[] = [];
+      let requestInterceptor: any;
+
+      const mockClient = {
+        defaults: {
+          host: HOST_URL,
+        },
+        interceptors: {
+          request: {
+            use: jest.fn((interceptor) => {
+              requestInterceptor = interceptor;
+            }),
+          },
+          response: {
+            use: jest.fn(),
+          },
+        },
+      };
+
+      createHttpClientMock.mockReturnValue(mockClient as any);
+
+      const mockPlugin1 = {
+        onRequest: jest.fn((req) => {
+          executionOrder.push('plugin1');
+          return req;
+        }),
+        onResponse: jest.fn((req, res, data) => res),
+      };
+
+      const mockPlugin2 = {
+        onRequest: jest.fn((req) => {
+          executionOrder.push('plugin2');
+          return req;
+        }),
+        onResponse: jest.fn((req, res, data) => res),
+      };
+
+      const config = {
+        apiKey: "apiKey",
+        deliveryToken: "delivery",
+        environment: "env",
+        plugins: [mockPlugin1, mockPlugin2],
+      };
+      
+      createStackInstance(config);
+
+      const mockRequest = { url: '/test' };
+      requestInterceptor(mockRequest);
+
+      expect(executionOrder).toEqual(['plugin1', 'plugin2']);
+    });
+  });
 });