Merge branch 'main' into fix/DX-9991

Author: cs-raj

.github/workflows/sca-scan.yml

@@ -5,6 +5,9 @@ on:
 jobs:
   security-sca:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
     steps:
       - uses: actions/checkout@master
       - name: Run Snyk to check for vulnerabilities

.talismanrc

@@ -66,4 +66,12 @@ fileignoreconfig:
   checksum: 9e7a4696561b790cb93f3be8406a70ec6fdc90a3f8bbb9739504495690158fe3
 - filename: src/query/term-query.ts
   checksum: 1f5b23177460d562076d93cf28b375106b19123a5ab135ffef75f4b2bb332d35
+- filename: test/bundlers/run-with-report.sh
+  checksum: fedb0c262e3d88ad3537943e828d8ed9412a9f7d78b6406997b3955b29816f20
+- filename: test/utils/assertion-tracker.ts
+  checksum: f02ce0af5948cd813020367c21da2cd0cd00168eeeb9e8af1858b852ae83e269
+- filename: test/utils/request-capture-plugin.ts
+  checksum: 596fbbbf4aace2431dc165208a81f1a03c5f1d5268aceda83385debeaba79b97
+- filename: test/reporting/rich-html-reporter.cjs
+  checksum: 1da275d7d083cc671a3888b1a045a616f79ac1fe023ee64ea34f0f23ddbc3706
 version: "1.0"

jest.config.ts

@@ -38,16 +38,12 @@ export default {
         includeConsoleLog: true,
       },
     ],
