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

import { beforeEach, describe, it } from "@jest/globals";
import { ServerContext } from "../../src/ServerContext";
import { UnoptimizedInMemoryRepository } from "../../src/repositories/UnoptimizedInMemoryRepository";
import { setUpTestServer } from "../testHelpers/apolloSetupHelpers";
import { ApolloServer } from "@apollo/server";
import { addMockSystemToRepository } from "../testHelpers/repositorySetupHelpers";
import { generateMockRoutes, generateMockStops } from "../generators";
import { IRoute, IStop, ISystem } from "../../src/entities/entities";

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

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

  let mockSystem: ISystem;
  let mockRoute: IRoute;
  let mockStop: IStop;

  beforeEach(async () => {
    mockSystem = await addMockSystemToRepository(repository);

    const mockRoutes = generateMockRoutes();
    mockRoute = mockRoutes[0];
    mockRoute.systemId = mockSystem.id;
    await repository.addOrUpdateRoute(mockRoute);

    const mockStops = generateMockStops();
    mockStop = mockStops[0];
    mockStop.systemId = mockSystem.id;
    await repository.addOrUpdateStop(mockStop);
  });


  describe("shuttles", () => {
    async function getResponseForShuttlesQuery() {
      const query = `
      query GetRouteShuttles($systemId: ID!, $routeId: ID!) {
        system(id: $systemId) {
          route(id: $routeId) {
            shuttles {
              id
              name
            }
          }
        }
      }
      `;

      return await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          routeId: mockRoute.id,
        },
      }, {
        contextValue: {
          repository,
        }
      });
    }

    it("returns shuttle array if there are shuttles", async () => {

    });

    it("returns empty array if there are no shuttles", async () => {

    });
  });

  describe("orderedStop", () => {
    async function getResponseForOrderedStopQuery() {
      const query = `
      query GetRouteOrderedStop($systemId: ID!, $routeId: ID!) {
        system(id: $systemId) {
          route(id: $routeId) {
            orderedStop(forStopId: $stopId) {
              stopId
            }
          }
        }
      }
      `;

      return await testServer.executeOperation({
        query,
        variables: {
          systemId: mockSystem.id,
          routeId: mockRoute.id,
          stopId: mockStop.id,
        }
      }, {
        contextValue: {
          repository,
        }
      });
    }

    it("returns ordered stop using provided data", async () => {

    });

    it("returns null if the stop doesn't exist", async () => {

    });
  });
});