@forge/events 2.0.1-next.0 → 2.0.1-next.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @forge/events
 
+## 2.0.1-next.1
+
+### Patch Changes
+
+- 457a5b4: Add missing .npmignore to prevent publishing source code for @forge/events
+
 ## 2.0.1-next.0
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/events",
-  "version": "2.0.1-next.0",
+  "version": "2.0.1-next.1",
   "description": "Forge Async Event methods",
   "author": "Atlassian",
   "license": "SEE LICENSE IN LICENSE.txt",

package/out/__test__/appEvents.test.d.ts

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

package/out/__test__/appEvents.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"appEvents.test.d.ts","sourceRoot":"","sources":["../../src/__test__/appEvents.test.ts"],"names":[],"mappings":""}

package/out/__test__/appEvents.test.js

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const appEvents_1 = require("../appEvents");
-const queries_1 = require("../queries");
-const api_1 = require("@forge/api");
-jest.mock('../queries', () => ({
-    post: jest.fn()
-}));
-jest.mock('@forge/api', () => ({
-    __requestAtlassianAsApp: jest.fn()
-}));
-describe('appEvents', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('publishEvent', () => {
-        it('should call post with the correct parameters', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: true,
-                json: jest.fn().mockResolvedValue({
-                    failedEvents: []
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(queries_1.post).toHaveBeenCalledTimes(1);
-            expect(queries_1.post).toHaveBeenCalledWith('/forge/events/v1/app-events', {
-                events: [
-                    {
-                        key: event.key
-                    }
-                ]
-            }, api_1.__requestAtlassianAsApp);
-            expect(result).toEqual({ type: 'success', failedEvents: [] });
-        });
-        it('should return a success result for successful requests', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: true,
-                json: jest.fn().mockResolvedValue({
-                    failedEvents: []
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({ type: 'success', failedEvents: [] });
-        });
-        it('should return an error result for failed requests', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: false,
-                status: 500,
-                json: jest.fn().mockResolvedValue({
-                    errorMessages: ['Internal server error']
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({
-                type: 'error',
-                errorType: 'SERVICE_ERROR',
-                errorMessage: 'Internal server error'
-            });
-        });
-        it('should handle validation errors', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: false,
-                status: 400,
-                json: jest.fn().mockResolvedValue({
-                    errorMessages: ['Invalid event type']
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({
-                type: 'error',
-                errorType: 'VALIDATION_ERROR',
-                errorMessage: 'Invalid event type'
-            });
-        });
-        it('should handle errors object in the error response', async () => {
-            const event = { key: 'test-event' };
-            const errorResponse = {
-                errorMessages: [],
-                errors: { key: 'Event key is required' }
-            };
-            const mockResponse = {
-                ok: false,
-                status: 400,
-                json: jest.fn().mockResolvedValue(errorResponse)
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({
-                type: 'error',
-                errorType: 'VALIDATION_ERROR',
-                errorMessage: 'key: Event key is required'
-            });
-        });
-        it('should use OTHER as errorType for unknown status codes', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: false,
-                status: 418,
-                json: jest.fn().mockResolvedValue({
-                    errorMessages: ['I refuse to brew coffee']
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({
-                type: 'error',
-                errorType: 'OTHER',
-                errorMessage: 'I refuse to brew coffee'
-            });
-        });
-        it('should handle empty error messages', async () => {
-            const event = { key: 'test-event' };
-            const mockResponse = {
-                ok: false,
-                status: 500,
-                json: jest.fn().mockResolvedValue({
-                    errorMessages: []
-                })
-            };
-            queries_1.post.mockResolvedValue(mockResponse);
-            const result = await appEvents_1.appEvents.publish(event);
-            expect(result).toEqual({
-                type: 'error',
-                errorType: 'SERVICE_ERROR',
-                errorMessage: '{"errorMessages":[]}'
-            });
-        });
-    });
-});

package/out/__test__/invocationError.test.d.ts

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

package/out/__test__/invocationError.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invocationError.test.d.ts","sourceRoot":"","sources":["../../src/__test__/invocationError.test.ts"],"names":[],"mappings":""}

package/out/__test__/invocationError.test.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const invocationError_1 = require("../invocationError");
-const invocationErrorCode_1 = require("../invocationErrorCode");
-const retryOptions_1 = require("../retryOptions");
-describe('InvocationError tests', () => {
-    let target = new invocationError_1.InvocationError();
-    it('Populate invocationError with default retryOptions and expect default retry option', async () => {
-        expect(target.retryOptions.retryAfter).toEqual(retryOptions_1.DEFAULT_RETRY_OPTIONS.retryAfter);
-        expect(target.retryOptions.retryReason).toEqual(invocationErrorCode_1.InvocationErrorCode.FUNCTION_RETRY_REQUEST);
-        expect(target.hasOwnProperty('_retry')).toBe(true);
-    });
-    it('Populate InvocationError with custom RetryOptions and expect the custom value to set.', () => {
-        const retryOptions = {
-            retryAfter: 10,
-            retryReason: invocationErrorCode_1.InvocationErrorCode.FUNCTION_OUT_OF_MEMORY,
-            retryData: {
-                eventsToSplit: 5
-            }
-        };
-        target = new invocationError_1.InvocationError(retryOptions);
-        expect(target.retryOptions).toEqual(retryOptions);
-        expect(target.hasOwnProperty('_retry')).toBe(true);
-    });
-    it('Use MIN_RETRY_AFTER when retryAfter <= 0', () => {
-        const retryOptions = {
-            retryAfter: 0,
-            retryReason: invocationErrorCode_1.InvocationErrorCode.FUNCTION_OUT_OF_MEMORY,
-            retryData: 'some string data'
-        };
-        target = new invocationError_1.InvocationError(retryOptions);
-        expect(target.retryOptions.retryAfter).toEqual(retryOptions_1.MIN_RETRY_AFTER);
-        expect(target.retryOptions.retryData).toEqual('some string data');
-        expect(target.hasOwnProperty('_retry')).toBe(true);
-    });
-});

package/out/__test__/jobProgress.test.d.ts

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

package/out/__test__/jobProgress.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jobProgress.test.d.ts","sourceRoot":"","sources":["../../src/__test__/jobProgress.test.ts"],"names":[],"mappings":""}

package/out/__test__/jobProgress.test.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
-const errors_1 = require("../errors");
-const jobProgress_1 = require("../jobProgress");
-const api_1 = require("@forge/api");
-jest.mock('@forge/api', () => ({
-    __requestAtlassianAsApp: (0, utils_1.getMockFetchMethod)({ done: true }, 200)
-}));
-const queueParams = { key: 'test-queue-name' };
-const getJobProgress = (jobId, apiClientMock) => new jobProgress_1.JobProgress(queueParams, jobId, apiClientMock);
-describe('JobProgress methods', () => {
-    describe('getStats', () => {
-        it('should call the queue/stats endpoint', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                success: 100,
-                inProgress: 50,
-                failed: 1
-            }, 200);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            const { success, inProgress, failed } = await jobProgress.getStats();
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-            expect(success).toEqual(100);
-            expect(inProgress).toEqual(50);
-            expect(failed).toEqual(1);
-        });
-        it('should throw JobDoesNotExistError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                message: 'Job Not Found',
-                code: 404
-            }, 404);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            await expect(jobProgress.getStats()).rejects.toThrow(new errors_1.JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`));
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-        });
-        it('should throw RateLimitError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 429);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            await expect(jobProgress.getStats()).rejects.toThrow(new errors_1.RateLimitError(`Too many requests.`));
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-        });
-        it('should throw InternalServerError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                message: 'Service is not available',
-                code: 513,
-                details: 'The request processing has failed because of an unknown error, exception or failure'
-            }, 513);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            await expect(jobProgress.getStats()).rejects.toThrow(new errors_1.InternalServerError(`513 Status Text: Service is not available`, 513));
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-        });
-    });
-    describe('cancel', () => {
-        it('should call the queue/cancel endpoint', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 204);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            await jobProgress.cancel();
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/cancel/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-        });
-        it('should throw JobDoesNotExistError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                message: 'Job Not Found',
-                code: 404
-            }, 404);
-            const jobProgress = getJobProgress('test-job-id', apiClientMock);
-            await expect(jobProgress.cancel()).rejects.toThrow(new errors_1.JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`));
-            (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/cancel/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-                queueName: 'test-queue-name',
-                jobId: 'test-job-id'
-            });
-        });
-    });
-    it('should throw InternalServerError when WHP returns 422 response', async () => {
-        const apiClientMock = (0, utils_1.getMockFetchMethod)({
-            errors: ['jobId must not be null', 'queueName must not be null']
-        }, 422);
-        const jobProgress = getJobProgress('test-job-id', apiClientMock);
-        await expect(jobProgress.getStats()).rejects.toThrow(new errors_1.InternalServerError(`422 Status Text: jobId must not be null, queueName must not be null`));
-        (0, utils_1.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-            queueName: 'test-queue-name',
-            jobId: 'test-job-id'
-        });
-    });
-    it('should throw errors when queueName or jobId is empty', async () => {
-        const apiClientMock = (0, utils_1.getMockFetchMethod)({
-            success: 100,
-            inProgress: 50,
-            failed: 1
-        }, 200);
-        const jobProgress1 = getJobProgress('', apiClientMock);
-        await expect(jobProgress1.getStats()).rejects.toThrow(new errors_1.JobDoesNotExistError(`jobId cannot be empty.`));
-        const jobProgress2 = new jobProgress_1.JobProgress({ key: '!' }, 'test-job-id', apiClientMock);
-        await expect(jobProgress2.getStats()).rejects.toThrow(new errors_1.InvalidQueueNameError('Queue names can only contain alphanumeric characters, dashes and underscores.'));
-        const jobProgress3 = getJobProgress('', apiClientMock);
-        await expect(jobProgress3.getStats()).rejects.toThrow(new errors_1.JobDoesNotExistError(`jobId cannot be empty.`));
-        expect(apiClientMock).toHaveBeenCalledTimes(0);
-    });
-    it('requests stargate if no api client is provided', async () => {
-        const jobProgress = getJobProgress('job-id');
-        await jobProgress.getStats();
-        expect(api_1.__requestAtlassianAsApp).toHaveBeenCalledTimes(1);
-    });
-});

