@devrev/ts-adaas 1.13.3 → 1.13.4-beta.0

package/dist/uploader/uploader.test.js

@@ -1,34 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const form_data_1 = __importDefault(require("form-data"));
+const js_jsonl_1 = require("js-jsonl");
+const zlib_1 = __importDefault(require("zlib"));
 const axios_client_internal_1 = require("../http/axios-client-internal");
 const test_helpers_1 = require("../tests/test-helpers");
-const types_1 = require("../types");
+const uploader_helpers_1 = require("./uploader.helpers");
 const uploader_1 = require("./uploader");
-jest.mock('../http/axios-client-internal', () => {
-    const originalModule = jest.requireActual('../http/axios-client-internal');
-    return Object.assign(Object.assign({}, originalModule), { axiosClient: {
-            get: jest.fn(),
-            post: jest.fn(),
-        } });
-});
-const getSuccessResponse = () => ({
-    data: {
-        message: 'Success',
-    },
-    status: 200,
-    statusText: 'OK',
-    headers: {},
-    config: {},
-});
-const getArtifactUploadUrlMockResponse = {
-    data: {
-        artifact_id: 'mockArtifactId',
-        upload_url: 'mockUploadUrl',
-        form_data: [],
-    },
-};
+jest.mock('../http/axios-client-internal');
+jest.mock('./uploader.helpers', () => (Object.assign(Object.assign({}, jest.requireActual('./uploader.helpers')), { downloadToLocal: jest.fn(), compressGzip: jest.fn(jest.requireActual('./uploader.helpers').compressGzip) })));
+const mockedAxiosClient = jest.mocked(axios_client_internal_1.axiosClient);
+const mockedDownloadToLocal = jest.mocked(uploader_helpers_1.downloadToLocal);
+const mockedCompressGzip = jest.mocked(uploader_helpers_1.compressGzip);
 describe(uploader_1.Uploader.name, () => {
-    const mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
+    const mockEvent = (0, test_helpers_1.createEvent)();
     let uploader;
     beforeEach(() => {
         uploader = new uploader_1.Uploader({ event: mockEvent });
@@ -36,56 +24,557 @@ describe(uploader_1.Uploader.name, () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should upload the file to the DevRev platform and return the artifact information', async () => {
-        // Mock successful response from getArtifactUploadUrl
-        axios_client_internal_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
-        // Mock successful response from confirmArtifactUpload and uploadArtifact
-        axios_client_internal_1.axiosClient.post.mockResolvedValue(getSuccessResponse());
-        const entity = 'entity';
-        const fetchedObjects = [{ key: 'value' }];
-        const uploadResponse = await uploader.upload(entity, fetchedObjects);
-        expect(uploadResponse).toEqual({
-            artifact: {
-                id: 'mockArtifactId',
-                item_type: entity,
-                item_count: fetchedObjects.length,
-            },
+    describe(uploader_1.Uploader.prototype.upload.name, () => {
+        const mockArtifactUploadUrlResponse = {
+            data: (0, test_helpers_1.createArtifact)(),
+        };
+        it('should return artifact info when upload flow succeeds', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [
+                { id: 1, name: 'Task 1' },
+                { id: 2, name: 'Task 2' },
+            ];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result).toEqual({
+                artifact: {
+                    id: 'art_123',
+                    item_type: itemType,
+                    item_count: 2,
+                },
+            });
+            expect(result.error).toBeUndefined();
+        });
+        it('should report item_count as 1 when uploading single object', async () => {
+            var _a;
+            // Arrange
+            const itemType = 'metadata';
+            const fetchedObject = { key: 'value' };
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            const result = await uploader.upload(itemType, fetchedObject);
+            // Assert
+            expect((_a = result.artifact) === null || _a === void 0 ? void 0 : _a.item_count).toBe(1);
+            expect(result.error).toBeUndefined();
+        });
+        it('should call downloadToLocal when isLocalDevelopment is true', async () => {
+            // Arrange
+            const localUploader = new uploader_1.Uploader({
+                event: mockEvent,
+                options: { isLocalDevelopment: true },
+            });
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await localUploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(mockedDownloadToLocal).toHaveBeenCalledWith(itemType, fetchedObjects);
+        });
+        it('should return error when getArtifactUploadUrl fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Get artifact upload URL failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when uploadArtifact fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Upload artifact failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when confirmArtifactUpload fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post
+                .mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)())
+                .mockRejectedValueOnce(new Error('Confirm artifact upload failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when compression fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedCompressGzip.mockReturnValueOnce(undefined);
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
         });
     });
-    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);
-        const entity = 'entity';
-        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).toBeDefined();
+    describe(uploader_1.Uploader.prototype.getArtifactUploadUrl.name, () => {
+        it('should return artifact upload info when API call succeeds', async () => {
+            // Arrange
+            const filename = 'test-file.jsonl.gz';
+            const fileType = 'application/x-gzip';
+            const fileSize = 1024;
+            const expectedArtifact = (0, test_helpers_1.createArtifact)();
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: expectedArtifact,
+            });
+            // Act
+            const result = await uploader.getArtifactUploadUrl(filename, fileType, fileSize);
+            // Assert
+            expect(result).toEqual(expectedArtifact);
+            expect(mockedAxiosClient.get).toHaveBeenCalledWith(expect.stringContaining('/internal/airdrop.artifacts.upload-url'), expect.objectContaining({
+                params: expect.objectContaining({
+                    file_type: fileType,
+                    file_name: filename,
+                    file_size: fileSize,
+                }),
+            }));
+        });
+        it('should return undefined when API call fails', async () => {
+            // Arrange
+            const filename = 'test-file.jsonl.gz';
+            const fileType = 'application/x-gzip';
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Get artifact upload URL failed'));
+            // Act
+            const result = await uploader.getArtifactUploadUrl(filename, fileType);
+            // Assert
+            expect(result).toBeUndefined();
+            expect(mockedAxiosClient.get).toHaveBeenCalled();
+        });
     });
