minotor 1.0.0

package/src/gtfs/__tests__/routes.test.ts

@@ -0,0 +1,63 @@
+import assert from 'node:assert';
+import { Readable } from 'node:stream';
+import { describe, it } from 'node:test';
+
+import { parseRoutes } from '../routes.js';
+
+describe('GTFS routes parser', () => {
+  describe('parsing a well formed stream', () => {
+    it('should find valid routes present in the source', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'route_id,agency_id,route_short_name,route_long_name,route_desc,route_type\n',
+      );
+      mockedStream.push('"routeA","agencyA","B1","BUS 1","A bus","3"\n');
+      mockedStream.push('"routeB","agencyB","T1","TRAM 1","A tram","0"\n');
+      mockedStream.push(null);
+
+      const routes = await parseRoutes(mockedStream);
+      assert.deepEqual(
+        routes,
+        new Map([
+          [
+            'routeA',
+            {
+              type: 'BUS',
+              name: 'B1',
+            },
+          ],
+          [
+            'routeB',
+            {
+              type: 'TRAM',
+              name: 'T1',
+            },
+          ],
+        ]),
+      );
+    });
+    it('should ignore routes with invalid route type', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'route_id,agency_id,route_short_name,route_long_name,route_desc,route_type\n',
+      );
+      mockedStream.push('"routeA","agencyA","B1","BUS 1","A bus","3"\n');
+      mockedStream.push('"routeB","agencyB","T1","TRAM 1","A tram","8"\n');
+      mockedStream.push(null);
+
+      const routes = await parseRoutes(mockedStream);
+      assert.deepEqual(
+        routes,
+        new Map([
+          [
+            'routeA',
+            {
+              type: 'BUS',
+              name: 'B1',
+            },
+          ],
+        ]),
+      );
+    });
+  });
+});

package/src/gtfs/__tests__/services.test.ts

@@ -0,0 +1,209 @@
+import * as assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { describe, it } from 'node:test';
+
+import { DateTime } from 'luxon';
+
+import { parseCalendar, parseCalendarDates, ServiceIds } from '../services.js';
+describe('GTFS calendar parser', () => {
+  describe('parsing a well formed stream', () => {
+    it('should find valid services present in the source', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date\n',
+      );
+      mockedStream.push(
+        '"testId","0","0","0","0","0","1","0","20231115","20231120"\n',
+      );
+      mockedStream.push(
+        '"otherTestId","0","0","0","0","0","1","0","20231010","20231220"\n',
+      );
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set();
+      await parseCalendar(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-18T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(validServiceIds, new Set(['testId', 'otherTestId']));
+    });
+    it('should not alter valid services already present in the input', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date\n',
+      );
+      mockedStream.push(
+        '"testId","0","0","0","0","0","1","0","20231115","20231120"\n',
+      );
+      mockedStream.push(
+        '"otherTestId","0","0","0","0","0","1","0","20231010","20231220"\n',
+      );
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set([
+        'testId',
+        'yetAnotherTestId',
+      ]);
+
+      await parseCalendar(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-18T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(
+        validServiceIds,
+        new Set(['testId', 'otherTestId', 'yetAnotherTestId']),
+      );
+    });
+    it('should ignore services not valid on the right weekday', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date\n',
+      );
+      mockedStream.push(
+        '"testId","1","0","0","0","0","0","0","20231115","20231120"\n',
+      );
+      mockedStream.push(
+        '"otherTestId","0","0","0","0","0","1","0","20231010","20231220"\n',
+      );
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set();
+      await parseCalendar(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-18T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(validServiceIds, new Set(['otherTestId']));
+    });
+    it('should ignore services not valid on the date window', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date\n',
+      );
+      mockedStream.push(
+        '"testId","0","0","0","0","0","1","0","20231119","20231120"\n',
+      );
+      mockedStream.push(
+        '"otherTestId","0","0","0","0","0","1","0","20231010","20231220"\n',
+      );
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set();
+      await parseCalendar(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-18T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(validServiceIds, new Set(['otherTestId']));
+    });
+  });
+});
+
+describe('GTFS calendar dates parser', () => {
+  describe('parsing a well formed stream', () => {
+    it('should find valid services present in the source', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push('service_id,date,exception_type\n');
+      mockedStream.push('"testId","20231115","1"\n');
+      mockedStream.push('"otherTestId","20231115","1"\n');
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set();
+      await parseCalendarDates(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-15T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(validServiceIds, new Set(['testId', 'otherTestId']));
+    });
+    it('should ignore services valid on a different date', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push('service_id,date,exception_type\n');
+      mockedStream.push('"testId","20231116","1"\n');
+      mockedStream.push('"otherTestId","20231115","1"\n');
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set();
+      await parseCalendarDates(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-15T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(validServiceIds, new Set(['otherTestId']));
+    });
+    it('should not alter valid services already present in the input', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push('service_id,date,exception_type\n');
+      mockedStream.push('"testId","20231115","1"\n');
+      mockedStream.push('"otherTestId","20231115","1"\n');
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set([
+        'testId',
+        'yetAnotherTestId',
+      ]);
+      await parseCalendarDates(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-15T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(
+        validServiceIds,
+        new Set(['testId', 'otherTestId', 'yetAnotherTestId']),
+      );
+    });
+    it('should remove services from the input in case of exception', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push('service_id,date,exception_type\n');
+      mockedStream.push('"testId","20231115","2"\n');
+      mockedStream.push('"otherTestId","20231115","1"\n');
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set([
+        'testId',
+        'yetAnotherTestId',
+      ]);
+      await parseCalendarDates(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-15T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(
+        validServiceIds,
+        new Set(['otherTestId', 'yetAnotherTestId']),
+      );
+    });
+    it('should ignore exceptions on a different date', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push('service_id,date,exception_type\n');
+      mockedStream.push('"testId","20231114","2"\n');
+      mockedStream.push('"otherTestId","20231115","1"\n');
+      mockedStream.push(null);
+
+      const validServiceIds: ServiceIds = new Set([
+        'testId',
+        'yetAnotherTestId',
+      ]);
+      await parseCalendarDates(
+        mockedStream,
+        validServiceIds,
+        DateTime.fromISO('2023-11-15T12:00:00+00:00'),
+      );
+
+      assert.deepEqual(
+        validServiceIds,
+        new Set(['testId', 'otherTestId', 'yetAnotherTestId']),
+      );
+    });
+  });
+});

