project-inter-server/test/resolvers/QueryResolverTests.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 { generateMockSystems } from "../generators";
import assert = require("node:assert");
import { setUpTestServer } from "../testHelpers/apolloSetupHelpers";

// See Apollo documentation for integration test guide
// https://www.apollographql.com/docs/apollo-server/testing/testing

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

  beforeEach(async () => {
    testServer = setUpTestServer();

    repository = new UnoptimizedInMemoryRepository();
  });

  async function addMockSystems() {
    const systems = generateMockSystems();
    await Promise.all(systems.map(async (system) => {
      await repository.addOrUpdateSystem(system);
    }));
    return systems;
  }

  describe("systems", () => {
    it("returns systems from the repository", async () => {
      const systems = await addMockSystems();

      const query = `
      query GetSystems
      {
        systems {
          name
        }
      }
      `;

      const response = await testServer.executeOperation({
        query,
      }, {
        contextValue: {
          repository,
        },
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect(response.body.singleResult.data?.systems).toHaveLength(systems.length);
    });
  });

  describe("system", () => {
    const query = `
    query GetSystem($id: ID!)
    {
      system(id: $id) {
        name
      }
    }
    `;

    it("returns a system for an ID from the repository", async () => {
      const systems = await addMockSystems();
      const systemToGet = systems[1];

      const response = await testServer.executeOperation({
        query,
        variables: {
          id: systemToGet.id,
        }
      }, {
        contextValue: {
          repository,
        }
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect(response.body.singleResult.data?.system).toBeDefined();
    });

    it("returns null if there is no system", async () => {
      const response = await testServer.executeOperation({
        query,
        variables: {
          id: "nonexistent-id",
        }
      }, {
        contextValue: {
          repository,
        }
      });

      assert(response.body.kind === "single");
      expect(response.body.singleResult.errors).toBeUndefined();
      expect(response.body.singleResult.data?.system).toBeNull();
    });
  });
});