@forge/events 2.0.0 → 2.0.1-next.1

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;

package/src/__test__/appEvents.test.ts

@@ -1,201 +0,0 @@
-import { appEvents, AppEvent } from '../appEvents';
-import { post } from '../queries';
-import { __requestAtlassianAsApp } from '@forge/api';
-
-// Mock the dependencies
-jest.mock('../queries', () => ({
-  post: jest.fn()
-}));
-
-jest.mock('@forge/api', () => ({
-  __requestAtlassianAsApp: jest.fn()
-}));
-
-describe('appEvents', () => {
-  beforeEach(() => {
-    // Clear all mocks before each test
-    jest.clearAllMocks();
-  });
-
-  describe('publishEvent', () => {
-    it('should call post with the correct parameters', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: true,
-        json: jest.fn().mockResolvedValue({
-          failedEvents: []
-        })
-      };
-
-      // Mock the post function to return a successful response
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(post).toHaveBeenCalledTimes(1);
-      expect(post).toHaveBeenCalledWith(
-        '/forge/events/v1/app-events',
-        {
-          events: [
-            {
-              key: event.key
-            }
-          ]
-        },
-        __requestAtlassianAsApp
-      );
-      expect(result).toEqual({ type: 'success', failedEvents: [] });
-    });
-
-    it('should return a success result for successful requests', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: true,
-        json: jest.fn().mockResolvedValue({
-          failedEvents: []
-        })
-      };
-
-      // Mock the post function to return a successful response
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(result).toEqual({ type: 'success', failedEvents: [] });
-    });
-
-    it('should return an error result for failed requests', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: false,
-        status: 500,
-        json: jest.fn().mockResolvedValue({
-          errorMessages: ['Internal server error']
-        })
-      };
-
-      // Mock the post function to return a failed response
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(result).toEqual({
-        type: 'error',
-        errorType: 'SERVICE_ERROR',
-        errorMessage: 'Internal server error'
-      });
-    });
-
-    it('should handle validation errors', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: false,
-        status: 400,
-        json: jest.fn().mockResolvedValue({
-          errorMessages: ['Invalid event type']
-        })
-      };
-
-      // Mock the post function to return a validation error response
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(result).toEqual({
-        type: 'error',
-        errorType: 'VALIDATION_ERROR',
-        errorMessage: 'Invalid event type'
-      });
-    });
-
-    it('should handle errors object in the error response', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const errorResponse = {
-        errorMessages: [],
-        errors: { key: 'Event key is required' }
-      };
-
-      const mockResponse = {
-        ok: false,
-        status: 400,
-        json: jest.fn().mockResolvedValue(errorResponse)
-      };
-
-      // Mock the post function to return an error response with errors object
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      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 () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: false,
-        status: 418, // I'm a teapot
-        json: jest.fn().mockResolvedValue({
-          errorMessages: ['I refuse to brew coffee']
-        })
-      };
-
-      // Mock the post function to return a response with unknown status code
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(result).toEqual({
-        type: 'error',
-        errorType: 'OTHER',
-        errorMessage: 'I refuse to brew coffee'
-      });
-    });
-
-    it('should handle empty error messages', async () => {
-      // Arrange
-      const event: AppEvent = { key: 'test-event' };
-      const mockResponse = {
-        ok: false,
-        status: 500,
-        json: jest.fn().mockResolvedValue({
-          errorMessages: []
-        })
-      };
-
-      // Mock the post function to return a response with empty error messages
-      (post as jest.Mock).mockResolvedValue(mockResponse);
-
-      // Act
-      const result = await appEvents.publish(event);
-
-      // Assert
-      expect(result).toEqual({
-        type: 'error',
-        errorType: 'SERVICE_ERROR',
-        errorMessage: '{"errorMessages":[]}'
-      });
-    });
-  });
-});

package/src/__test__/invocationError.test.ts

@@ -1,40 +0,0 @@
-import { InvocationError } from '../invocationError';
-import { InvocationErrorCode } from '../invocationErrorCode';
-import { DEFAULT_RETRY_OPTIONS, MIN_RETRY_AFTER, RetryOptions } from '../retryOptions';
-
-describe('InvocationError tests', () => {
-  let target = new InvocationError();
-
-  it('Populate invocationError with default retryOptions and expect default retry option', async () => {
-    expect(target.retryOptions.retryAfter).toEqual(DEFAULT_RETRY_OPTIONS.retryAfter);
-    expect(target.retryOptions.retryReason).toEqual(InvocationErrorCode.FUNCTION_RETRY_REQUEST);
-    expect((target as any).hasOwnProperty('_retry')).toBe(true);
-  });
-
-  it('Populate InvocationError with custom RetryOptions and expect the custom value to set.', () => {
-    const retryOptions: RetryOptions = {
-      retryAfter: 10,
-      retryReason: InvocationErrorCode.FUNCTION_OUT_OF_MEMORY,
-      retryData: {
-        eventsToSplit: 5
-      }
-    };
-    target = new InvocationError(retryOptions);
-
-    expect(target.retryOptions).toEqual(retryOptions);
-    expect((target as any).hasOwnProperty('_retry')).toBe(true);
-  });
-
-  it('Use MIN_RETRY_AFTER when retryAfter <= 0', () => {
-    const retryOptions: RetryOptions = {
-      retryAfter: 0,
-      retryReason: InvocationErrorCode.FUNCTION_OUT_OF_MEMORY,
-      retryData: 'some string data'
-    };
-    target = new InvocationError(retryOptions);
-
-    expect(target.retryOptions.retryAfter).toEqual(MIN_RETRY_AFTER);
-    expect(target.retryOptions.retryData).toEqual('some string data');
-    expect((target as any).hasOwnProperty('_retry')).toBe(true);
-  });
-});

