@devrev/ts-adaas 1.19.4 → 1.19.6-beta.0

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

@@ -1,1243 +0,0 @@
-"use strict";
-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 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");
-/* eslint-disable @typescript-eslint/no-require-imports */
-// Mock dependencies
-jest.mock('../../common/control-protocol', () => ({
-    emit: jest.fn().mockResolvedValue({}),
-}));
-// const mockPostState = jest.spyOn(State.prototype, 'postState').mockResolvedValue(); // Mock to resolve void
-// const mockFetchState = jest.spyOn(State.prototype, 'fetchState').mockResolvedValue({}); // Mock to resolve a default state
-jest.mock('../../mappers/mappers');
-jest.mock('../../uploader/uploader');
-// jest.mock('../../state/state');
-jest.mock('../../repo/repo');
-jest.mock('node:worker_threads', () => ({
-    parentPort: {
-        postMessage: jest.fn(),
-    },
-}));
-jest.mock('../../attachments-streaming/attachments-streaming-pool', () => {
-    return {
-        AttachmentsStreamingPool: jest.fn().mockImplementation(() => {
-            return {
-                streamAll: jest.fn().mockResolvedValue(undefined),
-            };
-        }),
-    };
-});
-describe(worker_adapter_1.WorkerAdapter.name, () => {
-    let adapter;
-    let mockEvent;
-    let mockAdapterState;
-    beforeEach(() => {
-        // Reset all mocks
-        jest.clearAllMocks();
-        // Create mock objects
-        mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-            payload: { event_type: types_1.EventType.StartExtractingData },
-        });
-        const initialState = {
-            attachments: { completed: false },
-            lastSyncStarted: '',
-            lastSuccessfulSyncStarted: '',
-            snapInVersionId: '',
-            toDevRev: {
-                attachmentsMetadata: {
-                    artifactIds: [],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            },
-        };
-        mockAdapterState = new state_1.State({
-            event: mockEvent,
-            initialState: initialState,
-        });
-        // Create the adapter instance
-        adapter = new worker_adapter_1.WorkerAdapter({
-            event: mockEvent,
-            adapterState: mockAdapterState,
-        });
-    });
-    describe(worker_adapter_1.WorkerAdapter.prototype.streamAttachments.name, () => {
-        it('should process all artifact batches successfully', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1', 'artifact2'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments from each artifact
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValueOnce({
-                attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
-                    {
-                        url: 'http://example.com/file2.pdf',
-                        id: 'attachment2',
-                        file_name: 'file2.pdf',
-                        parent_id: 'parent2',
-                    },
-                ],
-            })
-                .mockResolvedValueOnce({
-                attachments: [
-                    {
-                        url: 'http://example.com/file3.pdf',
-                        id: 'attachment3',
-                        file_name: 'file3.pdf',
-                        parent_id: 'parent3',
-                    },
-                ],
-            });
-            // Mock the initializeRepos method
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(adapter.initializeRepos).toHaveBeenCalledWith([
-                { itemType: 'ssor_attachment' },
-            ]);
-            expect(adapter.initializeRepos).toHaveBeenCalledTimes(1);
-            expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(2);
-            // Verify state was updated correctly
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
-            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
-            expect(result).toBeUndefined();
-        });
-        it('[edge] should handle invalid batch size by using 1 instead', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
-                ],
-            });
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-                batchSize: 0,
-            });
-            expect(result).toBeUndefined();
-        });
-        it('[edge] should cap batch size to 50 when batchSize is greater than 50', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
-                ],
-            });
-            // Mock the required methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-                batchSize: 100, // Set batch size greater than 50
-            });
-            expect(result).toBeUndefined();
-        });
-        it('[edge] should handle empty attachments metadata artifact IDs', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with no artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: [],
-                    lastProcessed: 0,
-                },
-            };
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(result).toBeUndefined();
-        });
-        it('[edge] should handle errors when getting attachments', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock error when getting attachments
-            const mockError = new Error('Failed to get attachments');
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                error: mockError,
-            });
-            // Mock methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(result).toEqual({
-                error: mockError,
-            });
-        });
-        it('[edge] should handle empty attachments array from artifact', async () => {
-            const mockStream = jest.fn();
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting empty attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [],
-            });
-            // Mock methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
-            expect(result).toBeUndefined();
-        });
-        it('should use custom processors when provided', async () => {
-            const mockStream = jest.fn();
-            const mockReducer = jest.fn().mockReturnValue(['custom-reduced']);
-            const mockIterator = jest.fn().mockResolvedValue({});
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [{ id: 'attachment1' }],
-            });
-            // Mock methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-                processors: {
-                    reducer: mockReducer,
-                    iterator: mockIterator,
-                },
-            });
-            expect(mockReducer).toHaveBeenCalledWith({
-                attachments: [{ id: 'attachment1' }],
-                adapter: adapter,
-                batchSize: 1,
-            });
-            expect(mockIterator).toHaveBeenCalledWith({
-                reducedAttachments: ['custom-reduced'],
-                adapter: adapter,
-                stream: mockStream,
-            });
-            expect(result).toBeUndefined();
-        });
-        it('should handle rate limiting from iterator', async () => {
-            const mockStream = jest.fn();
-            attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
-                return {
-                    // Return an object with a `streamAll` method that resolves to your desired value.
-                    streamAll: jest.fn().mockResolvedValue({ delay: 30 }),
-                };
-            });
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [{ id: 'attachment1' }],
-            });
-            // Mock methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(result).toEqual({
-                delay: 30,
-            });
-            // The artifactIds array should remain unchanged
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
-                'artifact1',
-            ]);
-        });
-        it('should handle error from iterator', async () => {
-            const mockStream = jest.fn();
-            attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
-                return {
-                    // Return an object with a `streamAll` method that resolves to your desired value.
-                    streamAll: jest.fn().mockResolvedValue({
-                        error: 'Mock error',
-                    }),
-                };
-            });
-            // Set up adapter state with artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [{ id: 'attachment1' }],
-            });
-            // Mock methods
-            adapter.initializeRepos = jest.fn();
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(result).toEqual({
-                error: 'Mock error',
-            });
-            // The artifactIds array should remain unchanged
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
-                'artifact1',
-            ]);
-        });
-        it('should emit progress event and exit process on timeout, preserving state for resumption', async () => {
-            const mockStream = jest.fn();
-            // Mock process.exit to prevent it from killing the test runner
-            const exitSpy = jest
-                .spyOn(process, 'exit')
-                .mockImplementation(() => undefined);
-            // Set up adapter state with multiple artifact IDs
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1', 'artifact2', 'artifact3'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            // Mock getting attachments for each artifact
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
-                attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
-                ],
-            });
-            // Mock the pool to simulate timeout happening during the first artifact
-            attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
-                return {
-                    streamAll: jest.fn().mockImplementation(() => {
-                        adapter.isTimeout = true;
-                        return {};
-                    }),
-                };
-            });
-            adapter.initializeRepos = jest.fn();
-            // Mock emit to verify it's called with progress event
-            const emitSpy = jest.spyOn(adapter, 'emit').mockResolvedValue();
-            await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            // Should have emitted progress event
-            expect(emitSpy).toHaveBeenCalledWith(types_1.ExtractorEventType.AttachmentExtractionProgress);
-            // Should have called process.exit(0)
-            expect(exitSpy).toHaveBeenCalledWith(0);
-            // The current artifact should NOT be removed from the list
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
-                'artifact1',
-                'artifact2',
-                'artifact3',
-            ]);
-            // Only the first artifact should have been fetched
-            expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(1);
-            exitSpy.mockRestore();
-        });
-        it('should reset lastProcessed and attachment IDs list after processing all artifacts', async () => {
-            const mockStream = jest.fn();
-            adapter.state.toDevRev = {
-                attachmentsMetadata: {
-                    artifactIds: ['artifact1'],
-                    lastProcessed: 0,
-                    lastProcessedAttachmentsIdsList: [],
-                },
-            };
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValueOnce({
-                attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
-                    {
-                        url: 'http://example.com/file2.pdf',
-                        id: 'attachment2',
-                        file_name: 'file2.pdf',
-                        parent_id: 'parent2',
-                    },
-                    {
-                        url: 'http://example.com/file3.pdf',
-                        id: 'attachment3',
-                        file_name: 'file3.pdf',
-                        parent_id: 'parent3',
-                    },
-                ],
-            });
-            adapter.processAttachment = jest.fn().mockResolvedValue(null);
-            await adapter.streamAttachments({
-                stream: mockStream,
-            });
-            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toHaveLength(0);
-            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
-        });
-    });
-    describe(worker_adapter_1.WorkerAdapter.prototype.processAttachment.name, () => {
-        const createMockHttpStream = (headers = {}) => ({
-            headers,
-            data: { destroy: jest.fn() },
-        });
-        beforeEach(() => {
-            adapter.initializeRepos([{ itemType: 'ssor_attachment' }]);
-            const mockRepo = { push: jest.fn().mockResolvedValue(undefined) };
-            adapter.getRepo = jest.fn().mockReturnValue(mockRepo);
-        });
-        it('should use attachment.content_type when provided, ignoring HTTP header', async () => {
-            const mockStream = jest.fn().mockResolvedValue({
-                httpStream: createMockHttpStream({
-                    'content-type': 'text/plain',
-                    'content-length': '100',
-                }),
-            });
-            adapter['uploader'].getArtifactUploadUrl = jest.fn().mockResolvedValue({
-                response: {
-                    artifact_id: 'art_1',
-                    upload_url: 'https://upload',
-                    form_data: [],
-                },
-            });
-            adapter['uploader'].streamArtifact = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            adapter['uploader'].confirmArtifactUpload = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            const attachment = {
-                id: 'att-1',
-                url: 'https://example.com/file.pdf',
-                file_name: 'file.pdf',
-                parent_id: 'parent-1',
-                content_type: 'application/pdf',
-            };
-            await adapter.processAttachment(attachment, mockStream);
-            expect(adapter['uploader'].getArtifactUploadUrl).toHaveBeenCalledWith('file.pdf', 'application/pdf', 100);
-        });
-        it('should use HTTP header content-type when attachment.content_type is not set', async () => {
-            const mockStream = jest.fn().mockResolvedValue({
-                httpStream: createMockHttpStream({
-                    'content-type': 'image/jpeg',
-                    'content-length': '200',
-                }),
-            });
-            adapter['uploader'].getArtifactUploadUrl = jest.fn().mockResolvedValue({
-                response: {
-                    artifact_id: 'art_2',
-                    upload_url: 'https://upload',
-                    form_data: [],
-                },
-            });
-            adapter['uploader'].streamArtifact = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            adapter['uploader'].confirmArtifactUpload = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            const attachment = {
-                id: 'att-2',
-                url: 'https://example.com/photo.jpg',
-                file_name: 'photo.jpg',
-                parent_id: 'parent-2',
-            };
-            await adapter.processAttachment(attachment, mockStream);
-            expect(adapter['uploader'].getArtifactUploadUrl).toHaveBeenCalledWith('photo.jpg', 'image/jpeg', 200);
-        });
-        it('should fall back to application/octet-stream when neither content_type nor HTTP header is set', async () => {
-            const mockStream = jest.fn().mockResolvedValue({
-                httpStream: createMockHttpStream({}),
-            });
-            adapter['uploader'].getArtifactUploadUrl = jest.fn().mockResolvedValue({
-                response: {
-                    artifact_id: 'art_3',
-                    upload_url: 'https://upload',
-                    form_data: [],
-                },
-            });
-            adapter['uploader'].streamArtifact = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            adapter['uploader'].confirmArtifactUpload = jest
-                .fn()
-                .mockResolvedValue({ response: {} });
-            const attachment = {
-                id: 'att-3',
-                url: 'https://example.com/file.bin',
-                file_name: 'file.bin',
-                parent_id: 'parent-3',
-            };
-            await adapter.processAttachment(attachment, mockStream);
-            expect(adapter['uploader'].getArtifactUploadUrl).toHaveBeenCalledWith('file.bin', 'application/octet-stream', undefined);
-        });
-    });
-    describe(worker_adapter_1.WorkerAdapter.prototype.emit.name, () => {
-        let counter;
-        let mockPostMessage;
-        beforeEach(() => {
-            counter = { counter: 0 };
-            // Import the worker_threads module and spy on parentPort.postMessage
-            const workerThreads = require('node:worker_threads');
-            mockPostMessage = jest.fn().mockImplementation(() => {
-                counter.counter += 1;
-            });
-            // Spy on the parentPort.postMessage method
-            if (workerThreads.parentPort) {
-                jest
-                    .spyOn(workerThreads.parentPort, 'postMessage')
-                    .mockImplementation(mockPostMessage);
-            }
-            else {
-                // If parentPort is null (not in worker context), create a mock
-                workerThreads.parentPort = {
-                    postMessage: mockPostMessage,
-                };
-            }
-        });
-        afterEach(() => {
-            // Restore all mocks
-            jest.restoreAllMocks();
-        });
-        it('should emit only one event when multiple events of same type are sent', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            expect(counter.counter).toBe(1);
-        });
-        it('should emit event when different event type is sent after previous events', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            expect(counter.counter).toBe(1);
-        });
-        it('should correctly emit one event even if postState errors', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockRejectedValue(new Error('postState error'));
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            expect(counter.counter).toBe(1);
-        });
-        it('should correctly emit one event even if uploadAllRepos errors', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest
-                .fn()
-                .mockRejectedValue(new Error('uploadAllRepos error'));
-            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                reports: [],
-                processed_files: [],
-            });
-            expect(counter.counter).toBe(1);
-        });
-        it('should include artifacts in data for extraction events', async () => {
-            const { emit: mockEmit } = require('../../common/control-protocol');
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            adapter['_artifacts'] = [
-                { id: 'art-1', item_count: 10, item_type: 'issues' },
-            ];
-            await adapter.emit(types_1.ExtractorEventType.DataExtractionDone);
-            expect(mockEmit).toHaveBeenCalledWith(expect.objectContaining({
-                data: expect.objectContaining({
-                    artifacts: expect.arrayContaining([
-                        expect.objectContaining({ id: 'art-1' }),
-                    ]),
-                }),
-            }));
-            // Should not include loader-specific fields
-            const callData = mockEmit.mock.calls[0][0].data;
-            expect(callData).not.toHaveProperty('reports');
-            expect(callData).not.toHaveProperty('processed_files');
-        });
-        it('should include reports and processed_files in data for loader events', async () => {
-            const { emit: mockEmit } = require('../../common/control-protocol');
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            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({
-                data: expect.objectContaining({
-                    reports: expect.arrayContaining([
-                        expect.objectContaining({ item_type: 'tasks' }),
-                    ]),
-                    processed_files: ['file-1', 'file-2'],
-                }),
-            }));
-            // Should not include extraction-specific fields
-            const callData = mockEmit.mock.calls[0][0].data;
-            expect(callData).not.toHaveProperty('artifacts');
-        });
-        it('should not include artifacts, reports, or processed_files for unknown event types', async () => {
-            const { emit: mockEmit } = require('../../common/control-protocol');
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-            adapter['_artifacts'] = [
-                { id: 'art-1', item_count: 10, item_type: 'issues' },
-            ];
-            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;
-            expect(callData).not.toHaveProperty('artifacts');
-            expect(callData).not.toHaveProperty('reports');
-            expect(callData).not.toHaveProperty('processed_files');
-        });
-        it('should include artifacts for all ExtractorEventType values', async () => {
-            var _a, _b;
-            const { emit: mockEmit } = require('../../common/control-protocol');
-            const extractorEvents = [
-                types_1.ExtractorEventType.DataExtractionDone,
-                types_1.ExtractorEventType.DataExtractionProgress,
-                types_1.ExtractorEventType.DataExtractionError,
-                types_1.ExtractorEventType.AttachmentExtractionDone,
-                types_1.ExtractorEventType.AttachmentExtractionProgress,
-            ];
-            for (const eventType of extractorEvents) {
-                jest.clearAllMocks();
-                adapter.hasWorkerEmitted = false;
-                adapter['adapterState'].postState = jest
-                    .fn()
-                    .mockResolvedValue(undefined);
-                adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-                await adapter.emit(eventType);
-                const callData = (_b = (_a = mockEmit.mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data;
-                expect(callData).toHaveProperty('artifacts');
-                expect(callData).not.toHaveProperty('reports');
-            }
-        });
-        it('should include reports and processed_files for all LoaderEventType values', async () => {
-            var _a, _b;
-            const { emit: mockEmit } = require('../../common/control-protocol');
-            const loaderEvents = [
-                types_1.LoaderEventType.DataLoadingDone,
-                types_1.LoaderEventType.DataLoadingProgress,
-                types_1.LoaderEventType.DataLoadingError,
-                types_1.LoaderEventType.AttachmentLoadingDone,
-                types_1.LoaderEventType.AttachmentLoadingProgress,
-            ];
-            for (const eventType of loaderEvents) {
-                jest.clearAllMocks();
-                adapter.hasWorkerEmitted = false;
-                adapter['adapterState'].postState = jest
-                    .fn()
-                    .mockResolvedValue(undefined);
-                adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-                await adapter.emit(eventType);
-                const callData = (_b = (_a = mockEmit.mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data;
-                expect(callData).toHaveProperty('reports');
-                expect(callData).toHaveProperty('processed_files');
-                expect(callData).not.toHaveProperty('artifacts');
-            }
-        });
-    });
-    describe('workersOldest / workersNewest boundary updates', () => {
-        let mockPostMessage;
-        beforeEach(() => {
-            const workerThreads = require('node:worker_threads');
-            mockPostMessage = jest.fn();
-            if (workerThreads.parentPort) {
-                jest
-                    .spyOn(workerThreads.parentPort, 'postMessage')
-                    .mockImplementation(mockPostMessage);
-            }
-            else {
-                workerThreads.parentPort = { postMessage: mockPostMessage };
-            }
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
-            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
-        });
-        afterEach(() => {
-            jest.restoreAllMocks();
-        });
-        /**
-         * Helper: sets extract_from and extract_to on the event context,
-         * resets the emit guard so the adapter can emit again, then emits
-         * AttachmentExtractionDone.
-         */
-        async function emitDone(adapterInstance, extractionStart, extractionEnd) {
-            adapterInstance.event.payload.event_context.extract_from =
-                extractionStart;
-            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, {
-                reports: [],
-                processed_files: [],
-            });
-        }
-        describe('initial import with UNBOUNDED start', () => {
-            it('should set workersOldest to UNBOUNDED_DATE_TIME_VALUE and workersNewest to extraction end', async () => {
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-                expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
-            });
-        });
-        describe('reconciliation after UNBOUNDED initial import', () => {
-            it('should NOT overwrite workersOldest when reconciliation start is later than sentinel', async () => {
-                // Initial import: UNBOUNDED start, NOW end
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                // Reconciliation: absolute dates within the range
-                await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-                expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
-            });
-            it('should NOT overwrite workersOldest even when reconciliation start is very early', async () => {
-                // Initial import: UNBOUNDED start, NOW end
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                // Reconciliation with a very old start date — still later than epoch
-                await emitDone(adapter, '1980-01-01T00:00:00.000Z', '1990-01-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-                expect(adapter.state.workersNewest).toBe('2025-06-01T00:00:00.000Z');
-            });
-        });
-        describe('forward sync after UNBOUNDED initial import', () => {
-            it('should expand workersNewest forward while preserving workersOldest', async () => {
-                // Initial import
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                // Forward sync: from workersNewest to now
-                await emitDone(adapter, '2025-06-01T00:00:00.000Z', '2025-07-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-                expect(adapter.state.workersNewest).toBe('2025-07-01T00:00:00.000Z');
-            });
-        });
-        describe('reconciliation with end beyond current newest', () => {
-            it('should expand workersNewest when reconciliation end is later', async () => {
-                // Initial import
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                // Reconciliation with end beyond current newest
-                await emitDone(adapter, '2024-01-01T00:00:00.000Z', '2025-08-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-                expect(adapter.state.workersNewest).toBe('2025-08-01T00:00:00.000Z');
-            });
-        });
-        describe('first sync with absolute dates (no UNBOUNDED)', () => {
-            it('should set both boundaries from the extraction range', async () => {
-                await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-        });
-        describe('reconciliation after absolute initial sync', () => {
-            it('should expand workersOldest backward when reconciliation start is earlier', async () => {
-                // Initial sync with absolute dates
-                await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
-                // Reconciliation with earlier start
-                await emitDone(adapter, '2024-06-01T00:00:00.000Z', '2025-02-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe('2024-06-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-            it('should NOT change boundaries when reconciliation is within existing range', async () => {
-                // Initial sync
-                await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
-                // Reconciliation entirely within existing range
-                await emitDone(adapter, '2025-01-15T00:00:00.000Z', '2025-02-15T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-            it('should expand both boundaries when reconciliation exceeds both', async () => {
-                // Initial sync
-                await emitDone(adapter, '2025-01-01T00:00:00.000Z', '2025-03-01T00:00:00.000Z');
-                // Reconciliation exceeding both ends
-                await emitDone(adapter, '2024-06-01T00:00:00.000Z', '2025-09-01T00:00:00.000Z');
-                expect(adapter.state.workersOldest).toBe('2024-06-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-09-01T00:00:00.000Z');
-            });
-        });
-        describe('multiple forward syncs', () => {
-            it('should progressively expand workersNewest while preserving workersOldest', async () => {
-                // Initial import
-                await emitDone(adapter, constants_1.UNBOUNDED_DATE_TIME_VALUE, '2025-06-01T00:00:00.000Z');
-                // First forward sync
-                await emitDone(adapter, '2025-06-01T00:00:00.000Z', '2025-07-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-07-01T00:00:00.000Z');
-                // Second forward sync
-                await emitDone(adapter, '2025-07-01T00:00:00.000Z', '2025-08-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-08-01T00:00:00.000Z');
-                // workersOldest should remain the sentinel throughout
-                expect(adapter.state.workersOldest).toBe(constants_1.UNBOUNDED_DATE_TIME_VALUE);
-            });
-        });
-        describe('non-AttachmentExtractionDone events should NOT update boundaries', () => {
-            it('should not update boundaries on DataExtractionDone', async () => {
-                adapter.state.workersOldest = '2025-01-01T00:00:00.000Z';
-                adapter.state.workersNewest = '2025-03-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_from =
-                    '2024-01-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_to =
-                    '2025-12-01T00:00:00.000Z';
-                await adapter.emit(types_1.ExtractorEventType.DataExtractionDone, {
-                    reports: [],
-                    processed_files: [],
-                });
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-            it('should not update boundaries on DataExtractionProgress', async () => {
-                adapter.state.workersOldest = '2025-01-01T00:00:00.000Z';
-                adapter.state.workersNewest = '2025-03-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_from =
-                    '2024-01-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_to =
-                    '2025-12-01T00:00:00.000Z';
-                await adapter.emit(types_1.ExtractorEventType.DataExtractionProgress, {
-                    reports: [],
-                    processed_files: [],
-                });
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-            it('should not update boundaries on MetadataExtractionError', async () => {
-                adapter.state.workersOldest = '2025-01-01T00:00:00.000Z';
-                adapter.state.workersNewest = '2025-03-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_from =
-                    '2024-01-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_to =
-                    '2025-12-01T00:00:00.000Z';
-                await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
-                    reports: [],
-                    processed_files: [],
-                });
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-            it('should not update boundaries on AttachmentExtractionError', async () => {
-                adapter.state.workersOldest = '2025-01-01T00:00:00.000Z';
-                adapter.state.workersNewest = '2025-03-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_from =
-                    '2024-01-01T00:00:00.000Z';
-                adapter.event.payload.event_context.extract_to =
-                    '2025-12-01T00:00:00.000Z';
-                await adapter.emit(types_1.ExtractorEventType.AttachmentExtractionError, {
-                    reports: [],
-                    processed_files: [],
-                });
-                expect(adapter.state.workersOldest).toBe('2025-01-01T00:00:00.000Z');
-                expect(adapter.state.workersNewest).toBe('2025-03-01T00:00:00.000Z');
-            });
-        });
-    });
-    describe('extractionScope', () => {
-        it('should return empty object by default', () => {
-            expect(adapter.extractionScope).toEqual({});
-        });
-        it('should return extraction scope from adapter state', () => {
-            const extractionScope = {
-                tasks: { extract: true },
-                users: { extract: false },
-            };
-            // Simulate what State.init() does when parsing objects from API
-            mockAdapterState._extractionScope = extractionScope;
-            expect(adapter.extractionScope).toEqual({
-                tasks: { extract: true },
-                users: { extract: false },
-            });
-        });
-    });
-    describe('shouldExtract', () => {
-        it('should return true when extraction scope is empty', () => {
-            expect(adapter.shouldExtract('tasks')).toBe(true);
-            expect(adapter.shouldExtract('users')).toBe(true);
-        });
-        it('should return true when item type is not in scope', () => {
-            mockAdapterState._extractionScope = {
-                tasks: { extract: true },
-            };
-            expect(adapter.shouldExtract('users')).toBe(true);
-        });
-        it('should return true when item type has extract: true', () => {
-            mockAdapterState._extractionScope = {
-                tasks: { extract: true },
-            };
-            expect(adapter.shouldExtract('tasks')).toBe(true);
-        });
-        it('should return false when item type has extract: false', () => {
-            mockAdapterState._extractionScope = {
-                tasks: { extract: false },
-                users: { extract: true },
-            };
-            expect(adapter.shouldExtract('tasks')).toBe(false);
-            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);
-        });
-    });
-});