mirror of
https://github.com/brendan-ch/project-inter-server.git
synced 2026-04-17 07:50:31 +00:00
Move all tests to subdirectories underneath code to be tested
This commit is contained in:
@@ -0,0 +1,68 @@
|
||||
import { afterEach, beforeAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { TimedApiBasedRepositoryLoader } from "../TimedApiBasedRepositoryLoader";
|
||||
import { resetGlobalFetchMockJson } from "../../../test/testHelpers/fetchMockHelpers";
|
||||
import { UnoptimizedInMemoryShuttleRepository } from "../../repositories/shuttle/UnoptimizedInMemoryShuttleRepository";
|
||||
import { ApiBasedShuttleRepositoryLoader } from "../shuttle/ApiBasedShuttleRepositoryLoader";
|
||||
|
||||
describe("TimedApiBasedRepositoryLoader", () => {
|
||||
let timedLoader: TimedApiBasedRepositoryLoader;
|
||||
let spies: any;
|
||||
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers();
|
||||
jest.spyOn(global, "setTimeout");
|
||||
resetGlobalFetchMockJson();
|
||||
|
||||
const mockLoader = new ApiBasedShuttleRepositoryLoader(
|
||||
"1",
|
||||
"1",
|
||||
new UnoptimizedInMemoryShuttleRepository(),
|
||||
);
|
||||
timedLoader = new TimedApiBasedRepositoryLoader(
|
||||
mockLoader,
|
||||
);
|
||||
|
||||
spies = {
|
||||
fetchAndUpdateAll: jest.spyOn(mockLoader, 'fetchAndUpdateAll'),
|
||||
};
|
||||
|
||||
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 timedLoader.start();
|
||||
expect(timedLoader["shouldBeRunning"]).toBe(true);
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), timedLoader.timeoutMs);
|
||||
expect(timedLoader.timeoutMs).not.toBeUndefined();
|
||||
});
|
||||
|
||||
it("does nothing if timer is already running", async () => {
|
||||
await timedLoader.start();
|
||||
await timedLoader.start();
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
expect(spy).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("stop", () => {
|
||||
it("should update internal state", async () => {
|
||||
timedLoader.stop();
|
||||
expect(timedLoader['shouldBeRunning']).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,113 @@
|
||||
import { beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import {
|
||||
ChapmanApiBasedParkingRepositoryLoader
|
||||
} from "../ChapmanApiBasedParkingRepositoryLoader";
|
||||
import { InMemoryParkingRepository } from "../../../repositories/parking/InMemoryParkingRepository";
|
||||
import {
|
||||
resetGlobalFetchMockJson,
|
||||
updateGlobalFetchMockJson,
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError
|
||||
} from "../../../../test/testHelpers/fetchMockHelpers";
|
||||
import {
|
||||
chapmanParkingStructureData
|
||||
} from "../../../../test/jsonSnapshots/chapmanParkingStructureData/chapmanParkingStructureData";
|
||||
import { IParkingStructure } from "../../../entities/ParkingRepositoryEntities";
|
||||
import { assertAsyncCallbackThrowsApiResponseError } from "../../../../test/testHelpers/assertAsyncCallbackThrowsApiResponseError";
|
||||
|
||||
describe("ChapmanApiBasedParkingRepositoryLoader", () => {
|
||||
let loader: ChapmanApiBasedParkingRepositoryLoader;
|
||||
|
||||
beforeEach(() => {
|
||||
loader = new ChapmanApiBasedParkingRepositoryLoader(
|
||||
new InMemoryParkingRepository(),
|
||||
);
|
||||
resetGlobalFetchMockJson();
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateAll", () => {
|
||||
it("calls all the correct methods", async () => {
|
||||
const spies = {
|
||||
fetchAndUpdateParkingStructures: jest.spyOn(loader, "fetchAndUpdateParkingStructures"),
|
||||
};
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
spy.mockResolvedValue(undefined);
|
||||
});
|
||||
|
||||
await loader.fetchAndUpdateAll();
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateParkingStructures", () => {
|
||||
it("fetches and update parking structures with unique IDs", async () => {
|
||||
updateGlobalFetchMockJson(chapmanParkingStructureData);
|
||||
|
||||
await loader.fetchAndUpdateParkingStructures();
|
||||
|
||||
let expectedStructures: IParkingStructure[] = [
|
||||
{
|
||||
address: "300 E Walnut, Orange, CA 92867",
|
||||
capacity: 871,
|
||||
spotsAvailable: 211,
|
||||
coordinates: {
|
||||
latitude: 33.7945513,
|
||||
longitude: -117.8518707,
|
||||
},
|
||||
name: "Anderson Structure",
|
||||
id: "",
|
||||
updatedTime: new Date(),
|
||||
},
|
||||
{
|
||||
address: "200 W Sycamore Ave, Orange, CA 92866-1053",
|
||||
capacity: 692,
|
||||
spotsAvailable: 282,
|
||||
coordinates: {
|
||||
latitude: 33.792937,
|
||||
longitude: -117.854782
|
||||
},
|
||||
name: "Barrera",
|
||||
id: "",
|
||||
updatedTime: new Date(),
|
||||
}
|
||||
];
|
||||
expectedStructures[0].id = ChapmanApiBasedParkingRepositoryLoader.generateId(expectedStructures[0].address);
|
||||
expectedStructures[1].id = ChapmanApiBasedParkingRepositoryLoader.generateId(expectedStructures[1].address);
|
||||
|
||||
const structuresFromLoader = await loader.repository.getParkingStructures();
|
||||
|
||||
// Set updatedTimeMs on expected data to avoid comparison
|
||||
expectedStructures[0].updatedTime = structuresFromLoader[0].updatedTime;
|
||||
expectedStructures[1].updatedTime = structuresFromLoader[1].updatedTime;
|
||||
|
||||
expect(structuresFromLoader).toEqual(expectedStructures);
|
||||
});
|
||||
|
||||
it("throws ApiResponseError if data is incorrect", async () => {
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError();
|
||||
|
||||
await assertAsyncCallbackThrowsApiResponseError(async () => {
|
||||
await loader.fetchAndUpdateParkingStructures();
|
||||
});
|
||||
})
|
||||
});
|
||||
|
||||
describe("constructIParkingStructureFromJson", () => {
|
||||
it("normalizes the spots available if it's over the capacity", async () => {
|
||||
const sampleJsonStructure: any = {
|
||||
Capacity: 10,
|
||||
Latitude: 1,
|
||||
Longitude: 1,
|
||||
Address: "300 E Walnut, Orange, CA 92867",
|
||||
Name: "Anderson Structure",
|
||||
CurrentCount: 11,
|
||||
};
|
||||
|
||||
const returnedStructure = loader.constructIParkingStructureFromJson(sampleJsonStructure);
|
||||
expect(returnedStructure.spotsAvailable).toEqual(returnedStructure.capacity);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,195 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { ApiBasedShuttleRepositoryLoader } from "../ApiBasedShuttleRepositoryLoader";
|
||||
import { UnoptimizedInMemoryShuttleRepository } from "../../../repositories/shuttle/UnoptimizedInMemoryShuttleRepository";
|
||||
import { fetchRouteDataSuccessfulResponse } from "../../../../test/jsonSnapshots/fetchRouteData/fetchRouteDataSuccessfulResponse";
|
||||
import {
|
||||
fetchStopAndPolylineDataSuccessfulResponse
|
||||
} from "../../../../test/jsonSnapshots/fetchStopAndPolylineData/fetchStopAndPolylineDataSuccessfulResponse";
|
||||
import { generateMockRoutes, generateMockShuttles, generateMockStops } from "../../../../test/testHelpers/mockDataGenerators";
|
||||
import {
|
||||
fetchShuttleDataSuccessfulResponse
|
||||
} from "../../../../test/jsonSnapshots/fetchShuttleData/fetchShuttleDataSuccessfulResponse";
|
||||
import { fetchEtaDataSuccessfulResponse } from "../../../../test/jsonSnapshots/fetchEtaData/fetchEtaDataSuccessfulResponse";
|
||||
import {
|
||||
resetGlobalFetchMockJson,
|
||||
updateGlobalFetchMockJson,
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError
|
||||
} from "../../../../test/testHelpers/fetchMockHelpers";
|
||||
import { assertAsyncCallbackThrowsApiResponseError } from "../../../../test/testHelpers/assertAsyncCallbackThrowsApiResponseError";
|
||||
|
||||
describe("ApiBasedShuttleRepositoryLoader", () => {
|
||||
let loader: ApiBasedShuttleRepositoryLoader;
|
||||
|
||||
beforeEach(() => {
|
||||
loader = new ApiBasedShuttleRepositoryLoader("263", "1", new UnoptimizedInMemoryShuttleRepository());
|
||||
resetGlobalFetchMockJson();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
const systemId = "1";
|
||||
|
||||
describe("fetchAndUpdateAll", () => {
|
||||
it("calls all the correct methods", async () => {
|
||||
const spies = {
|
||||
fetchAndUpdateRouteDataForSystem: jest.spyOn(loader, "fetchAndUpdateRouteDataForSystem"),
|
||||
fetchAndUpdateStopAndPolylineDataForRoutesInSystem: jest.spyOn(loader, "fetchAndUpdateStopAndPolylineDataForRoutesInSystem"),
|
||||
fetchAndUpdateShuttleDataForSystem: jest.spyOn(loader, "fetchAndUpdateShuttleDataForSystem"),
|
||||
fetchAndUpdateEtaDataForExistingStopsForSystem: jest.spyOn(loader, "fetchAndUpdateEtaDataForExistingStopsForSystem"),
|
||||
};
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
spy.mockResolvedValue(undefined);
|
||||
});
|
||||
|
||||
await loader.fetchAndUpdateAll();
|
||||
|
||||
Object.values(spies).forEach((spy: any) => {
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateRouteDataForSystem", () => {
|
||||
it("updates route data in repository if response received", async () => {
|
||||
// Arrange
|
||||
// Test pruning
|
||||
const routesToPrune = generateMockRoutes();
|
||||
await Promise.all(routesToPrune.map(async (route) => {
|
||||
route.systemId = systemId;
|
||||
await loader.repository.addOrUpdateRoute(route);
|
||||
}));
|
||||
|
||||
updateGlobalFetchMockJson(fetchRouteDataSuccessfulResponse);
|
||||
|
||||
// Act
|
||||
await loader.fetchAndUpdateRouteDataForSystem();
|
||||
|
||||
// Assert
|
||||
const routes = await loader.repository.getRoutes();
|
||||
|
||||
expect(routes.length).toEqual(fetchRouteDataSuccessfulResponse.all.length)
|
||||
});
|
||||
|
||||
it("throws the correct error if the API response contains no data", async () => {
|
||||
// The Passio API returns some invalid JSON if there is no data,
|
||||
// so simulate a JSON parsing error
|
||||
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError();
|
||||
|
||||
await assertAsyncCallbackThrowsApiResponseError(async () => {
|
||||
await loader.fetchAndUpdateRouteDataForSystem();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateStopAndPolylineDataForRoutesWithSystemId", () => {
|
||||
it("updates stop and polyline data if response received", async () => {
|
||||
// Arrange
|
||||
// Test pruning of stops only
|
||||
const stopsToPrune = generateMockStops();
|
||||
await Promise.all(stopsToPrune.map(async (stop) => {
|
||||
stop.systemId = systemId;
|
||||
await loader.repository.addOrUpdateStop(stop);
|
||||
}));
|
||||
|
||||
updateGlobalFetchMockJson(fetchStopAndPolylineDataSuccessfulResponse);
|
||||
|
||||
const stopsArray = Object.values(fetchStopAndPolylineDataSuccessfulResponse.stops);
|
||||
|
||||
await loader.fetchAndUpdateStopAndPolylineDataForRoutesInSystem();
|
||||
|
||||
const stops = await loader.repository.getStops();
|
||||
expect(stops.length).toEqual(stopsArray.length);
|
||||
|
||||
await Promise.all(stops.map(async (stop) => {
|
||||
const orderedStops = await loader.repository.getOrderedStopsByStopId(stop.id)
|
||||
expect(orderedStops.length).toBeGreaterThan(0);
|
||||
}));
|
||||
|
||||
const routes = await loader.repository.getRoutes();
|
||||
routes.forEach((route) => {
|
||||
expect(route.polylineCoordinates.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
it("throws the correct error if the API response contains no data", async () => {
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError();
|
||||
|
||||
await assertAsyncCallbackThrowsApiResponseError(async () => {
|
||||
await loader.fetchAndUpdateStopAndPolylineDataForRoutesInSystem();
|
||||
});
|
||||
})
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateShuttleDataForSystem", () => {
|
||||
it("updates shuttle data in repository if response received", async () => {
|
||||
const shuttlesToPrune = generateMockShuttles();
|
||||
await Promise.all(shuttlesToPrune.map(async (shuttle) => {
|
||||
shuttle.systemId = systemId;
|
||||
await loader.repository.addOrUpdateShuttle(shuttle);
|
||||
}))
|
||||
|
||||
updateGlobalFetchMockJson(fetchShuttleDataSuccessfulResponse);
|
||||
const busesInResponse = Object.values(fetchShuttleDataSuccessfulResponse.buses);
|
||||
|
||||
await loader.fetchAndUpdateShuttleDataForSystem();
|
||||
|
||||
const shuttles = await loader.repository.getShuttles();
|
||||
|
||||
expect(shuttles.length).toEqual(busesInResponse.length);
|
||||
});
|
||||
|
||||
it("throws the correct error if the API response contains no data", async () => {
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError();
|
||||
|
||||
await assertAsyncCallbackThrowsApiResponseError(async () => {
|
||||
await loader.fetchAndUpdateShuttleDataForSystem();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateEtaDataForExistingStopsForSystem", () => {
|
||||
it("calls fetchAndUpdateEtaDataForStopId for every stop in repository", async () => {
|
||||
const spy = jest.spyOn(loader, "fetchAndUpdateEtaDataForStopId");
|
||||
|
||||
const stops = generateMockStops();
|
||||
stops.forEach((stop) => {
|
||||
stop.systemId = "1";
|
||||
});
|
||||
|
||||
await Promise.all(stops.map(async (stop) => {
|
||||
await loader.repository.addOrUpdateStop(stop);
|
||||
}));
|
||||
|
||||
await loader.fetchAndUpdateEtaDataForExistingStopsForSystem();
|
||||
|
||||
expect(spy.mock.calls.length).toEqual(stops.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("fetchAndUpdateEtaDataForStopId", () => {
|
||||
const stopId = "177666";
|
||||
it("updates ETA data for stop id if response received", async () => {
|
||||
updateGlobalFetchMockJson(fetchEtaDataSuccessfulResponse);
|
||||
// @ts-ignore
|
||||
const etasFromResponse = fetchEtaDataSuccessfulResponse.ETAs[stopId]
|
||||
|
||||
await loader.fetchAndUpdateEtaDataForStopId(stopId);
|
||||
|
||||
const etas = await loader.repository.getEtasForStopId(stopId);
|
||||
expect(etas.length).toEqual(etasFromResponse.length);
|
||||
});
|
||||
|
||||
it("throws the correct error if the API response contains no data", async () => {
|
||||
updateGlobalFetchMockJsonToThrowSyntaxError();
|
||||
|
||||
await assertAsyncCallbackThrowsApiResponseError(async () => {
|
||||
await loader.fetchAndUpdateEtaDataForStopId("263");
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
import { beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { ETANotificationScheduler } from "../ETANotificationScheduler";
|
||||
import { UnoptimizedInMemoryShuttleRepository } from "../../../repositories/shuttle/UnoptimizedInMemoryShuttleRepository";
|
||||
import { IEta, IShuttle, IStop } from "../../../entities/ShuttleRepositoryEntities";
|
||||
import { addMockShuttleToRepository, addMockStopToRepository } from "../../../../test/testHelpers/repositorySetupHelpers";
|
||||
import { AppleNotificationSender } from "../../senders/AppleNotificationSender";
|
||||
import { InMemoryNotificationRepository } from "../../../repositories/notifications/InMemoryNotificationRepository";
|
||||
import { NotificationRepository } from "../../../repositories/notifications/NotificationRepository";
|
||||
|
||||
jest.mock("http2");
|
||||
jest.mock("../../senders/AppleNotificationSender");
|
||||
|
||||
const MockAppleNotificationSender = AppleNotificationSender as jest.MockedClass<typeof AppleNotificationSender>;
|
||||
|
||||
function mockNotificationSenderMethods(shouldSimulateNotificationSend: boolean) {
|
||||
MockAppleNotificationSender.prototype.sendNotificationImmediately = jest.fn(async () => shouldSimulateNotificationSend);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for a specified number of milliseconds.
|
||||
* @param ms
|
||||
*/
|
||||
async function waitForMilliseconds(ms: number): Promise<void> {
|
||||
await new Promise((resolve) => setTimeout(resolve, ms));
|
||||
}
|
||||
|
||||
|
||||
describe("ETANotificationScheduler", () => {
|
||||
let shuttleRepository: UnoptimizedInMemoryShuttleRepository
|
||||
let notificationService: ETANotificationScheduler;
|
||||
let notificationRepository: NotificationRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
shuttleRepository = new UnoptimizedInMemoryShuttleRepository();
|
||||
notificationRepository = new InMemoryNotificationRepository();
|
||||
|
||||
mockNotificationSenderMethods(true);
|
||||
|
||||
const appleNotificationSender = new MockAppleNotificationSender(false);
|
||||
notificationService = new ETANotificationScheduler(
|
||||
shuttleRepository,
|
||||
notificationRepository,
|
||||
appleNotificationSender,
|
||||
"1",
|
||||
);
|
||||
notificationService.startListeningForUpdates();
|
||||
});
|
||||
|
||||
function generateNotificationDataAndEta(shuttle: IShuttle, stop: IStop) {
|
||||
const eta: IEta = {
|
||||
shuttleId: shuttle.id,
|
||||
stopId: stop.id,
|
||||
secondsRemaining: 120,
|
||||
systemId: "1",
|
||||
updatedTime: new Date(),
|
||||
};
|
||||
|
||||
const notificationData1 = {
|
||||
deviceId: "1",
|
||||
shuttleId: eta.shuttleId,
|
||||
stopId: eta.stopId,
|
||||
secondsThreshold: 240,
|
||||
}
|
||||
const notificationData2 = {
|
||||
...notificationData1,
|
||||
deviceId: "2",
|
||||
secondsThreshold: 180,
|
||||
}
|
||||
return { eta, notificationData1, notificationData2 };
|
||||
}
|
||||
|
||||
describe("etaSubscriberCallback", () => {
|
||||
it("sends and clears correct notification after ETA changed", async () => {
|
||||
// Arrange
|
||||
const shuttle = await addMockShuttleToRepository(shuttleRepository, "1");
|
||||
const stop = await addMockStopToRepository(shuttleRepository, "1");
|
||||
|
||||
const { eta, notificationData1, notificationData2 } = generateNotificationDataAndEta(shuttle, stop);
|
||||
|
||||
// Act
|
||||
await notificationRepository.addOrUpdateNotification(notificationData1);
|
||||
await notificationRepository.addOrUpdateNotification(notificationData2);
|
||||
await shuttleRepository.addOrUpdateEta(eta);
|
||||
|
||||
// Assert
|
||||
// Wait for the callback to actually be called
|
||||
await waitForMilliseconds(1000);
|
||||
|
||||
const isFirstNotificationScheduled = await notificationRepository.isNotificationScheduled(notificationData1);
|
||||
const isSecondNotificationScheduled = await notificationRepository.isNotificationScheduled(notificationData2);
|
||||
|
||||
// No longer scheduled after being sent
|
||||
expect(isFirstNotificationScheduled).toBe(false);
|
||||
expect(isSecondNotificationScheduled).toBe(false);
|
||||
});
|
||||
|
||||
it("doesn't send notification if seconds threshold not exceeded", async () => {
|
||||
// Arrange
|
||||
const shuttle = await addMockShuttleToRepository(shuttleRepository, "1");
|
||||
const stop = await addMockStopToRepository(shuttleRepository, "1");
|
||||
const { eta, notificationData1 } = generateNotificationDataAndEta(shuttle, stop);
|
||||
notificationData1.secondsThreshold = eta.secondsRemaining - 10;
|
||||
|
||||
// Act
|
||||
await notificationRepository.addOrUpdateNotification(notificationData1);
|
||||
await shuttleRepository.addOrUpdateEta(eta);
|
||||
|
||||
// Assert
|
||||
await waitForMilliseconds(500);
|
||||
const isNotificationScheduled = await notificationRepository.isNotificationScheduled(notificationData1);
|
||||
expect(isNotificationScheduled).toBe(true);
|
||||
});
|
||||
|
||||
it("leaves notification in array if delivery unsuccessful", async () => {
|
||||
// Arrange
|
||||
const shuttle = await addMockShuttleToRepository(shuttleRepository, "1");
|
||||
const stop = await addMockStopToRepository(shuttleRepository, "1");
|
||||
const { eta, notificationData1 } = generateNotificationDataAndEta(shuttle, stop)
|
||||
|
||||
// replace the old notification scheduler with a new one
|
||||
// detach the old callback method from the shuttle repo
|
||||
notificationService.stopListeningForUpdates();
|
||||
|
||||
// replace the notification repository with a fresh one too
|
||||
const notificationRepository = new InMemoryNotificationRepository();
|
||||
|
||||
mockNotificationSenderMethods(false);
|
||||
const updatedNotificationSender = new MockAppleNotificationSender(false);
|
||||
notificationService = new ETANotificationScheduler(
|
||||
shuttleRepository,
|
||||
notificationRepository,
|
||||
updatedNotificationSender,
|
||||
"1",
|
||||
);
|
||||
notificationService.startListeningForUpdates();
|
||||
|
||||
// Act
|
||||
await notificationRepository.addOrUpdateNotification(notificationData1);
|
||||
await shuttleRepository.addOrUpdateEta(eta);
|
||||
|
||||
// Assert
|
||||
// The notification should stay scheduled to be retried once
|
||||
// the ETA updates again
|
||||
await waitForMilliseconds(500);
|
||||
const isNotificationScheduled = await notificationRepository.isNotificationScheduled(notificationData1);
|
||||
expect(isNotificationScheduled).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,190 @@
|
||||
import { beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import http2 from "http2";
|
||||
import { EventEmitter } from "node:events";
|
||||
import {
|
||||
AppleNotificationSender,
|
||||
NotificationAlertArguments
|
||||
} from "../AppleNotificationSender";
|
||||
import { ClientHttp2Session } from "node:http2";
|
||||
|
||||
jest.mock("http2");
|
||||
|
||||
const sampleKeyBase64 = "LS0tLS1CRUdJTiBQUklWQVRFIEtFWS0tLS0tCk1JR1RBZ0VBTUJNR0J5cUdTTTQ5QWdFR0NDcUdTTTQ5QXdFSEJIa3dkd0lCQVFRZ3NybVNBWklhZ09mQ1A4c0IKV2kyQ0JYRzFPbzd2MWJpc3BJWkN3SXI0UkRlZ0NnWUlLb1pJemowREFRZWhSQU5DQUFUWkh4VjJ3UUpMTUJxKwp5YSt5ZkdpM2cyWlV2NmhyZmUrajA4eXRla1BIalhTMHF6Sm9WRUx6S0hhNkVMOVlBb1pEWEJ0QjZoK2ZHaFhlClNPY09OYmFmCi0tLS0tRU5EIFBSSVZBVEUgS0VZLS0tLS0K";
|
||||
|
||||
class MockClient extends EventEmitter {
|
||||
constructor(
|
||||
private status: number,
|
||||
) {
|
||||
super()
|
||||
}
|
||||
|
||||
request = jest.fn((_) => {
|
||||
const mockRequest: any = new EventEmitter();
|
||||
mockRequest.setEncoding = jest.fn();
|
||||
mockRequest.write = jest.fn();
|
||||
mockRequest.end = jest.fn(() => {
|
||||
setTimeout(() => {
|
||||
mockRequest.emit('response', { ':status': this.status });
|
||||
}, 10);
|
||||
});
|
||||
return mockRequest;
|
||||
});
|
||||
|
||||
close = jest.fn(() => {});
|
||||
}
|
||||
|
||||
function mockHttp2Connect(status: number) {
|
||||
(http2.connect as jest.Mock) = jest.fn(() => new MockClient(status));
|
||||
}
|
||||
|
||||
describe("AppleNotificationSender", () => {
|
||||
let notificationSender: AppleNotificationSender;
|
||||
|
||||
beforeEach(() => {
|
||||
notificationSender = new AppleNotificationSender();
|
||||
|
||||
// Ensure that tests don't hit the server
|
||||
process.env = {
|
||||
...process.env,
|
||||
APNS_KEY_ID: "1",
|
||||
APNS_TEAM_ID: "1",
|
||||
APNS_BUNDLE_ID: "dev.bchen.ProjectInter",
|
||||
APNS_PRIVATE_KEY: sampleKeyBase64,
|
||||
};
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
mockHttp2Connect(200);
|
||||
});
|
||||
|
||||
describe("reloadAPNsTokenIfTimePassed", () => {
|
||||
it("reloads the token if token hasn't been generated yet", async () => {
|
||||
notificationSender.reloadAPNsTokenIfTimePassed();
|
||||
expect(notificationSender.lastRefreshedTimeMs).toBeDefined();
|
||||
});
|
||||
|
||||
it("doesn't reload the token if last refreshed time is recent", async () => {
|
||||
notificationSender.reloadAPNsTokenIfTimePassed();
|
||||
const lastRefreshedTimeMs = notificationSender.lastRefreshedTimeMs;
|
||||
|
||||
notificationSender.reloadAPNsTokenIfTimePassed();
|
||||
// Expect no change to have occurred
|
||||
expect(lastRefreshedTimeMs).toEqual(notificationSender.lastRefreshedTimeMs);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getAPNsFullUrlToUse', () => {
|
||||
it('should return the production URL when APNS_IS_PRODUCTION is set to "1"', () => {
|
||||
process.env.APNS_IS_PRODUCTION = "1";
|
||||
const deviceId = 'testDeviceId';
|
||||
const result = AppleNotificationSender.getAPNsFullUrlToUse(deviceId);
|
||||
|
||||
const { fullUrl, host, path } = result;
|
||||
expect(fullUrl).toBe(`https://api.push.apple.com/3/device/${deviceId}`);
|
||||
expect(host).toBe("https://api.push.apple.com");
|
||||
expect(path).toBe(`/3/device/${deviceId}`);
|
||||
});
|
||||
|
||||
it('should return the sandbox URL when APNS_IS_PRODUCTION is set to something other than 1', () => {
|
||||
process.env.APNS_IS_PRODUCTION = "0";
|
||||
const deviceId = 'testDeviceId';
|
||||
const result = AppleNotificationSender.getAPNsFullUrlToUse(deviceId);
|
||||
|
||||
const { fullUrl, host, path } = result;
|
||||
expect(fullUrl).toBe(`https://api.development.push.apple.com/3/device/${deviceId}`);
|
||||
expect(host).toBe("https://api.development.push.apple.com");
|
||||
expect(path).toBe(`/3/device/${deviceId}`);
|
||||
});
|
||||
});
|
||||
|
||||
describe("sendNotificationImmediately", () => {
|
||||
it('makes the connection to the http server if sending a notification for the first time', async () => {
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: 'This notification will send',
|
||||
}
|
||||
|
||||
const result = await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
|
||||
expect(http2.connect).toHaveBeenCalled();
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('reuses the existing connection if sending another notification', async () => {
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: 'This notification will send',
|
||||
}
|
||||
|
||||
const result1 = await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
const result2 = await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
|
||||
expect(http2.connect).toHaveBeenCalledTimes(1);
|
||||
expect(result1).toBe(true);
|
||||
expect(result2).toBe(true);
|
||||
});
|
||||
|
||||
it('throws an error if the bundle ID is not set correctly', async () => {
|
||||
process.env = {
|
||||
...process.env,
|
||||
APNS_BUNDLE_ID: undefined,
|
||||
}
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: 'This notification will not send',
|
||||
}
|
||||
|
||||
await expect(async () => {
|
||||
await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
}).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('returns false if there is an error sending the notification', async () => {
|
||||
mockHttp2Connect(403);
|
||||
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: 'This notification will not send',
|
||||
}
|
||||
|
||||
const result = await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
|
||||
expect(http2.connect).toHaveBeenCalled();
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
it('does not send notification if shouldActuallySendNotifications is false', async () => {
|
||||
notificationSender = new AppleNotificationSender(false);
|
||||
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: 'This notification should not send',
|
||||
}
|
||||
|
||||
const result = await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
|
||||
expect(http2.connect).not.toHaveBeenCalled();
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it("registers a handler to close the connection if `close` event fired", async () => {
|
||||
const connectionCloseEvents = ['close', 'goaway', 'error', 'timeout'];
|
||||
|
||||
await Promise.all(connectionCloseEvents.map(async (event) => {
|
||||
const mockClient = new MockClient(200);
|
||||
notificationSender = new AppleNotificationSender(true, mockClient as unknown as ClientHttp2Session);
|
||||
|
||||
const notificationArguments: NotificationAlertArguments = {
|
||||
title: 'Test notification',
|
||||
body: ''
|
||||
};
|
||||
|
||||
await notificationSender.sendNotificationImmediately('1', notificationArguments);
|
||||
|
||||
mockClient.emit(event);
|
||||
|
||||
expect(mockClient.close).toHaveBeenCalled();
|
||||
}));
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,213 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { InMemoryNotificationRepository } from "../InMemoryNotificationRepository";
|
||||
import { NotificationEvent, NotificationRepository } from "../NotificationRepository";
|
||||
import { RedisNotificationRepository } from "../RedisNotificationRepository";
|
||||
|
||||
interface RepositoryHolder {
|
||||
name: string;
|
||||
factory(): Promise<NotificationRepository>,
|
||||
teardown(): Promise<void>,
|
||||
}
|
||||
|
||||
class InMemoryRepositoryHolder implements RepositoryHolder {
|
||||
name = 'InMemoryNotificationRepository';
|
||||
factory = async () => {
|
||||
return new InMemoryNotificationRepository();
|
||||
}
|
||||
teardown = async () => {}
|
||||
}
|
||||
|
||||
class RedisNotificationRepositoryHolder implements RepositoryHolder {
|
||||
repo: RedisNotificationRepository | undefined;
|
||||
|
||||
name = 'RedisNotificationRepository';
|
||||
factory = async () => {
|
||||
this.repo = new RedisNotificationRepository();
|
||||
await this.repo.connect();
|
||||
return this.repo;
|
||||
}
|
||||
teardown = async () => {
|
||||
if (this.repo) {
|
||||
await this.repo.clearAllData();
|
||||
await this.repo.disconnect();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const repositoryImplementations = [
|
||||
new InMemoryRepositoryHolder(),
|
||||
new RedisNotificationRepositoryHolder(),
|
||||
]
|
||||
|
||||
describe.each(repositoryImplementations)('$name', (holder) => {
|
||||
let repo: NotificationRepository;
|
||||
|
||||
beforeEach(async () => {
|
||||
repo = await holder.factory();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await holder.teardown();
|
||||
})
|
||||
|
||||
const notification = {
|
||||
deviceId: "device1",
|
||||
shuttleId: "shuttle1",
|
||||
stopId: "stop1",
|
||||
secondsThreshold: 180
|
||||
};
|
||||
|
||||
describe("getAllNotificationsForShuttleAndStopId", () => {
|
||||
it("gets notifications correctly", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
const result = await repo.getAllNotificationsForShuttleAndStopId("shuttle1", "stop1");
|
||||
expect(result).toHaveLength(1);
|
||||
expect(result[0]).toEqual(notification);
|
||||
});
|
||||
|
||||
it("returns empty array if no notifications", async () => {
|
||||
const result = await repo.getAllNotificationsForShuttleAndStopId("shuttle1", "stop1");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getSecondsThresholdForNotificationIfExists", () => {
|
||||
it("gets the seconds threshold if exists", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
const result = await repo.getSecondsThresholdForNotificationIfExists({
|
||||
deviceId: "device1",
|
||||
shuttleId: "shuttle1",
|
||||
stopId: "stop1"
|
||||
});
|
||||
expect(result).toBe(180);
|
||||
});
|
||||
|
||||
it("returns null if there is no seconds threshold", async () => {
|
||||
const result = await repo.getSecondsThresholdForNotificationIfExists({
|
||||
deviceId: "device1",
|
||||
shuttleId: "shuttle1",
|
||||
stopId: "stop1"
|
||||
});
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateNotification", () => {
|
||||
// Add/get flow is covered in getAllNotificationsForShuttleAndStopId
|
||||
|
||||
it("updates the seconds threshold if the notification exists already", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
await repo.addOrUpdateNotification({...notification, secondsThreshold: 300});
|
||||
|
||||
const result = await repo.getSecondsThresholdForNotificationIfExists({
|
||||
deviceId: "device1",
|
||||
shuttleId: "shuttle1",
|
||||
stopId: "stop1"
|
||||
});
|
||||
expect(result).toBe(300);
|
||||
});
|
||||
});
|
||||
|
||||
describe("deleteNotificationIfExists", () => {
|
||||
it("deletes the notification", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
await repo.deleteNotificationIfExists(notification);
|
||||
|
||||
const result = await repo.getAllNotificationsForShuttleAndStopId("shuttle1", "stop1");
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
|
||||
|
||||
it("does nothing if there's no notification", async () => {
|
||||
await expect(repo.deleteNotificationIfExists({
|
||||
deviceId: "device1",
|
||||
shuttleId: "shuttle1",
|
||||
stopId: "stop1"
|
||||
})).resolves.not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("subscribeToNotificationChanges", () => {
|
||||
it("calls subscribers when something is added", async () => {
|
||||
const mockCallback = jest.fn();
|
||||
repo.subscribeToNotificationChanges(mockCallback);
|
||||
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
const expectedEvent: NotificationEvent = {
|
||||
event: 'addOrUpdate',
|
||||
notification,
|
||||
}
|
||||
expect(mockCallback).toHaveBeenCalledTimes(1);
|
||||
expect(mockCallback).toHaveBeenCalledWith(expectedEvent);
|
||||
});
|
||||
|
||||
it("calls subscribers when something is updated", async () => {
|
||||
const mockCallback = jest.fn();
|
||||
repo.subscribeToNotificationChanges(mockCallback);
|
||||
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
const updatedNotification = {
|
||||
...notification,
|
||||
secondsThreshold: notification.secondsThreshold + 60,
|
||||
};
|
||||
|
||||
await repo.addOrUpdateNotification(updatedNotification);
|
||||
|
||||
const expectedEvent: NotificationEvent = {
|
||||
event: 'addOrUpdate',
|
||||
notification,
|
||||
}
|
||||
expect(mockCallback).toHaveBeenCalledTimes(2);
|
||||
expect(mockCallback).toHaveBeenCalledWith(expectedEvent);
|
||||
});
|
||||
|
||||
it("calls subscribers when something is deleted", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
const mockCallback = jest.fn();
|
||||
repo.subscribeToNotificationChanges(mockCallback);
|
||||
|
||||
await repo.deleteNotificationIfExists(notification);
|
||||
|
||||
expect(mockCallback).toHaveBeenCalledTimes(1);
|
||||
|
||||
const expectedEvent: NotificationEvent = {
|
||||
event: 'delete',
|
||||
notification,
|
||||
};
|
||||
expect(mockCallback).toHaveBeenCalledWith(expectedEvent);
|
||||
});
|
||||
});
|
||||
|
||||
describe("unsubscribeFromNotificationChanges", () => {
|
||||
it("stops calling subscribers when unsubscribed", async () => {
|
||||
const mockCallback = jest.fn();
|
||||
repo.subscribeToNotificationChanges(mockCallback);
|
||||
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
|
||||
repo.unsubscribeFromNotificationChanges(mockCallback);
|
||||
|
||||
await repo.deleteNotificationIfExists(notification);
|
||||
|
||||
expect(mockCallback).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("isNotificationScheduled", () => {
|
||||
it("returns true if the notification is in the repo", async () => {
|
||||
await repo.addOrUpdateNotification(notification);
|
||||
const result = await repo.isNotificationScheduled(notification);
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it("returns false if the notification isn't in the repo", async () => {
|
||||
const result = await repo.isNotificationScheduled(notification);
|
||||
expect(result).toBe(false);
|
||||
})
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,205 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { InMemoryParkingRepository, } from "../InMemoryParkingRepository";
|
||||
import { IParkingStructure } from "../../../entities/ParkingRepositoryEntities";
|
||||
import { HistoricalParkingAverageQueryArguments } from "../ParkingGetterRepository";
|
||||
import { ParkingGetterSetterRepository } from "../ParkingGetterSetterRepository";
|
||||
import { RedisParkingRepository } from "../RedisParkingRepository";
|
||||
|
||||
interface RepositoryHolder {
|
||||
name: string;
|
||||
factory(): Promise<ParkingGetterSetterRepository>;
|
||||
teardown(): Promise<void>;
|
||||
}
|
||||
|
||||
class InMemoryParkingRepositoryHolder implements RepositoryHolder {
|
||||
name = 'InMemoryParkingRepository';
|
||||
factory = async () => {
|
||||
return new InMemoryParkingRepository();
|
||||
};
|
||||
teardown = async () => {};
|
||||
}
|
||||
|
||||
class RedisParkingRepositoryHolder implements RepositoryHolder {
|
||||
repo: RedisParkingRepository | undefined;
|
||||
|
||||
name = 'RedisParkingRepository';
|
||||
factory = async () => {
|
||||
this.repo = new RedisParkingRepository();
|
||||
await this.repo.connect();
|
||||
return this.repo;
|
||||
};
|
||||
teardown = async () => {
|
||||
if (this.repo) {
|
||||
await this.repo.clearAllData();
|
||||
await this.repo.disconnect();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const repositoryImplementations = [
|
||||
new InMemoryParkingRepositoryHolder(),
|
||||
new RedisParkingRepositoryHolder(),
|
||||
];
|
||||
|
||||
describe.each(repositoryImplementations)('$name', (holder) => {
|
||||
let repository: ParkingGetterSetterRepository;
|
||||
const testStructure: IParkingStructure = {
|
||||
coordinates: {
|
||||
latitude: 33.794795,
|
||||
longitude: -117.850807,
|
||||
},
|
||||
spotsAvailable: 0,
|
||||
id: "1",
|
||||
name: "Anderson Parking Structure",
|
||||
capacity: 100,
|
||||
address: "300 E Walnut Ave, Orange, CA 92867",
|
||||
updatedTime: new Date(),
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
repository = await holder.factory();
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await holder.teardown();
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
describe("addOrUpdateParkingStructure", () => {
|
||||
it("should add a new parking structure", async () => {
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
const result = await repository.getParkingStructureById(testStructure.id);
|
||||
expect(result).toEqual(testStructure);
|
||||
});
|
||||
|
||||
it("should update existing parking structure", async () => {
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
const updatedStructure = { ...testStructure, name: "Updated Garage" };
|
||||
await repository.addOrUpdateParkingStructure(updatedStructure);
|
||||
const result = await repository.getParkingStructureById(testStructure.id);
|
||||
expect(result).toEqual(updatedStructure);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeParkingStructureIfExists", () => {
|
||||
it("should remove existing parking structure and return it", async () => {
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
const removed = await repository.removeParkingStructureIfExists(testStructure.id);
|
||||
expect(removed).toEqual(testStructure);
|
||||
const result = await repository.getParkingStructureById(testStructure.id);
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("should return null when removing non-existent structure", async () => {
|
||||
const result = await repository.removeParkingStructureIfExists("non-existent");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearParkingStructureData", () => {
|
||||
it("should remove all parking structures", async () => {
|
||||
const structures = [
|
||||
testStructure,
|
||||
{ ...testStructure, id: "test-id-2", name: "Second Garage" }
|
||||
];
|
||||
|
||||
for (const structure of structures) {
|
||||
await repository.addOrUpdateParkingStructure(structure);
|
||||
}
|
||||
|
||||
await repository.clearParkingStructureData();
|
||||
const result = await repository.getParkingStructures();
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getParkingStructures", () => {
|
||||
it("should return empty array when no structures exist", async () => {
|
||||
const result = await repository.getParkingStructures();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
|
||||
it("should return all added structures", async () => {
|
||||
const structures = [
|
||||
testStructure,
|
||||
{ ...testStructure, id: "test-id-2", name: "Second Garage" }
|
||||
];
|
||||
|
||||
for (const structure of structures) {
|
||||
await repository.addOrUpdateParkingStructure(structure);
|
||||
}
|
||||
|
||||
const result = await repository.getParkingStructures();
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result).toEqual(expect.arrayContaining(structures));
|
||||
});
|
||||
});
|
||||
|
||||
describe("getParkingStructureById", () => {
|
||||
it("should return null for non-existent structure", async () => {
|
||||
const result = await repository.getParkingStructureById("non-existent");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it("should return structure by id", async () => {
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
const result = await repository.getParkingStructureById(testStructure.id);
|
||||
expect(result).toEqual(testStructure);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getHistoricalAveragesOfParkingStructureCounts", () => {
|
||||
it("should return empty array for non-existent structure or no data", async () => {
|
||||
const options: HistoricalParkingAverageQueryArguments = {
|
||||
from: new Date(1000),
|
||||
to: new Date(2000),
|
||||
intervalMs: 500
|
||||
};
|
||||
|
||||
expect(await repository.getHistoricalAveragesOfParkingStructureCounts("non-existent", options)).toEqual([]);
|
||||
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
expect(await repository.getHistoricalAveragesOfParkingStructureCounts(testStructure.id, options)).toEqual([]);
|
||||
});
|
||||
|
||||
it("should calculate average for one single large interval", async () => {
|
||||
// Set logging interval to 0 so every update creates historical data
|
||||
repository.setLoggingInterval(0);
|
||||
|
||||
await repository.addOrUpdateParkingStructure(testStructure);
|
||||
|
||||
const updates = [
|
||||
{ ...testStructure, spotsAvailable: 80, updatedTime: new Date() },
|
||||
{ ...testStructure, spotsAvailable: 70, updatedTime: new Date() },
|
||||
{ ...testStructure, spotsAvailable: 60, updatedTime: new Date() },
|
||||
];
|
||||
|
||||
for (let i = 0; i < updates.length; i++) {
|
||||
// Ensure that different timestamps are created, even after adding the first test structure
|
||||
await new Promise((resolve) => setTimeout(resolve, 200));
|
||||
await repository.addOrUpdateParkingStructure(updates[i]);
|
||||
}
|
||||
|
||||
const now = Date.now();
|
||||
const options: HistoricalParkingAverageQueryArguments = {
|
||||
from: new Date(now - 10000), // Look back 10 seconds
|
||||
to: new Date(now + 10000), // Look forward 10 seconds
|
||||
intervalMs: 20000 // Single large interval
|
||||
};
|
||||
|
||||
const result = await repository.getHistoricalAveragesOfParkingStructureCounts(testStructure.id, options);
|
||||
|
||||
// Should have at least some historical data
|
||||
expect(result.length).toEqual(1);
|
||||
if (result.length > 0) {
|
||||
expect(result[0]).toHaveProperty('from');
|
||||
expect(result[0]).toHaveProperty('to');
|
||||
expect(result[0].from).toBeInstanceOf(Date);
|
||||
expect(result[0].to).toBeInstanceOf(Date);
|
||||
expect(result[0]).toHaveProperty('averageSpotsAvailable');
|
||||
expect(result[0].averageSpotsAvailable).toBeCloseTo(52.5);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,643 @@
|
||||
import { beforeEach, describe, expect, jest, test } from "@jest/globals";
|
||||
import { UnoptimizedInMemoryShuttleRepository } from "../UnoptimizedInMemoryShuttleRepository";
|
||||
import {
|
||||
generateMockEtas,
|
||||
generateMockOrderedStops,
|
||||
generateMockRoutes,
|
||||
generateMockShuttles,
|
||||
generateMockStops,
|
||||
} from "../../../../test/testHelpers/mockDataGenerators";
|
||||
|
||||
// For repositories created in the future, reuse core testing
|
||||
// logic from here and differentiate setup (e.g. creating mocks)
|
||||
// Do this by creating a function which takes a ShuttleGetterRepository
|
||||
// or ShuttleGetterSetterRepository instance
|
||||
|
||||
describe("UnoptimizedInMemoryRepository", () => {
|
||||
let repository: UnoptimizedInMemoryShuttleRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
repository = new UnoptimizedInMemoryShuttleRepository();
|
||||
});
|
||||
|
||||
describe("getStops", () => {
|
||||
test("gets all stops in the repository", async () => {
|
||||
const mockStops = generateMockStops();
|
||||
for (const stop of mockStops) {
|
||||
await repository.addOrUpdateStop(stop);
|
||||
}
|
||||
|
||||
const result = await repository.getStops();
|
||||
expect(result).toEqual(mockStops);
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no stops for the given system ID", async () => {
|
||||
const result = await repository.getStops();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getStopById", () => {
|
||||
test("gets a stop by ID if it exists", async () => {
|
||||
const mockStops = generateMockStops();
|
||||
const mockStop = mockStops[0];
|
||||
await repository.addOrUpdateStop(mockStop);
|
||||
|
||||
const result = await repository.getStopById("st1");
|
||||
expect(result).toEqual(mockStop);
|
||||
});
|
||||
|
||||
test("returns null if the stop does not exist", async () => {
|
||||
const result = await repository.getStopById("nonexistent-stop");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("getRoutes", () => {
|
||||
test("gets all routes for a specific system ID", async () => {
|
||||
const mockRoutes = generateMockRoutes();
|
||||
for (const route of mockRoutes) {
|
||||
await repository.addOrUpdateRoute(route);
|
||||
}
|
||||
|
||||
const result = await repository.getRoutes();
|
||||
expect(result).toEqual(mockRoutes);
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no routes for the system ID", async () => {
|
||||
const result = await repository.getRoutes();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getRouteById", () => {
|
||||
test("gets a route by ID if it exists", async () => {
|
||||
const mockRoutes = generateMockRoutes();
|
||||
const mockRoute = mockRoutes[0];
|
||||
await repository.addOrUpdateRoute(mockRoute);
|
||||
|
||||
const result = await repository.getRouteById("r1");
|
||||
expect(result).toEqual(mockRoute);
|
||||
});
|
||||
|
||||
test("returns null if the route does not exist", async () => {
|
||||
const result = await repository.getRouteById("nonexistent-route");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
describe("getShuttles", () => {
|
||||
test("gets all shuttles for a specific system ID", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
for (const shuttle of mockShuttles) {
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}
|
||||
|
||||
const result = await repository.getShuttles();
|
||||
expect(result).toEqual(mockShuttles);
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no shuttles for the system ID", async () => {
|
||||
const result = await repository.getShuttles();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getShuttlesByRouteId", () => {
|
||||
test("gets all shuttles for a specific route ID", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
for (const shuttle of mockShuttles) {
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}
|
||||
|
||||
const result = await repository.getShuttlesByRouteId("r1");
|
||||
expect(result).toEqual(mockShuttles.filter((sh) => sh.routeId === "r1"));
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no shuttles for the route ID", async () => {
|
||||
const result = await repository.getShuttlesByRouteId("nonexistent-route");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getShuttleById", () => {
|
||||
test("gets a shuttle by ID if it exists", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
for (const shuttle of mockShuttles) {
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}
|
||||
|
||||
const result = await repository.getShuttleById("sh2");
|
||||
expect(result).toEqual(mockShuttles[1]);
|
||||
});
|
||||
|
||||
test("returns null if the shuttle doesn't exist", async () => {
|
||||
const result = await repository.getShuttleById("nonexistent-id");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("getEtasForShuttleId", () => {
|
||||
test("gets ETAs for a specific shuttle ID", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
for (const eta of mockEtas) {
|
||||
await repository.addOrUpdateEta(eta);
|
||||
}
|
||||
|
||||
const result = await repository.getEtasForShuttleId("sh1");
|
||||
expect(result).toEqual(mockEtas.filter((eta) => eta.shuttleId === "sh1"));
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no ETAs for the shuttle ID", async () => {
|
||||
const result = await repository.getEtasForShuttleId("nonexistent-shuttle");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getEtasForStopId", () => {
|
||||
test("gets ETAs for a specific stop ID", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
for (const eta of mockEtas) {
|
||||
await repository.addOrUpdateEta(eta);
|
||||
}
|
||||
|
||||
const result = await repository.getEtasForStopId("st1");
|
||||
expect(result).toEqual(mockEtas.filter((eta) => eta.stopId === "st1"));
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no ETAs for the stop ID", async () => {
|
||||
const result = await repository.getEtasForStopId("nonexistent-stop");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getEtaForShuttleAndStopId", () => {
|
||||
test("gets a single ETA for a specific shuttle and stop ID", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
const mockEta = mockEtas[0];
|
||||
await repository.addOrUpdateEta(mockEta);
|
||||
|
||||
const result = await repository.getEtaForShuttleAndStopId("sh1", "st1");
|
||||
expect(result).toEqual(mockEta);
|
||||
});
|
||||
|
||||
test("returns null if no ETA matches the shuttle and stop ID", async () => {
|
||||
const result = await repository.getEtaForShuttleAndStopId("nonexistent-shuttle", "nonexistent-stop");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("subscribeToEtaChanges", () => {
|
||||
test("notifies listeners if etas have been added or changed", async () => {
|
||||
const mockCallback = jest.fn(); // Jest mock function to simulate a listener
|
||||
repository.subscribeToEtaUpdates(mockCallback);
|
||||
|
||||
const mockEtas = generateMockEtas();
|
||||
for (const eta of mockEtas) {
|
||||
await repository.addOrUpdateEta(eta); // Trigger changes in ETAs
|
||||
}
|
||||
|
||||
expect(mockCallback).toHaveBeenCalledTimes(mockEtas.length);
|
||||
expect(mockCallback).toHaveBeenCalledWith(mockEtas[0]); // First notification
|
||||
expect(mockCallback).toHaveBeenCalledWith(mockEtas[mockEtas.length - 1]); // Last notification
|
||||
});
|
||||
});
|
||||
|
||||
describe("unsubscribeFromEtaChanges", () => {
|
||||
test("stops notifying listeners after etas have stopped changing", async () => {
|
||||
const mockCallback = jest.fn(); // Jest mock function to simulate a listener
|
||||
repository.subscribeToEtaUpdates(mockCallback);
|
||||
|
||||
const mockEtas = generateMockEtas();
|
||||
await repository.addOrUpdateEta(mockEtas[0]);
|
||||
|
||||
repository.unsubscribeFromEtaUpdates(mockCallback);
|
||||
|
||||
await repository.addOrUpdateEta(mockEtas[mockEtas.length - 1]);
|
||||
|
||||
expect(mockCallback).toHaveBeenCalledTimes(1);
|
||||
expect(mockCallback).toHaveBeenCalledWith(mockEtas[0]); // First notification
|
||||
expect(mockCallback).not.toHaveBeenCalledWith(mockEtas[mockEtas.length - 1]); // Last notification
|
||||
});
|
||||
|
||||
test("does nothing if the listener doesn't exist", async () => {
|
||||
const mockCallback = jest.fn();
|
||||
repository.subscribeToEtaUpdates(mockCallback);
|
||||
|
||||
const mockEtas = generateMockEtas();
|
||||
|
||||
repository.unsubscribeFromEtaUpdates(() => {});
|
||||
await repository.addOrUpdateEta(mockEtas[0]);
|
||||
expect(mockCallback).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getOrderedStopByRouteAndStopId", () => {
|
||||
test("gets an ordered stop by route ID and stop ID", async () => {
|
||||
const mockOrderedStops = generateMockOrderedStops();
|
||||
for (const orderedStop of mockOrderedStops) {
|
||||
await repository.addOrUpdateOrderedStop(orderedStop);
|
||||
}
|
||||
|
||||
const mockOrderedStop = mockOrderedStops[0];
|
||||
const { routeId, stopId } = mockOrderedStop;
|
||||
|
||||
const result = await repository.getOrderedStopByRouteAndStopId(routeId, stopId);
|
||||
expect(result).toEqual(mockOrderedStop);
|
||||
});
|
||||
|
||||
test("returns null if no ordered stop matches the given route ID and stop ID", async () => {
|
||||
const result = await repository.getOrderedStopByRouteAndStopId("nonexistent-route", "nonexistent-stop");
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("getOrderedStopsByStopId", () => {
|
||||
test("gets all ordered stops for a specific stop ID", async () => {
|
||||
const mockOrderedStops = generateMockOrderedStops();
|
||||
for (const orderedStop of mockOrderedStops) {
|
||||
await repository.addOrUpdateOrderedStop(orderedStop);
|
||||
}
|
||||
|
||||
const result = await repository.getOrderedStopsByStopId("st1");
|
||||
expect(result).toEqual(mockOrderedStops.filter((os) => os.stopId === "st1"));
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no ordered stops for the stop ID", async () => {
|
||||
const result = await repository.getOrderedStopsByStopId("nonexistent-stop");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getOrderedStopsByRouteId", () => {
|
||||
test("gets all ordered stops for a specific route ID", async () => {
|
||||
const mockOrderedStops = generateMockOrderedStops();
|
||||
for (const orderedStop of mockOrderedStops) {
|
||||
await repository.addOrUpdateOrderedStop(orderedStop);
|
||||
}
|
||||
|
||||
const result = await repository.getOrderedStopsByRouteId("r1");
|
||||
expect(result).toEqual(mockOrderedStops.filter((os) => os.routeId === "r1"));
|
||||
});
|
||||
|
||||
test("returns an empty list if there are no ordered stops for the route ID", async () => {
|
||||
const result = await repository.getOrderedStopsByRouteId("nonexistent-route");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateRoute", () => {
|
||||
test("adds a new route if nonexistent", async () => {
|
||||
const mockRoutes = generateMockRoutes();
|
||||
const newRoute = mockRoutes[0];
|
||||
|
||||
await repository.addOrUpdateRoute(newRoute);
|
||||
|
||||
const result = await repository.getRoutes();
|
||||
expect(result).toEqual([newRoute]);
|
||||
});
|
||||
|
||||
test("updates an existing route if it exists", async () => {
|
||||
const mockRoutes = generateMockRoutes();
|
||||
const existingRoute = mockRoutes[0];
|
||||
const updatedRoute = structuredClone(existingRoute);
|
||||
updatedRoute.name = "Updated Route";
|
||||
|
||||
await repository.addOrUpdateRoute(existingRoute);
|
||||
await repository.addOrUpdateRoute(updatedRoute);
|
||||
|
||||
const result = await repository.getRoutes();
|
||||
expect(result).toEqual([updatedRoute]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateShuttle", () => {
|
||||
test("adds a new shuttle if nonexistent", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
const newShuttle = mockShuttles[0];
|
||||
|
||||
await repository.addOrUpdateShuttle(newShuttle);
|
||||
|
||||
const result = await repository.getShuttles();
|
||||
expect(result).toEqual([newShuttle]);
|
||||
});
|
||||
|
||||
test("updates an existing shuttle if it exists", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
const existingShuttle = mockShuttles[0];
|
||||
const updatedShuttle = structuredClone(existingShuttle);
|
||||
updatedShuttle.name = "Updated Shuttle";
|
||||
|
||||
await repository.addOrUpdateShuttle(existingShuttle);
|
||||
await repository.addOrUpdateShuttle(updatedShuttle);
|
||||
|
||||
const result = await repository.getShuttles();
|
||||
expect(result).toEqual([updatedShuttle]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateStop", () => {
|
||||
test("adds a new stop if nonexistent", async () => {
|
||||
const mockStops = generateMockStops();
|
||||
const newStop = mockStops[0];
|
||||
|
||||
await repository.addOrUpdateStop(newStop);
|
||||
|
||||
const result = await repository.getStops();
|
||||
expect(result).toEqual([newStop]);
|
||||
});
|
||||
|
||||
test("updates an existing stop if it exists", async () => {
|
||||
const mockStops = generateMockStops();
|
||||
const existingStop = mockStops[0];
|
||||
const updatedStop = structuredClone(existingStop);
|
||||
updatedStop.name = "Updated Stop";
|
||||
|
||||
await repository.addOrUpdateStop(existingStop);
|
||||
await repository.addOrUpdateStop(updatedStop);
|
||||
|
||||
const result = await repository.getStops();
|
||||
expect(result).toEqual([updatedStop]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateOrderedStop", () => {
|
||||
test("adds a new ordered stop if nonexistent", async () => {
|
||||
const mockOrderedStops = generateMockOrderedStops();
|
||||
const newOrderedStop = mockOrderedStops[0];
|
||||
|
||||
await repository.addOrUpdateOrderedStop(newOrderedStop);
|
||||
|
||||
const result = await repository.getOrderedStopsByRouteId(newOrderedStop.routeId);
|
||||
expect(result).toEqual([newOrderedStop]);
|
||||
});
|
||||
|
||||
test("updates an existing ordered stop if it exists", async () => {
|
||||
const mockOrderedStops = generateMockOrderedStops();
|
||||
const existingOrderedStop = mockOrderedStops[0];
|
||||
const updatedOrderedStop = structuredClone(existingOrderedStop);
|
||||
updatedOrderedStop.position = 5;
|
||||
|
||||
await repository.addOrUpdateOrderedStop(existingOrderedStop);
|
||||
await repository.addOrUpdateOrderedStop(updatedOrderedStop);
|
||||
|
||||
const result = await repository.getOrderedStopsByRouteId(existingOrderedStop.routeId);
|
||||
expect(result).toEqual([updatedOrderedStop]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("addOrUpdateEta", () => {
|
||||
test("adds a new ETA if nonexistent", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
const newEta = mockEtas[0];
|
||||
|
||||
await repository.addOrUpdateEta(newEta);
|
||||
|
||||
const result = await repository.getEtasForShuttleId(newEta.shuttleId);
|
||||
expect(result).toEqual([newEta]);
|
||||
});
|
||||
|
||||
test("updates an existing ETA if it exists", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
const existingEta = mockEtas[0];
|
||||
const updatedEta = structuredClone(existingEta);
|
||||
updatedEta.secondsRemaining = existingEta.secondsRemaining + 60;
|
||||
|
||||
await repository.addOrUpdateEta(existingEta);
|
||||
await repository.addOrUpdateEta(updatedEta);
|
||||
|
||||
const result = await repository.getEtasForShuttleId(existingEta.shuttleId);
|
||||
expect(result).toEqual([updatedEta]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeRouteIfExists", () => {
|
||||
test("removes route given ID", async () => {
|
||||
const systemId = "1";
|
||||
const mockRoutes = generateMockRoutes();
|
||||
await Promise.all(mockRoutes.map(async (route) => {
|
||||
route.systemId = systemId;
|
||||
await repository.addOrUpdateRoute(route);
|
||||
}));
|
||||
|
||||
const routeToRemove = mockRoutes[0];
|
||||
await repository.removeRouteIfExists(routeToRemove.id);
|
||||
|
||||
const remainingRoutes = await repository.getRoutes();
|
||||
expect(remainingRoutes).toHaveLength(mockRoutes.length - 1);
|
||||
});
|
||||
|
||||
test("does nothing if route doesn't exist", async () => {
|
||||
const systemId = "1";
|
||||
const mockRoutes = generateMockRoutes();
|
||||
await Promise.all(mockRoutes.map(async (route) => {
|
||||
route.systemId = systemId;
|
||||
await repository.addOrUpdateRoute(route);
|
||||
}));
|
||||
|
||||
await repository.removeRouteIfExists("nonexistent-id");
|
||||
|
||||
const remainingRoutes = await repository.getRoutes();
|
||||
expect(remainingRoutes).toHaveLength(mockRoutes.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeShuttleIfExists", () => {
|
||||
test("removes shuttle given ID", async () => {
|
||||
const systemId = "1";
|
||||
const mockShuttles = generateMockShuttles();
|
||||
await Promise.all(mockShuttles.map(async (shuttle) => {
|
||||
shuttle.systemId = systemId;
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}));
|
||||
|
||||
const shuttleToRemove = mockShuttles[0];
|
||||
await repository.removeShuttleIfExists(shuttleToRemove.id);
|
||||
|
||||
const remainingShuttles = await repository.getShuttles();
|
||||
expect(remainingShuttles).toHaveLength(mockShuttles.length - 1);
|
||||
});
|
||||
|
||||
test("does nothing if shuttle doesn't exist", async () => {
|
||||
const systemId = "1";
|
||||
const mockShuttles = generateMockShuttles();
|
||||
await Promise.all(mockShuttles.map(async (shuttle) => {
|
||||
shuttle.systemId = systemId;
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}));
|
||||
|
||||
await repository.removeShuttleIfExists("nonexistent-id");
|
||||
|
||||
const remainingShuttles = await repository.getShuttles();
|
||||
expect(remainingShuttles).toHaveLength(mockShuttles.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeStopIfExists", () => {
|
||||
test("removes stop given ID", async () => {
|
||||
const systemId = "1";
|
||||
const mockStops = generateMockStops();
|
||||
await Promise.all(mockStops.map(async (stop) => {
|
||||
stop.systemId = systemId;
|
||||
await repository.addOrUpdateStop(stop);
|
||||
}));
|
||||
|
||||
const stopToRemove = mockStops[0];
|
||||
await repository.removeStopIfExists(stopToRemove.id);
|
||||
|
||||
const remainingStops = await repository.getStops();
|
||||
expect(remainingStops).toHaveLength(mockStops.length - 1);
|
||||
});
|
||||
|
||||
test("does nothing if stop doesn't exist", async () => {
|
||||
const systemId = "1";
|
||||
const mockStops = generateMockStops();
|
||||
await Promise.all(mockStops.map(async (stop) => {
|
||||
stop.systemId = systemId;
|
||||
await repository.addOrUpdateStop(stop);
|
||||
}));
|
||||
|
||||
await repository.removeStopIfExists("nonexistent-id");
|
||||
|
||||
const remainingStops = await repository.getStops();
|
||||
expect(remainingStops).toHaveLength(mockStops.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeOrderedStopIfExists", () => {
|
||||
test("removes ordered stop given stop ID and route ID", async () => {
|
||||
let mockOrderedStops = generateMockOrderedStops();
|
||||
const routeId = mockOrderedStops[0].routeId;
|
||||
mockOrderedStops = mockOrderedStops.filter((orderedStop) => orderedStop.routeId === routeId);
|
||||
await Promise.all(mockOrderedStops.map(async (stop) => {
|
||||
stop.routeId = routeId;
|
||||
await repository.addOrUpdateOrderedStop(stop);
|
||||
}));
|
||||
|
||||
const orderedStopToRemove = mockOrderedStops[0];
|
||||
await repository.removeOrderedStopIfExists(orderedStopToRemove.stopId, orderedStopToRemove.routeId);
|
||||
|
||||
const remainingOrderedStops = await repository.getOrderedStopsByRouteId(routeId);
|
||||
expect(remainingOrderedStops).toHaveLength(mockOrderedStops.length - 1);
|
||||
});
|
||||
|
||||
test("does nothing if ordered stop doesn't exist", async () => {
|
||||
let mockOrderedStops = generateMockOrderedStops();
|
||||
const routeId = mockOrderedStops[0].routeId;
|
||||
mockOrderedStops = mockOrderedStops.filter((orderedStop) => orderedStop.routeId === routeId);
|
||||
await Promise.all(mockOrderedStops.map(async (stop) => {
|
||||
stop.routeId = routeId;
|
||||
await repository.addOrUpdateOrderedStop(stop);
|
||||
}));
|
||||
|
||||
await repository.removeOrderedStopIfExists("nonexistent-stop-id", "nonexistent-route-id");
|
||||
|
||||
const remainingOrderedStops = await repository.getOrderedStopsByRouteId(routeId);
|
||||
expect(remainingOrderedStops).toHaveLength(mockOrderedStops.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("removeEtaIfExists", () => {
|
||||
test("removes eta given shuttle ID and stop ID", async () => {
|
||||
let mockEtas = generateMockEtas();
|
||||
const stopId = mockEtas[0].stopId;
|
||||
mockEtas = mockEtas.filter((eta) => eta.stopId === stopId);
|
||||
|
||||
await Promise.all(mockEtas.map(async (eta) => {
|
||||
eta.stopId = stopId;
|
||||
await repository.addOrUpdateEta(eta);
|
||||
}));
|
||||
|
||||
const etaToRemove = mockEtas[0];
|
||||
await repository.removeEtaIfExists(etaToRemove.shuttleId, etaToRemove.stopId);
|
||||
|
||||
const remainingEtas = await repository.getEtasForStopId(stopId);
|
||||
expect(remainingEtas).toHaveLength(mockEtas.length - 1);
|
||||
});
|
||||
|
||||
test("does nothing if eta doesn't exist", async () => {
|
||||
let mockEtas = generateMockEtas();
|
||||
const stopId = mockEtas[0].stopId;
|
||||
mockEtas = mockEtas.filter((eta) => eta.stopId === stopId);
|
||||
|
||||
await Promise.all(mockEtas.map(async (eta) => {
|
||||
eta.stopId = stopId;
|
||||
await repository.addOrUpdateEta(eta);
|
||||
}));
|
||||
|
||||
await repository.removeEtaIfExists("nonexistent-shuttle-id", "nonexistent-stop-id");
|
||||
|
||||
const remainingEtas = await repository.getEtasForStopId(stopId);
|
||||
expect(remainingEtas).toHaveLength(mockEtas.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearShuttleData", () => {
|
||||
test("clears all shuttles from the repository", async () => {
|
||||
const mockShuttles = generateMockShuttles();
|
||||
for (const shuttle of mockShuttles) {
|
||||
await repository.addOrUpdateShuttle(shuttle);
|
||||
}
|
||||
|
||||
await repository.clearShuttleData();
|
||||
|
||||
const result = await repository.getShuttles();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearEtaData", () => {
|
||||
test("clears all ETAs from the repository", async () => {
|
||||
const mockEtas = generateMockEtas();
|
||||
for (const eta of mockEtas) {
|
||||
await repository.addOrUpdateEta(eta);
|
||||
}
|
||||
|
||||
await repository.clearEtaData();
|
||||
|
||||
const result = await repository.getEtasForShuttleId("shuttle1");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearOrderedStopData", () => {
|
||||
test("clears all ordered stops from the repository", async () => {
|
||||
const mockOrderedStops = await generateMockOrderedStops();
|
||||
for (const system of mockOrderedStops) {
|
||||
await repository.addOrUpdateOrderedStop(system);
|
||||
}
|
||||
|
||||
await repository.clearOrderedStopData();
|
||||
|
||||
const result = await repository.getOrderedStopsByRouteId("route1");
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearRouteData", () => {
|
||||
test("clears all routes from the repository", async () => {
|
||||
const mockRoutes = generateMockRoutes();
|
||||
for (const route of mockRoutes) {
|
||||
await repository.addOrUpdateRoute(route);
|
||||
}
|
||||
|
||||
await repository.clearRouteData();
|
||||
|
||||
const result = await repository.getRoutes();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("clearStopData", () => {
|
||||
test("clears all stops from the repository", async () => {
|
||||
const mockStops = generateMockStops();
|
||||
for (const stop of mockStops) {
|
||||
await repository.addOrUpdateStop(stop);
|
||||
}
|
||||
|
||||
await repository.clearStopData();
|
||||
|
||||
const result = await repository.getStops();
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
});
|
||||
});
|
||||
87
src/resolvers/__tests__/EtaResolverTests.test.ts
Normal file
87
src/resolvers/__tests__/EtaResolverTests.test.ts
Normal file
@@ -0,0 +1,87 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { IEta, IShuttle, IStop } from "../../entities/ShuttleRepositoryEntities";
|
||||
import {
|
||||
addMockEtaToRepository,
|
||||
addMockShuttleToRepository,
|
||||
addMockStopToRepository,
|
||||
} from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
|
||||
describe("EtaResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockShuttle: IShuttle;
|
||||
let mockStop: IStop;
|
||||
let expectedEta: IEta;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockShuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, context.systems[0].id);
|
||||
mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, context.systems[0].id);
|
||||
expectedEta = await addMockEtaToRepository(context.systems[0].shuttleRepository, mockStop.id, mockShuttle.id);
|
||||
});
|
||||
|
||||
async function getResponseForEtaQuery(query: string) {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
shuttleId: mockShuttle.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
describe("stop", () => {
|
||||
const query = `
|
||||
query GetETAStop($systemId: ID!, $shuttleId: ID!) {
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
etas {
|
||||
stop {
|
||||
id
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("returns the associated stop if it exists", async () => {
|
||||
const response = await getResponseForEtaQuery(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const eta = (response.body.singleResult.data?.system as any).shuttle.etas[0];
|
||||
expect(eta.stop.id).toEqual(expectedEta.stopId);
|
||||
});
|
||||
});
|
||||
|
||||
describe("shuttle", () => {
|
||||
const query = `
|
||||
query GetETAShuttle($systemId: ID!, $shuttleId: ID!) {
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
etas {
|
||||
shuttle {
|
||||
id
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("returns the associated shuttle if it exists", async () => {
|
||||
const response = await getResponseForEtaQuery(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const eta = (response.body.singleResult.data?.system as any).shuttle.etas[0];
|
||||
expect(eta.shuttle.id).toEqual(expectedEta.shuttleId);
|
||||
});
|
||||
});
|
||||
});
|
||||
187
src/resolvers/__tests__/MutationResolverTests.test.ts
Normal file
187
src/resolvers/__tests__/MutationResolverTests.test.ts
Normal file
@@ -0,0 +1,187 @@
|
||||
import { describe, expect, it } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import {
|
||||
addMockShuttleToRepository,
|
||||
addMockStopToRepository,
|
||||
} from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
import { NotificationInput } from "../../generated/graphql";
|
||||
|
||||
describe("MutationResolvers", () => {
|
||||
const holder = setupTestServerHolder()
|
||||
const context = setupTestServerContext();
|
||||
|
||||
async function getServerResponse(query: string, notificationInput: { deviceId: string; shuttleId: string; stopId: string }) {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
input: notificationInput,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
});
|
||||
}
|
||||
|
||||
describe("scheduleNotification", () => {
|
||||
const query = `
|
||||
mutation ScheduleNotification($input: NotificationInput!) {
|
||||
scheduleNotification(input: $input) {
|
||||
success
|
||||
message
|
||||
data {
|
||||
deviceId
|
||||
shuttleId
|
||||
stopId
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
async function assertFailedResponse(response: any, notificationInput: NotificationInput) {
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
|
||||
expect(notificationResponse.success).toBe(false);
|
||||
|
||||
expect(await context.systems[0].notificationRepository.isNotificationScheduled(notificationInput)).toBe(false);
|
||||
}
|
||||
|
||||
|
||||
it("adds a notification to the notification service", async () => {
|
||||
const system = context.systems[0];
|
||||
const shuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
const stop = await addMockStopToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
|
||||
const notificationInput = {
|
||||
deviceId: "1",
|
||||
shuttleId: shuttle.id,
|
||||
stopId: stop.id,
|
||||
secondsThreshold: 240,
|
||||
};
|
||||
const response = await getServerResponse(query, notificationInput);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const expectedNotificationData: any = {
|
||||
...notificationInput,
|
||||
}
|
||||
delete expectedNotificationData.secondsThreshold;
|
||||
const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
|
||||
expect(notificationResponse?.success).toBe(true);
|
||||
expect(notificationResponse?.data).toEqual(expectedNotificationData);
|
||||
|
||||
expect(await context.systems[0].notificationRepository.getSecondsThresholdForNotificationIfExists(expectedNotificationData)).toBe(240);
|
||||
});
|
||||
|
||||
it("adds a notification with the default seconds threshold if none is provided", async () => {
|
||||
const system = context.systems[0];
|
||||
const shuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
const stop = await addMockStopToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
|
||||
const notificationInput = {
|
||||
deviceId: "1",
|
||||
shuttleId: shuttle.id,
|
||||
stopId: stop.id,
|
||||
};
|
||||
const response = await getServerResponse(query, notificationInput);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const notificationResponse = response.body.singleResult.data?.scheduleNotification as any;
|
||||
expect(notificationResponse?.success).toBe(true);
|
||||
|
||||
expect(await context.systems[0].notificationRepository.getSecondsThresholdForNotificationIfExists(notificationInput)).toBe(180);
|
||||
});
|
||||
|
||||
it("fails if the shuttle ID doesn't exist", async () => {
|
||||
const system = context.systems[0];
|
||||
const stop = await addMockStopToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
|
||||
const notificationInput = {
|
||||
deviceId: "1",
|
||||
shuttleId: "1",
|
||||
stopId: stop.id,
|
||||
}
|
||||
const response = await getServerResponse(query, notificationInput);
|
||||
await assertFailedResponse(response, notificationInput);
|
||||
});
|
||||
|
||||
it("fails if the stop ID doesn't exist", async () => {
|
||||
const system = context.systems[0];
|
||||
const shuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
|
||||
const notificationInput = {
|
||||
deviceId: "1",
|
||||
shuttleId: shuttle.id,
|
||||
stopId: "1",
|
||||
}
|
||||
const response = await getServerResponse(query, notificationInput);
|
||||
|
||||
await assertFailedResponse(response, notificationInput);
|
||||
});
|
||||
});
|
||||
|
||||
describe("cancelNotification", () => {
|
||||
const query = `
|
||||
mutation CancelNotification($input: NotificationInput!) {
|
||||
cancelNotification(input: $input) {
|
||||
success
|
||||
message
|
||||
data {
|
||||
deviceId
|
||||
shuttleId
|
||||
stopId
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
it("removes the notification from the notification service", async () => {
|
||||
const system = context.systems[0];
|
||||
const shuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
const stop = await addMockStopToRepository(context.systems[0].shuttleRepository, system.id);
|
||||
|
||||
const notificationInput: any = {
|
||||
deviceId: "1",
|
||||
shuttleId: shuttle.id,
|
||||
stopId: stop.id,
|
||||
secondsThreshold: 180,
|
||||
}
|
||||
await context.systems[0].notificationRepository.addOrUpdateNotification(notificationInput);
|
||||
|
||||
const notificationLookup = {
|
||||
...notificationInput
|
||||
}
|
||||
delete notificationLookup.secondsThreshold;
|
||||
|
||||
const response = await getServerResponse(query, notificationLookup);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const notificationResponse = response.body.singleResult.data?.cancelNotification as any;
|
||||
expect(notificationResponse.success).toBe(true);
|
||||
expect(notificationResponse.data).toEqual(notificationLookup);
|
||||
|
||||
expect(await context.systems[0].notificationRepository.isNotificationScheduled(notificationLookup)).toBe(false);
|
||||
});
|
||||
|
||||
it("fails if the notification doesn't exist", async () => {
|
||||
const notificationInput = {
|
||||
deviceId: "1",
|
||||
shuttleId: "1",
|
||||
stopId: "1",
|
||||
}
|
||||
|
||||
const response = await getServerResponse(query, notificationInput);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const notificationResponse = response.body.singleResult.data?.cancelNotification as any;
|
||||
expect(notificationResponse.success).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
283
src/resolvers/__tests__/OrderedStopResolverTests.test.ts
Normal file
283
src/resolvers/__tests__/OrderedStopResolverTests.test.ts
Normal file
@@ -0,0 +1,283 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { IRoute, IStop } from "../../entities/ShuttleRepositoryEntities";
|
||||
import { generateMockOrderedStops, generateMockStops } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { addMockRouteToRepository } from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
|
||||
describe("OrderedStopResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockRoute: IRoute;
|
||||
let mockStops: IStop[];
|
||||
|
||||
beforeEach(async () => {
|
||||
mockRoute = await addMockRouteToRepository(context.systems[0].shuttleRepository, context.systems[0].id);
|
||||
|
||||
mockStops = generateMockStops();
|
||||
await Promise.all(mockStops.map(async (mockStop) => {
|
||||
mockStop.systemId = context.systems[0].id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateStop(mockStop);
|
||||
}));
|
||||
});
|
||||
|
||||
async function setUpOrderedStopsInRepository() {
|
||||
const orderedStops = generateMockOrderedStops();
|
||||
|
||||
// Set up IDs and link stops together to work with the test query
|
||||
orderedStops[0].routeId = mockRoute.id;
|
||||
orderedStops[1].routeId = mockRoute.id;
|
||||
|
||||
// Ensure that there is no duplication
|
||||
orderedStops[0].stopId = mockStops[0].id;
|
||||
orderedStops[1].stopId = mockStops[1].id;
|
||||
|
||||
// Link the stops together
|
||||
orderedStops[0].nextStop = orderedStops[1];
|
||||
orderedStops[1].previousStop = orderedStops[0];
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[0]);
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[1]);
|
||||
return orderedStops;
|
||||
}
|
||||
|
||||
describe("nextStop", () => {
|
||||
async function getResponseForNextStopQuery(stopId: string) {
|
||||
const query = `
|
||||
query GetNextStop($systemId: ID!, $routeId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
orderedStop(forStopId: $stopId) {
|
||||
nextStop {
|
||||
routeId
|
||||
stopId
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
routeId: mockRoute.id,
|
||||
stopId,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
it("returns the next stop if it exists", async () => {
|
||||
// Arrange
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
|
||||
// Act
|
||||
const response = await getResponseForNextStopQuery(orderedStops[0].stopId);
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const nextStop = (response.body.singleResult.data?.system as any).route.orderedStop.nextStop;
|
||||
expect(nextStop.stopId).toEqual(orderedStops[1].stopId);
|
||||
expect(nextStop.routeId).toEqual(orderedStops[1].routeId);
|
||||
});
|
||||
|
||||
it("returns null if there is no next stop in the repository", async () => {
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
orderedStops[0].nextStop = undefined;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[0]);
|
||||
|
||||
const response = await getResponseForNextStopQuery(orderedStops[0].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
const nonexistentNextStop = (response.body.singleResult.data?.system as any).route.orderedStop.nextStop;
|
||||
expect(nonexistentNextStop).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null if the next stop object no longer exists", async () => {
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
await context.systems[0].shuttleRepository.removeStopIfExists(orderedStops[1].stopId);
|
||||
|
||||
const response = await getResponseForNextStopQuery(orderedStops[0].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
const nonexistentNextStop = (response.body.singleResult.data?.system as any).route.orderedStop.nextStop;
|
||||
expect(nonexistentNextStop).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("previousStop", () => {
|
||||
async function getResponseForPreviousStopQuery(stopId: string) {
|
||||
const query = `
|
||||
query GetNextStop($systemId: ID!, $routeId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
orderedStop(forStopId: $stopId) {
|
||||
previousStop {
|
||||
routeId
|
||||
stopId
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
routeId: mockRoute.id,
|
||||
stopId,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns the previous stop if it exists", async () => {
|
||||
// Arrange
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
|
||||
// Act
|
||||
const response = await getResponseForPreviousStopQuery(orderedStops[1].stopId);
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const previousStop = (response.body.singleResult.data?.system as any).route.orderedStop.previousStop;
|
||||
expect(previousStop.stopId).toEqual(orderedStops[0].stopId);
|
||||
expect(previousStop.routeId).toEqual(orderedStops[0].routeId);
|
||||
});
|
||||
|
||||
it("returns null if there is no previous stop in the repository", async () => {
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
orderedStops[1].previousStop = undefined;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[1]);
|
||||
|
||||
const response = await getResponseForPreviousStopQuery(orderedStops[1].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
const nonexistentPreviousStop = (response.body.singleResult.data?.system as any).route.orderedStop.previousStop;
|
||||
expect(nonexistentPreviousStop).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null if the current stop no longer exists", async () => {
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
await context.systems[0].shuttleRepository.removeStopIfExists(orderedStops[0].stopId);
|
||||
|
||||
const response = await getResponseForPreviousStopQuery(orderedStops[1].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
const nonexistentPreviousStop = (response.body.singleResult.data?.system as any).route.orderedStop.previousStop;
|
||||
expect(nonexistentPreviousStop).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("route", () => {
|
||||
// Note that there is no `orderedStop(forRouteId)` resolver,
|
||||
// so fetch all ordered stops for a stop instead.
|
||||
// If we went through the route ID, it would've
|
||||
// relied on the parent data within the route.orderedStop resolver
|
||||
async function getResponseForRouteQuery(stopId: string) {
|
||||
const query = `
|
||||
query GetNextStop($systemId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
stop(id: $stopId) {
|
||||
orderedStops {
|
||||
route {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
stopId,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns the associated route if it exists", async () => {
|
||||
const orderedStops = generateMockOrderedStops();
|
||||
orderedStops[0].routeId = mockRoute.id;
|
||||
orderedStops[0].stopId = mockStops[0].id;
|
||||
|
||||
// Add one stop only
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[0]);
|
||||
|
||||
const response = await getResponseForRouteQuery(orderedStops[1].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const route = (response.body.singleResult.data?.system as any).stop.orderedStops[0].route
|
||||
|
||||
expect(route.id).toEqual(mockRoute.id);
|
||||
expect(route.name).toEqual(mockRoute.name);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe("stop", () => {
|
||||
async function getResponseForStopQuery(stopId: string) {
|
||||
const query = `
|
||||
query GetNextStop($systemId: ID!, $routeId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
orderedStop(forStopId: $stopId) {
|
||||
stop {
|
||||
name
|
||||
id
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
routeId: mockRoute.id,
|
||||
stopId,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns the associated stop if it exists", async () => {
|
||||
const orderedStops = await setUpOrderedStopsInRepository();
|
||||
orderedStops[0].stopId = mockStops[0].id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(orderedStops[0]);
|
||||
|
||||
const response = await getResponseForStopQuery(orderedStops[0].stopId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const stop = (response.body.singleResult.data?.system as any).route.orderedStop.stop;
|
||||
expect(stop.name).toEqual(mockStops[0].name);
|
||||
expect(stop.id).toEqual(mockStops[0].id);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
import { beforeEach, describe, expect, it, jest } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { InterchangeSystem } from "../../entities/InterchangeSystem";
|
||||
import { generateParkingStructures } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { HistoricalParkingAverageQueryInput } from "../../generated/graphql";
|
||||
import assert = require("node:assert");
|
||||
|
||||
jest.mock("../../environment");
|
||||
|
||||
describe("ParkingStructureResolver", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockSystem: InterchangeSystem;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockSystem = context.systems[0];
|
||||
jest.useRealTimers();
|
||||
});
|
||||
|
||||
describe("historicalAverages", () => {
|
||||
const query = `
|
||||
query GetParkingStructureHistoricalAverages(
|
||||
$systemId: ID!,
|
||||
$parkingStructureId: ID!,
|
||||
$historicalAverageInput: HistoricalParkingAverageQueryInput!
|
||||
) {
|
||||
system(id: $systemId) {
|
||||
parkingSystem {
|
||||
parkingStructure(id: $parkingStructureId) {
|
||||
historicalAverages(input: $historicalAverageInput) {
|
||||
from
|
||||
to
|
||||
averageSpotsAvailable
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("gets data for historical averages", async () => {
|
||||
jest.useFakeTimers();
|
||||
jest.setSystemTime(new Date());
|
||||
|
||||
const parkingStructure = generateParkingStructures()[0];
|
||||
parkingStructure.spotsAvailable = parkingStructure.capacity;
|
||||
mockSystem.parkingRepository?.setLoggingInterval(100);
|
||||
|
||||
// Simulate repeated updates
|
||||
for (let i = 0; i < 6; i += 1) {
|
||||
jest.setSystemTime(new Date(Date.now() + 1000));
|
||||
parkingStructure.spotsAvailable = parkingStructure.spotsAvailable - 100;
|
||||
await mockSystem.parkingRepository?.addOrUpdateParkingStructure(parkingStructure);
|
||||
}
|
||||
|
||||
const historicalAverageInput: HistoricalParkingAverageQueryInput = {
|
||||
from: new Date(Date.now() - 5000).getTime(),
|
||||
intervalMs: 2000,
|
||||
to: new Date().getTime(),
|
||||
};
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
parkingStructureId: parkingStructure.id,
|
||||
historicalAverageInput,
|
||||
},
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
|
||||
assert(response.body.kind === 'single');
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const historicalAverages = (response.body.singleResult.data as any).system.parkingSystem.parkingStructure.historicalAverages;
|
||||
expect(historicalAverages).toHaveLength(3);
|
||||
});
|
||||
});
|
||||
});
|
||||
157
src/resolvers/__tests__/ParkingSystemResolverTests.test.ts
Normal file
157
src/resolvers/__tests__/ParkingSystemResolverTests.test.ts
Normal file
@@ -0,0 +1,157 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { generateParkingStructures } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { InterchangeSystem } from "../../entities/InterchangeSystem";
|
||||
import assert = require("node:assert");
|
||||
|
||||
|
||||
describe("ParkingSystemResolver", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockSystem: InterchangeSystem;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockSystem = context.systems[0];
|
||||
});
|
||||
|
||||
async function getResponseFromQueryNeedingSystemId(query: string) {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
}
|
||||
|
||||
describe("parkingStructures", () => {
|
||||
const query = `
|
||||
query GetParkingStructuresBySystem($systemId: ID!) {
|
||||
system(id: $systemId) {
|
||||
parkingSystem {
|
||||
parkingStructures {
|
||||
name
|
||||
id
|
||||
capacity
|
||||
spotsAvailable
|
||||
coordinates {
|
||||
latitude
|
||||
longitude
|
||||
}
|
||||
address
|
||||
updatedTime
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
it("gets parking structures associated with the system id", async () => {
|
||||
let expectedParkingStructures = generateParkingStructures();
|
||||
await Promise.all(expectedParkingStructures.map(async (structure) => {
|
||||
await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
|
||||
}));
|
||||
|
||||
// Dates are transformed into epoch timestamps when serialized
|
||||
expectedParkingStructures = expectedParkingStructures.map((structure) => {
|
||||
const newStructure = { ...structure };
|
||||
// @ts-ignore
|
||||
newStructure.updatedTime = newStructure.updatedTime.getTime();
|
||||
return newStructure;
|
||||
});
|
||||
|
||||
const response = await getResponseFromQueryNeedingSystemId(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const parkingStructures = (response.body.singleResult.data as any).system.parkingSystem.parkingStructures;
|
||||
expect(parkingStructures).toEqual(expectedParkingStructures);
|
||||
});
|
||||
|
||||
it("returns a blank array if there are no parking structures", async () => {
|
||||
const response = await getResponseFromQueryNeedingSystemId(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const parkingStructures = (response.body.singleResult.data as any).system.parkingSystem.parkingStructures;
|
||||
|
||||
expect(parkingStructures).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe("parkingStructure", () => {
|
||||
async function getResponseForParkingStructureQuery(parkingStructureId: string) {
|
||||
const query = `
|
||||
query GetParkingStructureBySystem($systemId: ID!, $parkingStructureId: ID!) {
|
||||
system(id: $systemId) {
|
||||
parkingSystem {
|
||||
parkingStructure(id: $parkingStructureId) {
|
||||
name
|
||||
id
|
||||
capacity
|
||||
spotsAvailable
|
||||
coordinates {
|
||||
latitude
|
||||
longitude
|
||||
}
|
||||
address
|
||||
updatedTime
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
parkingStructureId,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns the correct parking structure given the id", async () => {
|
||||
const generatedParkingStructures = generateParkingStructures();
|
||||
await Promise.all(generatedParkingStructures.map(async (structure) => {
|
||||
await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
|
||||
}));
|
||||
const expectedParkingStructure = generatedParkingStructures[1];
|
||||
// @ts-ignore
|
||||
expectedParkingStructure.updatedTime = expectedParkingStructure.updatedTime.getTime();
|
||||
|
||||
const response = await getResponseForParkingStructureQuery(expectedParkingStructure.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const parkingStructure = (response.body.singleResult.data as any).system.parkingSystem.parkingStructure;
|
||||
expect(parkingStructure).toEqual(expectedParkingStructure);
|
||||
});
|
||||
|
||||
it("returns null if there is no matching parking structure", async () => {
|
||||
const generatedParkingStructures = generateParkingStructures();
|
||||
await Promise.all(generatedParkingStructures.map(async (structure) => {
|
||||
await context.systems[0].parkingRepository?.addOrUpdateParkingStructure(structure);
|
||||
}));
|
||||
|
||||
const nonexistentId = generatedParkingStructures[0].id + "12345";
|
||||
|
||||
const response = await getResponseForParkingStructureQuery(nonexistentId);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const parkingStructure = (response.body.singleResult.data as any).system.parkingSystem.parkingStructure;
|
||||
expect(parkingStructure).toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
165
src/resolvers/__tests__/QueryResolverTests.test.ts
Normal file
165
src/resolvers/__tests__/QueryResolverTests.test.ts
Normal file
@@ -0,0 +1,165 @@
|
||||
import { describe, expect, it } from "@jest/globals";
|
||||
import {
|
||||
buildSystemForTesting,
|
||||
setupTestServerContext,
|
||||
setupTestServerHolder
|
||||
} from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import assert = require("node:assert");
|
||||
import { addMockShuttleToRepository, addMockStopToRepository } from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import { ScheduledNotification } from "../../repositories/notifications/NotificationRepository";
|
||||
|
||||
// See Apollo documentation for integration test guide
|
||||
// https://www.apollographql.com/docs/apollo-server/testing/testing
|
||||
|
||||
describe("QueryResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
describe("systems", () => {
|
||||
it("returns systems from the repository", async () => {
|
||||
const systems = context.systems;
|
||||
|
||||
const query = `
|
||||
query GetSystems
|
||||
{
|
||||
systems {
|
||||
name
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
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 () => {
|
||||
context.systems = [
|
||||
buildSystemForTesting(),
|
||||
buildSystemForTesting(),
|
||||
];
|
||||
context.findSystemById = (_: string) => context.systems[1];
|
||||
context.systems[1].id = "test-id";
|
||||
|
||||
const systems = context.systems;
|
||||
const systemToGet = systems[1];
|
||||
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
id: systemToGet.id,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
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 () => {
|
||||
context.findSystemById = (_: string) => null;
|
||||
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
id: "nonexistent-id",
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect(response.body.singleResult.data?.system).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("isNotificationScheduled and secondsThresholdForNotification", () => {
|
||||
const query = `
|
||||
query IsNotificationScheduled($input: NotificationInput!) {
|
||||
isNotificationScheduled(input: $input)
|
||||
secondsThresholdForNotification(input: $input)
|
||||
}
|
||||
`;
|
||||
|
||||
it("returns correct data if the notification is scheduled", async () => {
|
||||
// Arrange
|
||||
const shuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, "1");
|
||||
const stop = await addMockStopToRepository(context.systems[0].shuttleRepository, "1")
|
||||
|
||||
const notification: ScheduledNotification = {
|
||||
shuttleId: shuttle.id,
|
||||
stopId: stop.id,
|
||||
deviceId: "1",
|
||||
secondsThreshold: 240,
|
||||
};
|
||||
await context.systems[0].notificationRepository.addOrUpdateNotification(notification);
|
||||
|
||||
const notificationLookup: any = {
|
||||
...notification,
|
||||
}
|
||||
delete notificationLookup.secondsThreshold;
|
||||
|
||||
// Act
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
input: notificationLookup,
|
||||
}
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect(response.body.singleResult.data?.secondsThresholdForNotification).toEqual(240);
|
||||
expect(response.body.singleResult.data?.isNotificationScheduled).toBe(true);
|
||||
});
|
||||
|
||||
it("returns false/null data if the notification isn't scheduled", async () => {
|
||||
// Act
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
input: {
|
||||
shuttleId: "1",
|
||||
stopId: "1",
|
||||
deviceId: "1",
|
||||
},
|
||||
}
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect(response.body.singleResult.data?.isNotificationScheduled).toBe(false);
|
||||
expect(response.body.singleResult.data?.secondsThresholdForNotification).toBe(null);
|
||||
});
|
||||
});
|
||||
});
|
||||
147
src/resolvers/__tests__/RouteResolverTests.test.ts
Normal file
147
src/resolvers/__tests__/RouteResolverTests.test.ts
Normal file
@@ -0,0 +1,147 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import {
|
||||
addMockRouteToRepository,
|
||||
addMockStopToRepository
|
||||
} from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import { generateMockOrderedStops, generateMockShuttles } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { IRoute, IStop } from "../../entities/ShuttleRepositoryEntities";
|
||||
import assert = require("node:assert");
|
||||
import { InterchangeSystem } from "../../entities/InterchangeSystem";
|
||||
|
||||
describe("RouteResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockSystem: InterchangeSystem;
|
||||
let mockRoute: IRoute;
|
||||
let mockStop: IStop;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockSystem = context.systems[0];
|
||||
const systemId = mockSystem.id;
|
||||
|
||||
mockRoute = await addMockRouteToRepository(context.systems[0].shuttleRepository, systemId);
|
||||
mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, systemId);
|
||||
});
|
||||
|
||||
|
||||
describe("shuttles", () => {
|
||||
async function getResponseForShuttlesQuery() {
|
||||
const query = `
|
||||
query GetRouteShuttles($systemId: ID!, $routeId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
shuttles {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
routeId: mockRoute.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns shuttle array if there are shuttles", async () => {
|
||||
const expectedShuttles = generateMockShuttles();
|
||||
const expectedShuttle = expectedShuttles[0];
|
||||
expectedShuttle.systemId = mockSystem.id;
|
||||
expectedShuttle.routeId = mockRoute.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateShuttle(expectedShuttle);
|
||||
|
||||
const response = await getResponseForShuttlesQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined()
|
||||
const shuttle = (response.body.singleResult.data as
|
||||
any).system.route.shuttles[0];
|
||||
expect(shuttle.id).toEqual(expectedShuttle.id);
|
||||
expect(shuttle.name).toEqual(expectedShuttle.name);
|
||||
});
|
||||
|
||||
it("returns empty array if there are no shuttles", async () => {
|
||||
const response = await getResponseForShuttlesQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined()
|
||||
const shuttles = (response.body.singleResult.data as
|
||||
any).system.route.shuttles;
|
||||
expect(shuttles.length).toEqual(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("orderedStop", () => {
|
||||
async function getResponseForOrderedStopQuery() {
|
||||
const query = `
|
||||
query GetRouteOrderedStop($systemId: ID!, $routeId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
orderedStop(forStopId: $stopId) {
|
||||
stopId
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
routeId: mockRoute.id,
|
||||
stopId: mockStop.id,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns ordered stop using provided data", async () => {
|
||||
const orderedStops = generateMockOrderedStops();
|
||||
const expectedOrderedStop = orderedStops[0];
|
||||
expectedOrderedStop.stopId = mockStop.id;
|
||||
expectedOrderedStop.routeId = mockRoute.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(expectedOrderedStop);
|
||||
|
||||
const response = await getResponseForOrderedStopQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const orderedStop = (response.body.singleResult.data as
|
||||
any).system.route.orderedStop;
|
||||
expect(orderedStop.stopId).toEqual(expectedOrderedStop.stopId);
|
||||
});
|
||||
|
||||
it("returns null if the stop doesn't exist", async () => {
|
||||
const orderedStops = generateMockOrderedStops();
|
||||
const expectedOrderedStop = orderedStops[0];
|
||||
expectedOrderedStop.stopId = mockStop.id;
|
||||
expectedOrderedStop.routeId = mockRoute.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateOrderedStop(expectedOrderedStop);
|
||||
|
||||
await context.systems[0].shuttleRepository.removeStopIfExists(mockStop.id);
|
||||
|
||||
const response = await getResponseForOrderedStopQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const orderedStop = (response.body.singleResult.data as
|
||||
any).system.route.orderedStop;
|
||||
expect(orderedStop).toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
197
src/resolvers/__tests__/ShuttleResolverTests.test.ts
Normal file
197
src/resolvers/__tests__/ShuttleResolverTests.test.ts
Normal file
@@ -0,0 +1,197 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { generateMockEtas, generateMockRoutes } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { IShuttle } from "../../entities/ShuttleRepositoryEntities";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { addMockShuttleToRepository } from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
import { InterchangeSystem } from "../../entities/InterchangeSystem";
|
||||
|
||||
|
||||
describe("ShuttleResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockSystem: InterchangeSystem;
|
||||
let mockShuttle: IShuttle;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockSystem = context.systems[0];
|
||||
mockShuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository,
|
||||
mockSystem.id);
|
||||
});
|
||||
|
||||
|
||||
async function addMockEtas(shuttleId: string) {
|
||||
const etas = generateMockEtas();
|
||||
await Promise.all(etas.map(async (eta) => {
|
||||
eta.shuttleId = shuttleId;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateEta(eta);
|
||||
}));
|
||||
return etas;
|
||||
}
|
||||
|
||||
describe("eta", () => {
|
||||
const query = `
|
||||
query GetShuttleETAs($systemId: ID!, $shuttleId: ID!, $stopId: ID!)
|
||||
{
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
eta(forStopId: $stopId) {
|
||||
secondsRemaining
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
it("returns ETA data for stop ID if exists", async () => {
|
||||
const etas = await addMockEtas(mockShuttle.id);
|
||||
|
||||
const mockEta = etas[1];
|
||||
|
||||
// Act
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: mockShuttle.id,
|
||||
stopId: mockEta.stopId,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as
|
||||
any).system.shuttle.eta.secondsRemaining).toEqual(mockEta.secondsRemaining);
|
||||
});
|
||||
|
||||
it("returns null if it doesn't exist", async () => {
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: mockShuttle.id,
|
||||
stopId: "nonexistent-stop",
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
// Assert
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as
|
||||
any).system.shuttle.eta).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("etas", () => {
|
||||
const query = `
|
||||
query GetShuttleETAs($systemId: ID!, $shuttleId: ID!)
|
||||
{
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
etas {
|
||||
secondsRemaining
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
it("returns associated ETAs if they exist for the shuttle", async () => {
|
||||
const etas = await addMockEtas(mockShuttle.id);
|
||||
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: mockShuttle.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as
|
||||
any).system.shuttle.etas).toHaveLength(etas.length);
|
||||
});
|
||||
|
||||
it("returns empty array if no ETAs exist", async () => {
|
||||
const response = await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: mockShuttle.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as
|
||||
any).system.shuttle.etas).toHaveLength(0);
|
||||
|
||||
});
|
||||
});
|
||||
describe("route", () => {
|
||||
const query = `
|
||||
query GetShuttleRoute($systemId: ID!, $shuttleId: ID!) {
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
route {
|
||||
color
|
||||
id
|
||||
name
|
||||
polylineCoordinates {
|
||||
latitude
|
||||
longitude
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
async function getResponseForQuery() {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: mockShuttle.id,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("returns the route if it exists", async () => {
|
||||
const mockRoute = generateMockRoutes()[0];
|
||||
await context.systems[0].shuttleRepository.addOrUpdateRoute(mockRoute);
|
||||
|
||||
const response = await getResponseForQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as any).system.shuttle.route.id).toEqual(mockRoute.id);
|
||||
});
|
||||
|
||||
it("returns null if there is no route", async () => {
|
||||
const response = await getResponseForQuery();
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
expect((response.body.singleResult.data as any).system.shuttle.route).toBeNull();
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
108
src/resolvers/__tests__/StopResolverTests.test.ts
Normal file
108
src/resolvers/__tests__/StopResolverTests.test.ts
Normal file
@@ -0,0 +1,108 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import {
|
||||
setupTestServerContext,
|
||||
setupTestServerHolder
|
||||
} from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import { generateMockEtas, generateMockOrderedStops } from "../../../test/testHelpers/mockDataGenerators";
|
||||
import { IStop } from "../../entities/ShuttleRepositoryEntities";
|
||||
import { addMockStopToRepository } from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
|
||||
describe("StopResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockStop: IStop;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, context.systems[0].id);
|
||||
})
|
||||
|
||||
async function getResponseForQuery(query: string) {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: context.systems[0].id,
|
||||
stopId: mockStop.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
}
|
||||
|
||||
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.systems[0].shuttleRepository.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.systems[0].shuttleRepository.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);
|
||||
});
|
||||
});
|
||||
});
|
||||
317
src/resolvers/__tests__/SystemResolverTests.test.ts
Normal file
317
src/resolvers/__tests__/SystemResolverTests.test.ts
Normal file
@@ -0,0 +1,317 @@
|
||||
import { beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { setupTestServerContext, setupTestServerHolder } from "../../../test/testHelpers/apolloTestServerHelpers";
|
||||
import {
|
||||
generateMockRoutes,
|
||||
generateMockShuttles,
|
||||
generateMockStops,
|
||||
generateParkingStructures
|
||||
} from "../../../test/testHelpers/mockDataGenerators";
|
||||
import {
|
||||
addMockRouteToRepository,
|
||||
addMockShuttleToRepository,
|
||||
addMockStopToRepository,
|
||||
} from "../../../test/testHelpers/repositorySetupHelpers";
|
||||
import assert = require("node:assert");
|
||||
import { InterchangeSystem } from "../../entities/InterchangeSystem";
|
||||
|
||||
describe("SystemResolvers", () => {
|
||||
const holder = setupTestServerHolder();
|
||||
const context = setupTestServerContext();
|
||||
|
||||
let mockSystem: InterchangeSystem;
|
||||
|
||||
beforeEach(async () => {
|
||||
mockSystem = context.systems[0];
|
||||
});
|
||||
|
||||
// TODO: Consolidate these into one single method taking an object
|
||||
async function getResponseFromQueryNeedingSystemId(query: string) {
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
},
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
}
|
||||
|
||||
describe("routes", () => {
|
||||
const query = `
|
||||
query GetSystemRoutes($systemId: ID!) {
|
||||
system(id: $systemId) {
|
||||
routes {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("gets routes associated with system id", async () => {
|
||||
const expectedRoutes = generateMockRoutes();
|
||||
await Promise.all(expectedRoutes.map(async (route) => {
|
||||
route.systemId = mockSystem.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateRoute(route);
|
||||
}));
|
||||
|
||||
const response = await getResponseFromQueryNeedingSystemId(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined()
|
||||
const routes = (response.body.singleResult.data as any).system.routes;
|
||||
expect(routes.length === expectedRoutes.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("stops", () => {
|
||||
const query = `
|
||||
query GetSystemStops($systemId: ID!) {
|
||||
system(id: $systemId) {
|
||||
stops {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("gets stops associated with system id", async () => {
|
||||
const expectedStops = generateMockStops();
|
||||
await Promise.all(expectedStops.map(async (stop) => {
|
||||
stop.systemId = mockSystem.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateStop(stop);
|
||||
}));
|
||||
|
||||
const response = await getResponseFromQueryNeedingSystemId(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined()
|
||||
const stops = (response.body.singleResult.data as any).system.stops;
|
||||
expect(stops.length === expectedStops.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe("stop", () => {
|
||||
async function getResponseForStopQuery(stopId: string) {
|
||||
const query = `
|
||||
query GetSystemStop($systemId: ID!, $stopId: ID!) {
|
||||
system(id: $systemId) {
|
||||
stop(id: $stopId) {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
stopId: stopId,
|
||||
},
|
||||
}, {
|
||||
contextValue: context,
|
||||
});
|
||||
}
|
||||
|
||||
it("gets the stop with the correct id", async () => {
|
||||
const mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, mockSystem.id);
|
||||
|
||||
const response = await getResponseForStopQuery(mockStop.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const stop = (response.body.singleResult.data as any).system.stop;
|
||||
expect(stop.id).toEqual(mockStop.id);
|
||||
expect(stop.name).toEqual(mockStop.name);
|
||||
});
|
||||
|
||||
it("returns null if the stop isn't associated with the system", async () => {
|
||||
const updatedSystem = {
|
||||
...mockSystem,
|
||||
id: "2",
|
||||
}
|
||||
|
||||
const mockStop = await addMockStopToRepository(context.systems[0].shuttleRepository, updatedSystem.id);
|
||||
|
||||
const response = await getResponseForStopQuery(mockStop.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const stop = (response.body.singleResult.data as any).system.stop;
|
||||
expect(stop).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null if there is no stop", async () => {
|
||||
const response = await getResponseForStopQuery("1");
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const stop = (response.body.singleResult.data as any).system.stop;
|
||||
expect(stop).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("route", () => {
|
||||
async function getResponseForRouteQuery(routeId: string) {
|
||||
const query = `
|
||||
query GetSystemRoute($systemId: ID!, $routeId: ID!) {
|
||||
system(id: $systemId) {
|
||||
route(id: $routeId) {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
routeId,
|
||||
},
|
||||
}, {
|
||||
contextValue: context
|
||||
});
|
||||
}
|
||||
|
||||
it("gets the route with the correct id", async () => {
|
||||
const mockRoute = await addMockRouteToRepository(context.systems[0].shuttleRepository, mockSystem.id);
|
||||
|
||||
const response = await getResponseForRouteQuery(mockRoute.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const route = (response.body.singleResult.data as any).system.route;
|
||||
expect(route.id).toEqual(mockRoute.id);
|
||||
expect(route.name).toEqual(mockRoute.name);
|
||||
});
|
||||
|
||||
it("returns null if the route isn't associated with the system", async () => {
|
||||
const updatedSystem = {
|
||||
...mockSystem,
|
||||
id: "2",
|
||||
}
|
||||
|
||||
const mockRoute = await addMockRouteToRepository(context.systems[0].shuttleRepository, updatedSystem.id);
|
||||
|
||||
const response = await getResponseForRouteQuery(mockRoute.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const route = (response.body.singleResult.data as any).system.route;
|
||||
expect(route).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null if there is no route", async () => {
|
||||
const response = await getResponseForRouteQuery("nonexistent-route-id");
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const route = (response.body.singleResult.data as any).system.route;
|
||||
expect(route).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("shuttle", () => {
|
||||
async function getResponseForShuttleQuery(shuttleId: string) {
|
||||
const query = `
|
||||
query GetSystemShuttle($systemId: ID!, $shuttleId: ID!) {
|
||||
system(id: $systemId) {
|
||||
shuttle(id: $shuttleId) {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
return await holder.testServer.executeOperation({
|
||||
query,
|
||||
variables: {
|
||||
systemId: mockSystem.id,
|
||||
shuttleId: shuttleId,
|
||||
}
|
||||
}, {
|
||||
contextValue: context
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
it("gets the shuttle with the correct id", async () => {
|
||||
const mockShuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, mockSystem.id);
|
||||
|
||||
const response = await getResponseForShuttleQuery(mockShuttle.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
const shuttle = (response.body.singleResult.data as any).system.shuttle;
|
||||
expect(shuttle.id).toEqual(mockShuttle.id);
|
||||
expect(shuttle.name).toEqual(mockShuttle.name);
|
||||
});
|
||||
|
||||
it("returns null if the shuttle isn't associated with the system", async () => {
|
||||
const updatedSystem = {
|
||||
...mockSystem,
|
||||
id: "2",
|
||||
}
|
||||
|
||||
const mockShuttle = await addMockShuttleToRepository(context.systems[0].shuttleRepository, updatedSystem.id);
|
||||
|
||||
const response = await getResponseForShuttleQuery(mockShuttle.id);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const shuttle = (response.body.singleResult.data as any).system.shuttle;
|
||||
expect(shuttle).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null if there is no shuttle", async () => {
|
||||
const response = await getResponseForShuttleQuery("nonexistent-shuttle-id");
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined();
|
||||
|
||||
const shuttle = (response.body.singleResult.data as any).system.shuttle;
|
||||
expect(shuttle).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("shuttles", () => {
|
||||
const query = `
|
||||
query GetSystemShuttle($systemId: ID!) {
|
||||
system(id: $systemId) {
|
||||
shuttles {
|
||||
id
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
it("gets shuttles associated with system id", async () => {
|
||||
const expectedShuttles = generateMockShuttles();
|
||||
await Promise.all(expectedShuttles.map(async (shuttle) => {
|
||||
shuttle.systemId = mockSystem.id;
|
||||
await context.systems[0].shuttleRepository.addOrUpdateShuttle(shuttle);
|
||||
}));
|
||||
|
||||
const response = await getResponseFromQueryNeedingSystemId(query);
|
||||
|
||||
assert(response.body.kind === "single");
|
||||
expect(response.body.singleResult.errors).toBeUndefined()
|
||||
const shuttles = (response.body.singleResult.data as any).system.shuttles;
|
||||
expect(shuttles.length === expectedShuttles.length);
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
201
src/types/__tests__/CircularQueue.test.ts
Normal file
201
src/types/__tests__/CircularQueue.test.ts
Normal file
@@ -0,0 +1,201 @@
|
||||
import { describe, expect, it } from "@jest/globals";
|
||||
import { CircularQueue } from "../CircularQueue";
|
||||
|
||||
interface TestItem {
|
||||
id: number;
|
||||
value: string;
|
||||
}
|
||||
|
||||
describe("CircularQueue", () => {
|
||||
const testItems = {
|
||||
first: { id: 1, value: "first" },
|
||||
second: { id: 2, value: "second" },
|
||||
third: { id: 3, value: "third" },
|
||||
fourth: { id: 4, value: "fourth" },
|
||||
test: { id: 1, value: "test" },
|
||||
apple: { id: 1, value: "apple" },
|
||||
banana: { id: 2, value: "banana" },
|
||||
cherry: { id: 3, value: "cherry" },
|
||||
grape: { id: 5, value: "grape" },
|
||||
orange: { id: 7, value: "orange" },
|
||||
a: { id: 1, value: "a" },
|
||||
b: { id: 2, value: "b" },
|
||||
c: { id: 3, value: "c" },
|
||||
d: { id: 4, value: "d" }
|
||||
};
|
||||
|
||||
const sortingCallbacks = {
|
||||
byId: (a: TestItem, b: TestItem) => a.id - b.id,
|
||||
byValue: (a: TestItem, b: TestItem) => a.value.localeCompare(b.value)
|
||||
};
|
||||
|
||||
const keyExtractors = {
|
||||
id: (item: TestItem) => item.id,
|
||||
value: (item: TestItem) => item.value
|
||||
};
|
||||
|
||||
const createQueueWithItems = (size: number, items: TestItem[], sortingCallback: (a: TestItem, b: TestItem) => number) => {
|
||||
const queue = new CircularQueue<TestItem>(size);
|
||||
items.forEach(item => queue.appendWithSorting(item, sortingCallback));
|
||||
return queue;
|
||||
};
|
||||
|
||||
describe("constructor", () => {
|
||||
it("creates queue with specified size", () => {
|
||||
const queue = new CircularQueue<TestItem>(5);
|
||||
expect(queue).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("appendWithSorting", () => {
|
||||
it("adds items to the queue with sorting callback", () => {
|
||||
const queue = createQueueWithItems(3, [testItems.third, testItems.first, testItems.second], sortingCallbacks.byId);
|
||||
|
||||
expect(queue.size()).toBe(3);
|
||||
expect(queue.get(0)).toEqual(testItems.first);
|
||||
expect(queue.get(1)).toEqual(testItems.second);
|
||||
expect(queue.get(2)).toEqual(testItems.third);
|
||||
});
|
||||
|
||||
it("overwrites oldest items when queue is full", () => {
|
||||
const queue = createQueueWithItems(2, [testItems.first, testItems.second, testItems.third], sortingCallbacks.byId);
|
||||
|
||||
expect(queue.size()).toBe(2);
|
||||
});
|
||||
|
||||
it("handles appending to empty queue", () => {
|
||||
const queue = createQueueWithItems(3, [testItems.test], sortingCallbacks.byId);
|
||||
|
||||
expect(queue.size()).toBe(1);
|
||||
expect(queue.get(0)).toEqual(testItems.test);
|
||||
});
|
||||
|
||||
it("optimizes append when items are already in order", () => {
|
||||
const queue = new CircularQueue<TestItem>(5);
|
||||
let sortCallCount = 0;
|
||||
|
||||
const trackingSortCallback = (a: TestItem, b: TestItem) => {
|
||||
sortCallCount++;
|
||||
return a.id - b.id;
|
||||
};
|
||||
|
||||
queue.appendWithSorting(testItems.first, trackingSortCallback);
|
||||
expect(sortCallCount).toBe(0);
|
||||
|
||||
queue.appendWithSorting(testItems.second, trackingSortCallback);
|
||||
expect(sortCallCount).toBe(1);
|
||||
|
||||
queue.appendWithSorting(testItems.third, trackingSortCallback);
|
||||
expect(sortCallCount).toBe(2);
|
||||
|
||||
queue.appendWithSorting({ id: 0, value: "zero" }, trackingSortCallback);
|
||||
expect(sortCallCount).toBeGreaterThan(3);
|
||||
|
||||
expect(queue.get(0)).toEqual({ id: 0, value: "zero" });
|
||||
expect(queue.get(1)).toEqual(testItems.first);
|
||||
});
|
||||
});
|
||||
|
||||
describe("popFront", () => {
|
||||
it("removes the oldest item from queue", () => {
|
||||
const queue = createQueueWithItems(3, [testItems.first, testItems.second], sortingCallbacks.byId);
|
||||
|
||||
expect(queue.size()).toBe(2);
|
||||
queue.popFront();
|
||||
expect(queue.size()).toBe(1);
|
||||
expect(queue.get(0)).toEqual(testItems.second);
|
||||
});
|
||||
|
||||
it("handles popping from empty queue", () => {
|
||||
const queue = new CircularQueue<TestItem>(3);
|
||||
|
||||
expect(() => queue.popFront()).not.toThrow();
|
||||
expect(queue.size()).toBe(0);
|
||||
});
|
||||
|
||||
it("handles popping until empty", () => {
|
||||
const queue = createQueueWithItems(2, [testItems.first, testItems.second], sortingCallbacks.byId);
|
||||
|
||||
queue.popFront();
|
||||
expect(queue.size()).toBe(1);
|
||||
queue.popFront();
|
||||
expect(queue.size()).toBe(0);
|
||||
queue.popFront();
|
||||
expect(queue.size()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("binarySearch", () => {
|
||||
it("finds item using key extractor function", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.apple, testItems.cherry, testItems.grape, testItems.orange], sortingCallbacks.byId);
|
||||
|
||||
const result = queue.binarySearch(5, keyExtractors.id);
|
||||
|
||||
expect(result).toEqual(testItems.grape);
|
||||
});
|
||||
|
||||
it("returns undefined when item not found", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.apple, testItems.cherry, testItems.orange], sortingCallbacks.byId);
|
||||
|
||||
const result = queue.binarySearch(5, keyExtractors.id);
|
||||
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
|
||||
it("finds first item", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.apple, testItems.cherry, testItems.orange], sortingCallbacks.byId);
|
||||
|
||||
const result = queue.binarySearch(1, keyExtractors.id);
|
||||
|
||||
expect(result).toEqual(testItems.apple);
|
||||
});
|
||||
|
||||
it("finds last item", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.apple, testItems.cherry, testItems.orange], sortingCallbacks.byId);
|
||||
|
||||
const result = queue.binarySearch(7, keyExtractors.id);
|
||||
|
||||
expect(result).toEqual(testItems.orange);
|
||||
});
|
||||
|
||||
it("returns undefined for empty queue", () => {
|
||||
const queue = new CircularQueue<TestItem>(5);
|
||||
const result = queue.binarySearch(1, keyExtractors.id);
|
||||
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
|
||||
it("works with string keys", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.apple, testItems.banana, testItems.cherry], sortingCallbacks.byValue);
|
||||
|
||||
const result = queue.binarySearch("banana", keyExtractors.value);
|
||||
|
||||
expect(result).toEqual(testItems.banana);
|
||||
});
|
||||
|
||||
it("maintains sorted order assumption", () => {
|
||||
const queue = createQueueWithItems(5, [testItems.d, testItems.a, testItems.c, testItems.b], sortingCallbacks.byValue);
|
||||
|
||||
expect(queue.binarySearch("a", keyExtractors.value)).toEqual(testItems.a);
|
||||
expect(queue.binarySearch("b", keyExtractors.value)).toEqual(testItems.b);
|
||||
expect(queue.binarySearch("c", keyExtractors.value)).toEqual(testItems.c);
|
||||
expect(queue.binarySearch("d", keyExtractors.value)).toEqual(testItems.d);
|
||||
expect(queue.binarySearch("z", keyExtractors.value)).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("integration", () => {
|
||||
it("handles appendWithSorting, popFront, and binarySearch together", () => {
|
||||
const queue = createQueueWithItems(3, [testItems.third, testItems.first, testItems.second], sortingCallbacks.byId);
|
||||
|
||||
expect(queue.binarySearch(2, keyExtractors.id)).toEqual(testItems.second);
|
||||
|
||||
queue.popFront();
|
||||
expect(queue.binarySearch(1, keyExtractors.id)).toBeUndefined();
|
||||
expect(queue.binarySearch(2, keyExtractors.id)).toEqual(testItems.second);
|
||||
|
||||
queue.appendWithSorting(testItems.fourth, sortingCallbacks.byId);
|
||||
expect(queue.binarySearch(4, keyExtractors.id)).toEqual(testItems.fourth);
|
||||
});
|
||||
});
|
||||
});
|
||||
45
src/types/__tests__/TupleKeyTests.test.ts
Normal file
45
src/types/__tests__/TupleKeyTests.test.ts
Normal file
@@ -0,0 +1,45 @@
|
||||
import { describe, expect, it } from "@jest/globals";
|
||||
import { TupleKey } from "../TupleKey";
|
||||
|
||||
describe("TupleKey", () => {
|
||||
it("stores a value copy of the original tuple", () => {
|
||||
const tuple: [string, string] = ["150", "539"];
|
||||
const tupleKey = new TupleKey(...tuple);
|
||||
|
||||
expect(tupleKey.tuple).toEqual(tuple);
|
||||
});
|
||||
|
||||
it("returns a string representation of itself", () => {
|
||||
const tuple: [string, string] = ["150", "539"];
|
||||
const tupleKey = new TupleKey(...tuple);
|
||||
|
||||
expect(`${tupleKey}`).toEqual("150|539");
|
||||
});
|
||||
|
||||
it("supports usage as key in object", () => {
|
||||
const tupleKey1 = new TupleKey("1", "2");
|
||||
const tupleKey2 = new TupleKey("3", "4");
|
||||
|
||||
const sampleObject = {
|
||||
[tupleKey1.toString()]: "value1",
|
||||
[tupleKey2.toString()]: "value2",
|
||||
};
|
||||
|
||||
expect(sampleObject[tupleKey1.toString()]).toEqual("value1");
|
||||
expect(sampleObject[(new TupleKey("1", "2")).toString()]).toEqual("value1");
|
||||
});
|
||||
|
||||
describe("fromExistingStringKey", () => {
|
||||
it("creates a new TupleKey from an existing string key", () => {
|
||||
const strKey = "hello|there";
|
||||
const tupleKey = TupleKey.fromExistingStringKey(strKey);
|
||||
expect(tupleKey.toString()).toEqual(strKey);
|
||||
});
|
||||
|
||||
it("creates an empty tuple if there is no string", () => {
|
||||
const strKey = "";
|
||||
const tupleKey = TupleKey.fromExistingStringKey(strKey);
|
||||
expect(tupleKey.toString()).toEqual(strKey);
|
||||
})
|
||||
})
|
||||
});
|
||||
Reference in New Issue
Block a user