@squiz/optimization-utils 2.0.2 → 2.0.3

package/src/scheduler/__tests__/EventBridgeScheduler.spec.ts

@@ -1,308 +0,0 @@
-import { Container } from 'inversify';
-import {
-  CreateScheduleCommand,
-  CreateScheduleCommandInput,
-  DeleteScheduleCommand,
-  DeleteScheduleCommandInput,
-  GetScheduleCommand,
-  GetScheduleCommandInput,
-  ResourceNotFoundException,
-  SchedulerClient,
-} from '@aws-sdk/client-scheduler';
-import { randomUUID } from 'crypto';
-import { faker } from '@faker-js/faker';
-import { ExceptionOptionType } from '@smithy/smithy-client/dist-types/exceptions';
-import { SchedulerServiceException } from '@aws-sdk/client-scheduler/dist-types/models/SchedulerServiceException';
-import { Logger, createLoggerMock } from '@squiz/optimization-logger';
-import { createSchedulerClientMock } from '../../testing/mock';
-import { eventToDynamoDB } from '../../event/DynamoDBEventMapper';
-import { Scheduler } from '../Scheduler';
-import {
-  EventBridgeScheduler,
-  EventBridgeSchedulerConfig,
-} from '../EventBridgeScheduler';
-import { DomainEvent } from '../../event/DomainEvent';
-
-jest.mock('@aws-sdk/client-scheduler', () => {
-  return {
-    ...jest.requireActual('@aws-sdk/client-scheduler'),
-    CreateScheduleCommand: jest.fn(),
-    GetScheduleCommand: jest.fn(),
-    DeleteScheduleCommand: jest.fn(),
-  };
-});
-
-class ExampleEvent implements DomainEvent {
-  readonly detail: Record<string, unknown> = {};
-  readonly eventId: string = randomUUID();
-  readonly name: string = ExampleEvent.name;
-  readonly time: Date = new Date();
-  readonly version: string = '1';
-  readonly entityId = 'uuid';
-}
-
-describe('EventBridgeScheduler', () => {
-  let scheduler: Scheduler;
-  let schedulerClient: SchedulerClient;
-  let event: ExampleEvent;
-  const config: EventBridgeSchedulerConfig = {
-    eventTableName: 'event-table',
-    groupName: 'experiment',
-    region: 'eu-north-1',
-    schedulerRole: 'example-arn',
-  };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-
-    const container = new Container({ defaultScope: 'Singleton' });
-
-    container.bind(Scheduler).toDynamicValue(({ container: c }) => {
-      return new EventBridgeScheduler(
-        config,
-        c.get(SchedulerClient),
-        c.get(Logger),
-      );
-    });
-    container
-      .bind(SchedulerClient)
-      .toConstantValue(createSchedulerClientMock());
-    container.bind(Logger).toConstantValue(createLoggerMock());
-
-    event = new ExampleEvent();
-    schedulerClient = container.get(SchedulerClient);
-    scheduler = container.get(Scheduler);
-  });
-
-  describe('schedule', () => {
-    it('should call the CreateScheduleCommand with the PutItemCommandInput', async () => {
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Target: {
-            Arn: 'arn:aws:scheduler:::aws-sdk:dynamodb:putItem',
-            Input: JSON.stringify({
-              TableName: config.eventTableName,
-              Item: {
-                ...eventToDynamoDB(event),
-                eventId: {
-                  S: '<aws.scheduler.execution-id>',
-                },
-                time: {
-                  S: '<aws.scheduler.scheduled-time>',
-                },
-              },
-            }),
-            RoleArn: config.schedulerRole,
-          },
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "at" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: new Date('2023-01-01T00:00:00.000Z'),
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'at(2023-01-01T00:00:00)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "rate" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'rate',
-        value: 15,
-        unit: 'days',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'rate(15 days)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "cron" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'cron(* * * * ? *)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should create a schedule name which includes the event name', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: 'ExampleSchedule',
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: 'ExampleSchedule',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should trim end if the name contains more than 64 characters', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: 'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4Y',
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: 'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should call CreateScheduleCommand with correct params', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          GroupName: config.groupName,
-          State: 'ENABLED',
-          FlexibleTimeWindow: {
-            Mode: 'OFF',
-          },
-          ActionAfterCompletion: 'DELETE',
-          ClientToken: expect.any(String),
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should remove the existing schedule if it exists', async () => {
-      const scheduleName = randomUUID();
-
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: scheduleName,
-      });
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as GetScheduleCommandInput);
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as DeleteScheduleCommandInput);
-    });
-  });
-
-  describe('deleteSchedule', () => {
-    it('should delete schedule if it exists', async () => {
-      const scheduleName = 'example-schedule';
-
-      await scheduler.deleteSchedule(scheduleName);
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as GetScheduleCommandInput);
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as DeleteScheduleCommandInput);
-    });
-
-    it('should skip deleting schedule if it does not exist', async () => {
-      (schedulerClient.send as jest.Mock).mockRejectedValueOnce(
-        new ResourceNotFoundException(
-          {} as ExceptionOptionType<
-            ResourceNotFoundException,
-            SchedulerServiceException
-          >,
-        ),
-      );
-      const scheduleName = randomUUID();
-
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: scheduleName,
-      });
-
-      expect(GetScheduleCommand).toHaveBeenCalledTimes(1);
-      expect(DeleteScheduleCommand).toHaveBeenCalledTimes(0);
-    });
-
-    it('should rethrow exception if the GetScheduleCommand return exception other than ResourceNotFound', async () => {
-      (schedulerClient.send as jest.Mock).mockRejectedValueOnce(new Error());
-      const scheduleName = randomUUID();
-
-      await expect(() =>
-        scheduler.deleteSchedule(scheduleName),
-      ).rejects.toThrow();
-    });
-
-    it('should trim the scheduleName up to 64 characters', async () => {
-      const scheduleNameWith65Characters =
-        'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4Y';
-      const expectedScheduleName =
-        'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4';
-
-      await scheduler.deleteSchedule(scheduleNameWith65Characters);
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: expectedScheduleName,
-        }),
-      );
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: expectedScheduleName,
-        }),
-      );
-    });
-  });
-});

