Stop predictions

src/Contracts.ts

@@ -81,7 +81,7 @@ export interface GTFSRealTimeInterface {
 
 export interface StopDeparturePredictionsInterface {
     getStopPredictions(
-        stopId?: string | null,
+        stopId: string,
     ): Promise<any>;
 }
 

src/ResponseDataDecorator.ts

@@ -23,6 +23,12 @@ import {StopTimeUpdate} from "./domain/gtfs-rt/entity/trip-update/StopTimeUpdate
 import {Arrival} from "./domain/gtfs-rt/entity/trip-update/Arrival";
 import {Trip as TripUpdateTrip} from "./domain/gtfs-rt/entity/trip-update/Trip";
 import {VehicleId} from "./domain/gtfs-rt/entity/trip-update/VehicleId";
+import {Response as StopPredictionResponse} from "./domain/stop-departure-prediction/Response";
+import {Departure} from "./domain/stop-departure-prediction/Departure";
+import {Origin} from "./domain/stop-departure-prediction/Origin";
+import {Destination} from "./domain/stop-departure-prediction/Destination";
+import {Entity as StopPredictionEntity} from "./domain/stop-departure-prediction/Entity";
+import {Arrival as StopPredictionArrival} from "./domain/stop-departure-prediction/Arrival";
 
 export class ResponseDataDecorator implements MetlinkHttpClientInterface {
     private readonly httpClient: MetlinkHttpClientInterface;
@@ -343,8 +349,44 @@ export class ResponseDataDecorator implements MetlinkHttpClientInterface {
     }
 
 
-    public async getStopPredictions(stopId: string | null): Promise<any> {
-
+    public async getStopPredictions(stopId: string): Promise<any> {
+        const response = await this.httpClient.getStopPredictions(stopId);
+
+        return new StopPredictionResponse(
+            response.data.farezone,
+            response.data.closed,
+            response.data.departures.map((departure:any) => {
+                return new StopPredictionEntity(
+                    departure.stop_id,
+                    departure.service_id,
+                    departure.direction,
+                    departure.operator,
+                    new Origin(
+                        departure.origin.stop_id,
+                        departure.origin.name
+                    ),
+                    new Destination(
+                        departure.destination.stop_id,
+                        departure.destination.name
+                    ),
+                    departure.delay,
+                    departure.vehicle_id,
+                    departure.name,
+                    new StopPredictionArrival(
+                        departure.arrival.aimed,
+                        departure.arrival.expected
+                    ),
+                    new Departure(
+                        departure.departure.aimed,
+                        departure.departure.expected
+                    ),
+                    departure.status,
+                    departure.monitored,
+                    departure.wheelchair_accessible,
+                    departure.trip_id
+                );
+            })
+        );
     }
 
     public async getTripCancellations(query: TripCancellationQueryInterface | null): Promise<any> {

src/domain/stop-departure-prediction/Entity.ts

@@ -49,7 +49,23 @@ export class Entity {
     private readonly _wheelChairAccessible: boolean;
     private readonly _tripId: string;
 
-    constructor(stopId: string, serviceId: string, direction: string, operator: string, origin: Origin, destination: Destination, delay: string, vehicleId: string, name: string, arrival: Arrival, departure: Departure, status: string, monitored: boolean, wheelChairAccessible: boolean, tripId: string) {
+    constructor(
+        stopId: string,
+        serviceId: string,
+        direction: string,
+        operator: string,
+        origin: Origin,
+        destination: Destination,
+        delay: string,
+        vehicleId: string,
+        name: string,
+        arrival: Arrival,
+        departure: Departure,
+        status: string,
+        monitored: boolean,
+        wheelChairAccessible: boolean,
+        tripId: string
+    ) {
         this._stopId = stopId;
         this._serviceId = serviceId;
         this._direction = direction;

tests/integration/MetlinkHttpClient/StopPredictions.test.ts

@@ -4,6 +4,7 @@ import {MetlinkHttpClientInterface} from "../../../src/Contracts";
 
 describe("Integration: Metlink Http Client: Stop Predictions", () => {
 
+
     function getSchema(): {} {
         return {
             "$schema": "http://json-schema.org/draft-07/schema#",
@@ -59,10 +60,9 @@ describe("Integration: Metlink Http Client: Stop Predictions", () => {
                             },
                             "delay": {
                                 "type": "string",
-                                "pattern": "^PT\\d+M\\d+S$"
                             },
                             "vehicle_id": {
-                                "type": "string"
+                                "type": ["string","null"]
                             },
                             "name": {
                                 "type": "string"
@@ -74,7 +74,7 @@ describe("Integration: Metlink Http Client: Stop Predictions", () => {
                                         "type": "string"
                                     },
                                     "expected": {
-                                        "type": "string"
+                                        "type": ["string", "null"]
                                     }
                                 },
                                 "required": ["aimed", "expected"]
@@ -86,14 +86,13 @@ describe("Integration: Metlink Http Client: Stop Predictions", () => {
                                         "type": "string"
                                     },
                                     "expected": {
-                                        "type": "string"
+                                        "type": ["string", "null"]
                                     }
                                 },
                                 "required": ["aimed", "expected"]
                             },
                             "status": {
-                                "type": "string",
-                                "enum": ["on time", "delayed", "cancelled"]
+                                "type": ["string", "null"]
                             },
                             "monitored": {
                                 "type": "boolean"
@@ -136,7 +135,7 @@ describe("Integration: Metlink Http Client: Stop Predictions", () => {
 
     test("getStopPredictions", async () => {
         const client: MetlinkHttpClientInterface = MetlinkHttpClientBuilder.buildWithAxios(getMetlinkToken())
-        const response = await client.getStopPredictions();
+        const response = await client.getStopPredictions("5515");
 
         const result = SchemaValidator.validate(response.data, getSchema());
         expect(result.isValid).toBeTruthy();

tests/unit/ResponseDataDecorator/StopPredictions.test.ts

@@ -1,9 +1,15 @@
 import axios from 'axios';
 import MockAdapter from "axios-mock-adapter";
+import {MetlinkHttpClientInterface} from "../../../src/Contracts";
+import {ClientBuilder} from "../ClientBuilder";
+import {Response} from "../../../src/domain/stop-departure-prediction/Response";
 
 const mock: MockAdapter = new MockAdapter(axios);
 
-describe.skip("Response Data Decorator: Stop predictions", () => {
+describe("Response Data Decorator: Stop predictions", () => {
+
+    const STOP_ID: string = "5515";
+
 
     afterEach(function (): void {
         mock.reset();
@@ -50,10 +56,23 @@ describe.skip("Response Data Decorator: Stop predictions", () => {
         ]
     ];
 
-    function getPath(): string {
-        return "/stop-predictions";
+    function getPath(urlSearchParams: URLSearchParams | null = null): string {
+        let query: string = "";
+
+        if (urlSearchParams) {
+            query = "?"+urlSearchParams?.toString();
+        }
+
+        return "/stop-predictions" + query;
     }
 
+
     it.each(dataSet)("getStopPredictions", async (mockData) => {
+        mock.onGet(getPath(new URLSearchParams({"stop_id": STOP_ID}))).replyOnce(200, mockData);
+
+        const client: MetlinkHttpClientInterface = ClientBuilder.getHttpClientWithResponseDataDecorator(axios);
+        const entity: Response = await client.getStopPredictions(STOP_ID);
+
+        expect(entity).toBeInstanceOf(Response)
     });
 });