add unit tests for AssetQuery, Asset, BaseQuery, Cache, ContentType, Entries, Pagination, Query, and Stack classes

harshitha-cstk · harshitha-cstk · commit 139f5feaa86a · 2025-11-01T06:30:54.000+05:30
- Added tests for debug logging integration in Contentstack.
diff --git a/test/unit/asset-query.spec.ts b/test/unit/asset-query.spec.ts
@@ -48,6 +48,12 @@ describe('AssetQuery class', () => {
     expect(assetQuery._queryParams.include_fallback).toBe('true');
   });
 
+  it('should add "include_metadata" in queryParameter when includeMetadata method is called', () => {
+    const returnedValue = assetQuery.includeMetadata();
+    expect(returnedValue).toBeInstanceOf(AssetQuery);
+    expect(assetQuery._queryParams.include_metadata).toBe('true');
+  });
+
   it('should add "locale" in Parameter when locale method is called', () => {
     const returnedValue = assetQuery.locale('en-us');
     expect(returnedValue).toBeInstanceOf(AssetQuery);
diff --git a/test/unit/asset.spec.ts b/test/unit/asset.spec.ts
@@ -42,6 +42,12 @@ describe('Asset class', () => {
     expect(asset._queryParams.include_fallback).toBe('true');
   });
 
+  it('should add "include_metadata" in _queryParams when includeMetadata method is called', () => {
+    const returnedValue = asset.includeMetadata();
+    expect(returnedValue).toBeInstanceOf(Asset);
+    expect(asset._queryParams.include_metadata).toBe('true');
+  });
+
   it('should add "relative_urls" in _queryParams when relativeUrl method is called', () => {
     const returnedValue = asset.relativeUrls();
     expect(returnedValue).toBeInstanceOf(Asset);
@@ -59,4 +65,13 @@ describe('Asset class', () => {
     const returnedValue = await asset.fetch();
     expect(returnedValue).toEqual(assetFetchDataMock.asset);
   });
+
+  it('should return response directly when asset property is not present', async () => {
+    const responseWithoutAsset = { data: 'test', uid: 'test-uid' };
+    mockClient.onGet(`/assets/assetUid`).reply(200, responseWithoutAsset);
+    
+    const result = await asset.fetch();
+    
+    expect(result).toEqual(responseWithoutAsset);
+  });
 });
diff --git a/test/unit/base-query.spec.ts b/test/unit/base-query.spec.ts
@@ -76,10 +76,12 @@ describe('BaseQuery class', () => {
 });
 
 class TestableBaseQuery extends BaseQuery {
-  constructor(client: AxiosInstance, urlPath: string) {
+  constructor(client: AxiosInstance, urlPath: string | null = null) {
     super();
     this._client = client;
-    this._urlPath = urlPath;
+    if (urlPath !== null) {
+      this._urlPath = urlPath;
+    }
     this._variants = '';
   }
 
@@ -90,6 +92,10 @@ class TestableBaseQuery extends BaseQuery {
   setParameters(params: any) {
     this._parameters = params;
   }
+
+  setUrlPath(path: string) {
+    this._urlPath = path;
+  }
 }
 
 describe('BaseQuery find method', () => {
@@ -164,4 +170,12 @@ describe('BaseQuery find method', () => {
     
     expect(result).toEqual(entryFindMock);
   });
+
+  it('should handle empty _urlPath gracefully', () => {
+    const queryWithoutUrlPath = new TestableBaseQuery(client, null);
+    queryWithoutUrlPath.setUrlPath('');
+    
+    // Verify that URL path is empty (testing the null check in extractContentTypeUidFromUrl)
+    expect(queryWithoutUrlPath).toBeInstanceOf(TestableBaseQuery);
+  });
 }); 
diff --git a/test/unit/cache.spec.ts b/test/unit/cache.spec.ts
@@ -329,4 +329,93 @@ describe("Cache handleRequest function", () => {
       cacheStore.removeItem(enhancedCacheKey, config.contentTypeUid);
     });
   });
+
+  describe("Enhanced cache key with entryUid", () => {
+    it("should extract entryUid from URL pattern", async () => {
+      const cacheOptions = { policy: Policy.CACHE_THEN_NETWORK, maxAge: 3600 };
+      const defaultAdapter = jest.fn((_config) => ({
+        data: JSON.stringify("foo"),
+      }));
+      const configWithUrl = {
+        ...config,
+        url: '/content_types/test_ct/entries/entry123',
+      };
+
+      const cacheStore = new PersistanceStore(cacheOptions);
+
+      await handleRequest(
+        cacheOptions,
+        apiKey,
+        defaultAdapter,
+        resolve,
+        reject,
+        configWithUrl
+      );
+
+      expect(defaultAdapter).toHaveBeenCalled();
+      expect(resolve).toBeCalledWith({ data: "foo" });
+
+      // Clean up with enhanced key that includes entry UID
+      const enhancedCacheKey = `${config.contentTypeUid}_${apiKey}_entry_entry123`;
+      cacheStore.removeItem(enhancedCacheKey, config.contentTypeUid);
+    });
+
+    it("should use entryUid from config when available", async () => {
+      const cacheOptions = { policy: Policy.CACHE_THEN_NETWORK, maxAge: 3600 };
+      const defaultAdapter = jest.fn((_config) => ({
+        data: JSON.stringify("foo"),
+      }));
+      const configWithEntryUid = {
+        ...config,
+        entryUid: 'entry456',
+      };
+
+      const cacheStore = new PersistanceStore(cacheOptions);
+
+      await handleRequest(
+        cacheOptions,
+        apiKey,
+        defaultAdapter,
+        resolve,
+        reject,
+        configWithEntryUid
+      );
+
+      expect(defaultAdapter).toHaveBeenCalled();
+      expect(resolve).toBeCalledWith({ data: "foo" });
+
+      // Clean up with enhanced key that includes entry UID
+      const enhancedCacheKey = `${config.contentTypeUid}_${apiKey}_entry_entry456`;
+      cacheStore.removeItem(enhancedCacheKey, config.contentTypeUid);
+    });
+
+    it("should return null when URL does not match entry pattern", async () => {
+      const cacheOptions = { policy: Policy.CACHE_THEN_NETWORK, maxAge: 3600 };
+      const defaultAdapter = jest.fn((_config) => ({
+        data: JSON.stringify("foo"),
+      }));
+      const configWithInvalidUrl = {
+        ...config,
+        url: '/assets',
+      };
+
+      const cacheStore = new PersistanceStore(cacheOptions);
+
+      await handleRequest(
+        cacheOptions,
+        apiKey,
+        defaultAdapter,
+        resolve,
+        reject,
+        configWithInvalidUrl
+      );
+
+      expect(defaultAdapter).toHaveBeenCalled();
+      expect(resolve).toBeCalledWith({ data: "foo" });
+
+      // Clean up with standard enhanced key (no entry UID)
+      const enhancedCacheKey = `${config.contentTypeUid}_${apiKey}`;
+      cacheStore.removeItem(enhancedCacheKey, config.contentTypeUid);
+    });
+  });
 });
