add test cases and implementations for StopResolverTests

test/resolvers/StopResolverTests.test.ts

@@ -1,11 +1,95 @@
-import { beforeEach, describe } from "@jest/globals";
+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 { readFileSync } from "fs";
-import { MergedResolvers } from "../../src/MergedResolvers";
+import { setUpTestServer } from "../testHelpers/apolloSetupHelpers";
+import { generateMockOrderedStops, generateMockStops, generateMockSystems } from "../generators";
+import { IStop, ISystem } from "../../src/entities/entities";
+import assert = require("node:assert");
 
 describe("StopResolvers", () => {
-  // replicate setup code
+  let testServer: ApolloServer<ServerContext>;
+  let repository: UnoptimizedInMemoryRepository;
 
+  beforeEach(() => {
+    testServer = setUpTestServer();
+    repository = new UnoptimizedInMemoryRepository();
+  });
+
+  let mockStop: IStop;
+  let mockSystem: ISystem;
+
+  beforeEach(async () => {
+    const mockSystems = generateMockSystems();
+    mockSystem = mockSystems[0];
+    mockSystem.id = "1";
+    await repository.addOrUpdateSystem(mockSystem);
+
+    const mockStops = generateMockStops();
+    mockStop = mockStops[0];
+    mockStop.id = "1";
+    await repository.addOrUpdateStop(mockStop);
+  })
+
+  describe("orderedStops", () => {
+    const query = `
+    query GetOrderedStops($systemId: ID!, $stopId: ID!) {
+      system(id: $systemId) {
+        stop(id: $stopId) {
+          orderedStops {
+            routeId
+            stopId
+          }
+        }
+      }
+    }
+    `
+
+    async function getResponseForQuery() {
+      return await testServer.executeOperation({
+        query,
+        variables: {
+          systemId: mockSystem.id,
+          stopId: mockStop.id,
+        },
+      }, {
+        contextValue: {
+          repository,
+        }
+      });
+    }
+
+    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 repository.addOrUpdateOrderedStop(orderedStop);
+      }));
+
+      const response = await getResponseForQuery();
+
+      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();
+
+      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", () => {
+    it("returns ETAs if they exist for the stop ID", async () => {
+
+    });
+
+    it("returns empty array if no ETAs exist", async () => {
+
+    });
+  });
 });