+    // Rich single-file HTML report with inline per-test HTTP context (cURL,
+    // SDK method, request/response). Fixed path (the one the GoCD pipelines link to);
+    // prints the absolute path at run end.
     [
-      "jest-html-reporters",
-      {
-        publicPath: "./reports/contentstack-delivery/html",
-        filename: "index.html",
-        expand: true,
-        // Enable console log capture in reports
-        enableMergeData: true,
-        dataMergeLevel: 2,
-      },
+      "./test/reporting/rich-html-reporter.cjs",
+      { outputPath: "reports/contentstack-delivery/html/index.html" },
     ],
     [
       "jest-junit",

jest.setup.ts

@@ -6,6 +6,15 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import {
+  getLastCapturedRequest,
+  clearCapturedRequests,
+} from './test/utils/request-capture-plugin';
+import {
+  installAssertionTracker,
+  clearAssertions,
+  getAssertions,
+} from './test/utils/assertion-tracker';
 
 // Store captured console logs
 interface ConsoleLog {
@@ -37,7 +46,7 @@ const originalConsole = {
 const expectedErrors = [
   'Invalid key:',                                      // From query.search() validation
   'Invalid value (expected string or number):',       // From query.equalTo() validation
-  'Argument should be a String or an Array.',         // From entry/entries.includeReference() validation
+  'Invalid argument. Provide a string or an array',    // From entry/entries.includeReference() validation (ErrorMessages.INVALID_ARGUMENT_STRING_OR_ARRAY)
   'Invalid fieldUid:',                                 // From asset query validation
 ];
 
@@ -76,6 +85,47 @@ console.error = captureConsole('error');
 console.info = captureConsole('info');
 console.debug = captureConsole('debug');
 
+// ---------------------------------------------------------------------------
+// Rich per-test HTTP context (cURL / SDK method / request+response / status).
+// Active only when ENABLE_HTTP_CAPTURE=true (the request-capture plugin is
+// attached to the stack instance under the same flag). Each test's last
+// captured HTTP call is appended to a JSONL sidecar that the custom
+// rich-html-reporter reads at run-end to build the single-file HTML report.
+// ---------------------------------------------------------------------------
+const HTTP_CAPTURE_ENABLED = process.env.ENABLE_HTTP_CAPTURE === 'true';
+const CAPTURES_FILE = path.resolve(__dirname, 'test-results', 'http-captures.jsonl');
+
+if (HTTP_CAPTURE_ENABLED) {
+  beforeEach(() => {
+    // Install inside beforeEach so it runs AFTER the spec's `import { expect } from
+    // '@jest/globals'` has resolved the shared module object (idempotent via a guard).
+    // Records every assertion (expected/actual/pass) without changing any test.
+    installAssertionTracker();
+    clearCapturedRequests();
+    clearAssertions();
+  });
+
+  afterEach(() => {
+    try {
+      const cap = getLastCapturedRequest();
+      const assertions = getAssertions();
+      if (!cap && assertions.length === 0) return;
+      const state: any = (expect as any).getState();
+      const rec = {
+        testPath: state.testPath,
+        testName: state.currentTestName,
+        capture: cap || null,
+        assertions,
+      };
+      const dir = path.dirname(CAPTURES_FILE);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.appendFileSync(CAPTURES_FILE, JSON.stringify(rec) + '\n');
+    } catch {
+      // never let reporting break a test
+    }
+  });
+}
+
 // After all tests complete, write logs to file
 afterAll(() => {
   const logsPath = path.resolve(__dirname, 'test-results', 'console-logs.json');

package.json

@@ -26,11 +26,11 @@
     "prepare": "npm run build",
     "test": "jest ./test/unit",
     "test:unit": "jest ./test/unit",
-    "test:api": "jest ./test/api",
+    "test:api": "ENABLE_HTTP_CAPTURE=true jest ./test/api",
     "test:browser": "jest --config jest.config.browser.ts",
     "test:e2e": "node test/e2e/build-browser-bundle.js && playwright test",
     "test:e2e:ui": "node test/e2e/build-browser-bundle.js && playwright test --ui",
-    "test:api:report": "jest ./test/api --json --outputFile=test-results/jest-results.json",
+    "test:api:report": "ENABLE_HTTP_CAPTURE=true jest ./test/api --json --outputFile=test-results/jest-results.json",
     "test:bundlers:report": "cd test/bundlers && ./run-with-report.sh",
     "test:cicd": "mkdir -p test-results && npm run test:api:report && npm run test:bundlers:report && npm run test:e2e && node test/reporting/generate-unified-report.js",
     "test:cicd:no-browser": "mkdir -p test-results && npm run test:api:report && npm run test:bundlers:report && node test/reporting/generate-unified-report.js",

test/api/asset-management.spec.ts

@@ -337,7 +337,9 @@ describe('Asset Management Tests', () => {
         console.log('Non-existent asset properly rejected:', (error as Error).message);
         // Should handle gracefully
       }
-    });
+      // Non-prod regions can be slow to resolve a bogus asset UID; allow 60s so this
+      // error-path test rejects/resolves within timeout instead of flaking.
+    }, 60000);
 
     it('should handle empty asset queries', async () => {
       const result = await stack

test/api/asset-query.spec.ts

@@ -23,7 +23,9 @@ describe("AssetQuery API tests", () => {
   it("should check for include dimensions", async () => {
     const result = await makeAssetQuery().includeDimension().find<TAsset>();
     if (result.assets) {
-      expect(result.assets[0].dimension).toBeDefined();
+      // dimension is only present on image assets; the first asset may be a video/pdf/etc.
+      const imageAsset = result.assets.find((a: any) => String(a.content_type).startsWith("image/")) || result.assets[0];
+      expect(imageAsset.dimension).toBeDefined();
       expect(result.assets[0]._version).toBeDefined();
       expect(result.assets[0].uid).toBeDefined();
       expect(result.assets[0].content_type).toBeDefined();

test/api/deep-references.spec.ts

@@ -282,9 +282,9 @@ describe('Deep Reference Chains Tests', () => {
         .contentType(COMPLEX_CT)
         .entry(COMPLEX_ENTRY_UID!)
         .includeReference([
-          'related_content',
-          'authors',
-          'page_footer'
+          'single_ref',
+          'multi_ref',
+          'self_ref'
         ])
         .fetch<any>();
 
@@ -319,14 +319,14 @@ describe('Deep Reference Chains Tests', () => {
       };
 
       // Analyze root level reference fields
-      if (result.related_content) {
-        analyzeReferenceTypes(result.related_content);
+      if (result.single_ref) {
+        analyzeReferenceTypes(result.single_ref);
       }
-      if (result.authors) {
-        analyzeReferenceTypes(result.authors);
+      if (result.multi_ref) {
+        analyzeReferenceTypes(result.multi_ref);
       }
-      if (result.page_footer) {
-        analyzeReferenceTypes(result.page_footer);
+      if (result.self_ref) {
+        analyzeReferenceTypes(result.self_ref);
       }
 
       console.log('Reference type distribution:', referenceTypes);

test/api/query-operators-comprehensive.spec.ts

@@ -438,20 +438,20 @@ describe('Query Operators - Comprehensive Coverage', () => {
         .contentType(COMPLEX_CT)
         .entry()
         .query()
-        .referenceIn('authors', authorQuery)
+        .referenceIn('single_ref', authorQuery)
         .find<any>();
 
       expect(result).toBeDefined();
-      
+
       if (result.entries && result.entries?.length > 0) {
-        console.log(`Found ${result.entries?.length} entries with referenceIn authors`);
-        
-        // Verify all returned entries have authors references
+        console.log(`Found ${result.entries?.length} entries with referenceIn single_ref`);
+
+        // Verify all returned entries have single_ref references
         result.entries.forEach((entry: any) => {
-          if (entry.authors) {
-            expect(Array.isArray(entry.authors)).toBe(true);
-            // Verify authors are resolved
-            entry.authors.forEach((author: any) => {
+          if (entry.single_ref) {
+            expect(Array.isArray(entry.single_ref)).toBe(true);
+            // Verify references are resolved
+            entry.single_ref.forEach((author: any) => {
               expect(author.uid).toBeDefined();
               expect(author._content_type_uid).toBe('author');
             });
@@ -472,20 +472,20 @@ describe('Query Operators - Comprehensive Coverage', () => {
         .contentType(COMPLEX_CT)
         .entry()
         .query()
-        .referenceNotIn('authors', excludeAuthorQuery)
+        .referenceNotIn('single_ref', excludeAuthorQuery)
         .find<any>();
 
       expect(result).toBeDefined();
-      
+
       if (result.entries && result.entries?.length > 0) {
-        console.log(`Found ${result.entries?.length} entries with referenceNotIn authors`);
-        
+        console.log(`Found ${result.entries?.length} entries with referenceNotIn single_ref`);
+
         // Verify all returned entries don't have excluded author references
         result.entries.forEach((entry: any) => {
-          if (entry.authors) {
-            expect(Array.isArray(entry.authors)).toBe(true);
+          if (entry.single_ref) {
+            expect(Array.isArray(entry.single_ref)).toBe(true);
             // Verify no excluded author UID is referenced
-            entry.authors.forEach((author: any) => {
+            entry.single_ref.forEach((author: any) => {
               expect(author.uid).not.toBe('non_existent_author_uid');
             });
           }

test/api/sync-operations-comprehensive.spec.ts

@@ -83,8 +83,10 @@ describe('Sync Operations Comprehensive Tests', () => {
       expect(result).toBeDefined();
       expect(result.items).toBeDefined();
       expect(Array.isArray(result.items)).toBe(true);
-      expect(result.sync_token).toBeDefined();
-      
+      // Initial sync over a large stack paginates: first page returns a pagination_token,
+      // and sync_token only arrives on the final page. Accept either.
+      expect(result.sync_token ?? result.pagination_token).toBeDefined();
+
       console.log('Initial sync (all content types):', {
         duration: `${duration}ms`,
         entriesCount: result.items.length,
@@ -172,7 +174,16 @@ describe('Sync Operations Comprehensive Tests', () => {
       expect(result.items).toBeDefined();
       expect(Array.isArray(result.items)).toBe(true);
       expect(result.sync_token).toBeDefined();
-      expect(result.sync_token).toBe(initialSyncToken);
+      expect(typeof result.sync_token).toBe('string');
+      // A delta sync always returns a usable token. If there were NO changes since the
+      // initial sync, the token is unchanged; if the sync log has intervening events
+      // (e.g. prior publish/unpublish), the delta returns those change items and a NEW
+      // token. Assert the correct behaviour for each case instead of a blanket equality.
+      if (result.items.length === 0) {
+        expect(result.sync_token).toBe(initialSyncToken);
+      } else {
+        expect(result.sync_token).not.toBe(initialSyncToken);
+      }
 
       console.log('Delta sync completed:', {
         duration: `${duration}ms`,
@@ -275,8 +286,8 @@ describe('Sync Operations Comprehensive Tests', () => {
         syncToken: result.sync_token
       });
 
-      // Should respect the limit
-      expect(result.items.length).toBeLessThanOrEqual(5);
+      // The Sync API returns up to one page (max 100 items); it does not honor an arbitrary small limit.
+      expect(result.items.length).toBeLessThanOrEqual(100);
     });
 
     it('should handle sync pagination with skip', async () => {
@@ -480,9 +491,10 @@ describe('Sync Operations Comprehensive Tests', () => {
         ratio: initialTime / deltaTime
       });
 
-      // Delta sync should be reasonably fast (allow 2x tolerance OR absolute 100ms threshold)
-      // This accounts for network variability while catching real performance regressions
-      const maxAllowedTime = Math.max(initialTime * 2, 100);
+      // Delta sync should be reasonably fast, but wall-clock timing over a live network is noisy
+      // (initial sync warms caches, delta can hit a cold shard). Use a generous tolerance so this
+      // catches gross regressions without flaking on normal variance.
+      const maxAllowedTime = Math.max(initialTime * 3, 3000);
       expect(deltaTime).toBeLessThanOrEqual(maxAllowedTime);
     });
 
@@ -645,7 +657,14 @@ describe('Sync Operations Comprehensive Tests', () => {
 
       expect(deltaResult.sync_token).toBeDefined();
       expect(typeof deltaResult.sync_token).toBe('string');
-      expect(deltaResult.sync_token).toBe(initialResult.sync_token);
+      // The token is stable only when the delta finds no changes; if the sync log has
+      // intervening events the token advances (returning those change items). Assert the
+      // correct behaviour for each case rather than assuming a pristine event log.
+      if (deltaResult.items.length === 0) {
+        expect(deltaResult.sync_token).toBe(initialResult.sync_token);
+      } else {
+        expect(deltaResult.sync_token).not.toBe(initialResult.sync_token);
+      }
 
       console.log('Sync token consistency:', {
         initialToken: initialResult.sync_token,