@devrev/ts-adaas 1.18.0 → 1.18.1-beta.0

package/dist/multithreading/worker-adapter/worker-adapter.js

@@ -286,57 +286,74 @@ class WorkerAdapter {
                 };
             }
             console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
-            outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
-                .filesToLoad) {
-                const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
-                if (!itemTypeToLoad) {
-                    console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
-                    await this.emit(loading_1.LoaderEventType.DataLoadingError, {
-                        error: {
-                            message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
-                        },
-                    });
-                    break;
-                }
-                if (!fileToLoad.completed) {
-                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    });
-                    if (transformerFileError) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+            try {
+                outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
+                    .filesToLoad) {
+                    const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
+                    if (!itemTypeToLoad) {
+                        console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
                         await this.emit(loading_1.LoaderEventType.DataLoadingError, {
                             error: {
-                                message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
                             },
                         });
+                        break;
                     }
-                    const transformerFile = response;
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadItem({
-                            item: transformerFile[i],
-                            itemTypeToLoad,
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
                             });
                             break outerloop;
                         }
-                        if (report) {
-                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                                loaderReports: this.loaderReports,
-                                report,
+                        const transformerFile = response;
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during data loading. Emitting progress to allow continuation.');
+                                await this.emit(loading_1.LoaderEventType.DataLoadingProgress);
+                                process.exit(0);
+                            }
+                            const { report, rateLimit } = await this.loadItem({
+                                item: transformerFile[i],
+                                itemTypeToLoad,
                             });
-                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
+                                    delay: rateLimit.delay,
+                                    reports: this.reports,
+                                    processed_files: this.processedFiles,
+                                });
+                                break outerloop;
+                            }
+                            if (report) {
+                                (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
                         }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
                     }
-                    fileToLoad.completed = true;
-                    this._processedFiles.push(fileToLoad.id);
                 }
             }
+            catch (error) {
+                console.error('Error during data loading.', (0, logger_1.serializeError)(error));
+                await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                    error: {
+                        message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                });
+                process.exit(1);
+            }
             return {
                 reports: this.reports,
                 processed_files: this.processedFiles,
@@ -383,42 +400,63 @@ class WorkerAdapter {
                 };
             }
             const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
-            outerloop: for (const fileToLoad of filesToLoad) {
-                if (!fileToLoad.completed) {
-                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    });
-                    const transformerFile = response;
-                    if (transformerFileError) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                        break outerloop;
-                    }
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadAttachment({
-                            item: transformerFile[i],
-                            create,
+            try {
+                outerloop: for (const fileToLoad of filesToLoad) {
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
+                        const transformerFile = response;
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
                             });
                             break outerloop;
                         }
-                        if (report) {
-                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                                loaderReports: this.loaderReports,
-                                report,
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during attachment loading. Emitting progress to allow continuation.');
+                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingProgress);
+                                process.exit(0);
+                            }
+                            const { report, rateLimit } = await this.loadAttachment({
+                                item: transformerFile[i],
+                                create,
                             });
-                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
+                                    delay: rateLimit.delay,
+                                    reports: this.reports,
+                                    processed_files: this.processedFiles,
+                                });
+                                break outerloop;
+                            }
+                            if (report) {
+                                (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
                         }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
                     }
-                    fileToLoad.completed = true;
-                    this._processedFiles.push(fileToLoad.id);
                 }
             }
