@adtrackify/at-service-common 5.1.2 → 5.1.4

package/dist/cjs/__tests__/identity-cache/identity-cache-dynamodb-db-service.spec.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const at_shared_utils_1 = require("@adtrackify/at-shared-utils");
-vitest_1.vi.mock('../../clients/index.js', () => ({
+jest.mock('../../clients/index.js', () => ({
     DynamoDbClient: {
-        safeGet: vitest_1.vi.fn(),
-        safePut: vitest_1.vi.fn(),
-        safeDelete: vitest_1.vi.fn(),
-        safeBatchGet: vitest_1.vi.fn(),
-        safeBatchWrite: vitest_1.vi.fn(),
-        safeQueryByGSI: vitest_1.vi.fn(),
-        batchGet: vitest_1.vi.fn(),
-        batchWrite: vitest_1.vi.fn(),
+        safeGet: jest.fn(),
+        safePut: jest.fn(),
+        safeDelete: jest.fn(),
+        safeBatchGet: jest.fn(),
+        safeBatchWrite: jest.fn(),
+        safeQueryByGSI: jest.fn(),
+        batchGet: jest.fn(),
+        batchWrite: jest.fn(),
     },
 }));
-vitest_1.vi.mock('../../helpers/index.js', () => ({
+jest.mock('../../helpers/index.js', () => ({
     Logger: {
-        debug: vitest_1.vi.fn(),
-        info: vitest_1.vi.fn(),
-        warn: vitest_1.vi.fn(),
-        error: vitest_1.vi.fn(),
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
     },
 }));
 const identity_cache_dynamodb_db_service_js_1 = require("../../services/db/identity-cache-dynamodb-service/identity-cache-dynamodb-db-service.js");
@@ -28,18 +26,18 @@ const index_js_2 = require("../../helpers/index.js");
 const constants_js_1 = require("../../services/db/identity-cache-dynamodb-service/constants.js");
 const mockedDynamoDbClient = index_js_1.DynamoDbClient;
 const mockedLogger = index_js_2.Logger;
-(0, vitest_1.describe)('IdentityCacheDynamoDbDbService.getIdentityFromCachePure()', () => {
+describe('IdentityCacheDynamoDbDbService.getIdentityFromCachePure()', () => {
     const pixelId = 'pixel-test-123';
-    (0, vitest_1.beforeEach)(() => {
-        vitest_1.vi.clearAllMocks();
+    beforeEach(() => {
+        jest.clearAllMocks();
         mockedDynamoDbClient.safeGet.mockReset();
         mockedDynamoDbClient.safePut.mockReset();
         mockedDynamoDbClient.safeBatchWrite.mockReset();
         mockedDynamoDbClient.batchGet.mockReset();
         mockedDynamoDbClient.batchWrite.mockReset();
     });
-    (0, vitest_1.describe)('cache hit by identity ID', () => {
-        (0, vitest_1.it)('should return cachedIdentity with lookupPath=identity_id and cacheHit=true', async () => {
+    describe('cache hit by identity ID', () => {
+        it('should return cachedIdentity with lookupPath=identity_id and cacheHit=true', async () => {
             const incomingIdentity = {
                 identityId: 'identity-123',
                 traits: { emails: ['test@email.com'] },
@@ -59,14 +57,14 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(true);
-            (0, vitest_1.expect)(result.lookupPath).toBe('identity_id');
-            (0, vitest_1.expect)(result.cachedIdentity).toEqual(cachedRecord.response);
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBeUndefined();
-            (0, vitest_1.expect)(mockedDynamoDbClient.safeGet).toHaveBeenCalledTimes(1);
-            (0, vitest_1.expect)(mockedDynamoDbClient.safeGet).toHaveBeenCalledWith(vitest_1.expect.any(String), 'pk', `identity#${pixelId}#identity-123`);
-        });
-        (0, vitest_1.it)('should return cachedIdentity with all traits preserved', async () => {
+            expect(result.cacheHit).toBe(true);
+            expect(result.lookupPath).toBe('identity_id');
+            expect(result.cachedIdentity).toEqual(cachedRecord.response);
+            expect(result.discoveredIdentityId).toBeUndefined();
+            expect(mockedDynamoDbClient.safeGet).toHaveBeenCalledTimes(1);
+            expect(mockedDynamoDbClient.safeGet).toHaveBeenCalledWith(expect.any(String), 'pk', `identity#${pixelId}#identity-123`);
+        });
+        it('should return cachedIdentity with all traits preserved', async () => {
             const incomingIdentity = {
                 identityId: 'full-traits-id',
                 traits: { emails: ['new@email.com'] },
@@ -93,13 +91,13 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(true);
-            (0, vitest_1.expect)(result.cachedIdentity).toEqual(fullCachedIdentity);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.emails).toHaveLength(2);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.phones).toHaveLength(2);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.addresses).toHaveLength(1);
+            expect(result.cacheHit).toBe(true);
+            expect(result.cachedIdentity).toEqual(fullCachedIdentity);
+            expect(result.cachedIdentity?.traits?.emails).toHaveLength(2);
+            expect(result.cachedIdentity?.traits?.phones).toHaveLength(2);
+            expect(result.cachedIdentity?.traits?.addresses).toHaveLength(1);
         });
-        (0, vitest_1.it)('should NOT perform any merge logic', async () => {
+        it('should NOT perform any merge logic', async () => {
             const incomingIdentity = {
                 identityId: 'merge-test-id',
                 traits: {
@@ -122,11 +120,11 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.emails).toEqual(['old-email@test.com']);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.phones).toEqual(['111-2222']);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.emails).not.toContain('new-email@test.com');
+            expect(result.cachedIdentity?.traits?.emails).toEqual(['old-email@test.com']);
+            expect(result.cachedIdentity?.traits?.phones).toEqual(['111-2222']);
+            expect(result.cachedIdentity?.traits?.emails).not.toContain('new-email@test.com');
         });
-        (0, vitest_1.it)('should NOT perform staleness computation', async () => {
+        it('should NOT perform staleness computation', async () => {
             const incomingIdentity = {
                 identityId: 'stale-test-id',
                 traits: {
@@ -147,15 +145,15 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result).not.toHaveProperty('isCacheStale');
-            (0, vitest_1.expect)(result).not.toHaveProperty('staleTier');
-            (0, vitest_1.expect)(result).not.toHaveProperty('staleTracker');
-            (0, vitest_1.expect)(result).not.toHaveProperty('writeReason');
-            (0, vitest_1.expect)(result).not.toHaveProperty('skipNeptune');
+            expect(result).not.toHaveProperty('isCacheStale');
+            expect(result).not.toHaveProperty('staleTier');
+            expect(result).not.toHaveProperty('staleTracker');
+            expect(result).not.toHaveProperty('writeReason');
+            expect(result).not.toHaveProperty('skipNeptune');
         });
     });
-    (0, vitest_1.describe)('cache hit by email pointer', () => {
-        (0, vitest_1.it)('should return discoveredIdentityId with lookupPath=email_pointer and cacheHit=true', async () => {
+    describe('cache hit by email pointer', () => {
+        it('should return discoveredIdentityId with lookupPath=email_pointer and cacheHit=true', async () => {
             const incomingIdentity = {
                 traits: { emails: ['lookup@email.com'] },
             };
@@ -167,12 +165,12 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(emailPointerRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(true);
-            (0, vitest_1.expect)(result.lookupPath).toBe('email_pointer');
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBe('discovered-identity-456');
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
+            expect(result.cacheHit).toBe(true);
+            expect(result.lookupPath).toBe('email_pointer');
+            expect(result.discoveredIdentityId).toBe('discovered-identity-456');
+            expect(result.cachedIdentity).toBeUndefined();
         });
-        (0, vitest_1.it)('should use first email in emails array for lookup', async () => {
+        it('should use first email in emails array for lookup', async () => {
             const incomingIdentity = {
                 traits: { emails: ['first@email.com', 'second@email.com'] },
             };
@@ -184,10 +182,10 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(emailPointerRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBe('pointer-identity-789');
-            (0, vitest_1.expect)(mockedDynamoDbClient.safeGet).toHaveBeenCalledWith(vitest_1.expect.any(String), 'pk', `email#${pixelId}#first@email.com`);
+            expect(result.discoveredIdentityId).toBe('pointer-identity-789');
+            expect(mockedDynamoDbClient.safeGet).toHaveBeenCalledWith(expect.any(String), 'pk', `email#${pixelId}#first@email.com`);
         });
-        (0, vitest_1.it)('should NOT merge traits when returning email pointer discovery', async () => {
+        it('should NOT merge traits when returning email pointer discovery', async () => {
             const incomingIdentity = {
                 traits: {
                     emails: ['discovery@email.com'],
@@ -202,35 +200,35 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(emailPointerRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBe('discovered-id');
+            expect(result.cachedIdentity).toBeUndefined();
+            expect(result.discoveredIdentityId).toBe('discovered-id');
         });
     });
-    (0, vitest_1.describe)('cache miss', () => {
-        (0, vitest_1.it)('should return lookupPath=miss and cacheHit=false when identity not found', async () => {
+    describe('cache miss', () => {
+        it('should return lookupPath=miss and cacheHit=false when identity not found', async () => {
             const incomingIdentity = {
                 identityId: 'nonexistent-identity',
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('identity_id');
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBeUndefined();
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('identity_id');
+            expect(result.cachedIdentity).toBeUndefined();
+            expect(result.discoveredIdentityId).toBeUndefined();
         });
-        (0, vitest_1.it)('should return lookupPath=miss and cacheHit=false when email pointer not found', async () => {
+        it('should return lookupPath=miss and cacheHit=false when email pointer not found', async () => {
             const incomingIdentity = {
                 traits: { emails: ['unknown@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
-            (0, vitest_1.expect)(result.discoveredIdentityId).toBeUndefined();
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
+            expect(result.cachedIdentity).toBeUndefined();
+            expect(result.discoveredIdentityId).toBeUndefined();
         });
-        (0, vitest_1.it)('should return lookupPath=miss when cached record has no response field', async () => {
+        it('should return lookupPath=miss when cached record has no response field', async () => {
             const incomingIdentity = {
                 identityId: 'no-response-identity',
                 traits: { emails: ['test@email.com'] },
@@ -243,83 +241,83 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(incompleteRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('identity_id');
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('identity_id');
+            expect(result.cachedIdentity).toBeUndefined();
         });
-        (0, vitest_1.it)('should return lookupPath=miss when no email provided for pointer lookup', async () => {
+        it('should return lookupPath=miss when no email provided for pointer lookup', async () => {
             const incomingIdentity = {
                 traits: { phones: ['555-1234'] },
             };
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
-            (0, vitest_1.expect)(mockedDynamoDbClient.safeGet).not.toHaveBeenCalled();
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
+            expect(mockedDynamoDbClient.safeGet).not.toHaveBeenCalled();
         });
     });
-    (0, vitest_1.describe)('invalid input handling', () => {
-        (0, vitest_1.it)('should return cache miss for undefined pixelId', async () => {
+    describe('invalid input handling', () => {
+        it('should return cache miss for undefined pixelId', async () => {
             const incomingIdentity = {
                 identityId: 'test-identity',
                 traits: { emails: ['test@email.com'] },
             };
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(undefined, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
-            (0, vitest_1.expect)(mockedDynamoDbClient.safeGet).not.toHaveBeenCalled();
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
+            expect(mockedDynamoDbClient.safeGet).not.toHaveBeenCalled();
         });
-        (0, vitest_1.it)('should return cache miss for empty pixelId', async () => {
+        it('should return cache miss for empty pixelId', async () => {
             const incomingIdentity = {
                 identityId: 'test-identity',
                 traits: { emails: ['test@email.com'] },
             };
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure('', incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
         });
-        (0, vitest_1.it)('should return cache miss for undefined incomingIdentity', async () => {
+        it('should return cache miss for undefined incomingIdentity', async () => {
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, undefined);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
         });
-        (0, vitest_1.it)('should return cache miss for null incomingIdentity', async () => {
+        it('should return cache miss for null incomingIdentity', async () => {
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, null);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('miss');
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('miss');
         });
     });
-    (0, vitest_1.describe)('error handling', () => {
-        (0, vitest_1.it)('should return cache miss when DynamoDB throws an error', async () => {
+    describe('error handling', () => {
+        it('should return cache miss when DynamoDB throws an error', async () => {
             const incomingIdentity = {
                 identityId: 'error-test-identity',
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockRejectedValueOnce(new Error('DynamoDB connection failed'));
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('identity_id');
-            (0, vitest_1.expect)(result.cachedIdentity).toBeUndefined();
-            (0, vitest_1.expect)(mockedLogger.error).toHaveBeenCalledWith('IdentityCache - getItemByPk failed', vitest_1.expect.objectContaining({
-                error: vitest_1.expect.any(Error),
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('identity_id');
+            expect(result.cachedIdentity).toBeUndefined();
+            expect(mockedLogger.error).toHaveBeenCalledWith('IdentityCache - getItemByPk failed', expect.objectContaining({
+                error: expect.any(Error),
                 errorMessage: 'DynamoDB connection failed',
             }));
         });
-        (0, vitest_1.it)('should handle non-Error thrown values', async () => {
+        it('should handle non-Error thrown values', async () => {
             const incomingIdentity = {
                 identityId: 'string-error-identity',
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockRejectedValueOnce('String error message');
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cacheHit).toBe(false);
-            (0, vitest_1.expect)(result.lookupPath).toBe('identity_id');
-            (0, vitest_1.expect)(mockedLogger.error).toHaveBeenCalledWith('IdentityCache - getItemByPk failed', vitest_1.expect.objectContaining({
+            expect(result.cacheHit).toBe(false);
+            expect(result.lookupPath).toBe('identity_id');
+            expect(mockedLogger.error).toHaveBeenCalledWith('IdentityCache - getItemByPk failed', expect.objectContaining({
                 errorMessage: 'String error message',
             }));
         });
     });
-    (0, vitest_1.describe)('verification: no merge or staleness logic', () => {
-        (0, vitest_1.it)('should not call mergeIdentityTraits', async () => {
+    describe('verification: no merge or staleness logic', () => {
+        it('should not call mergeIdentityTraits', async () => {
             const incomingIdentity = {
                 identityId: 'verify-no-merge',
                 traits: { emails: ['incoming@email.com'] },
@@ -336,10 +334,10 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result.cachedIdentity).toBe(cachedRecord.response);
-            (0, vitest_1.expect)(result.cachedIdentity?.traits?.emails).toEqual(['cached@email.com']);
+            expect(result.cachedIdentity).toBe(cachedRecord.response);
+            expect(result.cachedIdentity?.traits?.emails).toEqual(['cached@email.com']);
         });
-        (0, vitest_1.it)('should not call isIdentityCacheStale', async () => {
+        it('should not call isIdentityCacheStale', async () => {
             const incomingIdentity = {
                 identityId: 'verify-no-staleness',
                 traits: {
@@ -358,9 +356,9 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(Object.keys(result)).toEqual(['cachedIdentity', 'lookupPath', 'cacheHit']);
+            expect(Object.keys(result)).toEqual(['cachedIdentity', 'lookupPath', 'cacheHit']);
         });
-        (0, vitest_1.it)('result should only contain pure lookup properties', async () => {
+        it('result should only contain pure lookup properties', async () => {
             const incomingIdentity = {
                 identityId: 'result-shape-test',
                 traits: { emails: ['test@email.com'] },
@@ -377,22 +375,22 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(result).toEqual({
+            expect(result).toEqual({
                 cachedIdentity: cachedRecord.response,
                 lookupPath: 'identity_id',
                 cacheHit: true,
             });
-            (0, vitest_1.expect)(result).not.toHaveProperty('resolvedIdentity');
-            (0, vitest_1.expect)(result).not.toHaveProperty('isCacheStale');
-            (0, vitest_1.expect)(result).not.toHaveProperty('staleTracker');
-            (0, vitest_1.expect)(result).not.toHaveProperty('staleTier');
-            (0, vitest_1.expect)(result).not.toHaveProperty('writeReason');
-            (0, vitest_1.expect)(result).not.toHaveProperty('skipNeptune');
-            (0, vitest_1.expect)(result).not.toHaveProperty('mergedIdentity');
+            expect(result).not.toHaveProperty('resolvedIdentity');
+            expect(result).not.toHaveProperty('isCacheStale');
+            expect(result).not.toHaveProperty('staleTracker');
+            expect(result).not.toHaveProperty('staleTier');
+            expect(result).not.toHaveProperty('writeReason');
+            expect(result).not.toHaveProperty('skipNeptune');
+            expect(result).not.toHaveProperty('mergedIdentity');
         });
     });
-    (0, vitest_1.describe)('logging', () => {
-        (0, vitest_1.it)('should log debug on cache hit by identity ID', async () => {
+    describe('logging', () => {
+        it('should log debug on cache hit by identity ID', async () => {
             const incomingIdentity = {
                 identityId: 'log-test-id',
                 traits: { emails: ['test@email.com'] },
@@ -409,24 +407,24 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedRecord);
             await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure lookup hit', vitest_1.expect.objectContaining({
+            expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure lookup hit', expect.objectContaining({
                 pixelId,
                 identityId: 'log-test-id',
             }));
         });
-        (0, vitest_1.it)('should log debug on cache miss', async () => {
+        it('should log debug on cache miss', async () => {
             const incomingIdentity = {
                 identityId: 'miss-log-test',
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
             await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure lookup miss', vitest_1.expect.objectContaining({
+            expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure lookup miss', expect.objectContaining({
                 pixelId,
                 identityId: 'miss-log-test',
             }));
         });
-        (0, vitest_1.it)('should log debug on email pointer discovery', async () => {
+        it('should log debug on email pointer discovery', async () => {
             const incomingIdentity = {
                 traits: { emails: ['email-pointer@test.com'] },
             };
@@ -438,21 +436,21 @@ const mockedLogger = index_js_2.Logger;
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(emailPointerRecord);
             await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            (0, vitest_1.expect)(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure email pointer discovery', vitest_1.expect.objectContaining({
+            expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache - pure email pointer discovery', expect.objectContaining({
                 pixelId,
                 discoveredIdentityId: 'discovered-from-pointer',
             }));
         });
     });
 });
-(0, vitest_1.describe)('IdentityCacheDynamoDbDbService cluster traits operations', () => {
+describe('IdentityCacheDynamoDbDbService cluster traits operations', () => {
     const pixelId = 'pixel-cluster';
     const primaryIdentityId = 'identity-primary';
     const secondaryIdentityId = 'identity-secondary';
-    (0, vitest_1.beforeEach)(() => {
-        vitest_1.vi.clearAllMocks();
+    beforeEach(() => {
+        jest.clearAllMocks();
     });
-    (0, vitest_1.it)('returns records by requested identity ID when every key is processed', async () => {
+    it('returns records by requested identity ID when every key is processed', async () => {
         const primaryRecord = {
             pk: `identity#${pixelId}#${primaryIdentityId}`,
             pixelId,
@@ -465,16 +463,13 @@ const mockedLogger = index_js_2.Logger;
             UnprocessedKeys: {},
             $metadata: {},
         });
-        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(result.complete).toBe(true);
-        (0, vitest_1.expect)(result.failedIdentityIds).toEqual([]);
-        (0, vitest_1.expect)(result.recordsByIdentityId.get(primaryIdentityId)).toEqual(primaryRecord);
-        (0, vitest_1.expect)(result.recordsByIdentityId.has(secondaryIdentityId)).toBe(false);
+        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(result.complete).toBe(true);
+        expect(result.failedIdentityIds).toEqual([]);
+        expect(result.recordsByIdentityId.get(primaryIdentityId)).toEqual(primaryRecord);
+        expect(result.recordsByIdentityId.has(secondaryIdentityId)).toBe(false);
     });
-    (0, vitest_1.it)('treats an unprocessed key as a failed read', async () => {
+    it('treats an unprocessed key as a failed read', async () => {
         mockedDynamoDbClient.batchGet.mockResolvedValue({
             Responses: { [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [] },
             UnprocessedKeys: {
@@ -484,23 +479,17 @@ const mockedLogger = index_js_2.Logger;
             },
             $metadata: {},
         });
-        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(result.complete).toBe(false);
-        (0, vitest_1.expect)(result.failedIdentityIds).toEqual([secondaryIdentityId]);
+        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(result.complete).toBe(false);
+        expect(result.failedIdentityIds).toEqual([secondaryIdentityId]);
     });
-    (0, vitest_1.it)('marks every key in a failed chunk as a failed read', async () => {
+    it('marks every key in a failed chunk as a failed read', async () => {
         mockedDynamoDbClient.batchGet.mockRejectedValue(new Error('read failed'));
-        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(result.complete).toBe(false);
-        (0, vitest_1.expect)(result.failedIdentityIds).toEqual([primaryIdentityId, secondaryIdentityId]);
+        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(result.complete).toBe(false);
+        expect(result.failedIdentityIds).toEqual([primaryIdentityId, secondaryIdentityId]);
     });
-    (0, vitest_1.it)('writes final primary traits and the migration marker in one item', async () => {
+    it('writes final primary traits and the migration marker in one item', async () => {
         mockedDynamoDbClient.safePut.mockResolvedValue({ $metadata: { httpStatusCode: 200 } });
         const success = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.putPrimaryIdentityTraits({
             pixelId,
@@ -508,8 +497,8 @@ const mockedLogger = index_js_2.Logger;
             traits: { emails: ['merged@test.com'] },
             traitsInDynamo: true,
         });
-        (0, vitest_1.expect)(success).toBe(true);
-        (0, vitest_1.expect)(mockedDynamoDbClient.safePut).toHaveBeenCalledWith(vitest_1.expect.any(String), vitest_1.expect.objectContaining({
+        expect(success).toBe(true);
+        expect(mockedDynamoDbClient.safePut).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
             pk: `identity#${pixelId}#${primaryIdentityId}`,
             identityId: primaryIdentityId,
             traitsInDynamo: true,
@@ -519,7 +508,7 @@ const mockedLogger = index_js_2.Logger;
             },
         }));
     });
-    (0, vitest_1.it)('reports a failed primary traits write', async () => {
+    it('reports a failed primary traits write', async () => {
         mockedDynamoDbClient.safePut.mockResolvedValue(null);
         const success = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.putPrimaryIdentityTraits({
             pixelId,
@@ -527,25 +516,20 @@ const mockedLogger = index_js_2.Logger;
             traits: {},
             traitsInDynamo: true,
         });
-        (0, vitest_1.expect)(success).toBe(false);
+        expect(success).toBe(false);
     });
-    (0, vitest_1.it)('deletes exact identity keys and returns unprocessed identity IDs', async () => {
+    it('deletes exact identity keys and returns unprocessed identity IDs', async () => {
         mockedDynamoDbClient.batchWrite.mockResolvedValue({
             UnprocessedItems: {
-                [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [
-                    {
+                [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [{
                         DeleteRequest: { Key: { pk: `identity#${pixelId}#${secondaryIdentityId}` } },
-                    },
-                ],
+                    }],
             },
             $metadata: {},
         });
-        const failedIdentityIds = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.deleteIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(failedIdentityIds).toEqual([secondaryIdentityId]);
-        (0, vitest_1.expect)(mockedDynamoDbClient.batchWrite).toHaveBeenCalledWith({
+        const failedIdentityIds = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.deleteIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(failedIdentityIds).toEqual([secondaryIdentityId]);
+        expect(mockedDynamoDbClient.batchWrite).toHaveBeenCalledWith({
             RequestItems: {
                 [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [
                     { DeleteRequest: { Key: { pk: `identity#${pixelId}#${primaryIdentityId}` } } },
@@ -554,26 +538,19 @@ const mockedLogger = index_js_2.Logger;
             },
         });
     });
-    (0, vitest_1.it)('returns every identity ID when an exact delete chunk fails', async () => {
+    it('returns every identity ID when an exact delete chunk fails', async () => {
         mockedDynamoDbClient.batchWrite.mockRejectedValue(new Error('delete failed'));
-        const failedIdentityIds = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.deleteIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(failedIdentityIds).toEqual([primaryIdentityId, secondaryIdentityId]);
+        const failedIdentityIds = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.deleteIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(failedIdentityIds).toEqual([primaryIdentityId, secondaryIdentityId]);
     });
-    (0, vitest_1.it)('deduplicates requested identity IDs before issuing batchGet', async () => {
+    it('deduplicates requested identity IDs before issuing batchGet', async () => {
         mockedDynamoDbClient.batchGet.mockResolvedValue({
             Responses: { [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [] },
             UnprocessedKeys: {},
             $metadata: {},
         });
-        await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [
-            primaryIdentityId,
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(mockedDynamoDbClient.batchGet).toHaveBeenCalledWith({
+        await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId, primaryIdentityId, secondaryIdentityId]);
+        expect(mockedDynamoDbClient.batchGet).toHaveBeenCalledWith({
             RequestItems: {
                 [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: {
                     Keys: [
@@ -584,21 +561,18 @@ const mockedLogger = index_js_2.Logger;
             },
         });
     });
-    (0, vitest_1.it)('treats a processed key with no returned item as a successful miss', async () => {
+    it('treats a processed key with no returned item as a successful miss', async () => {
         mockedDynamoDbClient.batchGet.mockResolvedValue({
             Responses: { [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [] },
             UnprocessedKeys: {},
             $metadata: {},
         });
-        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [
-            primaryIdentityId,
-            secondaryIdentityId,
-        ]);
-        (0, vitest_1.expect)(result.complete).toBe(true);
-        (0, vitest_1.expect)(result.failedIdentityIds).toEqual([]);
-        (0, vitest_1.expect)(result.recordsByIdentityId.size).toBe(0);
+        const result = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId, secondaryIdentityId]);
+        expect(result.complete).toBe(true);
+        expect(result.failedIdentityIds).toEqual([]);
+        expect(result.recordsByIdentityId.size).toBe(0);
     });
-    (0, vitest_1.it)('reports a failed primary traits write when safePut throws', async () => {
+    it('reports a failed primary traits write when safePut throws', async () => {
         mockedDynamoDbClient.safePut.mockRejectedValue(new Error('put failed'));
         const success = await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.putPrimaryIdentityTraits({
             pixelId,
@@ -606,38 +580,41 @@ const mockedLogger = index_js_2.Logger;
             traits: { emails: ['merged@test.com'] },
             traitsInDynamo: true,
         });
-        (0, vitest_1.expect)(success).toBe(false);
-        (0, vitest_1.expect)(mockedLogger.error).toHaveBeenCalledWith('IdentityCache [primary traits write]: failed', vitest_1.expect.objectContaining({ pixelId, primaryIdentityId }));
+        expect(success).toBe(false);
+        expect(mockedLogger.error).toHaveBeenCalledWith('IdentityCache [primary traits write]: failed', expect.objectContaining({ pixelId, primaryIdentityId }));
     });
-    (0, vitest_1.it)('deletes exact identity PKs without querying GSI1', async () => {
+    it('deletes exact identity PKs without querying GSI1', async () => {
         mockedDynamoDbClient.batchWrite.mockResolvedValue({
             UnprocessedItems: {},
             $metadata: {},
         });
         await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.deleteIdentityRecords(pixelId, [secondaryIdentityId]);
-        (0, vitest_1.expect)(mockedDynamoDbClient.safeQueryByGSI).not.toHaveBeenCalled();
-        (0, vitest_1.expect)(mockedDynamoDbClient.batchWrite).toHaveBeenCalledWith({
+        expect(mockedDynamoDbClient.safeQueryByGSI).not.toHaveBeenCalled();
+        expect(mockedDynamoDbClient.batchWrite).toHaveBeenCalledWith({
             RequestItems: {
-                [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [{ DeleteRequest: { Key: { pk: `identity#${pixelId}#${secondaryIdentityId}` } } }],
+                [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [
+                    { DeleteRequest: { Key: { pk: `identity#${pixelId}#${secondaryIdentityId}` } } },
+                ],
             },
         });
     });
-    (0, vitest_1.it)('logs cluster read completion with requested identity IDs', async () => {
+    it('logs cluster read completion with requested identity IDs', async () => {
         mockedDynamoDbClient.batchGet.mockResolvedValue({
             Responses: { [constants_js_1.IDENTITY_CACHE_TABLE_NAME]: [] },
             UnprocessedKeys: {},
             $metadata: {},
         });
         await identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getClusterIdentityRecords(pixelId, [primaryIdentityId]);
-        (0, vitest_1.expect)(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache [cluster traits read]: completed', vitest_1.expect.objectContaining({
+        expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityCache [cluster traits read]: completed', expect.objectContaining({
             pixelId,
             identityIds: [primaryIdentityId],
         }));
     });
 });
-(0, vitest_1.describe)('mergeAndComputeIdentityStaleness (pure function)', () => {
-    (0, vitest_1.describe)('merge behavior', () => {
-        (0, vitest_1.it)('should merge incoming traits with cached traits', () => {
+describe('mergeAndComputeIdentityStaleness (pure function)', () => {
+    const { mergeAndComputeIdentityStaleness, IDENTITY_CACHE_STALENESS_TIER } = jest.requireActual('@adtrackify/at-shared-utils');
+    describe('merge behavior', () => {
+        it('should merge incoming traits with cached traits', () => {
             const incomingIdentity = {
                 identityId: 'merge-test',
                 traits: {
@@ -651,14 +628,14 @@ const mockedLogger = index_js_2.Logger;
                     phones: ['555-1234'],
                 },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.mergedIdentity.traits?.emails).toContain('new@email.com');
-            (0, vitest_1.expect)(result.mergedIdentity.traits?.emails).toContain('cached@email.com');
-            (0, vitest_1.expect)(result.mergedIdentity.traits?.phones).toContain('555-1234');
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.mergedIdentity.traits?.emails).toContain('new@email.com');
+            expect(result.mergedIdentity.traits?.emails).toContain('cached@email.com');
+            expect(result.mergedIdentity.traits?.phones).toContain('555-1234');
         });
     });
-    (0, vitest_1.describe)('staleness tier computation', () => {
-        (0, vitest_1.it)('should return NONE tier when no traits are stale', () => {
+    describe('staleness tier computation', () => {
+        it('should return NONE tier when no traits are stale', () => {
             const incomingIdentity = {
                 identityId: 'same-test',
                 traits: { emails: ['same@email.com'] },
@@ -667,11 +644,11 @@ const mockedLogger = index_js_2.Logger;
                 identityId: 'same-test',
                 traits: { emails: ['same@email.com'] },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.NONE);
-            (0, vitest_1.expect)(result.isCacheStale).toBe(false);
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.NONE);
+            expect(result.isCacheStale).toBe(false);
         });
-        (0, vitest_1.it)('should return VOLATILE_ONLY tier when incoming has new IP address (cached has none)', () => {
+        it('should return VOLATILE_ONLY tier when incoming has new IP address (cached has none)', () => {
             const incomingIdentity = {
                 identityId: 'volatile-test',
                 traits: {
@@ -685,11 +662,11 @@ const mockedLogger = index_js_2.Logger;
                     emails: ['same@email.com'],
                 },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.VOLATILE_ONLY);
-            (0, vitest_1.expect)(result.isCacheStale).toBe(false);
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.VOLATILE_ONLY);
+            expect(result.isCacheStale).toBe(false);
         });
-        (0, vitest_1.it)('should return ADDRESS_UPDATE tier when non-IP address is new', () => {
+        it('should return ADDRESS_UPDATE tier when non-IP address is new', () => {
             const incomingIdentity = {
                 identityId: 'address-test',
                 traits: {
@@ -704,11 +681,11 @@ const mockedLogger = index_js_2.Logger;
                     addresses: [],
                 },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.ADDRESS_UPDATE);
-            (0, vitest_1.expect)(result.isCacheStale).toBe(true);
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.ADDRESS_UPDATE);
+            expect(result.isCacheStale).toBe(true);
         });
-        (0, vitest_1.it)('should return IDENTITY_STALE tier when email changes', () => {
+        it('should return IDENTITY_STALE tier when email changes', () => {
             const incomingIdentity = {
                 identityId: 'stale-test',
                 traits: {
@@ -721,13 +698,13 @@ const mockedLogger = index_js_2.Logger;
                     emails: ['old@email.com'],
                 },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.IDENTITY_STALE);
-            (0, vitest_1.expect)(result.isCacheStale).toBe(true);
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.IDENTITY_STALE);
+            expect(result.isCacheStale).toBe(true);
         });
     });
-    (0, vitest_1.describe)('staleTraits extraction', () => {
-        (0, vitest_1.it)('should include changed trait names in staleTraits array', () => {
+    describe('staleTraits extraction', () => {
+        it('should include changed trait names in staleTraits array', () => {
             const incomingIdentity = {
                 identityId: 'traits-test',
                 traits: {
@@ -742,9 +719,9 @@ const mockedLogger = index_js_2.Logger;
                     phones: ['111-2222'],
                 },
             };
-            const result = (0, at_shared_utils_1.mergeAndComputeIdentityStaleness)(incomingIdentity, cachedIdentity);
-            (0, vitest_1.expect)(result.staleTraits).toContain('emails');
-            (0, vitest_1.expect)(result.staleTraits).toContain('phones');
+            const result = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+            expect(result.staleTraits).toContain('emails');
+            expect(result.staleTraits).toContain('phones');
         });
     });
 });