fix(api-headless-cms-scheduler): tests which broke after refactor

Author: brunozoric

.github/workflows/wac/utils/listPackagesWithJestTests.ts

@@ -355,9 +355,9 @@ const CUSTOM_HANDLERS: Record<string, () => Array<PackageWithTests>> = {
     },
     "api-headless-cms-scheduler": () => {
         return [
-            {cmd: "packages/headless-cms-scheduler --storage=ddb-es,ddb", storage: "ddb-es"},
-            {cmd: "packages/headless-cms-scheduler --storage=ddb-os,ddb", storage: "ddb-os"},
-            {cmd: "packages/headless-cms-scheduler --storage=ddb", storage: "ddb"}
+            { cmd: "packages/headless-cms-scheduler --storage=ddb-es,ddb", storage: "ddb-es" },
+            { cmd: "packages/headless-cms-scheduler --storage=ddb-os,ddb", storage: "ddb-os" },
+            { cmd: "packages/headless-cms-scheduler --storage=ddb", storage: "ddb" }
         ];
     }
 };

packages/api-headless-cms-scheduler/__tests__/graphql/schema.test.ts

@@ -5,10 +5,25 @@ import {
     listScheduleSchema,
     updateScheduleSchema
 } from "~/graphql/schema.js";
+import { type ISchedulerInput, ScheduleType } from "~/scheduler/types.js";
+
+interface IExpectedSchemaInput {
+    id: string;
+    modelId: string;
+    input: ISchedulerInput;
+}
+
+interface IExpectedCancelSchemaInput {
+    id: string;
+    modelId: string;
+}
 
 describe("graphql/schema", () => {
     it("getScheduleSchema: accepts valid input and returns expected data", async () => {
-        const input = { modelId: "model", id: "123" };
+        const input = {
+            modelId: "model",
+            id: "123"
+        };
         const result = await getScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
         if (result.success) {
@@ -67,7 +82,10 @@ describe("graphql/schema", () => {
         const input = {
             modelId: "model",
             id: "123",
-            input: { immediately: true, type: "publish" }
+            input: {
+                immediately: true,
+                type: "publish"
+            }
         };
         const result = await createScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
@@ -77,31 +95,34 @@ describe("graphql/schema", () => {
     });
     it("createScheduleSchema: accepts dateOn input and returns expected data", async () => {
         const date = new Date();
-        const input = {
+        const input: IExpectedSchemaInput = {
             modelId: "model",
             id: "123",
-            input: { dateOn: date, type: "unpublish" }
+            input: {
+                scheduleOn: date,
+                type: ScheduleType.unpublish
+            }
         };
         const result = await createScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data).toEqual({
-                ...input,
-                input: {
-                    ...input.input,
-                    // @ts-expect-error
-                    dateOn: result.data.input.dateOn
-                }
-            });
-            // @ts-expect-error
-            expect(result.data.input.dateOn instanceof Date).toBe(true);
-        }
+
+        expect(result.data).toEqual({
+            ...input,
+            input: {
+                ...input.input,
+                scheduleOn: date
+            }
+        });
+        // @ts-expect-error
+        expect(result.data.input.scheduleOn).toBeInstanceOf(Date);
     });
     it("createScheduleSchema: rejects missing input fields", async () => {
         const result = await createScheduleSchema.safeParseAsync({
             modelId: "model",
             id: "123",
-            input: { type: "publish" }
+            input: {
+                type: "publish"
+            }
         });
         expect(result.success).toBe(false);
     });
@@ -110,7 +131,10 @@ describe("graphql/schema", () => {
         const input = {
             modelId: "model",
             id: "123",
-            input: { immediately: true, type: "publish" }
+            input: {
+                immediately: true,
+                type: "publish"
+            }
         };
         const result = await updateScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
@@ -120,10 +144,13 @@ describe("graphql/schema", () => {
     });
     it("updateScheduleSchema: accepts dateOn input and returns expected data", async () => {
         const date = new Date();
-        const input = {
+        const input: IExpectedSchemaInput = {
             modelId: "model",
             id: "123",
-            input: { dateOn: date, type: "unpublish" }
+            input: {
+                scheduleOn: date,
+                type: ScheduleType.unpublish
+            }
         };
         const result = await updateScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
@@ -132,25 +159,28 @@ describe("graphql/schema", () => {
                 ...input,
                 input: {
                     ...input.input,
-                    // @ts-expect-error
-                    dateOn: result.data.input.dateOn
+                    scheduleOn: date
                 }
             });
-            // @ts-expect-error
-            expect(result.data.input.dateOn instanceof Date).toBe(true);
+            expect(result.data.input.scheduleOn).toBeInstanceOf(Date);
         }
     });
     it("updateScheduleSchema: rejects missing input fields", async () => {
         const result = await updateScheduleSchema.safeParseAsync({
             modelId: "model",
             id: "123",
-            input: { type: "publish" }
+            input: {
+                type: "publish"
+            }
         });
         expect(result.success).toBe(false);
     });
 
     it("cancelScheduleSchema: accepts valid input and returns expected data", async () => {
-        const input = { modelId: "model", id: "123" };
+        const input: IExpectedCancelSchemaInput = {
+            modelId: "model",
+            id: "123"
+        };
         const result = await cancelScheduleSchema.safeParseAsync(input);
         expect(result.success).toBe(true);
         if (result.success) {

packages/api-headless-cms-scheduler/__tests__/scheduler/actions/PublishScheduleAction.test.ts

@@ -6,8 +6,12 @@ import { createMockTargetModel } from "~tests/mocks/targetModel.js";
 import { PublishScheduleAction } from "~/scheduler/actions/PublishScheduleAction.js";
 import type { CmsEntry, CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
 import { ScheduleRecord } from "~/scheduler/ScheduleRecord.js";
-import type { IScheduleEntryValues } from "~/scheduler/types.js";
+import { type IScheduleEntryValues, ScheduleType } from "~/scheduler/types.js";
 import { createScheduleRecordId } from "~/scheduler/createScheduleRecordId.js";
+import { dateToISOString } from "~/scheduler/dates.js";
+import { SchedulerService } from "~/service/SchedulerService.js";
+import { CreateScheduleCommand, SchedulerClient } from "@webiny/aws-sdk/client-scheduler/index.js";
+import { mockClient } from "aws-sdk-client-mock";
 
 describe("PublishScheduleAction", () => {
     const service = createMockService();
@@ -44,7 +48,7 @@ describe("PublishScheduleAction", () => {
         const result = await action.schedule({
             input: {
                 immediately: true,
-                type: "publish"
+                type: ScheduleType.publish
             },
             targetId: "target-id#0002",
             scheduleRecordId: createScheduleRecordId(`target-id#0002`)
@@ -58,12 +62,13 @@ describe("PublishScheduleAction", () => {
             scheduledBy: getIdentity(),
             publishOn: expect.any(Date),
             unpublishOn: undefined,
-            type: "publish",
+            dateOn: expect.any(Date),
+            type: ScheduleType.publish,
             title: "Test Entry"
         });
     });
 
-    it("should publish an entry immediately if the dateOn is in the past", async () => {
+    it("should publish an entry immediately if the scheduleOn is in the past", async () => {
         const updateEntryMock = jest.fn(async <T = CmsEntryValues>() => {
             return {} as CmsEntry<T>;
         });
@@ -93,11 +98,11 @@ describe("PublishScheduleAction", () => {
             cms
         });
 
-        const dateOn = new Date(Date.now() - 1000000);
+        const scheduleOn = new Date(Date.now() - 1000000);
         const result = await action.schedule({
             input: {
-                dateOn,
-                type: "publish"
+                scheduleOn,
+                type: ScheduleType.publish
             },
             targetId: "target-id#0002",
             scheduleRecordId: createScheduleRecordId(`target-id#0002`)
@@ -109,43 +114,53 @@ describe("PublishScheduleAction", () => {
             targetId: "target-id#0002",
             model: targetModel,
             scheduledBy: getIdentity(),
-            publishOn: dateOn,
+            publishOn: expect.any(Date),
             unpublishOn: undefined,
-            type: "publish",
+            dateOn: undefined,
+            type: ScheduleType.publish,
             title: "Test Entry"
         });
 
         expect(updateEntryMock).toHaveBeenCalledTimes(1);
         expect(updateEntryMock).toHaveBeenCalledWith(targetModel, "target-id#0002", {
             firstPublishedBy: getIdentity(),
-            firstPublishedOn: dateOn.toISOString(),
+            firstPublishedOn: scheduleOn.toISOString(),
             lastPublishedBy: getIdentity(),
-            lastPublishedOn: dateOn.toISOString()
+            lastPublishedOn: scheduleOn.toISOString()
         });
     });
 
     it("should schedule a publish action for a future date", async () => {
-        const serviceCreate = jest.fn(async () => {});
-        const service = createMockService({
-            create: serviceCreate
+        const client = mockClient(SchedulerClient);
+        client.on(CreateScheduleCommand).resolves({
+            $metadata: {
+                httpStatusCode: 200
+            }
         });
-        const dateOn = new Date(Date.now() + 1000000);
+        const service = new SchedulerService({
+            getClient: () => client,
+            config: {
+                lambdaArn: "arn:aws:lambda:us-east-1:123456789012:function:my-function",
+                roleArn: "arn:aws:iam::123456789012:role/my-role"
+            }
+        });
+        const scheduleOn = new Date(Date.now() + 1000000);
 
         const crateEntryMock = jest.fn(async () => {
-            // @ts-expect-error
-            const entry: CmsEntry<IScheduleEntryValues> = {
+            const entry: Pick<CmsEntry<IScheduleEntryValues>, "id" | "values" | "savedBy"> = {
                 id: createScheduleRecordId(`target-id#0002`),
                 values: {
                     targetId: "target-id#0002",
-                    type: "publish",
-                    dateOn: dateOn.toISOString(),
+                    type: ScheduleType.publish,
+                    scheduledOn: dateToISOString(scheduleOn),
+                    dateOn: dateToISOString(scheduleOn),
                     title: "Test Entry",
                     targetModelId: targetModel.modelId,
                     scheduledBy: getIdentity()
                 },
                 savedBy: getIdentity()
             };
-            return entry;
+            return entry as CmsEntry<IScheduleEntryValues>;
         });
         const cms = createMockCms({
             // @ts-expect-error
@@ -176,8 +191,8 @@ describe("PublishScheduleAction", () => {
 
         const result = await action.schedule({
             input: {
-                dateOn,
-                type: "publish"
+                scheduleOn,
+                type: ScheduleType.publish
             },
             targetId: "target-id#0002",
             scheduleRecordId: createScheduleRecordId(`target-id#0002`)
@@ -189,21 +204,23 @@ describe("PublishScheduleAction", () => {
             targetId: "target-id#0002",
             model: targetModel,
             scheduledBy: getIdentity(),
-            publishOn: dateOn,
+            publishOn: scheduleOn,
             unpublishOn: undefined,
-            type: "publish",
+            dateOn: scheduleOn,
+            type: ScheduleType.publish,
             title: "Test Entry"
         });
 
         expect(crateEntryMock).toHaveBeenCalledTimes(1);
         expect(crateEntryMock).toHaveBeenCalledWith(scheduleModel, {
             id: createScheduleRecordId(`target-id#0002`),
-            dateOn: dateOn.toISOString(),
+            dateOn: undefined,
             scheduledBy: getIdentity(),
+            scheduledOn: dateToISOString(scheduleOn),
             targetId: "target-id#0002",
             targetModelId: "targetModel",
             title: "Test Entry",
-            type: "publish"
+            type: ScheduleType.publish
         });
     });
 });