-    it('[edge] should handle failure when uploading artifact', async () => {
-        var _a;
-        // Mock successful response for getArtifactUploadUrl
-        axios_client_internal_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
-        // Mock unsuccessful response for uploadArtifact
-        axios_client_internal_1.axiosClient.post.mockResolvedValueOnce(undefined);
-        const entity = 'entity';
-        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).toBeDefined();
+    describe(uploader_1.Uploader.prototype.uploadArtifact.name, () => {
+        it('should return response when posting file as multipart form data', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const file = (0, test_helpers_1.createFileBuffer)();
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(result).toBe(mockResponse);
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.any(Object),
+            }));
+        });
+        it('should append form_data fields to the multipart form', async () => {
+            // Arrange
+            // form_data is typed as array but implementation iterates with for...in
+            const formDataFields = { key: 'test-key', 'x-amz-credential': 'cred123' };
+            const artifact = {
+                artifact_id: 'art_123',
+                upload_url: 'https://s3.example.com/upload',
+                form_data: formDataFields,
+            };
+            const file = (0, test_helpers_1.createFileBuffer)();
+            const appendSpy = jest.spyOn(form_data_1.default.prototype, 'append');
+            mockedAxiosClient.post.mockResolvedValueOnce({ status: 200 });
+            // Act
+            await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(appendSpy).toHaveBeenCalledWith('key', 'test-key');
+            expect(appendSpy).toHaveBeenCalledWith('x-amz-credential', 'cred123');
+            expect(appendSpy).toHaveBeenCalledWith('file', file);
+            appendSpy.mockRestore();
+        });
+        it('should return undefined when upload fails', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const file = (0, test_helpers_1.createFileBuffer)();
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Upload artifact failed'));
+            // Act
+            const result = await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(result).toBeUndefined();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.confirmArtifactUpload.name, () => {
+        it('should return response when confirming artifact upload', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.confirmArtifactUpload(artifactId);
+            // Assert
+            expect(result).toBe(mockResponse);
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                artifact_id: artifactId,
+            }), expect.any(Object));
+        });
+        it('should return undefined when confirmation fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Confirmation failed'));
+            // Act
+            const result = await uploader.confirmArtifactUpload(artifactId);
+            // Assert
+            expect(result).toBeUndefined();
+        });
     });