package/out/__test__/queue.test.d.ts

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

package/out/__test__/queue.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.test.d.ts","sourceRoot":"","sources":["../../src/__test__/queue.test.ts"],"names":[],"mappings":""}

package/out/__test__/queue.test.js

@@ -1,237 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../errors");
-const utils_1 = require("./utils");
-const queue_1 = require("../queue");
-const jobProgress_1 = require("../jobProgress");
-const api_1 = require("@forge/api");
-jest.mock('@forge/api', () => ({
-    __requestAtlassianAsApp: (0, utils_1.getMockFetchMethod)('done', 201)
-}));
-const getQueue = (queueName, apiClientMock) => new queue_1.Queue({ key: queueName }, apiClientMock);
-describe('Queue methods', () => {
-    describe('constructor', () => {
-        it('should throw InvalidQueueNameError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            expect(() => getQueue('invalid name', apiClientMock)).toThrowError(new errors_1.InvalidQueueNameError('Queue names can only contain alphanumeric characters, dashes and underscores.'));
-        });
-    });
-    const PAYLOAD = { body: { page: 1 } };
-    describe('push', () => {
-        it.each([
-            ['single payload', PAYLOAD, [PAYLOAD]],
-            ['payload array', [PAYLOAD, PAYLOAD], [PAYLOAD, PAYLOAD]]
-        ])('should call the queue/publish endpoint when given %s', async (_, payload, expectedPayload) => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await queue.push(payload);
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, expectedPayload, 'name');
-        });
-        it.each([
-            ['number', 1],
-            ['string', 'test'],
-            ['boolean', true],
-            ['array', [1, 2, 3]],
-            ['null', null],
-            ['undefined', undefined],
-            ['array with non-object', [1]],
-            ['array with an array', [[2, 3]]]
-        ])('rejects non-object (%s) event', async (_, payload) => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.InvalidPayloadError(`Event must be an object.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it.each([
-            ['number', 1],
-            ['string', 'test'],
-            ['boolean', true],
-            ['array', [1, 2, 3]],
-            ['null', null],
-            ['undefined', undefined],
-            ['array with non-object', [1]],
-            ['array with an array', [[2, 3]]]
-        ])('rejects non-object (%s) event body', async (_, body) => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push({ body })).rejects.toThrow(new errors_1.InvalidPayloadError(`Event body must be an object.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it('should throw InvalidPushSettingsError for delay', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push({ ...PAYLOAD, delayInSeconds: 901 })).rejects.toThrow(new errors_1.InvalidPushSettingsError(`The delayInSeconds setting must be between 0 and 900.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it('should throw NoEventsToPushError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push([])).rejects.toThrow(new errors_1.NoEventsToPushError(`No events pushed.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it('should throw TooManyEventsError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(Array(51).fill(PAYLOAD))).rejects.toThrow(new errors_1.TooManyEventsError(`This push contains more than the 50 events allowed.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it('should throw PayloadTooBigError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push({ body: { content: 'x'.repeat(201 * 1024) } })).rejects.toThrow(new errors_1.PayloadTooBigError(`The maximum payload size is 200KB.`));
-            expect(apiClientMock).toHaveBeenCalledTimes(0);
-        });
-        it('should throw RateLimitError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 429);
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.RateLimitError(`Too many requests.`));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
-        });
-        it('should throw InvocationLimitReachedError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({}, 405);
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InvocationLimitReachedError(`The limit on cyclic invocation has been reached.`));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
-        });
-        it('should throw PartialSuccessError when there are failed events', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                failedEvents: [
-                    {
-                        index: '0',
-                        errorMessage: 'failed-1'
-                    },
-                    {
-                        index: 2,
-                        errorMessage: 'failed-3'
-                    }
-                ]
-            }, 202);
-            const queue = getQueue('name', apiClientMock);
-            const payload = [
-                {
-                    body: {
-                        content: 'payload-1'
-                    }
-                },
-                {
-                    body: {
-                        content: 'payload-2'
-                    }
-                },
-                {
-                    body: {
-                        content: 'payload-3'
-                    }
-                }
-            ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 2 event(s).`, { jobId: 'some-job-id' }, [
-                {
-                    errorMessage: 'failed-1',
-                    event: {
-                        body: {
-                            content: 'payload-1'
-                        }
-                    }
-                },
-                {
-                    errorMessage: 'failed-3',
-                    event: {
-                        body: {
-                            content: 'payload-3'
-                        }
-                    }
-                }
-            ]));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
-        });
-        it('should throw PartialSuccessError when backend failed to create job stats', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                errorMessage: 'Failed to create stats for job name#12345'
-            }, 202);
-            const queue = getQueue('name', apiClientMock);
-            const payload = [
-                {
-                    body: {
-                        content: 'payload-1'
-                    }
-                },
-                {
-                    body: {
-                        content: 'payload-2'
-                    }
-                },
-                {
-                    body: {
-                        content: 'payload-3'
-                    }
-                }
-            ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to create stats for job name#12345`, { jobId: 'some-job-id' }, []));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
-        });
-        it('should throw PartialSuccessError when there are failed events and backend failed to create job stats', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                errorMessage: 'Failed to create stats for job name#12345',
-                failedEvents: [
-                    {
-                        index: '0',
-                        errorMessage: 'failed-1'
-                    }
-                ]
-            }, 202);
-            const queue = getQueue('name', apiClientMock);
-            const payload = [
-                {
-                    body: {
-                        content: 'payload-1'
-                    }
-                },
-                {
-                    body: {
-                        content: 'payload-2'
-                    }
-                }
-            ];
-            await expect(queue.push(payload)).rejects.toThrow(new errors_1.PartialSuccessError(`Failed to process 1 event(s). Failed to create stats for job name#12345`, { jobId: 'some-job-id' }, [
-                {
-                    errorMessage: 'failed-1',
-                    event: {
-                        body: {
-                            content: 'payload-1'
-                        }
-                    }
-                }
-            ]));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, payload, 'name');
-        });
-        it('should throw InternalServerError', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)({
-                message: 'AWS SQS timed out',
-                code: 500,
-                details: 'The request processing has failed because of an unknown error, exception or failure'
-            }, 500);
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InternalServerError(`500 Status Text: AWS SQS timed out`, 500, 'The request processing has failed because of an unknown error, exception or failure'));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
-        });
-        it('should throw InternalServerError for error response without response body', async () => {
-            const apiClientMock = (0, utils_1.getApiClientMockWithoutResponseBody)(504, 'Gateway Timeout');
-            const queue = getQueue('name', apiClientMock);
-            await expect(queue.push(PAYLOAD)).rejects.toThrow(new errors_1.InternalServerError(`504 Gateway Timeout`, 504));
-            (0, utils_1.verifyApiClientCalledPushPathWith)(apiClientMock, [PAYLOAD], 'name');
-        });
-        it('requests stargate if no api client is provided', async () => {
-            const queue = getQueue('queue');
-            await queue.push({ body: { test: 'stargate' } });
-            expect(api_1.__requestAtlassianAsApp).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('getJob', () => {
-        it('should create a JobProgress by jobId', async () => {
-            const apiClientMock = (0, utils_1.getMockFetchMethod)();
-            const queue = getQueue('name', apiClientMock);
-            const jobProgress = queue.getJob('test-job-id');
-            expect(jobProgress).toEqual(new jobProgress_1.JobProgress({ key: 'name' }, 'test-job-id', apiClientMock));
-        });
-    });
-});

