project-inter-server/test/loaders/TimedApiBasedRepositoryLoaderTests.test.ts

import { afterEach, beforeAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
import { TimedApiBasedRepositoryLoader } from "../../src/loaders/TimedApiBasedRepositoryLoader";
import { resetGlobalFetchMockJson } from "../mockHelpers/fetchMockHelpers";
import { GetterSetterRepository } from "../../src/repositories/GetterSetterRepository";

describe("TimedApiBasedRepositoryLoader", () => {
  let repositoryMock: GetterSetterRepository;
  let loader: TimedApiBasedRepositoryLoader;
  let spies: any;

  beforeAll(() => {
    jest.useFakeTimers();
    jest.spyOn(global, "setTimeout");
  });

  beforeEach(() => {
    resetGlobalFetchMockJson();

    repositoryMock = {
      clearSystemData: jest.fn(),
      clearRouteData: jest.fn(),
      clearStopData: jest.fn(),
      clearShuttleData: jest.fn(),
      clearEtaData: jest.fn(),
    } as unknown as GetterSetterRepository;

    loader = new TimedApiBasedRepositoryLoader(repositoryMock);

    spies = {
      fetchAndUpdateSystemData: jest.spyOn(loader, 'fetchAndUpdateSystemData'),
      fetchAndUpdateRouteDataForExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateRouteDataForExistingSystemsInRepository'),
      fetchAndUpdateStopAndPolylineDataForRoutesInExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateStopAndPolylineDataForRoutesInExistingSystemsInRepository'),
      fetchAndUpdateShuttleDataForExistingSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateShuttleDataForExistingSystemsInRepository'),
      fetchAndUpdateEtaDataForExistingStopsForSystemsInRepository: jest.spyOn(loader, 'fetchAndUpdateEtaDataForExistingStopsForSystemsInRepository')
    };

    Object.values(spies).forEach((spy: any) => {
      spy.mockResolvedValue(undefined);
    });
  });

  afterEach(() => {
    jest.clearAllMocks();
    jest.clearAllTimers();
  })

  describe("start", () => {
    it("should update internal state, call data fetching methods, and start a timer", async () => {
      await loader.start();
      expect(loader["shouldBeRunning"]).toBe(true);

      Object.values(repositoryMock).forEach((mockFn) => {
        expect(mockFn).toHaveBeenCalled();
      });
      Object.values(spies).forEach((spy: any) => {
        expect(spy).toHaveBeenCalled();
      });

      expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), loader.timeout);
      expect(loader.timeout).not.toBeUndefined();
    });

    it("does nothing if timer is already running", async () => {
      await loader.start();
      await loader.start();

      Object.values(repositoryMock).forEach((mockFn) => {
        expect(mockFn).toHaveBeenCalledTimes(1);
      });
      Object.values(spies).forEach((spy: any) => {
        expect(spy).toHaveBeenCalledTimes(1);
      });
    });
  });

  describe("stop", () => {
    it("should update internal state", async () => {
      loader.stop();
      expect(loader['shouldBeRunning']).toBe(false);
    });
  });
});