@adtrackify/at-service-common 4.0.25 → 4.0.28

package/dist/esm/__tests__/identity-cache/identity-client.spec.js

@@ -1,358 +1,358 @@
-const mockFns = {
-    invokeFunction: jest.fn(),
-    post: jest.fn(),
-    get: jest.fn(),
-    setBaseUrl: jest.fn(),
-};
-jest.mock('../../clients/generic', () => ({
-    __esModule: true,
-    axiosHttpService: jest.fn(() => ({
-        post: (...args) => mockFns.post(...args),
-        get: (...args) => mockFns.get(...args),
-        setBaseUrl: (...args) => mockFns.setBaseUrl(...args),
-    })),
-    LambdaInvokeClient: jest.fn().mockImplementation(() => ({
-        invokeFunction: (...args) => mockFns.invokeFunction(...args),
-    })),
-}));
-jest.mock('../../helpers', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-jest.mock('../../libs', () => ({
-    HttpStatusCodes: { OK: 200 },
-}));
-import { IdentityClient } from '../../clients/internal-api/identity-client.js';
-const { Logger } = jest.requireMock('../../helpers');
-const { LambdaInvokeClient } = jest.requireMock('../../clients/generic');
-const TEST_BASE_URL = 'https://api.example.com';
-const TEST_API_KEY = 'api-key-123';
-const TEST_LAMBDA_ARN = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
-const TEST_PIXEL_ID = 'pixel-abc';
-const buildMockIdentity = (overrides = {}) => ({
-    identityId: 'id-resolved',
-    traits: { emails: ['test@example.com'] },
-    ...overrides,
-});
-const buildMockEventContext = (overrides = {}) => ({
-    identity: { identityId: 'id-from-context', traits: {} },
-    ...overrides,
-});
-describe('IdentityClient', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('constructor', () => {
-        it('should set BASE_API_URL and SERVICE_API_ROOT_URL from string argument', () => {
-            const client = new IdentityClient(TEST_BASE_URL);
-            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
-            expect(client.SERVICE_API_ROOT_URL).toBe(`${TEST_BASE_URL}/identities`);
-        });
-        it('should set IDENTITY_API_KEY from second string argument', () => {
-            const client = new IdentityClient(TEST_BASE_URL, TEST_API_KEY);
-            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
-        });
-        it('should configure Lambda path from options with ARN', () => {
-            const options = {
-                baseApiUrl: TEST_BASE_URL,
-                identityApiKey: TEST_API_KEY,
-                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
-            };
-            const client = new IdentityClient(options);
-            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
-            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
-            expect(client.SERVICE_API_ROOT_URL).toBe(`${TEST_BASE_URL}/identities`);
-        });
-        it('should configure HTTP path from options without ARN', () => {
-            const options = {
-                baseApiUrl: TEST_BASE_URL,
-                identityApiKey: TEST_API_KEY,
-            };
-            const client = new IdentityClient(options);
-            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
-            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
-        });
-        it('should call setBaseUrl on the shared HTTP client', () => {
-            new IdentityClient(TEST_BASE_URL);
-            expect(mockFns.setBaseUrl).toHaveBeenCalledWith(`${TEST_BASE_URL}/identities`);
-        });
-    });
-    describe('getHeaders', () => {
-        it('should return x-api-key header when API key is configured', () => {
-            const client = new IdentityClient(TEST_BASE_URL, TEST_API_KEY);
-            expect(client.getHeaders()).toEqual({ 'x-api-key': TEST_API_KEY });
-        });
-        it('should return empty object when API key is not configured', () => {
-            const client = new IdentityClient(TEST_BASE_URL);
-            expect(client.getHeaders()).toEqual({});
-        });
-    });
-    describe('getIdentity — Lambda path', () => {
-        const buildLambdaClient = () => new IdentityClient({
-            baseApiUrl: TEST_BASE_URL,
-            identityApiKey: TEST_API_KEY,
-            identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
-        });
-        it('should return identity from Lambda response body', async () => {
-            const identity = buildMockIdentity();
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ identity }),
-            });
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toEqual(identity);
-            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, {
-                pixelId: TEST_PIXEL_ID,
-                context: expect.objectContaining({ identity: expect.any(Object) }),
-            });
-        });
-        it('should return eventContext.identity when Lambda returns non-200 status', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 500,
-                body: JSON.stringify({ error: 'Internal error' }),
-            });
-            const eventContext = buildMockEventContext();
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
-            expect(result).toEqual(eventContext.identity);
-        });
-        it('should return eventContext.identity when Lambda returns no body', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: undefined,
-            });
-            const eventContext = buildMockEventContext();
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
-            expect(result).toEqual(eventContext.identity);
-        });
-        it('should return null when Lambda invoke throws an error', async () => {
-            mockFns.invokeFunction.mockRejectedValue(new Error('Lambda timeout'));
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - Lambda invoke failed', expect.objectContaining({
-                error: expect.any(Error),
-                errorMessage: 'Lambda timeout',
-                pixelId: TEST_PIXEL_ID,
-            }));
-        });
-        it('should return eventContext.identity when Lambda invoke returns null', async () => {
-            mockFns.invokeFunction.mockResolvedValue(null);
-            const eventContext = buildMockEventContext();
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
-            expect(result).toEqual(eventContext.identity);
-        });
-        it('should NOT call HTTP post when Lambda ARN is configured', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ identity: buildMockIdentity() }),
-            });
-            const client = buildLambdaClient();
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(mockFns.post).not.toHaveBeenCalled();
-        });
-        it('should pass empty identity object when eventContext is undefined', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ identity: buildMockIdentity() }),
-            });
-            const client = buildLambdaClient();
-            await client.getIdentity(TEST_PIXEL_ID, undefined);
-            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, {
-                pixelId: TEST_PIXEL_ID,
-                context: { identity: {} },
-            });
-        });
-        it('should return null when eventContext is undefined and Lambda returns non-200', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 500,
-                body: JSON.stringify({ error: 'fail' }),
-            });
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, undefined);
-            expect(result).toBeNull();
-        });
-        it('should return null when response body has no identity field', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ someOtherField: 'value' }),
-            });
-            const client = buildLambdaClient();
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-        });
-        it('should lazily create LambdaInvokeClient on first use', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ identity: buildMockIdentity() }),
-            });
-            const client = buildLambdaClient();
-            const callCountBeforeGetIdentity = LambdaInvokeClient.mock.calls.length;
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            const callCountAfterFirst = LambdaInvokeClient.mock.calls.length;
-            expect(callCountAfterFirst).toBe(callCountBeforeGetIdentity + 1);
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            const callCountAfterSecond = LambdaInvokeClient.mock.calls.length;
-            expect(callCountAfterSecond).toBe(callCountAfterFirst);
-        });
-    });
-    describe('getIdentity — HTTP path', () => {
-        const buildHttpClient = (apiKey) => apiKey ? new IdentityClient(TEST_BASE_URL, apiKey) : new IdentityClient(TEST_BASE_URL);
-        it('should return identity from HTTP response data', async () => {
-            const identity = buildMockIdentity();
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toEqual(identity);
-        });
-        it('should return null and log error when HTTP returns non-200 status', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 500,
-                data: { message: 'Server error' },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP status code failed while retrieving identity', expect.objectContaining({
-                pixelId: TEST_PIXEL_ID,
-                statusCode: 500,
-            }));
-        });
-        it('should return null and log error when HTTP throws', async () => {
-            mockFns.post.mockRejectedValue(new Error('Network error'));
-            const client = buildHttpClient(TEST_API_KEY);
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP request failed', expect.objectContaining({
-                error: expect.any(Error),
-                errorMessage: 'Network error',
-                pixelId: TEST_PIXEL_ID,
-            }));
-        });
-        it('should NOT call Lambda invoke when no ARN is configured', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(mockFns.invokeFunction).not.toHaveBeenCalled();
-        });
-        it('should include x-api-key header when API key is configured', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(mockFns.post).toHaveBeenCalledWith('/', expect.any(Object), { headers: { 'x-api-key': TEST_API_KEY } });
-        });
-        it('should not include x-api-key header when API key is not configured', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient();
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(mockFns.post).toHaveBeenCalledWith('/', expect.any(Object), { headers: {} });
-        });
-        it('should pass excludeThirdPartyContacts parameter in request body', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            const eventContext = buildMockEventContext();
-            await client.getIdentity(TEST_PIXEL_ID, eventContext, true);
-            expect(mockFns.post).toHaveBeenCalledWith('/', {
-                pixelId: TEST_PIXEL_ID,
-                context: eventContext,
-                excludeThirdPartyContacts: true,
-            }, expect.any(Object));
-        });
-        it('should default excludeThirdPartyContacts to false', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(mockFns.post).toHaveBeenCalledWith('/', expect.objectContaining({ excludeThirdPartyContacts: false }), expect.any(Object));
-        });
-        it('should pass empty object as context when eventContext is undefined', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            await client.getIdentity(TEST_PIXEL_ID, undefined);
-            expect(mockFns.post).toHaveBeenCalledWith('/', { pixelId: TEST_PIXEL_ID, context: {}, excludeThirdPartyContacts: false }, expect.any(Object));
-        });
-        it('should return null when response data has no identity field', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { someOtherField: 'value' },
-            });
-            const client = buildHttpClient(TEST_API_KEY);
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle empty pixelId via Lambda path', async () => {
-            mockFns.invokeFunction.mockResolvedValue({
-                statusCode: 200,
-                body: JSON.stringify({ identity: buildMockIdentity() }),
-            });
-            const client = new IdentityClient({
-                baseApiUrl: TEST_BASE_URL,
-                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
-            });
-            const result = await client.getIdentity('', buildMockEventContext());
-            expect(result).toEqual(buildMockIdentity());
-            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, expect.objectContaining({ pixelId: '' }));
-        });
-        it('should handle empty pixelId via HTTP path', async () => {
-            mockFns.post.mockResolvedValue({
-                status: 200,
-                data: { identity: buildMockIdentity() },
-            });
-            const client = new IdentityClient(TEST_BASE_URL);
-            const result = await client.getIdentity('', buildMockEventContext());
-            expect(result).toEqual(buildMockIdentity());
-            expect(mockFns.post).toHaveBeenCalledWith('/', expect.objectContaining({ pixelId: '' }), expect.any(Object));
-        });
-        it('should handle non-Error thrown by Lambda invoke', async () => {
-            mockFns.invokeFunction.mockRejectedValue('string error');
-            const client = new IdentityClient({
-                baseApiUrl: TEST_BASE_URL,
-                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
-            });
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - Lambda invoke failed', expect.objectContaining({
-                errorMessage: 'string error',
-            }));
-        });
-        it('should handle non-Error thrown by HTTP request', async () => {
-            mockFns.post.mockRejectedValue({ code: 'ECONNREFUSED' });
-            const client = new IdentityClient(TEST_BASE_URL);
-            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
-            expect(result).toBeNull();
-            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP request failed', expect.objectContaining({
-                errorMessage: '[object Object]',
-            }));
-        });
-    });
-});
+const mockFns = {
+    invokeFunction: jest.fn(),
+    post: jest.fn(),
+    get: jest.fn(),
+    setBaseUrl: jest.fn(),
+};
+jest.mock('../../clients/generic', () => ({
+    __esModule: true,
+    axiosHttpService: jest.fn(() => ({
+        post: (...args) => mockFns.post(...args),
+        get: (...args) => mockFns.get(...args),
+        setBaseUrl: (...args) => mockFns.setBaseUrl(...args),
+    })),
+    LambdaInvokeClient: jest.fn().mockImplementation(() => ({
+        invokeFunction: (...args) => mockFns.invokeFunction(...args),
+    })),
+}));
+jest.mock('../../helpers', () => ({
+    Logger: {
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+jest.mock('../../libs', () => ({
+    HttpStatusCodes: { OK: 200 },
+}));
+import { IdentityClient } from '../../clients/internal-api/identity-client.js';
+const { Logger } = jest.requireMock('../../helpers');
+const { LambdaInvokeClient } = jest.requireMock('../../clients/generic');
+const TEST_BASE_URL = 'https://api.example.com';
+const TEST_API_KEY = 'api-key-123';
+const TEST_LAMBDA_ARN = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
+const TEST_PIXEL_ID = 'pixel-abc';
+const buildMockIdentity = (overrides = {}) => ({
+    identityId: 'id-resolved',
+    traits: { emails: ['test@example.com'] },
+    ...overrides,
+});
+const buildMockEventContext = (overrides = {}) => ({
+    identity: { identityId: 'id-from-context', traits: {} },
+    ...overrides,
+});
+describe('IdentityClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should set BASE_API_URL and SERVICE_API_ROOT_URL from string argument', () => {
+            const client = new IdentityClient(TEST_BASE_URL);
+            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
+            expect(client.SERVICE_API_ROOT_URL).toBe(`${TEST_BASE_URL}/identities`);
+        });
+        it('should set IDENTITY_API_KEY from second string argument', () => {
+            const client = new IdentityClient(TEST_BASE_URL, TEST_API_KEY);
+            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
+        });
+        it('should configure Lambda path from options with ARN', () => {
+            const options = {
+                baseApiUrl: TEST_BASE_URL,
+                identityApiKey: TEST_API_KEY,
+                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
+            };
+            const client = new IdentityClient(options);
+            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
+            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
+            expect(client.SERVICE_API_ROOT_URL).toBe(`${TEST_BASE_URL}/identities`);
+        });
+        it('should configure HTTP path from options without ARN', () => {
+            const options = {
+                baseApiUrl: TEST_BASE_URL,
+                identityApiKey: TEST_API_KEY,
+            };
+            const client = new IdentityClient(options);
+            expect(client.BASE_API_URL).toBe(TEST_BASE_URL);
+            expect(client.IDENTITY_API_KEY).toBe(TEST_API_KEY);
+        });
+        it('should call setBaseUrl on the shared HTTP client', () => {
+            new IdentityClient(TEST_BASE_URL);
+            expect(mockFns.setBaseUrl).toHaveBeenCalledWith(`${TEST_BASE_URL}/identities`);
+        });
+    });
+    describe('getHeaders', () => {
+        it('should return x-api-key header when API key is configured', () => {
+            const client = new IdentityClient(TEST_BASE_URL, TEST_API_KEY);
+            expect(client.getHeaders()).toEqual({ 'x-api-key': TEST_API_KEY });
+        });
+        it('should return empty object when API key is not configured', () => {
+            const client = new IdentityClient(TEST_BASE_URL);
+            expect(client.getHeaders()).toEqual({});
+        });
+    });
+    describe('getIdentity — Lambda path', () => {
+        const buildLambdaClient = () => new IdentityClient({
+            baseApiUrl: TEST_BASE_URL,
+            identityApiKey: TEST_API_KEY,
+            identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
+        });
+        it('should return identity from Lambda response body', async () => {
+            const identity = buildMockIdentity();
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ identity }),
+            });
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toEqual(identity);
+            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, {
+                pixelId: TEST_PIXEL_ID,
+                context: expect.objectContaining({ identity: expect.any(Object) }),
+            });
+        });
+        it('should return eventContext.identity when Lambda returns non-200 status', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 500,
+                body: JSON.stringify({ error: 'Internal error' }),
+            });
+            const eventContext = buildMockEventContext();
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
+            expect(result).toEqual(eventContext.identity);
+        });
+        it('should return eventContext.identity when Lambda returns no body', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: undefined,
+            });
+            const eventContext = buildMockEventContext();
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
+            expect(result).toEqual(eventContext.identity);
+        });
+        it('should return null when Lambda invoke throws an error', async () => {
+            mockFns.invokeFunction.mockRejectedValue(new Error('Lambda timeout'));
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - Lambda invoke failed', expect.objectContaining({
+                error: expect.any(Error),
+                errorMessage: 'Lambda timeout',
+                pixelId: TEST_PIXEL_ID,
+            }));
+        });
+        it('should return eventContext.identity when Lambda invoke returns null', async () => {
+            mockFns.invokeFunction.mockResolvedValue(null);
+            const eventContext = buildMockEventContext();
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, eventContext);
+            expect(result).toEqual(eventContext.identity);
+        });
+        it('should NOT call HTTP post when Lambda ARN is configured', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ identity: buildMockIdentity() }),
+            });
+            const client = buildLambdaClient();
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(mockFns.post).not.toHaveBeenCalled();
+        });
+        it('should pass empty identity object when eventContext is undefined', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ identity: buildMockIdentity() }),
+            });
+            const client = buildLambdaClient();
+            await client.getIdentity(TEST_PIXEL_ID, undefined);
+            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, {
+                pixelId: TEST_PIXEL_ID,
+                context: { identity: {} },
+            });
+        });
+        it('should return null when eventContext is undefined and Lambda returns non-200', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 500,
+                body: JSON.stringify({ error: 'fail' }),
+            });
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, undefined);
+            expect(result).toBeNull();
+        });
+        it('should return null when response body has no identity field', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ someOtherField: 'value' }),
+            });
+            const client = buildLambdaClient();
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+        });
+        it('should lazily create LambdaInvokeClient on first use', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ identity: buildMockIdentity() }),
+            });
+            const client = buildLambdaClient();
+            const callCountBeforeGetIdentity = LambdaInvokeClient.mock.calls.length;
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            const callCountAfterFirst = LambdaInvokeClient.mock.calls.length;
+            expect(callCountAfterFirst).toBe(callCountBeforeGetIdentity + 1);
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            const callCountAfterSecond = LambdaInvokeClient.mock.calls.length;
+            expect(callCountAfterSecond).toBe(callCountAfterFirst);
+        });
+    });
+    describe('getIdentity — HTTP path', () => {
+        const buildHttpClient = (apiKey) => apiKey ? new IdentityClient(TEST_BASE_URL, apiKey) : new IdentityClient(TEST_BASE_URL);
+        it('should return identity from HTTP response data', async () => {
+            const identity = buildMockIdentity();
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toEqual(identity);
+        });
+        it('should return null and log error when HTTP returns non-200 status', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 500,
+                data: { message: 'Server error' },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP status code failed while retrieving identity', expect.objectContaining({
+                pixelId: TEST_PIXEL_ID,
+                statusCode: 500,
+            }));
+        });
+        it('should return null and log error when HTTP throws', async () => {
+            mockFns.post.mockRejectedValue(new Error('Network error'));
+            const client = buildHttpClient(TEST_API_KEY);
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP request failed', expect.objectContaining({
+                error: expect.any(Error),
+                errorMessage: 'Network error',
+                pixelId: TEST_PIXEL_ID,
+            }));
+        });
+        it('should NOT call Lambda invoke when no ARN is configured', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(mockFns.invokeFunction).not.toHaveBeenCalled();
+        });
+        it('should include x-api-key header when API key is configured', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(mockFns.post).toHaveBeenCalledWith('/', expect.any(Object), { headers: { 'x-api-key': TEST_API_KEY } });
+        });
+        it('should not include x-api-key header when API key is not configured', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient();
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(mockFns.post).toHaveBeenCalledWith('/', expect.any(Object), { headers: {} });
+        });
+        it('should pass excludeThirdPartyContacts parameter in request body', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            const eventContext = buildMockEventContext();
+            await client.getIdentity(TEST_PIXEL_ID, eventContext, true);
+            expect(mockFns.post).toHaveBeenCalledWith('/', {
+                pixelId: TEST_PIXEL_ID,
+                context: eventContext,
+                excludeThirdPartyContacts: true,
+            }, expect.any(Object));
+        });
+        it('should default excludeThirdPartyContacts to false', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(mockFns.post).toHaveBeenCalledWith('/', expect.objectContaining({ excludeThirdPartyContacts: false }), expect.any(Object));
+        });
+        it('should pass empty object as context when eventContext is undefined', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            await client.getIdentity(TEST_PIXEL_ID, undefined);
+            expect(mockFns.post).toHaveBeenCalledWith('/', { pixelId: TEST_PIXEL_ID, context: {}, excludeThirdPartyContacts: false }, expect.any(Object));
+        });
+        it('should return null when response data has no identity field', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { someOtherField: 'value' },
+            });
+            const client = buildHttpClient(TEST_API_KEY);
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty pixelId via Lambda path', async () => {
+            mockFns.invokeFunction.mockResolvedValue({
+                statusCode: 200,
+                body: JSON.stringify({ identity: buildMockIdentity() }),
+            });
+            const client = new IdentityClient({
+                baseApiUrl: TEST_BASE_URL,
+                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
+            });
+            const result = await client.getIdentity('', buildMockEventContext());
+            expect(result).toEqual(buildMockIdentity());
+            expect(mockFns.invokeFunction).toHaveBeenCalledWith(TEST_LAMBDA_ARN, expect.objectContaining({ pixelId: '' }));
+        });
+        it('should handle empty pixelId via HTTP path', async () => {
+            mockFns.post.mockResolvedValue({
+                status: 200,
+                data: { identity: buildMockIdentity() },
+            });
+            const client = new IdentityClient(TEST_BASE_URL);
+            const result = await client.getIdentity('', buildMockEventContext());
+            expect(result).toEqual(buildMockIdentity());
+            expect(mockFns.post).toHaveBeenCalledWith('/', expect.objectContaining({ pixelId: '' }), expect.any(Object));
+        });
+        it('should handle non-Error thrown by Lambda invoke', async () => {
+            mockFns.invokeFunction.mockRejectedValue('string error');
+            const client = new IdentityClient({
+                baseApiUrl: TEST_BASE_URL,
+                identifyPrivateLambdaArn: TEST_LAMBDA_ARN,
+            });
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - Lambda invoke failed', expect.objectContaining({
+                errorMessage: 'string error',
+            }));
+        });
+        it('should handle non-Error thrown by HTTP request', async () => {
+            mockFns.post.mockRejectedValue({ code: 'ECONNREFUSED' });
+            const client = new IdentityClient(TEST_BASE_URL);
+            const result = await client.getIdentity(TEST_PIXEL_ID, buildMockEventContext());
+            expect(result).toBeNull();
+            expect(Logger.error).toHaveBeenCalledWith('IdentityClient - HTTP request failed', expect.objectContaining({
+                errorMessage: '[object Object]',
+            }));
+        });
+    });
+});
 //# sourceMappingURL=identity-client.spec.js.map