package/out/__test__/queueResponse.test.d.ts

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

package/out/__test__/queueResponse.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queueResponse.test.d.ts","sourceRoot":"","sources":["../../src/__test__/queueResponse.test.ts"],"names":[],"mappings":""}

package/out/__test__/queueResponse.test.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const queueResponse_1 = require("../queueResponse");
-describe('QueueResponse', () => {
-    it('should contain property retry=false by default', async () => {
-        const res = new queueResponse_1.QueueResponse();
-        expect(JSON.stringify(res)).toEqual('{"_retry":false}');
-    });
-    it('doRetry() should change property retry=true', async () => {
-        const res = new queueResponse_1.QueueResponse();
-        res.retry();
-        expect(JSON.stringify(res)).toEqual('{"_retry":true}');
-    });
-});

package/out/__test__/utils.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="jest" />
-/// <reference types="jest-matcher-specific-error" />
-import { Payload } from '../types';
-export declare const getMockFetchMethod: (response?: any, statusCode?: number) => jest.Mock<any, any, any>;
-export declare const getApiClientMockWithoutResponseBody: (statusCode: number, statusText: string) => jest.Mock<any, any, any>;
-export declare const verifyApiClientCalledWith: (apiClientMock: jest.Mock, path: string, expectedBody: any) => void;
-export declare const verifyApiClientCalledPushPathWith: (apiClientMock: jest.Mock, payloads: Payload | Payload[], name: string) => void;
-//# sourceMappingURL=utils.d.ts.map

