get-platform-notification-usage.e2e-ee.ts

import { PinoLogger } from '@novu/application-generic';
import {
  GetPlatformNotificationUsage,
  GetPlatformNotificationUsageCommand,
} from '@novu/ee-billing';
import { CommunityOrganizationRepository, EnvironmentRepository, NotificationRepository } from '@novu/dal';
import { ApiServiceLevelEnum, isClerkEnabled } from '@novu/shared';
import { UserSession } from '@novu/testing';
import { expect } from 'chai';
import sinon from 'sinon';

describe('GetPlatformNotificationUsage #novu-v2', () => {
  const environmentRepo = new EnvironmentRepository();
  const notificationRepo = new NotificationRepository();
  const communityOrganizationRepo = new CommunityOrganizationRepository();

  const mockWorkflowRunRepository = {
    getPlatformUsageByDateRange: sinon.stub().resolves([]),
  };

  const mockFeatureFlagsService = {
    getFlag: sinon.stub().resolves(false),
  };

  const mockCacheService = {
    cacheEnabled: sinon.stub().returns(false),
    get: sinon.stub().resolves(undefined),
  };

  const createUseCase = () => {
    return new GetPlatformNotificationUsage(
      mockWorkflowRunRepository,
      environmentRepo,
      notificationRepo,
      communityOrganizationRepo,
      mockFeatureFlagsService,
      mockCacheService,
      new PinoLogger({})
    );
  };
  let session: UserSession;

  beforeEach(async () => {
    session = new UserSession();
    await session.initialize();
    mockWorkflowRunRepository.getPlatformUsageByDateRange.reset();
    mockWorkflowRunRepository.getPlatformUsageByDateRange.resolves([]);
    mockFeatureFlagsService.getFlag.reset();
    mockFeatureFlagsService.getFlag.resolves(false);
  });

  it(`should return an empty array when there is no recorded usage`, async () => {
    const useCase = createUseCase();

    // Create organizations without notifications
    const orgsWithoutNotificationsPromises = new Array(10).fill(null).map(async () => {
      const orgSession = new UserSession();
      await orgSession.initialize();

      return Promise.resolve(orgSession.organization._id);
    });
    await Promise.all(orgsWithoutNotificationsPromises);

    const result = await useCase.execute(
      GetPlatformNotificationUsageCommand.create({
        startDate: new Date('2021-01-01'),
        endDate: new Date('2021-01-31'),
      })
    );

    expect(result).to.deep.equal([]);
  });

  it(`should return the usage for the given date range`, async () => {
    const useCase = createUseCase();
    const mockStartDate = new Date('2021-01-01');
    const mockNotificationDate = new Date('2021-01-05');
    const mockEndDate = new Date('2021-01-31');
    const notificationCountPerIndex = 10;
    const orgCount = 10;

    const organizations: any[] = [];

    for (let index = 0; index < orgCount; index += 1) {
      const orgSession = new UserSession();
      await orgSession.initialize();

      const notificationsCount = notificationCountPerIndex * (index + 1);
      await notificationRepo.insertMany(
        new Array(notificationsCount).fill({
          _organizationId: orgSession.organization._id,
          _environmentId: orgSession.environment._id,
          createdAt: mockNotificationDate,
        })
      );
      await orgSession.updateOrganizationServiceLevel(ApiServiceLevelEnum.BUSINESS);

      organizations.push({ id: orgSession.organization._id, notificationsCount });
    }

    let expectedResult = organizations.map((org) => ({
      _id: org.id.toString(),
      apiServiceLevel: ApiServiceLevelEnum.BUSINESS,
      notificationsCount: org.notificationsCount,
    }));

    if (isClerkEnabled()) {
      // we have just one organization in Clerk - we don't create new ones on initialize()
      expectedResult = [expectedResult[expectedResult.length - 1]];
    }

    const result = await useCase.execute(
      GetPlatformNotificationUsageCommand.create({
        startDate: mockStartDate,
        endDate: mockEndDate,
      })
    );

    expect(result).to.include.deep.members(expectedResult.splice(0, 1));
  });

  it(`should return the usage for the given single organization`, async () => {
    await session.updateOrganizationServiceLevel(ApiServiceLevelEnum.BUSINESS);

    const useCase = createUseCase();
    const notificationsCount = 110;
    const mockNotificationDate = new Date('2021-01-05');

    await notificationRepo.insertMany(
      new Array(notificationsCount).fill({
        _organizationId: session.organization._id,
        _environmentId: session.environment._id,
        createdAt: mockNotificationDate,
      })
    );

    const result = await useCase.execute(
      GetPlatformNotificationUsageCommand.create({
        startDate: new Date('2021-01-01'),
        endDate: new Date('2021-01-31'),
        organizationId: session.organization._id,
      })
    );

    expect(result).to.deep.equal([
      {
        _id: session.organization._id.toString(),
        apiServiceLevel: ApiServiceLevelEnum.BUSINESS,
        notificationsCount,
      },
    ]);
  });
});