@adtrackify/at-service-common 5.0.7 → 5.1.2

package/dist/esm/__tests__/identity-cache/identity-cache-tier-routing.spec.js

@@ -1,630 +1,639 @@
-import { ADDRESS_INFO_SOURCE } from '@adtrackify/at-tracking-event-types';
-const mockLambdaInvoke = jest.fn();
-const mockBuildAndSendMessage = jest.fn();
-const mockSQSClientConstructor = jest.fn();
-jest.mock('../../clients/index.js', () => ({
-    DynamoDbClient: {
-        safeGet: jest.fn(),
-        safePut: jest.fn(),
-        safeDelete: jest.fn(),
-        safeBatchGet: jest.fn(),
-        safeBatchWrite: jest.fn(),
-        safeQueryByGSI: jest.fn(),
-        batchWrite: jest.fn(),
-    },
-    LambdaInvokeClient: jest.fn().mockImplementation(() => ({
-        invokeFunction: mockLambdaInvoke,
-    })),
-    SQSClient: jest.fn().mockImplementation((_region, _accountId, _queueName) => {
-        mockSQSClientConstructor(_region, _accountId, _queueName);
-        return {
-            buildAndSendMessage: mockBuildAndSendMessage,
-            queueUrl: `https://sqs.${_region}.amazonaws.com/${_accountId}/${_queueName}`,
-        };
-    }),
-}));
-jest.mock('../../helpers/index.js', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-const mockGetIdentity = jest.fn();
-jest.mock('../../clients/internal-api/identity-client.js', () => ({
-    IdentityClient: jest.fn().mockImplementation(() => ({
-        getIdentity: mockGetIdentity,
-    })),
-}));
-import { IdentityGatewayService, } from '../../services/db/identity-cache-dynamodb-service/identity-gateway-service.js';
-import { IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from '../../services/db/identity-cache-dynamodb-service/types.js';
-import { DynamoDbClient, SQSClient } from '../../clients/index.js';
-const mockedDynamoDbClient = DynamoDbClient;
-const _mockedSQSClient = SQSClient;
-const createService = (options = { identifyPrivateLambdaArn: 'arn:aws:lambda:us-east-1:123456789:function:identity-private' }) => {
-    return new IdentityGatewayService(options);
-};
-describe('Identity Cache Three-Tier Routing', () => {
-    const pixelId = 'pixel123';
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedDynamoDbClient.safeGet.mockReset();
-        mockedDynamoDbClient.safePut.mockReset();
-        mockedDynamoDbClient.safeDelete.mockReset();
-        mockedDynamoDbClient.safeBatchGet.mockReset();
-        mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockedDynamoDbClient.safeQueryByGSI.mockReset();
-        mockedDynamoDbClient.batchWrite.mockReset();
-        mockGetIdentity.mockReset();
-        mockBuildAndSendMessage.mockReset();
-        mockSQSClientConstructor.mockReset();
-        _mockedSQSClient.mockClear();
-        service = createService();
-    });
-    describe('TIER: VOLATILE_ONLY — Returns merged identity, NO Neptune, NO cache write', () => {
-        it('should return merged identity without Neptune call when only ipAddress is stale', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    ipAddress: '10.0.0.1',
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        ipAddress: '192.168.1.1',
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(result.identity?.identityId).toBe('identity456');
-            expect(mockGetIdentity).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should return merged identity without Neptune call when only userAgent is stale', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    userAgent: 'Chrome/120.0',
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        userAgent: 'Mozilla/5.0',
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(mockGetIdentity).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should return merged identity without Neptune call when only IP-sourced addresses are stale', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'New York', s: ADDRESS_INFO_SOURCE.IP_ADDRESS }],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [{ city: 'Chicago', s: ADDRESS_INFO_SOURCE.IP_ADDRESS }],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(mockGetIdentity).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-    });
-    describe('TIER: IDENTITY_STALE — Calls Neptune AND writes to cache', () => {
-        it('should call Neptune and write to cache when emails are stale', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['old@email.com'],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { emails: ['old@email.com', 'new@email.com', 'resolved@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(mockGetIdentity).toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should call Neptune and write to cache when phones are stale', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    phones: ['+1234567890', '+9876543210'],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        phones: ['+1234567890'],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { phones: ['+1234567890', '+9876543210'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(mockGetIdentity).toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should return NEPTUNE_WRITE_BACK outcome with staleTraits in summary', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: { emails: ['old@email.com'] },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.stalenessResult?.staleTraits).toContain('emails');
-            expect(result.didCallNeptune).toBe(true);
-            expect(result.didWriteCache).toBe(false);
-        });
-    });
-    describe('CACHE_MISS — Calls Neptune AND writes to cache', () => {
-        it('should call Neptune and write to cache on complete cache miss', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: { emails: ['test@email.com'] },
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { emails: ['test@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity).toBeDefined();
-            expect(mockGetIdentity).toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should return NEPTUNE_WRITE_BACK outcome for cache miss', async () => {
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: { emails: ['test@email.com'] },
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { emails: ['test@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.didCallNeptune).toBe(true);
-            expect(result.didWriteCache).toBe(false);
-        });
-    });
-    describe('EMAIL_POINTER_DISCOVERY — Calls Neptune with discovered identityId', () => {
-        it('should call Neptune with discovered identityId from email pointer', async () => {
-            const incomingIdentity = {
-                traits: { emails: ['test@email.com'] },
-            };
-            const pointerRecord = {
-                pk: `email#${pixelId}#test@email.com`,
-                pixelId,
-                identityId: 'discovered-id',
-                gsi1pk: 'discovered-id',
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(pointerRecord);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'discovered-id',
-                traits: { emails: ['test@email.com', 'other@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity?.identityId).toBe('discovered-id');
-            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
-                identity: expect.objectContaining({
-                    identityId: 'discovered-id',
-                    traits: expect.objectContaining({ emails: ['test@email.com'] }),
-                }),
-            }));
-        });
-    });
-});
-describe('Identity Cache stripAddressTimestamps', () => {
-    const pixelId = 'pixel123';
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedDynamoDbClient.safeGet.mockReset();
-        mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockGetIdentity.mockReset();
-        service = createService();
-    });
-    it('should strip cra and upa from addresses during comparison', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [
-                    {
-                        city: 'Test City',
-                        s: ADDRESS_INFO_SOURCE.INPUT,
-                        cra: Date.parse('2024-01-01T00:00:00Z'),
-                        upa: Date.parse('2024-01-15T00:00:00Z'),
-                    },
-                ],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [
-                        {
-                            city: 'Test City',
-                            s: ADDRESS_INFO_SOURCE.INPUT,
-                            cra: Date.parse('2023-06-01T00:00:00Z'),
-                            upa: Date.parse('2023-12-01T00:00:00Z'),
-                        },
-                    ],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-    });
-    it('should NOT mutate the original object when stripping timestamps', async () => {
-        const originalAddress = {
-            city: 'Original City',
-            s: ADDRESS_INFO_SOURCE.INPUT,
-            cra: Date.parse('2024-01-01T00:00:00Z'),
-            upa: Date.parse('2024-01-15T00:00:00Z'),
-        };
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [{ ...originalAddress }],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [
-                        {
-                            city: 'Original City',
-                            s: ADDRESS_INFO_SOURCE.INPUT,
-                            cra: Date.parse('2023-06-01T00:00:00Z'),
-                            upa: Date.parse('2023-06-15T00:00:00Z'),
-                        },
-                    ],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('cra');
-        expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('upa');
-        expect(cachedResponse.response.traits?.addresses?.[0]).toHaveProperty('cra');
-        expect(cachedResponse.response.traits?.addresses?.[0]).toHaveProperty('upa');
-    });
-    it('should handle identity with no addresses', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-    });
-    it('should handle identity with empty addresses array', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-    });
-    it('should handle addresses without cra/upa (no-op)', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [{ city: 'Simple City', s: ADDRESS_INFO_SOURCE.INPUT }],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'Simple City', s: ADDRESS_INFO_SOURCE.INPUT }],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-    });
-});
-describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
-    const pixelId = 'pixel123';
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedDynamoDbClient.safeGet.mockReset();
-        mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockGetIdentity.mockReset();
-        service = createService();
-    });
-    it('should treat cached and merged as equal when they differ ONLY in cra/upa', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [
-                    {
-                        city: 'Same City',
-                        province: 'Same State',
-                        country: 'Same Country',
-                        s: ADDRESS_INFO_SOURCE.INPUT,
-                        cra: Date.parse('2024-06-01T00:00:00Z'),
-                        upa: Date.parse('2024-06-15T00:00:00Z'),
-                    },
-                ],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [
-                        {
-                            city: 'Same City',
-                            province: 'Same State',
-                            country: 'Same Country',
-                            s: ADDRESS_INFO_SOURCE.INPUT,
-                            cra: Date.parse('2024-01-01T00:00:00Z'),
-                            upa: Date.parse('2024-01-15T00:00:00Z'),
-                        },
-                    ],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-        expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-    });
-    it('should treat cached and merged as NOT equal when address content differs (plus cra/upa)', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [
-                    {
-                        city: 'Different City',
-                        province: 'Same State',
-                        s: ADDRESS_INFO_SOURCE.INPUT,
-                        cra: Date.parse('2024-06-01T00:00:00Z'),
-                        upa: Date.parse('2024-06-15T00:00:00Z'),
-                    },
-                ],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [
-                        {
-                            city: 'Original City',
-                            province: 'Same State',
-                            s: ADDRESS_INFO_SOURCE.INPUT,
-                            cra: Date.parse('2024-01-01T00:00:00Z'),
-                            upa: Date.parse('2024-01-15T00:00:00Z'),
-                        },
-                    ],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.identity).toBeDefined();
-    });
-});
-describe('Identity Cache Logging Levels', () => {
-    const pixelId = 'pixel123';
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedDynamoDbClient.safeGet.mockReset();
-        mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockGetIdentity.mockReset();
-        service = createService();
-    });
-    it('should return fresh cache hit without calling Neptune or writing cache', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-        expect(mockGetIdentity).not.toHaveBeenCalled();
-        expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-    });
-    it('should return NEPTUNE_WRITE_BACK outcome with traitChanges for stale traits', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['old@email.com', 'new@email.com'],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['old@email.com'],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        mockGetIdentity.mockResolvedValueOnce({
-            identityId: 'identity456',
-            traits: { emails: ['old@email.com', 'new@email.com'] },
-        });
-        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-        expect(result.stalenessResult?.staleTraits).toContain('emails');
-        expect(result.traitChanges).toBeDefined();
-        expect(result.didCallNeptune).toBe(true);
-        expect(result.didWriteCache).toBe(false);
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ADDRESS_INFO_SOURCE } from '@adtrackify/at-tracking-event-types';
+const mockLambdaInvoke = vi.fn();
+const mockBuildAndSendMessage = vi.fn();
+const mockSQSClientConstructor = vi.fn();
+vi.mock('../../clients/index.js', () => ({
+    DynamoDbClient: {
+        safeGet: vi.fn(),
+        safePut: vi.fn(),
+        safeDelete: vi.fn(),
+        safeBatchGet: vi.fn(),
+        safeBatchWrite: vi.fn(),
+        safeQueryByGSI: vi.fn(),
+        batchWrite: vi.fn(),
+    },
+    LambdaInvokeClient: vi.fn().mockImplementation(function () {
+        return {
+            invokeFunction: mockLambdaInvoke,
+        };
+    }),
+    SQSClient: vi
+        .fn()
+        .mockImplementation(function (_region, _accountId, _queueName) {
+        mockSQSClientConstructor(_region, _accountId, _queueName);
+        return {
+            buildAndSendMessage: mockBuildAndSendMessage,
+            queueUrl: `https://sqs.${_region}.amazonaws.com/${_accountId}/${_queueName}`,
+        };
+    }),
+}));
+vi.mock('../../helpers/index.js', () => ({
+    Logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
+const mockGetIdentity = vi.fn();
+vi.mock('../../clients/internal-api/identity-client.js', () => ({
+    IdentityClient: vi.fn().mockImplementation(function () {
+        return {
+            getIdentity: mockGetIdentity,
+        };
+    }),
+}));
+import { IdentityGatewayService, } from '../../services/db/identity-cache-dynamodb-service/identity-gateway-service.js';
+import { IDENTITY_CACHE_WITH_CACHING_OUTCOME } from '../../services/db/identity-cache-dynamodb-service/types.js';
+import { DynamoDbClient, SQSClient } from '../../clients/index.js';
+const mockedDynamoDbClient = DynamoDbClient;
+const _mockedSQSClient = SQSClient;
+const createService = (options = {
+    identifyPrivateLambdaArn: 'arn:aws:lambda:us-east-1:123456789:function:identity-private',
+}) => {
+    return new IdentityGatewayService(options);
+};
+describe('Identity Cache Three-Tier Routing', () => {
+    const pixelId = 'pixel123';
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockedDynamoDbClient.safeGet.mockReset();
+        mockedDynamoDbClient.safePut.mockReset();
+        mockedDynamoDbClient.safeDelete.mockReset();
+        mockedDynamoDbClient.safeBatchGet.mockReset();
+        mockedDynamoDbClient.safeBatchWrite.mockReset();
+        mockedDynamoDbClient.safeQueryByGSI.mockReset();
+        mockedDynamoDbClient.batchWrite.mockReset();
+        mockGetIdentity.mockReset();
+        mockBuildAndSendMessage.mockReset();
+        mockSQSClientConstructor.mockReset();
+        _mockedSQSClient.mockClear();
+        service = createService();
+    });
+    describe('TIER: VOLATILE_ONLY — Returns merged identity, NO Neptune, NO cache write', () => {
+        it('should return merged identity without Neptune call when only ipAddress is stale', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    ipAddress: '10.0.0.1',
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        emails: ['test@email.com'],
+                        ipAddress: '192.168.1.1',
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(result.identity?.identityId).toBe('identity456');
+            expect(mockGetIdentity).not.toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should return merged identity without Neptune call when only userAgent is stale', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    userAgent: 'Chrome/120.0',
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        emails: ['test@email.com'],
+                        userAgent: 'Mozilla/5.0',
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(mockGetIdentity).not.toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should return merged identity without Neptune call when only IP-sourced addresses are stale', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [{ city: 'New York', s: ADDRESS_INFO_SOURCE.IP_ADDRESS }],
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        emails: ['test@email.com'],
+                        addresses: [{ city: 'Chicago', s: ADDRESS_INFO_SOURCE.IP_ADDRESS }],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(mockGetIdentity).not.toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+    });
+    describe('TIER: IDENTITY_STALE — Calls Neptune AND writes to cache', () => {
+        it('should call Neptune and write to cache when emails are stale', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        emails: ['old@email.com'],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['old@email.com', 'new@email.com', 'resolved@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(mockGetIdentity).toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should call Neptune and write to cache when phones are stale', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    phones: ['+1234567890', '+9876543210'],
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        phones: ['+1234567890'],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { phones: ['+1234567890', '+9876543210'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(mockGetIdentity).toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should return NEPTUNE_WRITE_BACK outcome with staleTraits in summary', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                },
+            };
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: { emails: ['old@email.com'] },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(result.stalenessResult?.staleTraits).toContain('emails');
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
+        });
+    });
+    describe('CACHE_MISS — Calls Neptune AND writes to cache', () => {
+        it('should call Neptune and write to cache on complete cache miss', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity).toBeDefined();
+            expect(mockGetIdentity).toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should return NEPTUNE_WRITE_BACK outcome for cache miss', async () => {
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
+        });
+    });
+    describe('EMAIL_POINTER_DISCOVERY — Calls Neptune with discovered identityId', () => {
+        it('should call Neptune with discovered identityId from email pointer', async () => {
+            const incomingIdentity = {
+                traits: { emails: ['test@email.com'] },
+            };
+            const pointerRecord = {
+                pk: `email#${pixelId}#test@email.com`,
+                pixelId,
+                identityId: 'discovered-id',
+                gsi1pk: 'discovered-id',
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(pointerRecord);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'discovered-id',
+                traits: { emails: ['test@email.com', 'other@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity?.identityId).toBe('discovered-id');
+            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
+                identity: expect.objectContaining({
+                    identityId: 'discovered-id',
+                    traits: expect.objectContaining({ emails: ['test@email.com'] }),
+                }),
+            }));
+        });
+    });
+});
+describe('Identity Cache stripAddressTimestamps', () => {
+    const pixelId = 'pixel123';
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockedDynamoDbClient.safeGet.mockReset();
+        mockedDynamoDbClient.safeBatchWrite.mockReset();
+        mockGetIdentity.mockReset();
+        service = createService();
+    });
+    it('should strip cra and upa from addresses during comparison', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [
+                    {
+                        city: 'Test City',
+                        s: ADDRESS_INFO_SOURCE.INPUT,
+                        cra: Date.parse('2024-01-01T00:00:00Z'),
+                        upa: Date.parse('2024-01-15T00:00:00Z'),
+                    },
+                ],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [
+                        {
+                            city: 'Test City',
+                            s: ADDRESS_INFO_SOURCE.INPUT,
+                            cra: Date.parse('2023-06-01T00:00:00Z'),
+                            upa: Date.parse('2023-12-01T00:00:00Z'),
+                        },
+                    ],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+    });
+    it('should NOT mutate the original object when stripping timestamps', async () => {
+        const originalAddress = {
+            city: 'Original City',
+            s: ADDRESS_INFO_SOURCE.INPUT,
+            cra: Date.parse('2024-01-01T00:00:00Z'),
+            upa: Date.parse('2024-01-15T00:00:00Z'),
+        };
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [{ ...originalAddress }],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [
+                        {
+                            city: 'Original City',
+                            s: ADDRESS_INFO_SOURCE.INPUT,
+                            cra: Date.parse('2023-06-01T00:00:00Z'),
+                            upa: Date.parse('2023-06-15T00:00:00Z'),
+                        },
+                    ],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('cra');
+        expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('upa');
+        expect(cachedResponse.response.traits?.addresses?.[0]).toHaveProperty('cra');
+        expect(cachedResponse.response.traits?.addresses?.[0]).toHaveProperty('upa');
+    });
+    it('should handle identity with no addresses', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+    });
+    it('should handle identity with empty addresses array', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+    });
+    it('should handle addresses without cra/upa (no-op)', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [{ city: 'Simple City', s: ADDRESS_INFO_SOURCE.INPUT }],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [{ city: 'Simple City', s: ADDRESS_INFO_SOURCE.INPUT }],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+    });
+});
+describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
+    const pixelId = 'pixel123';
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockedDynamoDbClient.safeGet.mockReset();
+        mockedDynamoDbClient.safeBatchWrite.mockReset();
+        mockGetIdentity.mockReset();
+        service = createService();
+    });
+    it('should treat cached and merged as equal when they differ ONLY in cra/upa', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [
+                    {
+                        city: 'Same City',
+                        province: 'Same State',
+                        country: 'Same Country',
+                        s: ADDRESS_INFO_SOURCE.INPUT,
+                        cra: Date.parse('2024-06-01T00:00:00Z'),
+                        upa: Date.parse('2024-06-15T00:00:00Z'),
+                    },
+                ],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [
+                        {
+                            city: 'Same City',
+                            province: 'Same State',
+                            country: 'Same Country',
+                            s: ADDRESS_INFO_SOURCE.INPUT,
+                            cra: Date.parse('2024-01-01T00:00:00Z'),
+                            upa: Date.parse('2024-01-15T00:00:00Z'),
+                        },
+                    ],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+        expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+    });
+    it('should treat cached and merged as NOT equal when address content differs (plus cra/upa)', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+                addresses: [
+                    {
+                        city: 'Different City',
+                        province: 'Same State',
+                        s: ADDRESS_INFO_SOURCE.INPUT,
+                        cra: Date.parse('2024-06-01T00:00:00Z'),
+                        upa: Date.parse('2024-06-15T00:00:00Z'),
+                    },
+                ],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [
+                        {
+                            city: 'Original City',
+                            province: 'Same State',
+                            s: ADDRESS_INFO_SOURCE.INPUT,
+                            cra: Date.parse('2024-01-01T00:00:00Z'),
+                            upa: Date.parse('2024-01-15T00:00:00Z'),
+                        },
+                    ],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.identity).toBeDefined();
+    });
+});
+describe('Identity Cache Logging Levels', () => {
+    const pixelId = 'pixel123';
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockedDynamoDbClient.safeGet.mockReset();
+        mockedDynamoDbClient.safeBatchWrite.mockReset();
+        mockGetIdentity.mockReset();
+        service = createService();
+    });
+    it('should return fresh cache hit without calling Neptune or writing cache', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['test@email.com'],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
+        expect(mockGetIdentity).not.toHaveBeenCalled();
+        expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+    });
+    it('should return NEPTUNE_WRITE_BACK outcome with traitChanges for stale traits', async () => {
+        const incomingIdentity = {
+            identityId: 'identity456',
+            traits: {
+                emails: ['old@email.com', 'new@email.com'],
+            },
+        };
+        const cachedResponse = {
+            pk: `identity#${pixelId}#identity456`,
+            pixelId,
+            identityId: 'identity456',
+            response: {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['old@email.com'],
+                },
+            },
+            updatedAt: new Date().toISOString(),
+        };
+        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+        mockGetIdentity.mockResolvedValueOnce({
+            identityId: 'identity456',
+            traits: { emails: ['old@email.com', 'new@email.com'] },
+        });
+        const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+        expect(result.stalenessResult?.staleTraits).toContain('emails');
+        expect(result.traitChanges).toBeDefined();
+        expect(result.didCallNeptune).toBe(true);
+        expect(result.didWriteCache).toBe(false);
+    });
+});
 //# sourceMappingURL=identity-cache-tier-routing.spec.js.map