package/src/__test__/jobProgress.test.ts

@@ -1,184 +0,0 @@
-import { getMockFetchMethod, verifyApiClientCalledWith } from './utils';
-import { InternalServerError, InvalidQueueNameError, JobDoesNotExistError, RateLimitError } from '../errors';
-import { JobProgress } from '../jobProgress';
-import { __requestAtlassianAsApp } from '@forge/api';
-import { QueueParams } from '../types';
-
-jest.mock('@forge/api', () => ({
-  __requestAtlassianAsApp: getMockFetchMethod({ done: true }, 200)
-}));
-
-const queueParams: QueueParams = { key: 'test-queue-name' };
-const getJobProgress = (jobId: string, apiClientMock?: any) => new JobProgress(queueParams, jobId, apiClientMock);
-
-describe('JobProgress methods', () => {
-  describe('getStats', () => {
-    it('should call the queue/stats endpoint', async () => {
-      const apiClientMock = getMockFetchMethod(
-        {
-          success: 100,
-          inProgress: 50,
-          failed: 1
-        },
-        200
-      );
-      const jobProgress = getJobProgress('test-job-id', apiClientMock);
-      const { success, inProgress, failed } = await jobProgress.getStats();
-      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 = getMockFetchMethod(
-        {
-          message: 'Job Not Found',
-          code: 404
-        },
-        404
-      );
-      const jobProgress = getJobProgress('test-job-id', apiClientMock);
-      await expect(jobProgress.getStats()).rejects.toThrow(
-        new JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`)
-      );
-      verifyApiClientCalledWith(
-        apiClientMock,
-        '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}',
-        {
-          queueName: 'test-queue-name',
-          jobId: 'test-job-id'
-        }
-      );
-    });
-
-    it('should throw RateLimitError', async () => {
-      const apiClientMock = getMockFetchMethod({}, 429);
-      const jobProgress = getJobProgress('test-job-id', apiClientMock);
-      await expect(jobProgress.getStats()).rejects.toThrow(new RateLimitError(`Too many requests.`));
-      verifyApiClientCalledWith(
-        apiClientMock,
-        '/webhook/queue/stats/{contextAri}/{environmentId}/{appId}/{appVersion}',
-        {
-          queueName: 'test-queue-name',
-          jobId: 'test-job-id'
-        }
-      );
-    });
-
-    it('should throw InternalServerError', async () => {
-      const apiClientMock = 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 InternalServerError(`513 Status Text: Service is not available`, 513)
-      );
-      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 = getMockFetchMethod({}, 204);
-      const jobProgress = getJobProgress('test-job-id', apiClientMock);
-      await jobProgress.cancel();
-      verifyApiClientCalledWith(
-        apiClientMock,
-        '/webhook/queue/cancel/{contextAri}/{environmentId}/{appId}/{appVersion}',
-        {
-          queueName: 'test-queue-name',
-          jobId: 'test-job-id'
-        }
-      );
-    });
-
-    it('should throw JobDoesNotExistError', async () => {
-      const apiClientMock = getMockFetchMethod(
-        {
-          message: 'Job Not Found',
-          code: 404
-        },
-        404
-      );
-      const jobProgress = getJobProgress('test-job-id', apiClientMock);
-      await expect(jobProgress.cancel()).rejects.toThrow(
-        new JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`)
-      );
-      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 = 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 InternalServerError(`422 Status Text: jobId must not be null, queueName must not be null`)
-    );
-
-    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 = getMockFetchMethod(
-      {
-        success: 100,
-        inProgress: 50,
-        failed: 1
-      },
-      200
-    );
-    const jobProgress1 = getJobProgress('', apiClientMock);
-    await expect(jobProgress1.getStats()).rejects.toThrow(new JobDoesNotExistError(`jobId cannot be empty.`));
-
-    const jobProgress2 = new JobProgress({ key: '!' }, 'test-job-id', apiClientMock);
-    await expect(jobProgress2.getStats()).rejects.toThrow(
-      new InvalidQueueNameError('Queue names can only contain alphanumeric characters, dashes and underscores.')
-    );
-
-    const jobProgress3 = getJobProgress('', apiClientMock);
-    await expect(jobProgress3.getStats()).rejects.toThrow(new 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(__requestAtlassianAsApp).toHaveBeenCalledTimes(1);
-  });
-});