test: add 6 socket/transport error tests for v3.27.0 retry coverage

Adds tests covering the new UND_ERR_SOCKET / UND_ERR_ABORTED retry logic
introduced in src/core/lib/request.js (v3.27.0).

RetryLogic.test.js — Socket & Transport Error Handling:
- RetryLogic_AuthError_FailsFast_NotSlowedByRetryDelay: timing proof
  that 4xx errors are never retried regardless of retryLimit/retryDelay
- RetryLogic_CustomRetryCondition_InvokesOnError_WithDelayBetweenRetries:
  proves retryCondition → onError() wiring applies retry delays
- RetryLogic_ZeroRetryLimit_NetworkFailure_RejectsWithoutWaiting: proves
  the retryLimit > 0 guard in the new socket-error path is enforced

ErrorHandling.test.js — Transport Layer vs API Errors:
- ErrorHandling_TransportError_HasNoAPIErrorCode: transport errors must
  not be wrapped with API error_code fields
- ErrorHandling_APIError_StructureDistinctFromTransportError: proves the
  two error shapes remain distinguishable for app-level error routing
- ErrorHandling_ZeroRetryLimit_TransportError_ErrorShapeUnchanged: proves
  retryLimit does not mutate the error object shape

Also removes stale duplicate test/config.js entry from .talismanrc.

Author: aniket-shikhare-cstk

.talismanrc

@@ -12,7 +12,7 @@ fileignoreconfig:
 - filename: test/integration/GlobalFieldsTests/ContentBlockGlobalField.test.js
   checksum: 8d2bc8cb6661336b57397649259f7e12786256706019efb644f133b336629d96
 - filename: test/integration/NetworkResilienceTests/RetryLogic.test.js
-  checksum: 681543c7c982eba430189b541116ffeb06c7955da220b5fd8c6b034b1e9a5e43
+  checksum: 3b5fe23398bdc2327848b3caa95339e51a0aed059c1eb299e78d3dd215ecbd30
 - filename: test/integration/QueryTests/ExistsSearchOperators.test.js
   checksum: e4774c805f1d0876cdc03439ed14a2f35a0ceb6028d86370a49ef0558a7bc46e
 - filename: index.d.ts
@@ -35,8 +35,6 @@ fileignoreconfig:
   checksum: 49d6742d014ce111735611ebab16dc8c888ce8d678dfbc99620252257e780ec5
 - filename: src/core/contentstack.js
   checksum: 22e723507c1fed8b3175b57791f4249889c9305b79e5348d59d741bdf4f006ba
-- filename: test/config.js
-  checksum: 4ada746af34f2868c038f53126c08c21d750ddbd037d0a62e88824dd5d9e20be
 - filename: test/live-preview/live-preview-test.js
   checksum: d742465789e00a17092a7e9664adda4342a13bc4975553371a26df658f109952
 - filename: src/core/lib/request.js

test/integration/ErrorTests/ErrorHandling.test.js

@@ -123,7 +123,7 @@ describe('Error Tests - Error Handling & Validation', () => {
 
         console.log(`✅ Invalid entry UID error: ${error.error_code}`);
       }
-    });
+    }, 15000); // Increased timeout for error handling tests
 
     test('Error_EmptyEntryUID_HandlesGracefully', async () => {
       const contentTypeUID = TestDataHelper.getContentTypeUID('article', true);
@@ -269,7 +269,7 @@ describe('Error Tests - Error Handling & Validation', () => {
         expect(error.error_code).toBeDefined();
         console.log('✅ Special characters in field name trigger validation error (acceptable)');
       }
-    });
+    }, 15000); // Increased timeout for error handling tests
   });
 
   describe('Error Response Structure Validation', () => {
@@ -513,6 +513,130 @@ describe('Error Tests - Error Handling & Validation', () => {
     });
   });
 