package/out/__test__/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/__test__/utils.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,eAAO,MAAM,kBAAkB,cAAe,GAAG,kDAOhD,CAAC;AAEF,eAAO,MAAM,mCAAmC,eAAgB,MAAM,cAAc,MAAM,6BAMzF,CAAC;AAEF,eAAO,MAAM,yBAAyB,kBAAmB,KAAK,IAAI,QAAQ,MAAM,gBAAgB,GAAG,SAclG,CAAC;AAEF,eAAO,MAAM,iCAAiC,kBAC7B,KAAK,IAAI,YACd,OAAO,GAAG,OAAO,EAAE,QACvB,MAAM,SAQb,CAAC"}

package/out/__test__/utils.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyApiClientCalledPushPathWith = exports.verifyApiClientCalledWith = exports.getApiClientMockWithoutResponseBody = exports.getMockFetchMethod = void 0;
-const getMockFetchMethod = (response, statusCode = 201) => {
-    return jest.fn().mockReturnValue({
-        created: statusCode === 201,
-        status: statusCode,
-        statusText: 'Status Text',
-        json: jest.fn().mockResolvedValue(response)
-    });
-};
-exports.getMockFetchMethod = getMockFetchMethod;
-const getApiClientMockWithoutResponseBody = (statusCode, statusText) => {
-    return jest.fn().mockReturnValue({
-        ok: statusCode === 200,
-        status: statusCode,
-        statusText: statusText
-    });
-};
-exports.getApiClientMockWithoutResponseBody = getApiClientMockWithoutResponseBody;
-const verifyApiClientCalledWith = (apiClientMock, path, expectedBody) => {
-    expect(apiClientMock).toHaveBeenCalledWith(path, expect.objectContaining({
-        method: 'POST',
-        body: expect.any(String),
-        headers: {
-            'content-type': 'application/json'
-        }
-    }));
-    const [, { body }] = apiClientMock.mock.calls[0];
-    expect(JSON.parse(body)).toEqual(expect.objectContaining(expectedBody));
-};
-exports.verifyApiClientCalledWith = verifyApiClientCalledWith;
-const verifyApiClientCalledPushPathWith = (apiClientMock, payloads, name) => {
-    (0, exports.verifyApiClientCalledWith)(apiClientMock, '/webhook/queue/publish/{contextAri}/{environmentId}/{appId}/{appVersion}', {
-        queueName: name,
-        schema: 'ari:cloud:ecosystem::forge/app-event-2',
-        type: 'avi:forge:app:event',
-        payload: payloads
-    });
-};
-exports.verifyApiClientCalledPushPathWith = verifyApiClientCalledPushPathWith;