diff --git a/test/unit/contentstack-debug-integration.spec.ts b/test/unit/contentstack-debug-integration.spec.ts
@@ -0,0 +1,195 @@
+import { httpClient, AxiosInstance } from '@contentstack/core';
+import * as Contentstack from '../../src/lib/contentstack';
+import { Stack } from '../../src/lib/stack';
+import { Policy, StackConfig } from '../../src/lib/types';
+import MockAdapter from 'axios-mock-adapter';
+
+describe('Contentstack Debug Logging Integration', () => {
+  let mockLogHandler: jest.Mock;
+
+  beforeEach(() => {
+    mockLogHandler = jest.fn();
+  });
+
+  it('should execute debug logging for request interceptor', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      debug: true,
+      logHandler: mockLogHandler,
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    mockClient.onGet('/content_types/test').reply(200, {
+      content_types: []
+    });
+
+    // Make an actual request to trigger interceptors
+    try {
+      await client.get('/content_types/test');
+    } catch (e) {
+      // Ignore errors
+    }
+
+    // Verify request logging was called
+    const requestLogs = mockLogHandler.mock.calls.filter((call: any) => 
+      call[1]?.type === 'request'
+    );
+    expect(requestLogs.length).toBeGreaterThan(0);
+
+    mockClient.restore();
+  });
+
+  it('should execute debug logging for response interceptor with 2xx status', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      debug: true,
+      logHandler: mockLogHandler,
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    mockClient.onGet('/content_types/test').reply(200, {
+      content_types: []
+    });
+
+    await client.get('/content_types/test');
+
+    // Verify response logging was called with info level
+    const responseLogs = mockLogHandler.mock.calls.filter((call: any) => 
+      call[1]?.type === 'response' && call[0] === 'info'
+    );
+    expect(responseLogs.length).toBeGreaterThan(0);
+
+    mockClient.restore();
+  });
+
+  it('should execute debug logging for response interceptor with 3xx status', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      debug: true,
+      logHandler: mockLogHandler,
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    // 3xx responses are treated as errors by axios-mock-adapter
+    mockClient.onGet('/content_types/test').reply(304, {});
+
+    try {
+      await client.get('/content_types/test');
+    } catch (e) {
+      // Expected - 3xx responses trigger error handler in mock adapter
+    }
+
+    // Verify error response logging was called - 3xx goes through error interceptor
+    const errorLogs = mockLogHandler.mock.calls.filter((call: any) => 
+      call[1]?.type === 'response_error' && call[1]?.status === 304
+    );
+    expect(errorLogs.length).toBeGreaterThan(0);
+
+    mockClient.restore();
+  });
+
+  it('should execute debug logging for error response interceptor with 4xx status', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      debug: true,
+      logHandler: mockLogHandler,
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    mockClient.onGet('/content_types/test').reply(404, {
+      error: 'Not found'
+    });
+
+    try {
+      await client.get('/content_types/test');
+    } catch (e) {
+      // Expected error
+    }
+
+    // Verify error logging was called
+    const errorLogs = mockLogHandler.mock.calls.filter((call: any) => 
+      call[1]?.type === 'response_error' && call[0] === 'error'
+    );
+    expect(errorLogs.length).toBeGreaterThan(0);
+
+    mockClient.restore();
+  });
+
+  it('should execute debug logging for error response without status', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      debug: true,
+      logHandler: mockLogHandler,
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    mockClient.onGet('/content_types/test').networkError();
+
+    try {
+      await client.get('/content_types/test');
+    } catch (e) {
+      // Expected network error
+    }
+
+    // Verify error logging was called with debug level for no status
+    const errorLogs = mockLogHandler.mock.calls.filter((call: any) => 
+      call[1]?.type === 'response_error' && call[0] === 'debug'
+    );
+    expect(errorLogs.length).toBeGreaterThan(0);
+
+    mockClient.restore();
+  });
+
+  it('should execute cache adapter when cacheOptions is provided', async () => {
+    const config: StackConfig = {
+      apiKey: "apiKey",
+      deliveryToken: "delivery",
+      environment: "env",
+      cacheOptions: {
+        policy: Policy.CACHE_THEN_NETWORK,
+        maxAge: 3600,
+      },
+    };
+
+    const stack = Contentstack.stack(config);
+    const client = stack.getClient();
+    const mockClient = new MockAdapter(client);
+
+    mockClient.onGet('/content_types/test').reply(200, {
+      content_types: []
+    });
+
+    // Make request to trigger cache adapter
+    await client.get('/content_types/test', { contentTypeUid: 'test' });
+
+    expect(client.defaults.adapter).toBeDefined();
+
+    mockClient.restore();
+  });
+});
+
diff --git a/test/unit/contenttype.spec.ts b/test/unit/contenttype.spec.ts
@@ -41,4 +41,13 @@ describe('ContentType class', () => {
     const response = await contentType.fetch();
     expect(response).toEqual(contentTypeResponseMock.content_type);
   });