+            catch (error) {
+                console.error('Error during attachment loading.', (0, logger_1.serializeError)(error));
+                await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                    error: {
+                        message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                });
+                process.exit(1);
+            }
             return {
                 reports: this.reports,
                 processed_files: this.processedFiles,

package/dist/multithreading/worker-adapter/worker-adapter.test.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const attachments_streaming_pool_1 = require("../../attachments-streaming/attachments-streaming-pool");
 const constants_1 = require("../../common/constants");
 const state_1 = require("../../state/state");
-const test_helpers_1 = require("../../tests/test-helpers");
+const jest_setup_1 = require("../../tests/jest.setup");
+const test_utils_1 = require("../../common/test-utils");
 const types_1 = require("../../types");
 const loading_1 = require("../../types/loading");
 const worker_adapter_1 = require("./worker-adapter");
@@ -40,7 +41,9 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
         // Reset all mocks
         jest.clearAllMocks();
         // Create mock objects
-        mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.StartExtractingData });
+        mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: types_1.EventType.StartExtractingData },
+        });
         const initialState = {
             attachments: { completed: false },
             lastSyncStarted: '',
@@ -385,7 +388,7 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
             // Mock the pool to simulate timeout happening during the first artifact
             attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
                 return {
-                    streamAll: jest.fn().mockImplementation(async () => {
+                    streamAll: jest.fn().mockImplementation(() => {
                         adapter.isTimeout = true;
                         return {};
                     }),
@@ -661,7 +664,9 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
                 .fn()
                 .mockResolvedValue(undefined);
             adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            adapter['loaderReports'] = [{ item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 }];
+            adapter['loaderReports'] = [
+                { item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 },
+            ];
             adapter['_processedFiles'] = ['file-1', 'file-2'];
             await adapter.emit(types_1.LoaderEventType.DataLoadingDone);
             expect(mockEmit).toHaveBeenCalledWith(expect.objectContaining({
@@ -685,7 +690,9 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
             adapter['_artifacts'] = [
                 { id: 'art-1', item_count: 10, item_type: 'issues' },
             ];
-            adapter['loaderReports'] = [{ item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 }];
+            adapter['loaderReports'] = [
+                { item_type: 'tasks', [loading_1.ActionType.CREATED]: 5 },
+            ];
             adapter['_processedFiles'] = ['file-1'];
             await adapter.emit('SOME_UNKNOWN_EVENT');
             const callData = mockEmit.mock.calls[0][0].data;
@@ -770,8 +777,7 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
         async function emitDone(adapterInstance, extractionStart, extractionEnd) {
             adapterInstance.event.payload.event_context.extract_from =
                 extractionStart;
-            adapterInstance.event.payload.event_context.extract_to =
-                extractionEnd;
+            adapterInstance.event.payload.event_context.extract_to = extractionEnd;
             // Reset the emit guard so we can emit multiple times in a single test
             adapterInstance['hasWorkerEmitted'] = false;
             await adapterInstance.emit(types_1.ExtractorEventType.AttachmentExtractionDone, {
@@ -973,4 +979,265 @@ describe(worker_adapter_1.WorkerAdapter.name, () => {
             expect(adapter.shouldExtract('users')).toBe(true);
         });
     });
+    describe(worker_adapter_1.WorkerAdapter.prototype.loadItemTypes.name, () => {
+        let exitSpy;
+        let emitSpy;
+        beforeEach(() => {
+            exitSpy = jest
+                .spyOn(process, 'exit')
+                .mockImplementation(() => undefined);
+            emitSpy = jest.spyOn(adapter, 'emit').mockResolvedValue();
+            // Set event type to loading continuation (not StartLoadingData) so we can
+            // set fromDevRev state directly without mocking getLoaderBatches
+            mockEvent.payload.event_type =
+                types_1.EventType.ContinueLoadingData;
+        });
+        afterEach(() => {
+            exitSpy.mockRestore();
+        });
+        function setupFilesToLoad(items) {
+            adapter['adapterState'].state.fromDevRev = {
+                filesToLoad: [
+                    {
+                        id: 'artifact-1',
+                        file_name: 'file1.json',
+                        itemType: 'tasks',
+                        count: items.length,
+                        lineToProcess: 0,
+                        completed: false,
+                    },
+                ],
+            };
+            adapter['uploader'].getJsonObjectByArtifactId = jest
+                .fn()
+                .mockResolvedValue({ response: items });
+        }
+        it('should emit DataLoadingProgress and exit on timeout', async () => {
+            const items = [
+                {
+                    id: { devrev: 'dev-1', external: 'ext-1' },
+                    created_date: '',
+                    modified_date: '',
+                    data: {},
+                },
+                {
+                    id: { devrev: 'dev-2', external: 'ext-2' },
+                    created_date: '',
+                    modified_date: '',
+                    data: {},
+                },
+            ];
+            setupFilesToLoad(items);
+            // Set timeout before calling loadItemTypes
+            adapter.isTimeout = true;
+            const itemTypesToLoad = [
+                {
+                    itemType: 'tasks',
+                    create: jest.fn(),
+                    update: jest.fn(),
+                },
+            ];
+            await adapter.loadItemTypes({ itemTypesToLoad });
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.DataLoadingProgress);
+            expect(exitSpy).toHaveBeenCalledWith(0);
+        });
+        it('should emit DataLoadingProgress mid-loop when timeout arrives between items', async () => {
+            const items = [
+                {
+                    id: { devrev: 'dev-1', external: 'ext-1' },
+                    created_date: '',
+                    modified_date: '',
+                    data: {},
+                },
+                {
+                    id: { devrev: 'dev-2', external: 'ext-2' },
+                    created_date: '',
+                    modified_date: '',
+                    data: {},
+                },
+                {
+                    id: { devrev: 'dev-3', external: 'ext-3' },
+                    created_date: '',
+                    modified_date: '',
+                    data: {},
+                },
+            ];
+            setupFilesToLoad(items);
+            // Mock process.exit to throw so it stops execution like a real exit would
+            exitSpy.mockRestore();
+            exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error(`process.exit`);
+            }));
+            let loadItemCallCount = 0;
+            // Mock loadItem to set timeout after the first call
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/require-await
+            jest.spyOn(adapter, 'loadItem').mockImplementation(async () => {
+                loadItemCallCount++;
+                if (loadItemCallCount === 1) {
+                    adapter.isTimeout = true;
+                }
+                return { report: { item_type: 'tasks', updated: 1 } };
+            });
+            const itemTypesToLoad = [
+                {
+                    itemType: 'tasks',
+                    create: jest.fn(),
+                    update: jest.fn(),
+                },
+            ];
+            // process.exit throws, so this will throw
+            await expect(adapter.loadItemTypes({ itemTypesToLoad })).rejects.toThrow('process.exit');
+            // First item processed, then timeout detected on second iteration
+            expect(loadItemCallCount).toBe(1);
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.DataLoadingProgress);
+        });
+        it('should emit DataLoadingError and exit(1) on unexpected error', async () => {
+            adapter['adapterState'].state.fromDevRev = {
+                filesToLoad: [
+                    {
+                        id: 'artifact-1',
+                        file_name: 'file1.json',
+                        itemType: 'tasks',
+                        count: 1,
+                        lineToProcess: 0,
+                        completed: false,
+                    },
+                ],
+            };
+            // Make getJsonObjectByArtifactId throw (not return error — throw)
+            adapter['uploader'].getJsonObjectByArtifactId = jest
+                .fn()
+                .mockRejectedValue(new Error('Unexpected network failure'));
+            const itemTypesToLoad = [
+                {
+                    itemType: 'tasks',
+                    create: jest.fn(),
+                    update: jest.fn(),
+                },
+            ];
+            await adapter.loadItemTypes({ itemTypesToLoad });
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.DataLoadingError, expect.objectContaining({
+                error: expect.objectContaining({
+                    message: expect.stringContaining('Error during data loading'),
+                }),
+            }));
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+    describe(worker_adapter_1.WorkerAdapter.prototype.loadAttachments.name, () => {
+        let exitSpy;
+        let emitSpy;
+        beforeEach(() => {
+            exitSpy = jest
+                .spyOn(process, 'exit')
+                .mockImplementation(() => undefined);
+            emitSpy = jest.spyOn(adapter, 'emit').mockResolvedValue();
+            // Set event type to continuation so we can set fromDevRev state directly
+            mockEvent.payload.event_type =
+                types_1.EventType.ContinueLoadingAttachments;
+        });
+        afterEach(() => {
+            exitSpy.mockRestore();
+        });
+        function setupFilesToLoad(items) {
+            adapter['adapterState'].state.fromDevRev = {
+                filesToLoad: [
+                    {
+                        id: 'artifact-1',
+                        file_name: 'attachments.json',
+                        itemType: 'attachment',
+                        count: items.length,
+                        lineToProcess: 0,
+                        completed: false,
+                    },
+                ],
+            };
+            adapter['uploader'].getJsonObjectByArtifactId = jest
+                .fn()
+                .mockResolvedValue({ response: items });
+        }
+        it('should emit AttachmentLoadingProgress and exit on timeout', async () => {
+            const items = [
+                {
+                    reference_id: 'ref-1',
+                    parent_type: 'task',
+                    parent_reference_id: 'parent-1',
+                    file_name: 'file.pdf',
+                    file_type: 'application/pdf',
+                    file_size: 100,
+                    url: 'https://example.com/file.pdf',
+                    valid_until: '',
+                    created_by_id: 'user-1',
+                    created_date: '',
+                    modified_by_id: 'user-1',
+                    modified_date: '',
+                },
+            ];
+            setupFilesToLoad(items);
+            adapter.isTimeout = true;
+            await adapter.loadAttachments({
+                create: jest.fn(),
+            });
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.AttachmentLoadingProgress);
+            expect(exitSpy).toHaveBeenCalledWith(0);
+        });
+        it('should emit AttachmentLoadingError on transformer file error', async () => {
+            adapter['adapterState'].state.fromDevRev = {
+                filesToLoad: [
+                    {
+                        id: 'bad-artifact',
+                        file_name: 'attachments.json',
+                        itemType: 'attachment',
+                        count: 1,
+                        lineToProcess: 0,
+                        completed: false,
+                    },
+                ],
+            };
+            adapter['uploader'].getJsonObjectByArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                response: null,
+                error: new Error('Artifact not found'),
+            });
+            await adapter.loadAttachments({
+                create: jest.fn(),
+            });
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.AttachmentLoadingError, expect.objectContaining({
+                error: expect.objectContaining({
+                    message: expect.stringContaining('Transformer file not found'),
+                }),
+            }));
+        });
+        it('should emit AttachmentLoadingError and exit(1) on unexpected error', async () => {
+            const items = [
+                {
+                    reference_id: 'ref-1',
+                    parent_type: 'task',
+                    parent_reference_id: 'parent-1',
+                    file_name: 'file.pdf',
+                    file_type: 'application/pdf',
+                    file_size: 100,
+                    url: 'https://example.com/file.pdf',
+                    valid_until: '',
+                    created_by_id: 'user-1',
+                    created_date: '',
+                    modified_by_id: 'user-1',
+                    modified_date: '',
+                },
+            ];
+            setupFilesToLoad(items);
+            // Make the create function throw
+            const mockCreate = jest
+                .fn()
+                .mockRejectedValue(new Error('Unexpected API failure'));
+            await adapter.loadAttachments({ create: mockCreate });
+            expect(emitSpy).toHaveBeenCalledWith(types_1.LoaderEventType.AttachmentLoadingError, expect.objectContaining({
+                error: expect.objectContaining({
+                    message: expect.stringContaining('Error during attachment loading'),
+                }),
+            }));
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+    });
 });

package/dist/repo/repo.test.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("../common/constants");
 const test_helpers_1 = require("../tests/test-helpers");
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
 const types_1 = require("../types");
 const repo_1 = require("./repo");
 jest.mock('../tests/test-helpers', () => (Object.assign(Object.assign({}, jest.requireActual('../tests/test-helpers')), { normalizeItem: jest.fn() })));
@@ -11,7 +13,9 @@ describe(repo_1.Repo.name, () => {
     beforeEach(() => {
         normalize = jest.fn();
         repo = new repo_1.Repo({
-            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: { event_type: types_1.EventType.ExtractionDataStart },
+            }),
             itemType: 'test_item_type',
             normalize,
             onUpload: jest.fn(),
@@ -29,7 +33,9 @@ describe(repo_1.Repo.name, () => {
     });
     it('should not normalize items when normalize function is not provided', async () => {
         repo = new repo_1.Repo({
-            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: { event_type: types_1.EventType.ExtractionDataStart },
+            }),
             itemType: 'test_item_type',
             onUpload: jest.fn(),
             options: {},
@@ -44,7 +50,9 @@ describe(repo_1.Repo.name, () => {
     });
     it('should not normalize items when item type is external_domain_metadata', async () => {
         repo = new repo_1.Repo({
-            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: { event_type: types_1.EventType.ExtractionDataStart },
+            }),
             itemType: constants_1.AirSyncDefaultItemTypes.EXTERNAL_DOMAIN_METADATA,
             normalize,
             onUpload: jest.fn(),
@@ -56,7 +64,9 @@ describe(repo_1.Repo.name, () => {
     });
     it('should not normalize items when item type is ssor_attachment', async () => {
         repo = new repo_1.Repo({
-            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: { event_type: types_1.EventType.ExtractionDataStart },
+            }),
             itemType: constants_1.SSOR_ATTACHMENT,
             normalize,
             onUpload: jest.fn(),
@@ -91,7 +101,9 @@ describe(repo_1.Repo.name, () => {
     describe('should take batch size into account', () => {
         beforeEach(() => {
             repo = new repo_1.Repo({
-                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                    payload: { event_type: types_1.EventType.ExtractionDataStart },
+                }),
                 itemType: 'test_item_type',
                 normalize,
                 onUpload: jest.fn(),