+  // =============================================================================
+  // TRANSPORT LAYER ERROR HANDLING (v3.27.0 socket-retry coverage)
+  // =============================================================================
+
+  describe('Transport Layer vs API Errors', () => {
+
+    test('ErrorHandling_TransportError_HasNoAPIErrorCode', async () => {
+      // When fetch itself fails (DNS failure, socket drop, etc.) the error is a
+      // TypeError thrown by the runtime — it has no error_code / error_message
+      // from the Contentstack API response body.
+      // Bug this catches: if transport errors are accidentally wrapped in the
+      // same object shape as API errors, callers can't distinguish them and
+      // may show misleading error messages to users.
+      const localStack = Contentstack.Stack({
+        ...init.stack,
+        fetchOptions: { retryLimit: 0, timeout: 3000 }
+      });
+      localStack.setHost('host-that-does-not-exist-transport-test.contentstack.io');
+
+      const contentTypeUID = TestDataHelper.getContentTypeUID('article', true);
+
+      try {
+        await localStack.ContentType(contentTypeUID).Query().limit(1).toJSON().find();
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeDefined();
+        // Transport errors have no API error_code — they are runtime TypeError objects
+        expect(error.error_code).toBeUndefined();
+        expect(error.error_message).toBeUndefined();
+
+        console.log('✅ Transport error has no API error_code — correctly not wrapped as API error');
+      }
+    }, 8000);
+
+    test('ErrorHandling_APIError_StructureDistinctFromTransportError', async () => {
+      // API errors and transport errors must be distinguishable by structure so
+      // application error-handling code can route them correctly.
+      // Bug this catches: if a refactor makes both paths produce the same shape,
+      // callers cannot tell whether the network is down or the query was invalid.
+      let apiError = null;
+      let transportError = null;
+
+      const unreachableStack = Contentstack.Stack({
+        ...init.stack,
+        fetchOptions: { retryLimit: 0, timeout: 3000 }
+      });
+      unreachableStack.setHost('host-that-does-not-exist-struct-test.contentstack.io');
+
+      try {
+        await Stack.ContentType('non_existent_ct_struct_test_xyz').Query().limit(1).toJSON().find();
+      } catch (err) {
+        apiError = err;
+      }
+
+      try {
+        await unreachableStack.ContentType('any_ct').Query().limit(1).toJSON().find();
+      } catch (err) {
+        transportError = err;
+      }
+
+      expect(apiError).not.toBeNull();
+      expect(transportError).not.toBeNull();
+
+      // API errors have structured fields from the Contentstack response body
+      expect(apiError.error_code).toBeDefined();
+      expect(typeof apiError.error_code).toBe('number');
+      expect(apiError.error_message).toBeDefined();
+
+      // Transport errors are raw runtime errors — no API response body fields
+      expect(transportError.error_code).toBeUndefined();
+      expect(transportError.error_message).toBeUndefined();
+
+      console.log(`✅ API error has error_code=${apiError.error_code}; transport error has none — shapes are distinct`);
+    }, 12000);
+
+    test('ErrorHandling_ZeroRetryLimit_TransportError_ErrorShapeUnchanged', async () => {
+      // retryLimit=0 takes the reject() path in onError() immediately.
+      // The error object passed to reject() must be the original transport error,
+      // not re-wrapped or mutated.
+      // Bug this catches: if the retryLimit=0 branch wraps the error differently,
+      // downstream catch blocks that check error shape would break silently.
+      const stackDefaultRetry = Contentstack.Stack({
+        ...init.stack,
+        fetchOptions: { retryLimit: 5, timeout: 3000 }
+      });
+      stackDefaultRetry.setHost('host-that-does-not-exist-shape-test.contentstack.io');
+
+      const stackZeroRetry = Contentstack.Stack({
+        ...init.stack,
+        fetchOptions: { retryLimit: 0, timeout: 3000 }
+      });
+      stackZeroRetry.setHost('host-that-does-not-exist-shape-test.contentstack.io');
+
+      let defaultRetryError = null;
+      let zeroRetryError = null;
+
+      try {
+        await stackDefaultRetry.ContentType('any_ct').Query().limit(1).toJSON().find();
+      } catch (err) {
+        defaultRetryError = err;
+      }
+
+      try {
+        await stackZeroRetry.ContentType('any_ct').Query().limit(1).toJSON().find();
+      } catch (err) {
+        zeroRetryError = err;
+      }
+
+      expect(defaultRetryError).not.toBeNull();
+      expect(zeroRetryError).not.toBeNull();
+
+      // Both must be transport errors (no API error_code) regardless of retryLimit
+      expect(defaultRetryError.error_code).toBeUndefined();
+      expect(zeroRetryError.error_code).toBeUndefined();
+
+      // Both should have the same constructor type — error shape must not change
+      // based on whether retries were attempted
+      expect(defaultRetryError.constructor).toBe(zeroRetryError.constructor);
+
+      console.log(`✅ Transport error shape is identical regardless of retryLimit (${defaultRetryError.constructor.name})`);
+    }, 15000);
+
+  });
+
   describe('Special Error Cases', () => {
     test('Error_VeryLongUID_HandlesGracefully', async () => {
       const veryLongUID = 'a'.repeat(1000);

test/integration/NetworkResilienceTests/RetryLogic.test.js

@@ -433,6 +433,120 @@ describe('Retry Logic & Network Resilience - Comprehensive Tests', () => {
 
   });
 
+  // =============================================================================
+  // SOCKET & TRANSPORT ERROR HANDLING (v3.27.0 retry coverage)
+  // =============================================================================
+
+  describe('Socket & Transport Error Handling', () => {
+
+    test('RetryLogic_AuthError_FailsFast_NotSlowedByRetryDelay', async () => {
+      // 4xx API errors go through data.then(json => reject) — no retryCondition,
+      // so they are NEVER retried regardless of retryLimit.
+      // Bug this catches: if SDK starts retrying 4xx errors, timing balloons to
+      // retryLimit * retryDelay (5 * 2000ms = 10 000ms) instead of failing fast.
+      const RETRY_DELAY = 2000;
+      const RETRY_LIMIT = 5;
+
+      const localStack = Contentstack.Stack({
+        api_key: 'invalid_api_key_for_timing_test',
+        delivery_token: config.stack.delivery_token,
+        environment: config.stack.environment,
+        fetchOptions: {
+          retryLimit: RETRY_LIMIT,
+          retryDelay: RETRY_DELAY
+        }
+      });
+      localStack.setHost(config.host);
+
+      const contentTypeUID = TestDataHelper.getContentTypeUID('article', true);
+      const start = Date.now();
+
+      try {
+        await localStack.ContentType(contentTypeUID).Query().limit(1).toJSON().find();
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        const duration = Date.now() - start;
+
+        // If retried RETRY_LIMIT times: RETRY_LIMIT * RETRY_DELAY = 10 000ms
+        // Auth errors must be rejected immediately — well under one retry delay.
+        expect(duration).toBeLessThan(RETRY_DELAY);
+        expect(error.error_code).toBeDefined();
+
+        console.log(`✅ Auth error rejected in ${duration}ms — no retry delay (retryLimit=${RETRY_LIMIT}, retryDelay=${RETRY_DELAY}ms)`);
+      }
+    }, 12000);
+
+    test('RetryLogic_CustomRetryCondition_InvokesOnError_WithDelayBetweenRetries', async () => {
+      // retryCondition returning true routes through onError(), which applies
+      // retryDelay before each retry attempt.
+      // Bug this catches: if the retryCondition → onError() wiring is broken,
+      // the test fails immediately (no delays) instead of after >= 2 * retryDelay.
+      const RETRY_DELAY = 400;
+      const RETRY_LIMIT = 2;
+
+      const localStack = Contentstack.Stack({
+        ...config.stack,
+        fetchOptions: {
+          retryLimit: RETRY_LIMIT,
+          retryDelay: RETRY_DELAY,
+          retryCondition: (response) => response.status === 422
+        }
+      });
+      localStack.setHost(config.host);
+
+      const start = Date.now();
+
+      try {
+        await localStack.ContentType('non_existent_ct_retry_test_xyz').Query().limit(1).toJSON().find();
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        const duration = Date.now() - start;
+
+        // 2 retries × 400ms delay = minimum 800ms of intentional waiting.
+        // Subtract a small tolerance for scheduling jitter.
+        expect(duration).toBeGreaterThan(RETRY_LIMIT * RETRY_DELAY * 0.75);
+        expect(error).toBeDefined();
+
+        console.log(`✅ retryCondition triggered ${RETRY_LIMIT} retries, total ${duration}ms (min expected: ${RETRY_LIMIT * RETRY_DELAY}ms)`);
+      }
+    }, 20000);
+
+    test('RetryLogic_ZeroRetryLimit_NetworkFailure_RejectsWithoutWaiting', async () => {
+      // onError() checks retryLimit === 0 first and calls reject() immediately.
+      // The new socket-error path also has: if (isSocketOrAbort && retryLimit > 0).
+      // Bug this catches: if either guard is removed, a network failure with
+      // retryLimit=0 would enter a retry loop and add retryDelay * N ms of latency.
+      const RETRY_DELAY = 1500;
+
+      const localStack = Contentstack.Stack({
+        ...config.stack,
+        fetchOptions: {
+          retryLimit: 0,
+          retryDelay: RETRY_DELAY,
+          timeout: 3000
+        }
+      });
+      localStack.setHost('host-that-does-not-exist-xyz.contentstack.io');
+
+      const contentTypeUID = TestDataHelper.getContentTypeUID('article', true);
+      const start = Date.now();
+
+      try {
+        await localStack.ContentType(contentTypeUID).Query().limit(1).toJSON().find();
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        const duration = Date.now() - start;
+
+        // With retryLimit=0, no retry delays should be added at all.
+        expect(duration).toBeLessThan(RETRY_DELAY);
+        expect(error).toBeDefined();
+
+        console.log(`✅ retryLimit=0 rejects network failure in ${duration}ms (no ${RETRY_DELAY}ms retry delay added)`);
+      }
+    }, 10000);
+
+  });
+
   // =============================================================================
   // EDGE CASES
   // =============================================================================