-    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);
-        // Mock successful response from uploadArtifact
-        axios_client_internal_1.axiosClient.post.mockResolvedValueOnce(getSuccessResponse());
-        // Mock unsuccessful response from confirmArtifactUpload
-        axios_client_internal_1.axiosClient.post.mockResolvedValueOnce(undefined);
-        const entity = 'entity';
-        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).toBeDefined();
+    describe(uploader_1.Uploader.prototype.streamArtifact.name, () => {
+        it('should return response when streaming file to upload URL', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const destroyFn = jest.fn();
+            const fileStream = (0, test_helpers_1.createFileStream)({
+                contentLength: 1024,
+                destroyFn,
+            });
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(result).toBe(mockResponse);
+            expect(axios_client_internal_1.axiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.any(Object),
+                maxRedirects: 0,
+                validateStatus: expect.any(Function),
+            }));
+            expect(destroyFn).toHaveBeenCalled();
+        });
+        it('should append form_data fields to the multipart form', async () => {
+            // Arrange
+            const formDataFields = { key: 'test-key', 'x-amz-credential': 'cred123' };
+            const artifact = {
+                artifact_id: 'art_123',
+                upload_url: 'https://s3.example.com/upload',
+                form_data: formDataFields,
+            };
+            const fileStream = (0, test_helpers_1.createFileStream)({ contentLength: 1024 });
+            const appendSpy = jest.spyOn(form_data_1.default.prototype, 'append');
+            mockedAxiosClient.post.mockResolvedValueOnce({ status: 200 });
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(appendSpy).toHaveBeenCalledWith('key', 'test-key');
+            expect(appendSpy).toHaveBeenCalledWith('x-amz-credential', 'cred123');
+            appendSpy.mockRestore();
+        });
+        it('should use validateStatus that accepts 2xx and 3xx status codes', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const fileStream = (0, test_helpers_1.createFileStream)({ contentLength: 1024 });
+            mockedAxiosClient.post.mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            const callArgs = mockedAxiosClient.post.mock.calls[0];
+            const config = callArgs[2];
+            const validateStatus = config === null || config === void 0 ? void 0 : config.validateStatus;
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(200)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(201)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(299)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(300)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(301)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(399)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(400)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(404)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(500)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(199)).toBe(false);
+        });
+        it('should set Content-Length header when missing from file stream', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const fileStream = (0, test_helpers_1.createFileStream)({ includeContentLength: false });
+            mockedAxiosClient.post.mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.objectContaining({
+                    'Content-Length': expect.any(Number),
+                }),
+            }));
+        });
+        it('should destroy stream and return undefined when streaming fails', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const destroyFn = jest.fn();
+            const fileStream = (0, test_helpers_1.createFileStream)({ destroyFn });
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Streaming failed'));
+            // Act
+            const result = await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(result).toBeUndefined();
+            expect(destroyFn).toHaveBeenCalled();
+        });
+    });
+    describe('Uploader.destroyStream', () => {
+        it('should call destroy when stream has destroy method', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn();
+            const fileStream = {
+                data: { destroy: destroyFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(destroyFn).toHaveBeenCalled();
+        });
+        it('should call close when stream has close but no destroy method', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const closeFn = jest.fn();
+            const fileStream = {
+                data: { close: closeFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(closeFn).toHaveBeenCalled();
+        });
+        it('should prefer destroy over close when both are available', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn();
+            const closeFn = jest.fn();
+            const fileStream = {
+                data: { destroy: destroyFn, close: closeFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(destroyFn).toHaveBeenCalled();
+            expect(closeFn).not.toHaveBeenCalled();
+        });
+        it('[edge] should handle stream with no destroy or close methods', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const fileStream = {
+                data: {},
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStream)).not.toThrow();
+        });
+        it('[edge] should handle null/undefined data gracefully', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const fileStreamNullData = {
+                data: null,
+            };
+            const fileStreamUndefinedData = {
+                data: undefined,
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStreamNullData)).not.toThrow();
+            expect(() => destroyStream(fileStreamUndefinedData)).not.toThrow();
+        });
+        it('[edge] should warn when destroy throws an error', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn().mockImplementation(() => {
+                throw new Error('Destroy failed');
+            });
+            const fileStream = {
+                data: { destroy: destroyFn },
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStream)).not.toThrow();
+        });
+    });
+    describe('Uploader.getArtifactDownloadUrl', () => {
+        it('should return download URL when API call succeeds', async () => {
+            // Arrange
+            const getArtifactDownloadUrl = (0, test_helpers_1.callPrivateMethod)()(uploader, 'getArtifactDownloadUrl');
+            const artifactId = 'art_123';
+            const expectedDownloadUrl = 'https://s3.example.com/download/art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: { download_url: expectedDownloadUrl },
+            });
+            // Act
+            const result = await getArtifactDownloadUrl(artifactId);
+            // Assert
+            expect(result).toBe(expectedDownloadUrl);
+            expect(mockedAxiosClient.get).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                params: expect.objectContaining({
+                    artifact_id: artifactId,
+                }),
+            }));
+        });
+        it('should return undefined when API call fails', async () => {
+            // Arrange
+            const getArtifactDownloadUrl = (0, test_helpers_1.callPrivateMethod)()(uploader, 'getArtifactDownloadUrl');
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('API error'));
+            // Act
+            const result = await getArtifactDownloadUrl(artifactId);
+            // Assert
+            expect(result).toBeUndefined();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.getAttachmentsFromArtifactId.name, () => {
+        it('should return attachments when download and parse succeeds', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockAttachments = [
+                { id: '1', url: 'https://example.com/1', file_name: 'file1.txt' },
+                { id: '2', url: 'https://example.com/2', file_name: 'file2.txt' },
+            ];
+            const gzippedData = zlib_1.default.gzipSync(js_jsonl_1.jsonl.stringify(mockAttachments));
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedData,
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.attachments).toEqual(mockAttachments);
+            expect(result.error).toBeUndefined();
+        });
+        it('should return error when getArtifactDownloadUrl fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            (0, test_helpers_1.spyOnPrivateMethod)(uploader, 'getArtifactDownloadUrl').mockResolvedValueOnce(undefined);
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when downloadArtifact fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Download error'));
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when decompression fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from('not valid gzip data'),
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when JSONL parsing fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const gzippedInvalidJsonl = zlib_1.default.gzipSync('not valid jsonl {{{');
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedInvalidJsonl,
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.getJsonObjectByArtifactId.name, () => {
+        it('should return parsed data when downloading non-gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockData = [
+                { id: 1, name: 'Item 1' },
+                { id: 2, name: 'Item 2' },
+            ];
+            const jsonlData = js_jsonl_1.jsonl.stringify(mockData);
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from(jsonlData),
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: false,
+            });
+            // Assert
+            expect(result).toEqual(mockData);
+        });
+        it('should return parsed data when downloading gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockData = [
+                { id: 1, name: 'Item 1' },
+                { id: 2, name: 'Item 2' },
+            ];
+            const gzippedData = zlib_1.default.gzipSync(js_jsonl_1.jsonl.stringify(mockData));
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedData,
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: true,
+            });
+            // Assert
+            expect(result).toEqual(mockData);
+        });
+        it('[edge] should return undefined when getArtifactDownloadUrl fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            (0, test_helpers_1.spyOnPrivateMethod)(uploader, 'getArtifactDownloadUrl').mockResolvedValueOnce(undefined);
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({ artifactId });
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should return undefined when downloadArtifact fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Download error'));
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({ artifactId });
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should return undefined when decompression fails for gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from('not valid gzip'),
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: true,
+            });
+            // Assert
+            expect(result).toBeUndefined();
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.13.3",
+  "version": "1.13.4-beta.0",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",

package/dist/common/helpers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=helpers.test.d.ts.map