package/src/gtfs/__tests__/stops.test.ts

@@ -0,0 +1,177 @@
+import assert from 'node:assert';
+import { Readable } from 'node:stream';
+import { describe, it } from 'node:test';
+
+import { StopsMap } from '../../stops/stops.js';
+import { chGtfsProfile } from '../profiles/ch.js';
+import { parseStops } from '../stops.js';
+
+describe('GTFS stops parser', () => {
+  describe('parsing a well formed stream', () => {
+    it('should parse valid stops present in the source', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n',
+      );
+      mockedStream.push(
+        '"Parent8587255","Fribourg, Tilleul/Cathédrale","46.8061375857565","7.16145029437328","1",""\n',
+      );
+      mockedStream.push(
+        '"Parent8504100","Fribourg/Freiburg","46.8031492395272","7.15104780338173","1",""\n',
+      );
+
+      mockedStream.push(null);
+      const stops = await parseStops(
+        mockedStream,
+        chGtfsProfile.platformParser,
+      );
+      const expectedStops: StopsMap = new Map([
+        [
+          'Parent8587255',
+          {
+            id: 'Parent8587255',
+            lat: 46.8061375857565,
+            locationType: 'STATION',
+            lon: 7.16145029437328,
+            name: 'Fribourg, Tilleul/Cathédrale',
+            children: [],
+          },
+        ],
+        [
+          'Parent8504100',
+          {
+            id: 'Parent8504100',
+            lat: 46.8031492395272,
+            locationType: 'STATION',
+            lon: 7.15104780338173,
+            name: 'Fribourg/Freiburg',
+            children: [],
+          },
+        ],
+      ]);
+
+      assert.deepEqual(stops, expectedStops);
+    });
+    it('should parse nested stops', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n',
+      );
+      mockedStream.push(
+        '"8504100:0:1","Fribourg/Freiburg","46.8018210323626","7.14993389242926","","Parent8504100"\n',
+      );
+      mockedStream.push(
+        '"8504100:0:2","Fribourg/Freiburg","46.8010031847878","7.14920625704902","","Parent8504100"\n',
+      );
+      mockedStream.push(
+        '"Parent8504100","Fribourg/Freiburg","46.8031492395272","7.15104780338173","1",""\n',
+      );
+
+      mockedStream.push(null);
+
+      const stops = await parseStops(mockedStream);
+      const expectedStops: StopsMap = new Map([
+        [
+          '8504100:0:1',
+          {
+            id: '8504100:0:1',
+            lat: 46.8018210323626,
+            lon: 7.14993389242926,
+            name: 'Fribourg/Freiburg',
+            parent: 'Parent8504100',
+            locationType: 'SIMPLE_STOP_OR_PLATFORM',
+            children: [],
+          },
+        ],
+        [
+          '8504100:0:2',
+          {
+            id: '8504100:0:2',
+            lat: 46.8010031847878,
+            lon: 7.14920625704902,
+            name: 'Fribourg/Freiburg',
+            parent: 'Parent8504100',
+            locationType: 'SIMPLE_STOP_OR_PLATFORM',
+            children: [],
+          },
+        ],
+        [
+          'Parent8504100',
+          {
+            id: 'Parent8504100',
+            children: ['8504100:0:1', '8504100:0:2'],
+            lat: 46.8031492395272,
+            locationType: 'STATION',
+            lon: 7.15104780338173,
+            name: 'Fribourg/Freiburg',
+          },
+        ],
+      ]);
+
+      assert.deepEqual(stops, expectedStops);
+    });
+    it('should parse the platform', async () => {
+      const mockedStream = new Readable();
+      mockedStream.push(
+        'stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n',
+      );
+      mockedStream.push(
+        '"8504100:0:1","Fribourg/Freiburg","46.8018210323626","7.14993389242926","","Parent8504100"\n',
+      );
+      mockedStream.push(
+        '"8504100:0:2","Fribourg/Freiburg","46.8010031847878","7.14920625704902","","Parent8504100"\n',
+      );
+      mockedStream.push(
+        '"Parent8504100","Fribourg/Freiburg","46.8031492395272","7.15104780338173","1",""\n',
+      );
+
+      mockedStream.push(null);
+
+      const stops = await parseStops(
+        mockedStream,
+        chGtfsProfile.platformParser,
+      );
+      const expectedStops: StopsMap = new Map([
+        [
+          '8504100:0:1',
+          {
+            id: '8504100:0:1',
+            lat: 46.8018210323626,
+            lon: 7.14993389242926,
+            name: 'Fribourg/Freiburg',
+            parent: 'Parent8504100',
+            platform: '1',
+            locationType: 'SIMPLE_STOP_OR_PLATFORM',
+            children: [],
+          },
+        ],
+        [
+          '8504100:0:2',
+          {
+            id: '8504100:0:2',
+            lat: 46.8010031847878,
+            lon: 7.14920625704902,
+            name: 'Fribourg/Freiburg',
+            parent: 'Parent8504100',
+            platform: '2',
+            locationType: 'SIMPLE_STOP_OR_PLATFORM',
+            children: [],
+          },
+        ],
+        [
+          'Parent8504100',
+          {
+            id: 'Parent8504100',
+            children: ['8504100:0:1', '8504100:0:2'],
+            lat: 46.8031492395272,
+            locationType: 'STATION',
+            lon: 7.15104780338173,
+            name: 'Fribourg/Freiburg',
+          },
+        ],
+      ]);
+
+      assert.deepEqual(stops, expectedStops);
+    });
+  });
+});

