@squiz/dx-common-lib 1.72.1 → 1.72.3

package/src/events/EventBusService.spec.ts

@@ -0,0 +1,707 @@
+import { EventBusService, EventBusConfig } from './EventBusService';
+
+interface MockLogger {
+  error: jest.Mock;
+  warn: jest.Mock;
+  info: jest.Mock;
+}
+
+describe('EventBusService', () => {
+  let eventBusService: EventBusService;
+  let mockLogger: MockLogger;
+  let mockConfig: EventBusConfig;
+  let mockFetch: jest.Mock;
+
+  beforeEach(() => {
+    // Create mock logger
+    mockLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+    };
+
+    // Create mock config
+    mockConfig = {
+      eventBusUrl: 'https://test-event-bus.com',
+      eventBusKey: 'test-api-key',
+      tenantId: 'test-tenant',
+      deploymentEnvironment: 'test',
+      squizRegion: 'us',
+    };
+
+    // Mock fetch globally
+    const mockApiResponse = [
+      {
+        statusCode: 202,
+        event: {
+          id: '12345678-1234-5678-9abc-123456789012',
+          source: 'component-service',
+          detailType: 'component.change.create',
+          time: '2023-01-01T00:00:05.000Z',
+          detail: {
+            metadata: { action: 'component.change.create' },
+            event: { name: 'test-component' },
+          },
+        },
+      },
+    ];
+
+    mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: jest.fn().mockResolvedValue(mockApiResponse),
+    });
+
+    global.fetch = mockFetch;
+
+    eventBusService = new EventBusService(mockLogger as any, mockConfig);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('publishEvent', () => {
+    const testDetailType = 'component.change.create';
+    const testDetail = { name: 'test-component', version: '1.0.0' };
+
+    it('should successfully publish an event and return API response', async () => {
+      // Mock Date constructor to make eventTime predictable
+      const mockDate = new Date('2023-01-01T00:00:00.000Z');
+      const originalDate = Date;
+      (global as any).Date = jest.fn(() => mockDate);
+      global.Date.now = originalDate.now;
+
+      const response = await eventBusService.publishEvent(testDetailType, testDetail);
+
+      // Verify fetch was called with correct URL
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://test-event-bus.com/events',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'x-api-key': 'test-api-key',
+            'x-dxp-tenant': 'test-tenant',
+            'Content-Type': 'application/json',
+          },
+        }),
+      );
+
+      // Verify the payload structure
+      const callArgs = mockFetch.mock.calls[0];
+      const payload = JSON.parse(callArgs[1].body);
+
+      expect(payload).toHaveLength(1);
+      expect(payload[0]).toMatchObject({
+        source: 'component-service',
+        'detail-type': testDetailType,
+        action: testDetailType,
+        eventTime: '2023-01-01T00:00:00.000Z',
+        metadata: {
+          tenantID: 'test-tenant',
+          environment: 'test',
+          region: 'us',
+        },
+        event: testDetail,
+      });
+
+      expect(mockLogger.info).not.toHaveBeenCalled();
+
+      // Verify the response is returned correctly
+      expect(response).toEqual([
+        {
+          statusCode: 202,
+          event: {
+            id: '12345678-1234-5678-9abc-123456789012',
+            source: 'component-service',
+            detailType: 'component.change.create',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {
+              metadata: { action: 'component.change.create' },
+              event: { name: 'test-component' },
+            },
+          },
+        },
+      ]);
+
+      // Restore Date
+      global.Date = originalDate;
+    });
+
+    it('should throw error when eventBusUrl is not configured', async () => {
+      // Create service with config missing URL
+      const configWithoutUrl = { ...mockConfig, eventBusUrl: '' };
+      const serviceWithoutUrl = new EventBusService(mockLogger as any, configWithoutUrl);
+
+      await expect(serviceWithoutUrl.publishEvent(testDetailType, testDetail)).rejects.toThrow(
+        /Event Bus is not configured: missing EVENT_BUS_URL/,
+      );
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when eventBusKey is not configured', async () => {
+      // Create service with config missing key
+      const configWithoutKey = { ...mockConfig, eventBusKey: '' };
+      const serviceWithoutKey = new EventBusService(mockLogger as any, configWithoutKey);
+
+      await expect(serviceWithoutKey.publishEvent(testDetailType, testDetail)).rejects.toThrow(
+        /Event Bus is not configured: missing EVENT_BUS_KEY/,
+      );
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when tenantId is not set', async () => {
+      // Create service with config missing tenantId
+      const configWithoutTenantId = { ...mockConfig, tenantId: '' };
+      const serviceWithoutTenantId = new EventBusService(mockLogger as any, configWithoutTenantId);
+
+      await expect(serviceWithoutTenantId.publishEvent(testDetailType, testDetail)).rejects.toThrow(
+        /Tenant ID is not set/,
+      );
+
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should handle HTTP errors when response is not ok', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        text: jest.fn().mockResolvedValue('upstream failure body'),
+      });
+
+      await expect(eventBusService.publishEvent(testDetailType, testDetail)).rejects.toThrow(
+        'Event Bus API error: HTTP 500 Internal Server Error for POST https://test-event-bus.com/events. Response body (preview): upstream failure body',
+      );
+    });
+
+    it('should handle network errors', async () => {
+      const networkError = new Error('Network error');
+      mockFetch.mockRejectedValueOnce(networkError);
+
+      await expect(eventBusService.publishEvent(testDetailType, testDetail)).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('publishEventSafely', () => {
+    const testDetailType = 'component.change.update';
+    const testDetail = { name: 'test-component', version: '2.0.0' };
+
+    it('should successfully publish an event and log success with event ID', async () => {
+      await expect(eventBusService.publishEventSafely(testDetailType, testDetail)).resolves.not.toThrow();
+      expect(mockFetch).toHaveBeenCalled();
+      expect(mockLogger.error).not.toHaveBeenCalled();
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        `Successfully published event: ${testDetailType} with IDs [12345678-1234-5678-9abc-123456789012] to https://test-event-bus.com/events`,
+      );
+    });
+
+    it('should fail silently when API returns non-202 status codes', async () => {
+      // Mock API response with failed status
+      const failedResponse = [
+        {
+          statusCode: 400,
+          event: {
+            id: 'failed-event-id',
+            source: 'component-service',
+            detailType: 'component.change.update',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: { error: 'Invalid event data' },
+          },
+        },
+      ];
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue(failedResponse),
+      });
+
+      await expect(eventBusService.publishEventSafely(testDetailType, testDetail)).resolves.not.toThrow();
+
+      expect(mockFetch).toHaveBeenCalled();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Event publishing failed: received non-valid status codes [400] for event ${testDetailType}`,
+      );
+      expect(mockLogger.info).not.toHaveBeenCalled();
+    });
+
+    it('should fail silently when API returns mixed status codes', async () => {
+      // Mock API response with mixed statuses (batch)
+      const mixedResponse = [
+        {
+          statusCode: 202,
+          event: {
+            id: 'success-id',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+        {
+          statusCode: 400,
+          event: {
+            id: 'failed-id',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+        {
+          statusCode: 500,
+          event: {
+            id: 'error-id',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+      ];
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue(mixedResponse),
+      });
+
+      await expect(eventBusService.publishEventSafely(testDetailType, testDetail)).resolves.not.toThrow();
+
+      expect(mockFetch).toHaveBeenCalled();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Event publishing failed: received non-valid status codes [400, 500] for event ${testDetailType}`,
+      );
+      expect(mockLogger.info).not.toHaveBeenCalled();
+    });
+
+    it('should catch errors and log them via the logger without throwing', async () => {
+      const publishError = new Error('Publish failed');
+      jest.spyOn(eventBusService, 'publishEvent').mockRejectedValue(publishError);
+
+      await expect(eventBusService.publishEventSafely(testDetailType, testDetail)).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Failed to publish event ${testDetailType} to event bus: Publish failed`,
+        expect.objectContaining({ detailType: testDetailType }),
+      );
+    });
+
+    it('should handle Error objects in safe error logging', async () => {
+      const publishError = new Error('Connection timeout');
+      jest.spyOn(eventBusService, 'publishEvent').mockRejectedValue(publishError);
+
+      await eventBusService.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Failed to publish event ${testDetailType} to event bus: Connection timeout`,
+        expect.objectContaining({ detailType: testDetailType }),
+      );
+    });
+
+    it('should handle string errors in safe error logging', async () => {
+      const publishError = 'String error message';
+      jest.spyOn(eventBusService, 'publishEvent').mockRejectedValue(publishError);
+
+      await eventBusService.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Failed to publish event ${testDetailType} to event bus: String error message`,
+        expect.objectContaining({ detailType: testDetailType }),
+      );
+    });
+
+    it('should handle complex objects in safe error logging', async () => {
+      const publishError = { status: 500, data: { error: 'Internal error' } };
+      jest.spyOn(eventBusService, 'publishEvent').mockRejectedValue(publishError);
+
+      await eventBusService.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        `Failed to publish event ${testDetailType} to event bus: ${JSON.stringify(publishError)}`,
+        expect.objectContaining({ detailType: testDetailType }),
+      );
+    });
+
+    it('should log error when eventBusUrl is not configured', async () => {
+      const configWithoutUrl = { ...mockConfig, eventBusUrl: '' };
+      const serviceWithoutUrl = new EventBusService(mockLogger as any, configWithoutUrl);
+
+      await serviceWithoutUrl.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringMatching(
+          /Failed to publish event component\.change\.update to event bus: Event Bus is not configured: missing EVENT_BUS_URL/,
+        ),
+        expect.objectContaining({ detailType: 'component.change.update' }),
+      );
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(mockLogger.info).not.toHaveBeenCalled();
+    });
+
+    it('should log error when eventBusKey is not configured', async () => {
+      const configWithoutKey = { ...mockConfig, eventBusKey: '' };
+      const serviceWithoutKey = new EventBusService(mockLogger as any, configWithoutKey);
+
+      await serviceWithoutKey.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringMatching(
+          /Failed to publish event component\.change\.update to event bus: Event Bus is not configured: missing EVENT_BUS_KEY/,
+        ),
+        expect.objectContaining({ detailType: 'component.change.update' }),
+      );
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(mockLogger.info).not.toHaveBeenCalled();
+    });
+
+    it('should log error when tenantId is not set', async () => {
+      const configWithoutTenantId = { ...mockConfig, tenantId: '' };
+      const serviceWithoutTenantId = new EventBusService(mockLogger as any, configWithoutTenantId);
+
+      await serviceWithoutTenantId.publishEventSafely(testDetailType, testDetail);
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.stringMatching(/Failed to publish event component\.change\.update to event bus: Tenant ID is not set/),
+        expect.objectContaining({ detailType: 'component.change.update' }),
+      );
+    });
+  });
+
+  describe('event payload structure', () => {
+    it('should create correct payload structure with all required fields', async () => {
+      const testDetailType = 'test.event';
+      const testDetail = { foo: 'bar', nested: { key: 'value' } };
+
+      await eventBusService.publishEvent(testDetailType, testDetail);
+
+      const callArgs = mockFetch.mock.calls[0];
+      const payload = JSON.parse(callArgs[1].body);
+
+      expect(payload).toHaveLength(1);
+
+      const event = payload[0];
+      expect(event).toMatchObject({
+        source: 'component-service',
+        'detail-type': testDetailType,
+        action: testDetailType,
+        metadata: {
+          tenantID: 'test-tenant',
+          environment: 'test',
+          region: 'us',
+        },
+        event: testDetail,
+      });
+
+      // Verify eventTime is a valid ISO string
+      expect(event.eventTime).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    });
+
+    it('should include the event object in the request payload', async () => {
+      const complexDetail = {
+        componentName: 'my-component',
+        version: '1.2.3',
+        metadata: { author: 'test-user' },
+        tags: ['frontend', 'react'],
+      };
+
+      await eventBusService.publishEvent('component.created', complexDetail);
+
+      const callArgs = mockFetch.mock.calls[0];
+      const payload = JSON.parse(callArgs[1].body);
+      expect(payload[0].event).toEqual(complexDetail);
+    });
+  });
+
+  describe('integration with config', () => {
+    it('should use config values for URL and headers', async () => {
+      await eventBusService.publishEvent('test.event', {});
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://test-event-bus.com/events',
+        expect.objectContaining({
+          headers: {
+            'x-api-key': 'test-api-key',
+            'x-dxp-tenant': 'test-tenant',
+            'Content-Type': 'application/json',
+          },
+        }),
+      );
+    });
+
+    it('should include config values in event metadata', async () => {
+      await eventBusService.publishEvent('test.event', {});
+
+      const callArgs = mockFetch.mock.calls[0];
+      const payload = JSON.parse(callArgs[1].body);
+      const event = payload[0];
+
+      expect(event.metadata.tenantID).toBe('test-tenant');
+      expect(event.metadata.environment).toBe('test');
+      expect(event.metadata.region).toBe('us');
+    });
+  });
+
+  describe('publishEvents', () => {
+    it('should successfully publish multiple events and return API response', async () => {
+      const events = [
+        { detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } },
+        { detailType: 'component.change.update', detail: { name: 'comp2', version: '2.0.0' } },
+        { detailType: 'component.change.delete', detail: { name: 'comp3', version: '3.0.0' } },
+      ];
+
+      const mockApiResponse = [
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-1',
+            source: 'component-service',
+            detailType: 'component.change.create',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: { metadata: {}, event: {} },
+          },
+        },
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-2',
+            source: 'component-service',
+            detailType: 'component.change.update',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: { metadata: {}, event: {} },
+          },
+        },
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-3',
+            source: 'component-service',
+            detailType: 'component.change.delete',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: { metadata: {}, event: {} },
+          },
+        },
+      ];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue(mockApiResponse),
+      });
+
+      const response = await eventBusService.publishEvents(events);
+
+      expect(mockFetch).toHaveBeenCalled();
+      expect(response).toEqual(mockApiResponse);
+
+      const callArgs = mockFetch.mock.calls[0];
+      const payload = JSON.parse(callArgs[1].body);
+      expect(payload).toHaveLength(3);
+      expect(payload[0]['detail-type']).toBe('component.change.create');
+      expect(payload[1]['detail-type']).toBe('component.change.update');
+      expect(payload[2]['detail-type']).toBe('component.change.delete');
+    });
+
+    it('should return empty array when events array is empty', async () => {
+      const response = await eventBusService.publishEvents([]);
+
+      expect(response).toEqual([]);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when tenantId is not set', async () => {
+      const configWithoutTenantId = { ...mockConfig, tenantId: '' };
+      const serviceWithoutTenantId = new EventBusService(mockLogger as any, configWithoutTenantId);
+
+      const events = [{ detailType: 'test.event', detail: { test: 'data' } }];
+
+      await expect(serviceWithoutTenantId.publishEvents(events)).rejects.toThrow(/Tenant ID is not set/);
+    });
+
+    it('should throw error when eventBusUrl is not configured', async () => {
+      const configWithoutUrl = { ...mockConfig, eventBusUrl: '' };
+      const serviceWithoutUrl = new EventBusService(mockLogger as any, configWithoutUrl);
+
+      const events = [{ detailType: 'test.event', detail: { test: 'data' } }];
+
+      await expect(serviceWithoutUrl.publishEvents(events)).rejects.toThrow(
+        /Event Bus is not configured: missing EVENT_BUS_URL/,
+      );
+    });
+
+    it('should throw error when HTTP response is not ok', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        text: jest.fn().mockResolvedValue('bad request detail'),
+      });
+
+      const events = [{ detailType: 'test.event', detail: { test: 'data' } }];
+
+      await expect(eventBusService.publishEvents(events)).rejects.toThrow(
+        'Event Bus API error: HTTP 400 Bad Request for POST https://test-event-bus.com/events. Response body (preview): bad request detail',
+      );
+    });
+  });
+
+  describe('publishEventsSafely', () => {
+    it('should successfully publish multiple events and log success', async () => {
+      const events = [
+        { detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } },
+        { detailType: 'component.change.update', detail: { name: 'comp2', version: '2.0.0' } },
+      ];
+
+      const mockApiResponse = [
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-1',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-2',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+      ];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue(mockApiResponse),
+      });
+
+      await expect(eventBusService.publishEventsSafely(events)).resolves.not.toThrow();
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        `Successfully published batch of ${events.length} events with IDs [event-1, event-2] to https://test-event-bus.com/events`,
+      );
+      expect(mockLogger.error).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when batch publishing fails', async () => {
+      const events = [
+        { detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } },
+        { detailType: 'component.change.update', detail: { name: 'comp2', version: '2.0.0' } },
+      ];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        text: jest.fn().mockResolvedValue('batch error body'),
+      });
+
+      await expect(eventBusService.publishEventsSafely(events)).rejects.toThrow(
+        /Event Bus API error: HTTP 500 Internal Server Error for POST https:\/\/test-event-bus\.com\/events/,
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should throw error when one or more events in batch fail', async () => {
+      const events = [
+        { detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } },
+        { detailType: 'component.change.update', detail: { name: 'comp2', version: '2.0.0' } },
+      ];
+
+      const mixedResponse = [
+        {
+          statusCode: 202,
+          event: {
+            id: 'event-1',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+        {
+          statusCode: 400,
+          event: {
+            id: 'event-2',
+            source: 'component-service',
+            detailType: 'test',
+            time: '2023-01-01T00:00:05.000Z',
+            detail: {},
+          },
+        },
+      ];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue(mixedResponse),
+      });
+
+      await expect(eventBusService.publishEventsSafely(events)).rejects.toThrow(
+        `Event publishing failed: received non-valid status codes [400] for batch of ${events.length} events`,
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should log error when network error occurs during batch publishing', async () => {
+      const events = [{ detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } }];
+
+      const networkError = new Error('Network timeout');
+      mockFetch.mockRejectedValueOnce(networkError);
+
+      await expect(eventBusService.publishEventsSafely(events)).rejects.toThrow(
+        `Failed to publish batch of ${events.length} events to event bus: Network timeout`,
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should throw error when tenantId is not set', async () => {
+      const configWithoutTenantId = { ...mockConfig, tenantId: '' };
+      const serviceWithoutTenantId = new EventBusService(mockLogger as any, configWithoutTenantId);
+
+      const events = [{ detailType: 'test.event', detail: { test: 'data' } }];
+
+      await expect(serviceWithoutTenantId.publishEventsSafely(events)).rejects.toThrow(
+        /Failed to publish batch of 1 events to event bus: Tenant ID is not set/,
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should correctly set tenant ID before publishing', async () => {
+      const events = [{ detailType: 'component.change.create', detail: { name: 'comp1', version: '1.0.0' } }];
+
+      // Create service without tenant ID initially
+      const configWithoutTenantId = { ...mockConfig, tenantId: '' };
+      const service = new EventBusService(mockLogger as any, configWithoutTenantId);
+
+      // Set tenant ID
+      service.setTenantId('new-tenant');
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: jest.fn().mockResolvedValue([
+          {
+            statusCode: 202,
+            event: {
+              id: 'event-1',
+              source: 'component-service',
+              detailType: 'test',
+              time: '2023-01-01T00:00:05.000Z',
+              detail: {},
+            },
+          },
+        ]),
+      });
+
+      await expect(service.publishEventsSafely(events)).resolves.not.toThrow();
+
+      const callArgs = mockFetch.mock.calls[0];
+      expect(callArgs[1].headers['x-dxp-tenant']).toBe('new-tenant');
+    });
+  });
+});