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

import { beforeEach, describe, expect, it } from "@jest/globals";
import { ApolloServer } from "@apollo/server";
import { ServerContext } from "../../src/ServerContext";
import { UnoptimizedInMemoryRepository } from "../../src/repositories/UnoptimizedInMemoryRepository";
import { generateMockEtas, generateMockRoutes, generateMockShuttles, generateMockSystems } from "../generators";
import { IShuttle, ISystem } from "../../src/entities/entities";
import assert = require("node:assert");
import { setUpTestServer } from "../testHelpers/apolloSetupHelpers";

describe("ShuttleResolvers", () => {
  let testServer: ApolloServer<ServerContext>
  let repository: UnoptimizedInMemoryRepository;

  beforeEach(async () => {
    testServer = setUpTestServer();
    repository = new UnoptimizedInMemoryRepository();
  });

  let mockSystem: ISystem;
  let mockShuttle: IShuttle;

  beforeEach(async () => {
    const mockSystems = generateMockSystems();
    mockSystem = mockSystems[0];
    mockSystem.id = "1";
    await repository.addOrUpdateSystem(mockSystem);

    const mockShuttles = generateMockShuttles();
    mockShuttle = mockShuttles[0];
    mockShuttle.systemId = mockSystem.id;
    mockShuttle.id = "1";
    await repository.addOrUpdateShuttle(mockShuttle);
  });


  async function addMockEtas(shuttleId: string) {
    const etas = generateMockEtas();
    await Promise.all(etas.map(async (eta) => {
      eta.shuttleId = shuttleId;
      await repository.addOrUpdateEta(eta);
    }));
    return etas;
  }

  describe("eta", () => {
    const query = `
    query GetShuttleETAs($systemId: ID!, $shuttleId: ID!, $stopId: ID!)
    {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          eta(forStopId: $stopId) {
            secondsRemaining
          }
        }
      }
    }
    `
    it("returns ETA data for stop ID if exists", async () => {
      const etas = await addMockEtas(mockShuttle.id);

      const mockEta = etas[1];

      // Act
      const response = await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
          stopId: mockEta.stopId,
        },
      }, {
        contextValue: {
          repository,
        },
      });

      // Assert
      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.eta.secondsRemaining).toEqual(mockEta.secondsRemaining);
    });

    it("returns null if it doesn't exist", async () => {
      const response = await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
          stopId: "nonexistent-stop",
        }
      }, {
        contextValue: {
          repository,
        }
      });

      // Assert
      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.eta).toBeNull();
    });
  });

  describe("etas", () => {
    const query = `
    query GetShuttleETAs($systemId: ID!, $shuttleId: ID!)
    {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          etas {
            secondsRemaining
          }
        }
      }
    }
    `

    it("returns associated ETAs if they exist for the shuttle", async () => {
      const etas = await addMockEtas(mockShuttle.id);

      const response = await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
        },
      }, {
        contextValue: {
          repository,
        }
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.etas).toHaveLength(etas.length);
    });

    it("returns empty array if no ETAs exist", async () => {
      const response = await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
        },
      }, {
        contextValue: {
          repository,
        }
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.etas).toHaveLength(0);

    });
  });

  describe("route", () => {
    const query = `
    query GetShuttleRoute($systemId: ID!, $shuttleId: ID!) {
      system(id: $systemId) {
        shuttle(id: $shuttleId) {
          route {
             color
             id
             name
             polylineCoordinates {
               latitude
               longitude
             }
          }
        }
      }
    }
    `

    async function getResponseForQuery() {
      return await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          shuttleId: mockShuttle.id,
        }
      }, {
        contextValue: {
          repository,
        }
      });
    }

    it("returns the route if it exists", async () => {
      const mockRoute = generateMockRoutes()[0];
      await repository.addOrUpdateRoute(mockRoute);

      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.route.id).toEqual(mockRoute.id);
    });

    it("returns null if there is no route", async () => {
      const response = await getResponseForQuery();

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect((response.body.singleResult.data as any).system.shuttle.route).toBeNull();
    });
  });
});