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

import { beforeEach, describe, expect, it } from "@jest/globals";
import { setupTestServerContext, setupTestServerHolder } from "../testHelpers/apolloTestServerHelpers";
import { generateMockEtas, generateMockOrderedStops } from "../testHelpers/mockDataGenerators";
import { IStop, ISystem } from "../../src/entities/entities";
import { addMockStopToRepository, addMockSystemToRepository } from "../testHelpers/repositorySetupHelpers";
import assert = require("node:assert");

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

  let mockStop: IStop;
  let mockSystem: ISystem;

  beforeEach(async () => {
    mockSystem = await addMockSystemToRepository(context.repository);
    mockStop = await addMockStopToRepository(context.repository, mockSystem.id);
  })

  async function getResponseForQuery(query: string) {
    return await holder.testServer.executeOperation({
      query,
      variables: {
        systemId: mockSystem.id,
        stopId: mockStop.id,
      },
    }, {
      contextValue: {
        repository: context.repository,
      }
    });
  }

  describe("orderedStops", () => {
    const query = `
    query GetOrderedStops($systemId: ID!, $stopId: ID!) {
      system(id: $systemId) {
        stop(id: $stopId) {
          orderedStops {
            routeId
            stopId
          }
        }
      }
    }
    `


    it("returns ordered stops if they exist for the stop ID", async () => {
      let mockOrderedStops = generateMockOrderedStops();
      mockOrderedStops = mockOrderedStops.filter((orderedStop) => orderedStop.stopId === mockOrderedStops[0].stopId);
      await Promise.all(mockOrderedStops.map(async orderedStop => {
        orderedStop.stopId = mockStop.id;
        await context.repository.addOrUpdateOrderedStop(orderedStop);
      }));

      const response = await getResponseForQuery(query);

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

    it("returns empty array if no ordered stops exist", async () => {
      const response = await getResponseForQuery(query);

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

  describe("etas", () => {
    const query = `
    query GetEtas($systemId: ID!, $stopId: ID!) {
      system(id: $systemId) {
        stop(id: $stopId) {
          etas {
            secondsRemaining
          }
        }
      }
    }
    `

    it("returns ETAs if they exist for the stop ID", async () => {
      let mockEtas = generateMockEtas();
      mockEtas = mockEtas.filter((eta) => eta.stopId === mockEtas[0].stopId);
      await Promise.all(mockEtas.map(async eta => {
        eta.stopId = mockStop.id;
        await context.repository.addOrUpdateEta(eta);
      }));

      const response = await getResponseForQuery(query);

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

    it("returns empty array if no ETAs exist", async () => {
      const response = await getResponseForQuery(query);

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