package/src/testing/mock.ts

@@ -1,15 +0,0 @@
-import { SchedulerClient } from '@aws-sdk/client-scheduler';
-import { Scheduler } from '../scheduler/Scheduler';
-
-export const createSchedulerClientMock = (): SchedulerClient => {
-  return {
-    send: jest.fn(),
-  } as unknown as SchedulerClient;
-};
-
-export const createSchedulerMock = (): Scheduler => {
-  return {
-    schedule: jest.fn(),
-    deleteSchedule: jest.fn(),
-  };
-};

package/src/typesUtils/DynamoDB.ts

@@ -1,17 +0,0 @@
-import { AttributeValue } from '@aws-sdk/client-dynamodb';
-
-export type MarshalledResult<T> = {
-  [K in keyof T]: T[K] extends string
-    ? AttributeValue.SMember
-    : T[K] extends number
-      ? AttributeValue.NMember
-      : T[K] extends Record<string, unknown>
-        ? AttributeValue.MMember
-        : T[K] extends Array<unknown>
-          ? AttributeValue.LMember
-          : T[K] extends boolean
-            ? AttributeValue.BOOLMember
-            : T[K] extends undefined
-              ? Partial<T[K]>
-              : never;
-};

package/src/typesUtils/utilities.ts

@@ -1,11 +0,0 @@
-type MethodKeysOrNever<T> = {
-  [K in keyof T]: T[K] extends Function ? K : never;
-};
-export type MethodKeys<T> = MethodKeysOrNever<T>[keyof T];
-export type ClassFields<T> = Omit<T, Exclude<MethodKeys<T>, undefined>>;
-export type OverwriteValueOf<TInstance, DValueOfReturn> = Omit<
-  TInstance,
-  'valueOf'
-> & {
-  valueOf(): DValueOfReturn;
-};

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "@tsconfig/node20/tsconfig.json",
-  "compilerOptions": {
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "sourceMap": true,
-    "declaration": true,
-    "outDir": "dist",
-    "baseUrl": "."
-  },
-  "include": ["src"],
-  "exclude": ["dist", "**/*.spec.ts"]
-}