+
+  it('should return response directly when content_type property is not present', async () => {
+    const responseWithoutContentType = { data: 'test', uid: 'test-uid' };
+    mockClient.onGet('/content_types/contentTypeUid').reply(200, responseWithoutContentType);
+    
+    const result = await contentType.fetch();
+    
+    expect(result).toEqual(responseWithoutContentType);
+  });
 });
diff --git a/test/unit/entries.spec.ts b/test/unit/entries.spec.ts
@@ -91,6 +91,13 @@ describe('Entries class', () => {
     expect(returnedValue).toBeInstanceOf(Query);
   });
 
+  it('should return Query instance with queryObj when query method is called with object', () => {
+    const queryObj = { title: 'Test' };
+    const returnedValue = entry.query(queryObj);
+    expect(returnedValue).toBeInstanceOf(Query);
+    expect(returnedValue._parameters).toEqual(queryObj);
+  });
+
   it('should add a fieldUid to the _queryParams object', () => {
     entry.only('fieldUid');
     expect(entry._queryParams).toEqual({ 'only[BASE][]': 'fieldUid' });
diff --git a/test/unit/pagination.spec.ts b/test/unit/pagination.spec.ts
diff --git a/test/unit/query.spec.ts b/test/unit/query.spec.ts
diff --git a/test/unit/stack.spec.ts b/test/unit/stack.spec.ts
