@devrev/ts-adaas 1.8.1-beta.1 → 1.8.1

package/dist/attachments-streaming/attachments-streaming-pool.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const attachments_streaming_pool_1 = require("./attachments-streaming-pool");
-describe('AttachmentsStreamingPool', () => {
+describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
     let mockAdapter;
     let mockStream;
     let mockAttachments;
@@ -50,7 +50,7 @@ describe('AttachmentsStreamingPool', () => {
         jest.clearAllMocks();
         jest.restoreAllMocks();
     });
-    describe('constructor', () => {
+    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.constructor.name, () => {
         it('should initialize with default values', () => {
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
@@ -82,7 +82,7 @@ describe('AttachmentsStreamingPool', () => {
             expect(pool['attachments']).not.toBe(mockAttachments); // Different reference
         });
     });
-    describe('streamAll', () => {
+    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.streamAll.name, () => {
         it('should initialize lastProcessedAttachmentsIdsList if it does not exist', async () => {
             mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList = undefined;
             mockAdapter.processAttachment.mockResolvedValue({});
@@ -116,7 +116,6 @@ describe('AttachmentsStreamingPool', () => {
             const result = await pool.streamAll();
             expect(result).toEqual({});
             expect(mockAdapter.processAttachment).not.toHaveBeenCalled();
-            expect(console.log).toHaveBeenCalledWith('Starting download of 0 attachments, streaming 10 at once.');
         });
         it('should return delay when rate limit is hit', async () => {
             const delayResponse = { delay: 5000 };
@@ -130,7 +129,7 @@ describe('AttachmentsStreamingPool', () => {
             expect(result).toEqual({ delay: 5000 });
         });
     });
-    describe('startPoolStreaming', () => {
+    describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.startPoolStreaming.name, () => {
         it('should skip already processed attachments', async () => {
             mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList = ['attachment-1'];
             mockAdapter.processAttachment.mockResolvedValue({});
@@ -140,7 +139,6 @@ describe('AttachmentsStreamingPool', () => {
                 stream: mockStream
             });
             await pool.streamAll();
-            expect(console.log).toHaveBeenCalledWith('Attachment with ID attachment-1 has already been processed. Skipping.');
             expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(2); // Only 2 out of 3
         });
         it('should add successfully processed attachment IDs to the list', async () => {
@@ -156,9 +154,6 @@ describe('AttachmentsStreamingPool', () => {
                 'attachment-2',
                 'attachment-3'
             ]);
-            expect(console.log).toHaveBeenCalledWith('Successfully processed attachment: attachment-1');
-            expect(console.log).toHaveBeenCalledWith('Successfully processed attachment: attachment-2');
-            expect(console.log).toHaveBeenCalledWith('Successfully processed attachment: attachment-3');
         });
         it('should handle processing errors gracefully', async () => {
             const error = new Error('Processing failed');
@@ -206,40 +201,38 @@ describe('AttachmentsStreamingPool', () => {
             expect(mockAdapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0], mockStream);
         });
     });
-    describe('edge cases', () => {
-        it('should handle single attachment', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachments: [mockAttachments[0]],
-                stream: mockStream
-            });
-            const result = await pool.streamAll();
-            expect(result).toEqual({});
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(1);
+    it('[edge] should handle single attachment', async () => {
+        mockAdapter.processAttachment.mockResolvedValue({});
+        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+            adapter: mockAdapter,
+            attachments: [mockAttachments[0]],
+            stream: mockStream
         });
-        it('should handle batch size larger than attachments array', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachments: mockAttachments,
-                batchSize: 100,
-                stream: mockStream
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
+        const result = await pool.streamAll();
+        expect(result).toEqual({});
+        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(1);
+    });
+    it('[edge] should handle batch size larger than attachments array', async () => {
+        mockAdapter.processAttachment.mockResolvedValue({});
+        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+            adapter: mockAdapter,
+            attachments: mockAttachments,
+            batchSize: 100,
+            stream: mockStream
         });
-        it('should handle batch size of 1', async () => {
-            mockAdapter.processAttachment.mockResolvedValue({});
-            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
-                adapter: mockAdapter,
-                attachments: mockAttachments,
-                batchSize: 1,
-                stream: mockStream
-            });
-            await pool.streamAll();
-            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
+        await pool.streamAll();
+        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
+    });
+    it('[edge] should handle batch size of 1', async () => {
+        mockAdapter.processAttachment.mockResolvedValue({});
+        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+            adapter: mockAdapter,
+            attachments: mockAttachments,
+            batchSize: 1,
+            stream: mockStream
         });
+        await pool.streamAll();
+        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
     });
     describe('concurrency behavior', () => {
         it('should process attachments concurrently within batch size', async () => {

package/dist/common/helpers.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const helpers_1 = require("./helpers");
-describe('getFilesToLoad', () => {
+describe(helpers_1.getFilesToLoad.name, () => {
     let statsFile;
     beforeEach(() => {
         statsFile = [
@@ -49,34 +49,7 @@ describe('getFilesToLoad', () => {
             },
         ];
     });
-    it('should return an empty array if statsFile is empty', () => {
-        statsFile = [];
-        const itemTypesToLoad = [];
-        const result = (0, helpers_1.getFilesToLoad)({
-            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
-            statsFile,
-        });
-        expect(result).toEqual([]);
-    });
-    it('should return an empty array if itemTypesToLoad is empty', () => {
-        const itemTypesToLoad = [];
-        const result = (0, helpers_1.getFilesToLoad)({
-            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
-            statsFile,
-        });
-        expect(result).toEqual([]);
-    });
-    it('should return an empty array if statsFile has no matching items', () => {
-        const itemTypesToLoad = [
-            { itemType: 'users', create: jest.fn(), update: jest.fn() },
-        ];
-        const result = (0, helpers_1.getFilesToLoad)({
-            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
-            statsFile,
-        });
-        expect(result).toEqual([]);
-    });
-    it('should filter out files not in itemTypesToLoad and order them by itemTypesToLoad', () => {
+    it('should filter files by supported item types and order them correctly', () => {
         const itemTypesToLoad = [
             { itemType: 'attachments', create: jest.fn(), update: jest.fn() },
             { itemType: 'issues', create: jest.fn(), update: jest.fn() },
@@ -155,4 +128,31 @@ describe('getFilesToLoad', () => {
             },
         ]);
     });
+    it('[edge] should return an empty array when statsFile is empty', () => {
+        statsFile = [];
+        const itemTypesToLoad = [];
+        const result = (0, helpers_1.getFilesToLoad)({
+            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
+            statsFile,
+        });
+        expect(result).toEqual([]);
+    });
+    it('[edge] should return an empty array when itemTypesToLoad is empty', () => {
+        const itemTypesToLoad = [];
+        const result = (0, helpers_1.getFilesToLoad)({
+            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
+            statsFile,
+        });
+        expect(result).toEqual([]);
+    });
+    it('[edge] should return an empty array when statsFile has no matching items', () => {
+        const itemTypesToLoad = [
+            { itemType: 'users', create: jest.fn(), update: jest.fn() },
+        ];
+        const result = (0, helpers_1.getFilesToLoad)({
+            supportedItemTypes: itemTypesToLoad.map((it) => it.itemType),
+            statsFile,
+        });
+        expect(result).toEqual([]);
+    });
 });

package/dist/common/install-initial-domain-mapping.test.js

@@ -20,7 +20,7 @@ jest.mock('../http/axios-client-internal', () => {
 jest.mock('../logger/logger');
 const mockAxiosClient = axios_client_internal_1.axiosClient;
 const mockIsAxiosError = axios_1.default.isAxiosError;
-describe('installInitialDomainMapping', () => {
+describe(install_initial_domain_mapping_1.installInitialDomainMapping.name, () => {
     // Create mock objects
     const mockEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
     const mockInitialDomainMapping = {
@@ -42,18 +42,6 @@ describe('installInitialDomainMapping', () => {
     };
     const mockEndpoint = 'test_devrev_endpoint';
     const mockToken = 'test_token';
-    let mockConsoleLog;
-    let mockConsoleWarn;
-    let mockConsoleError;
-    // Before each test, create a fresh spy.
-    beforeEach(() => {
-        // Re-initialize the spy and its mock implementation
-        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-        mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        mockConsoleError = jest
-            .spyOn(console, 'error')
-            .mockImplementation(() => { });
-    });
     // After each test, clear all mocks to prevent state from leaking.
     afterEach(() => {
         jest.clearAllMocks();
@@ -109,8 +97,6 @@ describe('installInitialDomainMapping', () => {
                 Authorization: mockToken,
             },
         });
-        expect(mockConsoleLog).toHaveBeenCalledWith('Successfully created recipe blueprint with id: recipe-blueprint-123');
-        expect(mockConsoleLog).toHaveBeenCalledWith(`Successfully installed initial domain mapping ${JSON.stringify(mockDomainMappingResponse.data)}`);
     });
     it('should successfully install without recipe blueprint when not provided', async () => {
         const mappingWithoutBlueprint = {
@@ -153,19 +139,17 @@ describe('installInitialDomainMapping', () => {
         // Should only make one POST request (no recipe blueprint creation for empty object)
         expect(mockAxiosClient.post).toHaveBeenCalledTimes(1);
     });
-    it('should return early with warning when no initial domain mapping provided', async () => {
+    it('[edge] should return early with warning when initial domain mapping is null', async () => {
         await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, null);
-        expect(mockConsoleWarn).toHaveBeenCalledWith('No initial domain mapping found.');
         expect(mockAxiosClient.get).not.toHaveBeenCalled();
         expect(mockAxiosClient.post).not.toHaveBeenCalled();
     });
-    it('should return early with warning when undefined initial domain mapping provided', async () => {
+    it('[edge] should return early with warning when initial domain mapping is undefined', async () => {
         await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, undefined);
-        expect(mockConsoleWarn).toHaveBeenCalledWith('No initial domain mapping found.');
         expect(mockAxiosClient.get).not.toHaveBeenCalled();
         expect(mockAxiosClient.post).not.toHaveBeenCalled();
     });
-    it('should throw error when import slug is missing', async () => {
+    it('[edge] should throw error when import slug is missing', async () => {
         const snapInResponseWithoutImport = {
             data: {
                 snap_in: {
@@ -175,9 +159,9 @@ describe('installInitialDomainMapping', () => {
             },
         };
         mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutImport);
-        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('No import slug or snap-in slug found');
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
     });
-    it('should throw error when snap-in slug is missing', async () => {
+    it('[edge] should throw error when snap-in slug is missing', async () => {
         const snapInResponseWithoutSlug = {
             data: {
                 snap_in: {
@@ -187,7 +171,7 @@ describe('installInitialDomainMapping', () => {
             },
         };
         mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutSlug);
-        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('No import slug or snap-in slug found');
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
     });
     it('should handle the error during recipe blueprint creation', async () => {
         mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
@@ -216,6 +200,6 @@ describe('installInitialDomainMapping', () => {
         mockAxiosClient.post.mockResolvedValueOnce(mockRecipeBlueprintResponse);
         const domainMappingError = new Error('Domain mapping installation failed');
         mockAxiosClient.post.mockRejectedValueOnce(domainMappingError);
-        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow('Domain mapping installation failed');
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
     });
 });

package/dist/logger/logger.test.js

@@ -14,7 +14,7 @@ jest.mock('node:worker_threads', () => ({
     isMainThread: true,
     parentPort: null,
 }));
-describe('Logger', () => {
+describe(logger_1.Logger.name, () => {
     let mockEvent;
     let mockOptions;
     beforeEach(() => {
@@ -137,7 +137,7 @@ describe('Logger', () => {
             mockOptions.isLocalDevelopment = false;
             logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
         });
-        it('should handle empty string message', () => {
+        it('[edge] should handle empty string message', () => {
             logger.info('');
             expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
             const callArgs = mockConsoleInfo.mock.calls[0][0];
@@ -146,7 +146,7 @@ describe('Logger', () => {
             expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
             expect(logObject.request_id).toBe(mockEvent.payload.event_context.request_id);
         });
-        it('should handle null and undefined values', () => {
+        it('[edge] should handle null and undefined values', () => {
             logger.info('test', null, undefined);
             expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
             const callArgs = mockConsoleInfo.mock.calls[0][0];
@@ -155,7 +155,7 @@ describe('Logger', () => {
             expect(logObject.message).toBe('test null undefined');
             expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
         });
-        it('should handle complex nested objects', () => {
+        it('[edge] should handle complex nested objects', () => {
             const complexObject = {
                 level1: {
                     level2: {

package/dist/repo/repo.test.js

@@ -5,7 +5,7 @@ const test_helpers_1 = require("../tests/test-helpers");
 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() })));
-describe('Repo class push method', () => {
+describe(repo_1.Repo.name, () => {
     let repo;
     let normalize;
     beforeEach(() => {
@@ -20,18 +20,14 @@ describe('Repo class push method', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should not push items if items array is empty', async () => {
-        await repo.push([]);
-        expect(repo.getItems()).toEqual([]);
-    });
-    it('should normalize and push 10 items if array is not empty', async () => {
+    it('should normalize and push items when array contains items', async () => {
         const items = (0, test_helpers_1.createItems)(10);
         await repo.push(items);
         expect(normalize).toHaveBeenCalledTimes(10);
         const normalizedItems = items.map((item) => (0, test_helpers_1.normalizeItem)(item));
         expect(repo.getItems()).toEqual(normalizedItems);
     });
-    it('should not normalize items if normalize function is not provided', async () => {
+    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 }),
             itemType: 'test_item_type',
@@ -42,46 +38,56 @@ describe('Repo class push method', () => {
         await repo.push(items);
         expect(normalize).not.toHaveBeenCalled();
     });
-    describe('should not normalize items if type is "external_domain_metadata" or "ssor_attachment"', () => {
-        it('item type: external_domain_metadata', async () => {
-            repo = new repo_1.Repo({
-                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
-                itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA,
-                normalize,
-                onUpload: jest.fn(),
-                options: {},
-            });
-            const items = (0, test_helpers_1.createItems)(10);
-            await repo.push(items);
-            expect(normalize).not.toHaveBeenCalled();
+    it('[edge] should not push items when items array is empty', async () => {
+        await repo.push([]);
+        expect(repo.getItems()).toEqual([]);
+    });
+    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 }),
+            itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA,
+            normalize,
+            onUpload: jest.fn(),
+            options: {},
         });
-        it('item type: ssor_attachment', async () => {
-            repo = new repo_1.Repo({
-                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
-                itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT,
-                normalize,
-                onUpload: jest.fn(),
-                options: {},
-            });
-            const items = (0, test_helpers_1.createItems)(10);
-            await repo.push(items);
-            expect(normalize).not.toHaveBeenCalled();
+        const items = (0, test_helpers_1.createItems)(10);
+        await repo.push(items);
+        expect(normalize).not.toHaveBeenCalled();
+    });
+    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 }),
+            itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT,
+            normalize,
+            onUpload: jest.fn(),
+            options: {},
         });
+        const items = (0, test_helpers_1.createItems)(10);
+        await repo.push(items);
+        expect(normalize).not.toHaveBeenCalled();
     });
     it('should leave 5 items in the items array after pushing 2005 items with batch size of 2000', async () => {
         const items = (0, test_helpers_1.createItems)(2005);
         await repo.push(items);
         expect(repo.getItems().length).toBe(5);
     });
-    it('should upload 2 batches of 2000 and leave 5 items in the items array after pushing 4005 items with batch size of 2000', async () => {
-        const uploadSpy = jest.spyOn(repo, 'upload');
+    it('should normalize all items when pushing 4005 items with batch size of 2000', async () => {
         const items = (0, test_helpers_1.createItems)(4005);
         await repo.push(items);
         expect(normalize).toHaveBeenCalledTimes(4005);
-        expect(repo.getItems().length).toBe(5);
-        expect(uploadSpy).toHaveBeenCalledTimes(2); // Check that upload was called twice
+    });
+    it('should upload 2 batches when pushing 4005 items with batch size of 2000', async () => {
+        const uploadSpy = jest.spyOn(repo, 'upload');
+        const items = (0, test_helpers_1.createItems)(4005);
+        await repo.push(items);
+        expect(uploadSpy).toHaveBeenCalledTimes(2);
         uploadSpy.mockRestore();
     });
+    it('should leave 5 items in array after pushing 4005 items with batch size of 2000', async () => {
+        const items = (0, test_helpers_1.createItems)(4005);
+        await repo.push(items);
+        expect(repo.getItems().length).toBe(5);
+    });
     describe('should take batch size into account', () => {
         beforeEach(() => {
             repo = new repo_1.Repo({
@@ -104,14 +110,22 @@ describe('Repo class push method', () => {
             await repo.push(items);
             expect(repo.getItems().length).toBe(5);
         });
-        it('should upload 4 batches of 50 and leave 5 items in the items array after pushing 205 items with batch size of 50', async () => {
-            const uploadSpy = jest.spyOn(repo, 'upload');
+        it('should normalize all items when pushing 205 items with batch size of 50', async () => {
             const items = (0, test_helpers_1.createItems)(205);
             await repo.push(items);
             expect(normalize).toHaveBeenCalledTimes(205);
-            expect(repo.getItems().length).toBe(5);
+        });
+        it('should upload 4 batches when pushing 205 items with batch size of 50', async () => {
+            const uploadSpy = jest.spyOn(repo, 'upload');
+            const items = (0, test_helpers_1.createItems)(205);
+            await repo.push(items);
             expect(uploadSpy).toHaveBeenCalledTimes(4);
             uploadSpy.mockRestore();
         });
+        it('should leave 5 items in array after pushing 205 items with batch size of 50', async () => {
+            const items = (0, test_helpers_1.createItems)(205);
+            await repo.push(items);
+            expect(repo.getItems().length).toBe(5);
+        });
     });
 });

package/dist/tests/timeout-handling/timeout-1.test.js

@@ -7,7 +7,7 @@ const extraction_1 = require("../../types/extraction");
 const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
-describe('timeout-1', () => {
+describe('timeout-1 extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-2.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-2', () => {
+describe('timeout-2 extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-3a.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-3a', () => {
+describe('timeout-3a extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-3b.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-3b', () => {
+describe('timeout-3b extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/types/extraction.test.js

@@ -2,22 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const extraction_1 = require("./extraction");
 const test_helpers_1 = require("../tests/test-helpers");
-describe('EventContext type tests', () => {
+// Test the EventContext interface and related extraction types
+describe('ExtractionTypes', () => {
     const baseEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
-    it('should handle context without optional fields', () => {
+    it('should create event context without optional fields', () => {
         const event = Object.assign({}, baseEvent);
         // If this compiles, the test passes
         expect(event).toBeDefined();
+        expect(event.payload.event_context).toBeDefined();
     });
-    it('should handle context with all optional fields', () => {
+    it('should create event context with all optional fields', () => {
         const event = Object.assign({}, baseEvent);
         event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extract_from: true });
-        // Test with all optionals present
         expect(event).toBeDefined();
+        expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
+        expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.TIME_SCOPED);
+        expect(event.payload.event_context.reset_extract_from).toBe(true);
     });
-    it('should handle partial optional fields', () => {
+    it('should create event context with partial optional fields', () => {
         const event = Object.assign({}, baseEvent);
         event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z' });
         expect(event).toBeDefined();
+        expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
+    });
+    it('should handle different InitialSyncScope values', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { initial_sync_scope: extraction_1.InitialSyncScope.FULL_HISTORY });
+        expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.FULL_HISTORY);
+    });
+    it('[edge] should handle null event context gracefully', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = null;
+        expect(event.payload.event_context).toBeNull();
+    });
+    it('[edge] should handle undefined optional fields', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: undefined, initial_sync_scope: undefined, reset_extract_from: undefined });
+        expect(event.payload.event_context.extract_from).toBeUndefined();
+        expect(event.payload.event_context.initial_sync_scope).toBeUndefined();
+        expect(event.payload.event_context.reset_extract_from).toBeUndefined();
+    });
+    it('[edge] should handle invalid date format in extract_from', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: 'invalid-date-format' });
+        expect(event.payload.event_context.extract_from).toBe('invalid-date-format');
+        // Note: Type validation would typically happen at runtime, not compile time
+    });
+    it('[edge] should handle explicit boolean values for reset_extract_from', () => {
+        const eventWithTrue = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            eventContextOverrides: {
+                reset_extract_from: true
+            }
+        });
+        const eventWithFalse = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            eventContextOverrides: {
+                reset_extract_from: false
+            }
+        });
+        expect(eventWithTrue.payload.event_context.reset_extract_from).toBe(true);
+        expect(eventWithFalse.payload.event_context.reset_extract_from).toBe(false);
+        expect(typeof eventWithTrue.payload.event_context.reset_extract_from).toBe('boolean');
+        expect(typeof eventWithFalse.payload.event_context.reset_extract_from).toBe('boolean');
     });
 });

package/dist/uploader/uploader.test.js

@@ -27,17 +27,14 @@ const getArtifactUploadUrlMockResponse = {
         form_data: [],
     },
 };
-describe('Uploader Class Tests', () => {
+describe(uploader_1.Uploader.name, () => {
     const mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
     let uploader;
-    let consoleWarnSpy;
     beforeEach(() => {
         uploader = new uploader_1.Uploader({ event: mockEvent });
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
     });
     afterEach(() => {
         jest.clearAllMocks();
-        consoleWarnSpy.mockRestore();
     });
     it('should upload the file to the DevRev platform and return the artifact information', async () => {
         // Mock successful response from getArtifactUploadUrl
@@ -55,7 +52,7 @@ describe('Uploader Class Tests', () => {
             },
         });
     });
-    it('should handle failure in getArtifactUploadUrl', async () => {
+    it('[edge] should handle failure when getting artifact upload URL', async () => {
         var _a;
         // Mock unsuccessful response for getArtifactUploadUrl
         axios_client_internal_1.axiosClient.get.mockResolvedValueOnce(undefined);
@@ -63,9 +60,9 @@ describe('Uploader Class Tests', () => {
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
         expect(uploadResponse.error).toBeInstanceOf(Error);
-        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while getting artifact upload URL.');
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBeDefined();
     });
-    it('should handle failure in uploadArtifact', async () => {
+    it('[edge] should handle failure when uploading artifact', async () => {
         var _a;
         // Mock successful response for getArtifactUploadUrl
         axios_client_internal_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
@@ -75,9 +72,9 @@ describe('Uploader Class Tests', () => {
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
         expect(uploadResponse.error).toBeInstanceOf(Error);
-        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while uploading artifact.');
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBeDefined();
     });
-    it('should handle failure in confirmArtifactUpload', async () => {
+    it('[edge] should handle failure when confirming artifact upload', async () => {
         var _a;
         // Mock successful response for getArtifactUploadUrl
         axios_client_internal_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
@@ -89,6 +86,6 @@ describe('Uploader Class Tests', () => {
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
         expect(uploadResponse.error).toBeInstanceOf(Error);
-        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBe('Error while confirming artifact upload.');
+        expect((_a = uploadResponse.error) === null || _a === void 0 ? void 0 : _a.message).toBeDefined();
     });
 });

package/dist/workers/create-worker.test.js

@@ -4,8 +4,8 @@ const worker_threads_1 = require("worker_threads");
 const test_helpers_1 = require("../tests/test-helpers");
 const extraction_1 = require("../types/extraction");
 const create_worker_1 = require("./create-worker");
-describe('createWorker function', () => {
-    it('should return a Worker instance when a valid worker script is found', async () => {
+describe(create_worker_1.createWorker.name, () => {
+    it('should create a Worker instance when valid parameters are provided', async () => {
         const workerPath = __dirname + '../tests/dummy-worker.ts';
         const worker = worker_threads_1.isMainThread
             ? await (0, create_worker_1.createWorker)({
@@ -22,4 +22,66 @@ describe('createWorker function', () => {
             await worker.terminate();
         }
     });
+    it('should throw error when not in main thread', async () => {
+        const originalIsMainThread = worker_threads_1.isMainThread;
+        worker_threads_1.isMainThread = false;
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        await expect((0, create_worker_1.createWorker)({
+            event: (0, test_helpers_1.createEvent)({
+                eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+            }),
+            initialState: {},
+            workerPath,
+        })).rejects.toThrow('Worker threads can not start more worker threads.');
+        // Restore original value
+        worker_threads_1.isMainThread = originalIsMainThread;
+    });
+    it('[edge] should handle worker creation with minimal valid data', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+                }),
+                initialState: {},
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
+    it('[edge] should handle worker creation with complex initial state', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const complexState = {
+            nested: {
+                data: [1, 2, 3],
+                config: { enabled: true }
+            }
+        };
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionDataStart,
+                }),
+                initialState: complexState,
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
+    it('[edge] should handle different event types', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        if (worker_threads_1.isMainThread) {
+            const worker = await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionMetadataStart,
+                }),
+                initialState: {},
+                workerPath,
+            });
+            expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+            await worker.terminate();
+        }
+    });
 });

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

@@ -29,7 +29,7 @@ jest.mock('../attachments-streaming/attachments-streaming-pool', () => {
         }),
     };
 });
-describe('WorkerAdapter', () => {
+describe(worker_adapter_1.WorkerAdapter.name, () => {
     let adapter;
     let mockEvent;
     let mockAdapterState;
@@ -61,9 +61,8 @@ describe('WorkerAdapter', () => {
             adapterState: mockAdapterState,
         });
     });
-    describe('streamAttachments', () => {
+    describe(worker_adapter_1.WorkerAdapter.prototype.streamAttachments.name, () => {
         it('should process all artifact batches successfully', async () => {
-            // Arrange
             const mockStream = jest.fn();
             // Set up adapter state with artifact IDs
             adapter.state.toDevRev = {
@@ -107,7 +106,6 @@ describe('WorkerAdapter', () => {
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
             expect(adapter.initializeRepos).toHaveBeenCalledWith([
                 { itemType: 'ssor_attachment' },
             ]);
@@ -118,10 +116,8 @@ describe('WorkerAdapter', () => {
             expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
             expect(result).toBeUndefined();
         });
-        it('should handle invalid batch size', async () => {
-            // Arrange
+        it('[edge] should handle invalid batch size by using 1 instead', async () => {
             const mockStream = jest.fn();
-            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
             // Set up adapter state with artifact IDs
             adapter.state.toDevRev = {
                 attachmentsMetadata: {
@@ -131,34 +127,20 @@ describe('WorkerAdapter', () => {
                 },
             };
             // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
                 attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
+                    { 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(consoleWarnSpy).toHaveBeenCalledWith('The specified batch size (0) is invalid. Using 1 instead.');
             expect(result).toBeUndefined();
-            // Restore console.warn
-            consoleWarnSpy.mockRestore();
         });
-        it('should cap batch size to 50 when batchSize is greater than 50', async () => {
-            // Arrange
+        it('[edge] should cap batch size to 50 when batchSize is greater than 50', async () => {
             const mockStream = jest.fn();
-            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
             // Set up adapter state with artifact IDs
             adapter.state.toDevRev = {
                 attachmentsMetadata: {
@@ -168,33 +150,20 @@ describe('WorkerAdapter', () => {
                 },
             };
             // Mock getting attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
                 attachments: [
-                    {
-                        url: 'http://example.com/file1.pdf',
-                        id: 'attachment1',
-                        file_name: 'file1.pdf',
-                        parent_id: 'parent1',
-                    },
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
                 ],
             });
             // Mock the required methods
             adapter.initializeRepos = jest.fn();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
                 batchSize: 100, // Set batch size greater than 50
             });
-            // Assert
-            expect(consoleWarnSpy).toHaveBeenCalledWith('The specified batch size (100) is too large. Using 50 instead.');
             expect(result).toBeUndefined();
-            // Restore console.warn
-            consoleWarnSpy.mockRestore();
         });
-        it('should handle empty attachments metadata artifact IDs', async () => {
-            // Arrange
+        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 = {
@@ -203,19 +172,12 @@ describe('WorkerAdapter', () => {
                     lastProcessed: 0,
                 },
             };
-            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
-            expect(consoleLogSpy).toHaveBeenCalledWith('No attachments metadata artifact IDs found in state.');
             expect(result).toBeUndefined();
-            // Restore console.log
-            consoleLogSpy.mockRestore();
         });
-        it('should handle errors when getting attachments', async () => {
-            // Arrange
+        it('[edge] should handle errors when getting attachments', async () => {
             const mockStream = jest.fn();
             // Set up adapter state with artifact IDs
             adapter.state.toDevRev = {
@@ -227,28 +189,19 @@ describe('WorkerAdapter', () => {
             };
             // Mock error when getting attachments
             const mockError = new Error('Failed to get attachments');
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
                 error: mockError,
             });
             // Mock methods
             adapter.initializeRepos = jest.fn();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
-            expect(consoleErrorSpy).toHaveBeenCalled();
             expect(result).toEqual({
                 error: mockError,
             });
-            // Restore console.error
-            consoleErrorSpy.mockRestore();
         });
-        it('should handle empty attachments array from artifact', async () => {
-            // Arrange
+        it('[edge] should handle empty attachments array from artifact', async () => {
             const mockStream = jest.fn();
             // Set up adapter state with artifact IDs
             adapter.state.toDevRev = {
@@ -259,27 +212,18 @@ describe('WorkerAdapter', () => {
                 },
             };
             // Mock getting empty attachments
-            adapter['uploader'].getAttachmentsFromArtifactId = jest
-                .fn()
-                .mockResolvedValue({
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
                 attachments: [],
             });
             // Mock methods
             adapter.initializeRepos = jest.fn();
-            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
-            expect(consoleWarnSpy).toHaveBeenCalled();
             expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
             expect(result).toBeUndefined();
-            // Restore console.warn
-            consoleWarnSpy.mockRestore();
         });
         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({});
@@ -299,8 +243,6 @@ describe('WorkerAdapter', () => {
             });
             // Mock methods
             adapter.initializeRepos = jest.fn();
-            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
                 processors: {
@@ -308,7 +250,6 @@ describe('WorkerAdapter', () => {
                     iterator: mockIterator,
                 },
             });
-            // Assert
             expect(mockReducer).toHaveBeenCalledWith({
                 attachments: [{ id: 'attachment1' }],
                 adapter: adapter,
@@ -320,11 +261,8 @@ describe('WorkerAdapter', () => {
                 stream: mockStream,
             });
             expect(result).toBeUndefined();
-            // Restore console.log
-            consoleLogSpy.mockRestore();
         });
         it('should handle rate limiting from iterator', async () => {
-            // Arrange
             const mockStream = jest.fn();
             attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
                 return {
@@ -348,11 +286,9 @@ describe('WorkerAdapter', () => {
             });
             // Mock methods
             adapter.initializeRepos = jest.fn();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
             expect(result).toEqual({
                 delay: 30,
             });
@@ -362,7 +298,6 @@ describe('WorkerAdapter', () => {
             ]);
         });
         it('should handle error from iterator', async () => {
-            // Arrange
             const mockStream = jest.fn();
             attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
                 return {
@@ -388,11 +323,9 @@ describe('WorkerAdapter', () => {
             });
             // Mock methods
             adapter.initializeRepos = jest.fn();
-            // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
             });
-            // Assert
             expect(result).toEqual({
                 error: 'Mock error',
             });
@@ -442,7 +375,7 @@ describe('WorkerAdapter', () => {
             expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
         });
     });
-    describe('emit', () => {
+    describe(worker_adapter_1.WorkerAdapter.prototype.emit.name, () => {
         let counter;
         let mockPostMessage;
         beforeEach(() => {
@@ -450,7 +383,6 @@ describe('WorkerAdapter', () => {
             // Import the worker_threads module and spy on parentPort.postMessage
             const workerThreads = require('node:worker_threads');
             mockPostMessage = jest.fn().mockImplementation((a) => {
-                console.log('postMessage called with:', a);
                 counter.counter += 1;
             });
             // Spy on the parentPort.postMessage method
@@ -470,10 +402,21 @@ describe('WorkerAdapter', () => {
             // Restore all mocks
             jest.restoreAllMocks();
         });
-        test('should correctly emit event', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockResolvedValue(undefined);
+        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.ExtractionMetadataError, {
+                reports: [],
+                processed_files: [],
+            });
+            await adapter.emit(types_1.ExtractorEventType.ExtractionMetadataError, {
+                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.ExtractionMetadataError, {
                 reports: [],
@@ -489,10 +432,8 @@ describe('WorkerAdapter', () => {
             });
             expect(counter.counter).toBe(1);
         });
-        test('should correctly emit one event even if postState errors', async () => {
-            adapter['adapterState'].postState = jest
-                .fn()
-                .mockRejectedValue(new Error('postState error'));
+        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.ExtractionMetadataError, {
                 reports: [],
@@ -500,13 +441,9 @@ describe('WorkerAdapter', () => {
             });
             expect(counter.counter).toBe(1);
         });
-        test('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'));
+        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.ExtractionMetadataError, {
                 reports: [],
                 processed_files: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.8.1-beta.1",
+  "version": "1.8.1",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -11,7 +11,7 @@
     "start": "ts-node src/index.ts",
     "lint": "eslint .",
     "lint:fix": "eslint .  --fix",
-    "test": "jest --forceExit --coverage --runInBand"
+    "test": "jest --forceExit --coverage --runInBand --testPathIgnorePatterns='./dist/'"
   },
   "repository": {
     "type": "git",