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

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

@@ -0,0 +1,801 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attachments_streaming_pool_1 = require("../../attachments-streaming/attachments-streaming-pool");
+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 worker_adapter_1 = require("./worker-adapter");
+/* eslint-disable @typescript-eslint/no-require-imports */
+jest.mock('../../common/control-protocol', () => ({
+    emit: jest.fn().mockResolvedValue({}),
+}));
+jest.mock('../../mappers/mappers');
+jest.mock('../../uploader/uploader');
+jest.mock('../../repo/repo');
+jest.mock('node:worker_threads', () => ({
+    parentPort: { postMessage: jest.fn() },
+}));
+jest.mock('../../attachments-streaming/attachments-streaming-pool', () => ({
+    AttachmentsStreamingPool: jest.fn().mockImplementation(() => ({
+        streamAll: jest.fn().mockResolvedValue(undefined),
+    })),
+}));
+function makeAdapter(eventType = types_1.EventType.StartExtractingData) {
+    const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+        payload: { event_type: eventType },
+    });
+    const initialState = {
+        attachments: { completed: false },
+        lastSyncStarted: '',
+        lastSuccessfulSyncStarted: '',
+        snapInVersionId: '',
+        toDevRev: {
+            attachmentsMetadata: {
+                artifactIds: [],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        },
+    };
+    const adapterState = new state_1.State({ event, initialState });
+    const adapter = new worker_adapter_1.WorkerAdapter({ event, adapterState });
+    return { adapter, event, adapterState };
+}
+describe(`${worker_adapter_1.WorkerAdapter.name}.streamAttachments`, () => {
+    let adapter;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ({ adapter } = makeAdapter());
+    });
+    it('should process all artifact batches successfully', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1', 'artifact2'],
+                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',
+                },
+            ],
+        })
+            .mockResolvedValueOnce({
+            attachments: [
+                {
+                    url: 'http://example.com/file3.pdf',
+                    id: 'attachment3',
+                    file_name: 'file3.pdf',
+                    parent_id: 'parent3',
+                },
+            ],
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(adapter.initializeRepos).toHaveBeenCalledWith([
+            { itemType: 'ssor_attachment' },
+        ]);
+        expect(adapter.initializeRepos).toHaveBeenCalledTimes(1);
+        expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(2);
+        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 () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        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();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+            batchSize: 0,
+        });
+        // Assert
+        expect(result).toBeUndefined();
+    });
+    it('[edge] should cap batch size to 50 when batchSize is greater than 50', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        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();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+            batchSize: 100,
+        });
+        // Assert
+        expect(result).toBeUndefined();
+    });
+    it('[edge] should handle empty attachments metadata artifact IDs', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: [],
+                lastProcessed: 0,
+            },
+        };
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(result).toBeUndefined();
+    });
+    it('[edge] should handle errors when getting attachments', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        const mockError = new Error('Failed to get attachments');
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            error: mockError,
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(result).toEqual({
+            error: mockError,
+        });
+    });
+    it('[edge] should handle empty attachments array from artifact', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [],
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
+        expect(result).toBeUndefined();
+    });
+    it('should use custom processors when provided', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        const mockReducer = jest.fn().mockReturnValue(['custom-reduced']);
+        const mockIterator = jest.fn().mockResolvedValue({});
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [{ id: 'attachment1' }],
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+            processors: {
+                reducer: mockReducer,
+                iterator: mockIterator,
+            },
+        });
+        // Assert
+        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 () => {
+        // Arrange
+        const mockStream = jest.fn();
+        attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => ({
+            streamAll: jest.fn().mockResolvedValue({ delay: 30 }),
+        }));
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [{ id: 'attachment1' }],
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(result).toEqual({ delay: 30 });
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+            'artifact1',
+        ]);
+    });
+    it('should handle error from iterator', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => ({
+            streamAll: jest.fn().mockResolvedValue({
+                error: 'Mock error',
+            }),
+        }));
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [{ id: 'attachment1' }],
+        });
+        adapter.initializeRepos = jest.fn();
+        // Act
+        const result = await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(result).toEqual({ error: 'Mock error' });
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+            'artifact1',
+        ]);
+    });
+    it('should emit progress event and exit process on timeout, preserving state for resumption', async () => {
+        // Arrange
+        const mockStream = jest.fn();
+        const exitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation(() => undefined);
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1', 'artifact2', 'artifact3'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [
+                {
+                    url: 'http://example.com/file1.pdf',
+                    id: 'attachment1',
+                    file_name: 'file1.pdf',
+                    parent_id: 'parent1',
+                },
+            ],
+        });
+        attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => ({
+            streamAll: jest.fn().mockImplementation(() => {
+                adapter.isTimeout = true;
+                return {};
+            }),
+        }));
+        adapter.initializeRepos = jest.fn();
+        const emitSpy = jest.spyOn(adapter, 'emit').mockResolvedValue();
+        // Act
+        await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(emitSpy).toHaveBeenCalledWith(types_1.ExtractorEventType.AttachmentExtractionProgress);
+        expect(exitSpy).toHaveBeenCalledWith(0);
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+            'artifact1',
+            'artifact2',
+            'artifact3',
+        ]);
+        expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(1);
+        exitSpy.mockRestore();
+    });
+    it('should stop after the timeout flips between batches and preserve unprocessed artifacts for resumption', async () => {
+        // Arrange: three artifacts. The first batch's streamAll completes
+        // successfully; the second sets isTimeout=true mid-run. The third batch
+        // must never be reached.
+        const mockStream = jest.fn();
+        const exitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation(() => undefined);
+        adapter.state.toDevRev = {
+            attachmentsMetadata: {
+                artifactIds: ['artifact1', 'artifact2', 'artifact3'],
+                lastProcessed: 0,
+                lastProcessedAttachmentsIdsList: [],
+            },
+        };
+        adapter['uploader'].getAttachmentsFromArtifactId = jest
+            .fn()
+            .mockResolvedValue({
+            attachments: [
+                {
+                    url: 'http://example.com/file.pdf',
+                    id: 'attachment-x',
+                    file_name: 'file.pdf',
+                    parent_id: 'parent-x',
+                },
+            ],
+        });
+        // First call: clean streamAll. Second call: flip isTimeout AFTER streaming.
+        attachments_streaming_pool_1.AttachmentsStreamingPool
+            .mockImplementationOnce(() => ({
+            streamAll: jest.fn().mockResolvedValue({}),
+        }))
+            .mockImplementationOnce(() => ({
+            streamAll: jest.fn().mockImplementation(() => {
+                adapter.isTimeout = true;
+                return {};
+            }),
+        }));
+        adapter.initializeRepos = jest.fn();
+        const emitSpy = jest.spyOn(adapter, 'emit').mockResolvedValue();
+        // Act
+        await adapter.streamAttachments({ stream: mockStream });
+        // Assert
+        // - Fetched attachments for the first two artifacts only; the third never ran
+        expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(2);
+        // - Progress emitted and process.exit(0) called once the timeout was detected
+        expect(emitSpy).toHaveBeenCalledWith(types_1.ExtractorEventType.AttachmentExtractionProgress);
+        expect(exitSpy).toHaveBeenCalledWith(0);
+        // - Artifact 1 was shifted out cleanly; artifact 2 remains (timeout caught
+        //   before its shift) along with the untouched artifact 3
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+            'artifact2',
+            'artifact3',
+        ]);
+        exitSpy.mockRestore();
+    });
+    it('should reset lastProcessed and attachment IDs list after processing all artifacts', async () => {
+        // Arrange
+        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);
+        // Act
+        await adapter.streamAttachments({
+            stream: mockStream,
+        });
+        // Assert
+        expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toHaveLength(0);
+        expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name}.processAttachment`, () => {
+    let adapter;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ({ adapter } = makeAdapter(types_1.EventType.StartExtractingAttachments));
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    const createMockHttpStream = (headers = {}) => ({
+        headers,
+        data: { destroy: jest.fn() },
+    });
+    const makeAttachment = (overrides = {}) => (Object.assign({ id: 'att-1', url: 'https://example.com/file.pdf', file_name: 'file.pdf', parent_id: 'parent-1', content_type: 'application/pdf' }, overrides));
+    function setupUploaderHappyPath() {
+        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 pushMock = jest.fn().mockResolvedValue(undefined);
+        adapter.getRepo = jest.fn().mockReturnValue({ push: pushMock });
+        return pushMock;
+    }
+    // ---- content-type resolution ----
+    it('should use attachment.content_type when provided, ignoring HTTP header', async () => {
+        // Arrange
+        setupUploaderHappyPath();
+        const mockStream = jest.fn().mockResolvedValue({
+            httpStream: createMockHttpStream({
+                'content-type': 'text/plain',
+                'content-length': '100',
+            }),
+        });
+        // Act
+        await adapter.processAttachment(makeAttachment({ content_type: 'application/pdf' }), mockStream);
+        // Assert
+        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 () => {
+        // Arrange
+        setupUploaderHappyPath();
+        const mockStream = jest.fn().mockResolvedValue({
+            httpStream: createMockHttpStream({
+                'content-type': 'image/jpeg',
+                'content-length': '200',
+            }),
+        });
+        const attachment = {
+            id: 'att-2',
+            url: 'https://example.com/photo.jpg',
+            file_name: 'photo.jpg',
+            parent_id: 'parent-2',
+        };
+        // Act
+        await adapter.processAttachment(attachment, mockStream);
+        // Assert
+        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 () => {
+        // Arrange
+        setupUploaderHappyPath();
+        const mockStream = jest.fn().mockResolvedValue({
+            httpStream: createMockHttpStream({}),
+        });
+        const attachment = {
+            id: 'att-3',
+            url: 'https://example.com/file.bin',
+            file_name: 'file.bin',
+            parent_id: 'parent-3',
+        };
+        // Act
+        await adapter.processAttachment(attachment, mockStream);
+        // Assert
+        expect(adapter['uploader'].getArtifactUploadUrl).toHaveBeenCalledWith('file.bin', 'application/octet-stream', undefined);
+    });
+    // ---- error paths ----
+    it('should return the stream error directly when the stream function returns an error', async () => {
+        // Arrange
+        const stream = jest
+            .fn()
+            .mockResolvedValue({ error: new Error('stream failed') });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect(result === null || result === void 0 ? void 0 : result.error).toBeDefined();
+    });
+    it('should propagate a rate-limit delay from the stream function', async () => {
+        // Arrange
+        const stream = jest.fn().mockResolvedValue({ delay: 5 });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect(result === null || result === void 0 ? void 0 : result.delay).toBe(5);
+    });
+    it('should return an error containing the attachment ID when getArtifactUploadUrl fails', async () => {
+        var _a, _b;
+        // Arrange
+        const stream = jest
+            .fn()
+            .mockResolvedValue({ httpStream: createMockHttpStream() });
+        adapter['uploader'].getArtifactUploadUrl = jest
+            .fn()
+            .mockResolvedValue({ error: new Error('upload url failed') });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('att-1');
+        expect((_b = result === null || result === void 0 ? void 0 : result.error) === null || _b === void 0 ? void 0 : _b.message).toContain('preparing artifact');
+    });
+    it('should return an error when streamArtifact fails', async () => {
+        var _a;
+        // Arrange
+        const stream = jest
+            .fn()
+            .mockResolvedValue({ httpStream: createMockHttpStream() });
+        adapter['uploader'].getArtifactUploadUrl = jest.fn().mockResolvedValue({
+            response: {
+                artifact_id: 'art-1',
+                upload_url: 'https://upload',
+                form_data: [],
+            },
+        });
+        adapter['uploader'].streamArtifact = jest
+            .fn()
+            .mockResolvedValue({ error: new Error('stream failed') });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('streaming to artifact');
+    });
+    it('should return an error when confirmArtifactUpload fails', async () => {
+        var _a;
+        // Arrange
+        const stream = jest
+            .fn()
+            .mockResolvedValue({ httpStream: createMockHttpStream() });
+        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({ error: new Error('confirm failed') });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('confirming upload');
+    });
+    it.each([
+        { inline: true, expected: true },
+        { inline: false, expected: false },
+    ])('should set inline=$expected on the ssorAttachment when attachment.inline=$inline', async ({ inline, expected }) => {
+        // Arrange
+        const pushMock = setupUploaderHappyPath();
+        const stream = jest
+            .fn()
+            .mockResolvedValue({ httpStream: createMockHttpStream() });
+        // Act
+        await adapter.processAttachment(makeAttachment({ inline }), stream);
+        // Assert
+        const ssorItem = pushMock.mock.calls[0][0][0];
+        expect(ssorItem.inline).toBe(expected);
+    });
+    it('should return a descriptive error when the stream function returns no httpStream', async () => {
+        var _a;
+        // Arrange
+        const stream = jest.fn().mockResolvedValue({ httpStream: null });
+        // Act
+        const result = await adapter.processAttachment(makeAttachment(), stream);
+        // Assert
+        expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('Error while opening attachment stream');
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name}.initializeRepos — event size threshold`, () => {
+    it('should set isTimeout=true once the cumulative artifact payload exceeds EVENT_SIZE_THRESHOLD_BYTES', () => {
+        // Arrange
+        const { adapter } = makeAdapter();
+        let capturedOnUpload;
+        const { Repo } = require('../../repo/repo');
+        Repo.mockImplementationOnce((opts) => {
+            capturedOnUpload = opts.onUpload;
+            return { itemType: 'issues', upload: jest.fn(), uploadedArtifacts: [] };
+        });
+        // Act
+        adapter.initializeRepos([{ itemType: 'issues' }]);
+        expect(capturedOnUpload).toBeDefined();
+        capturedOnUpload({
+            id: 'artifact-x',
+            item_count: 1,
+            item_type: 'x'.repeat(200000),
+        });
+        // Assert
+        expect(adapter.isTimeout).toBe(true);
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name}.getRepo`, () => {
+    it('should return undefined when the requested repo was never initialised', () => {
+        // Arrange
+        const { adapter } = makeAdapter();
+        // Act
+        const result = adapter.getRepo('non-existent-type');
+        // Assert
+        expect(result).toBeUndefined();
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name}.destroyHttpStream`, () => {
+    let adapter;
+    beforeEach(() => {
+        ({ adapter } = makeAdapter());
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it.each([
+        {
+            label: 'calls destroy() when available',
+            data: { destroy: jest.fn(), close: jest.fn() },
+            expectDestroy: true,
+            expectClose: false,
+        },
+        {
+            label: 'calls close() when destroy is not present',
+            data: { close: jest.fn() },
+            expectDestroy: false,
+            expectClose: true,
+        },
+        {
+            label: 'does not throw when neither method is present',
+            data: {},
+            expectDestroy: false,
+            expectClose: false,
+        },
+        {
+            label: 'does not throw when data is null',
+            data: null,
+            expectDestroy: false,
+            expectClose: false,
+        },
+    ])('$label', ({ data, expectDestroy, expectClose }) => {
+        // Arrange
+        const httpStream = { data };
+        // Act & Assert
+        expect(() => adapter['destroyHttpStream'](httpStream)).not.toThrow();
+        if (expectDestroy) {
+            expect(data.destroy).toHaveBeenCalled();
+        }
+        if (expectClose) {
+            expect(data.close).toHaveBeenCalled();
+        }
+    });
+    it('should not re-throw when destroy() itself throws', () => {
+        // Arrange
+        const httpStream = {
+            data: {
+                destroy: () => {
+                    throw new Error('stream error');
+                },
+            },
+        };
+        // Act & Assert
+        expect(() => adapter['destroyHttpStream'](httpStream)).not.toThrow();
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name} — extractionScope`, () => {
+    it('should return empty object by default', () => {
+        const { adapter } = makeAdapter();
+        expect(adapter.extractionScope).toEqual({});
+    });
+    it('should return extraction scope from adapter state', () => {
+        const { adapter, adapterState } = makeAdapter();
+        const extractionScope = {
+            tasks: { extract: true },
+            users: { extract: false },
+        };
+        adapterState._extractionScope = extractionScope;
+        expect(adapter.extractionScope).toEqual(extractionScope);
+    });
+});
+describe(`${worker_adapter_1.WorkerAdapter.name} — shouldExtract`, () => {
+    it('should return true when extraction scope is empty', () => {
+        const { adapter } = makeAdapter();
+        expect(adapter.shouldExtract('tasks')).toBe(true);
+        expect(adapter.shouldExtract('users')).toBe(true);
+    });
+    it('should return true when item type is not in scope', () => {
+        const { adapter, adapterState } = makeAdapter();
+        adapterState._extractionScope = {
+            tasks: { extract: true },
+        };
+        expect(adapter.shouldExtract('users')).toBe(true);
+    });
+    it('should return true when item type has extract: true', () => {
+        const { adapter, adapterState } = makeAdapter();
+        adapterState._extractionScope = {
+            tasks: { extract: true },
+        };
+        expect(adapter.shouldExtract('tasks')).toBe(true);
+    });
+    it('should return false when item type has extract: false', () => {
+        const { adapter, adapterState } = makeAdapter();
+        adapterState._extractionScope = {
+            tasks: { extract: false },
+            users: { extract: true },
+        };
+        expect(adapter.shouldExtract('tasks')).toBe(false);
+        expect(adapter.shouldExtract('users')).toBe(true);
+    });
+});