package/src/gtfs/__tests__/time.test.ts

@@ -0,0 +1,27 @@
+import * as assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { DateTime } from 'luxon';
+
+import { toGtfsDate, toTime } from '../time.js';
+
+describe('Date converter', () => {
+  it('should convert a valid date to GTFS format', () => {
+    assert.equal(
+      toGtfsDate(DateTime.fromISO('2007-01-10T12:00:00+00:00')),
+      20070110,
+    );
+  });
+});
+
+describe('Time converter', () => {
+  it('should convert a valid service time to numerical format', () => {
+    assert.equal(toTime('10:23:54').toSeconds(), 37434);
+  });
+  it('should convert a valid service time after midnight to numerical format', () => {
+    assert.equal(toTime('25:13:31').toSeconds(), 90811);
+  });
+  it('should throw when trying to convert an invalid time', () => {
+    assert.throws(() => toTime('2513:31'));
+  });
+});

package/src/gtfs/__tests__/transfers.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert';
+import { Readable } from 'node:stream';
+import { describe, it } from 'node:test';
+
+import { Duration } from '../../timetable/duration.js';
+import { parseTransfers } from '../transfers.js';
+
+describe('GTFS transfers parser', () => {
+  it('should correctly parse valid transfers', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440:0:1","2","180"\n');
+    mockedStream.push('"1100097","8014447","2","240"\n');
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    const expectedTransfers = new Map([
+      [
+        '1100084',
+        [
+          {
+            destination: '8014440:0:1',
+            type: 'REQUIRES_MINIMAL_TIME',
+            minTransferTime: Duration.fromSeconds(180),
+          },
+        ],
+      ],
+      [
+        '1100097',
+        [
+          {
+            destination: '8014447',
+            type: 'REQUIRES_MINIMAL_TIME',
+            minTransferTime: Duration.fromSeconds(240),
+          },
+        ],
+      ],
+    ]);
+
+    assert.deepEqual(transfers, expectedTransfers);
+  });
+
+  it('should ignore impossible transfer types', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440:0:1","3","180"\n');
+    mockedStream.push('"1100097","8014447","5","240"\n');
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    assert.deepEqual(transfers, new Map());
+  });
+
+  it('should ignore unsupported transfer types between routes', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_route_id,to_route_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440","2","180"\n');
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    assert.deepEqual(transfers, new Map());
+  });
+
+  it('should ignore unsupported transfer types between trips', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_trip_id,to_trip_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440","2","180"\n');
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    assert.deepEqual(transfers, new Map());
+  });
+
+  it('should allow missing minimum transfer time', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push('"1100084","8014440:0:1","2"\n');
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    assert.deepEqual(
+      transfers,
+      new Map([
+        [
+          '1100084',
+          [
+            {
+              destination: '8014440:0:1',
+              type: 'REQUIRES_MINIMAL_TIME',
+            },
+          ],
+        ],
+      ]),
+    );
+  });
+
+  it('should handle empty transfers', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
+    );
+    mockedStream.push(null);
+
+    const transfers = await parseTransfers(mockedStream);
+    assert.deepEqual(transfers, new Map());
+  });
+});