project-inter-server/test/resolvers/MutationResolverTests.test.ts

import { describe, expect, it } from "@jest/globals";
import { setupTestServerContext, setupTestServerHolder } from "../testHelpers/apolloTestServerHelpers";
import {
  addMockShuttleToRepository,
  addMockStopToRepository,
  addMockSystemToRepository
} from "../testHelpers/repositorySetupHelpers";
import assert = require("node:assert");
import { NotificationInput } from "../../src/generated/graphql";

describe("MutationResolvers", () => {
  const holder = setupTestServerHolder()
  const context = setupTestServerContext();

  describe("scheduleNotification", () => {
    const query = `
    mutation ScheduleNotification($input: NotificationInput!) {
      scheduleNotification(input: $input) {
         success
         message
         data {
           deviceId
           shuttleId
           stopId
         }
      }
    }
    `

    async function getServerResponse(notificationInput: { deviceId: string; shuttleId: string; stopId: string }) {
      return await holder.testServer.executeOperation({
        query,
        variables: {
          input: notificationInput,
        }
      }, {
        contextValue: context
      });
    }

    function assertFailedResponse(response: any, notificationInput: NotificationInput) {
      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
      expect(notificationResponse.success).toBe(false);

      expect(context.notificationService.isNotificationScheduled(notificationInput)).toBe(false);
    }


    it("adds a notification to the notification service", async () => {
      const system = await addMockSystemToRepository(context.repository);
      const shuttle = await addMockShuttleToRepository(context.repository, system.id);
      const stop = await addMockStopToRepository(context.repository, system.id);

      const notificationInput = {
        deviceId: "1",
        shuttleId: shuttle.id,
        stopId: stop.id,
      };
      const response = await getServerResponse(notificationInput);

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();

      const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
      expect(notificationResponse?.success).toBe(true);
      expect(notificationResponse?.notification).toStrictEqual(notificationInput);

      expect(context.notificationService.isNotificationScheduled(notificationInput)).toBe(true);
    });

    it("fails if the shuttle ID doesn't exist", async () => {
      const system = await addMockSystemToRepository(context.repository);
      const stop = await addMockStopToRepository(context.repository, system.id);

      const notificationInput = {
        deviceId: "1",
        shuttleId: "1",
        stopId: stop.id,
      }
      const response = await getServerResponse(notificationInput);
      assertFailedResponse(response, notificationInput);
    });

    it("fails if the stop ID doesn't exist", async () => {
      const system = await addMockSystemToRepository(context.repository);
      const shuttle = await addMockShuttleToRepository(context.repository, system.id);

      const notificationInput = {
        deviceId: "1",
        shuttleId: shuttle.id,
        stopId: "1",
      }
      const response = await getServerResponse(notificationInput);

      assertFailedResponse(response, notificationInput);
    });
  });

  describe("cancelNotification", () => {
    it("removes the notification from the notification service", async () => {

    });
  });
});