@transportme/load-ptv-gtfs 1.4.2 → 1.4.3

package/lib/gtfs-parser/GTFSRoute.mjs

@@ -23,7 +23,7 @@ export default class GTFSRoute {
     this.agencyID = agencyID
     this.routeName = routeName
 
-    if (routeNumber !== null && routeNumber.length === 0) routeNumber = null
+    if (!routeNumber || routeNumber.toString().trim().length === 0) routeNumber = null
     this.routeNumber = routeNumber
   }
 
@@ -57,7 +57,7 @@ export default class GTFSRoute {
    */
   static create(data, mode) {
     let { routeGTFSID } = data
-    let routeTypes = [ RailGTFSRoute, NewGTFSRoute, SmartrakGTFSRoute, GTFSRoute ]
+    let routeTypes = [ RailGTFSRoute, NewGTFSRoute, SmartrakGTFSRoute, MTMRailRoute, GTFSRoute ]
     for (let type of routeTypes) {
       if (type.canProcess(routeGTFSID, mode)) return new type(data)
     }
@@ -78,7 +78,7 @@ class SmartrakGTFSRoute extends GTFSRoute {
   parseRouteID(routeGTFSID) {
     let [ _, routeNumber ] = routeGTFSID.match(/^\d+\-(\w+)/)
     return `4-${routeNumber}`
-  }  
+  }
 
   static canProcess(routeGTFSID, mode) {
     return routeGTFSID.includes('-aus-')
@@ -100,7 +100,7 @@ class NewGTFSRoute extends GTFSRoute {
   parseRouteID(routeGTFSID) {
     let [ _, modeID, routeNumber ] = routeGTFSID.match(/vic-0*(\d+)\-(\w+)/)
     return `${modeID}-${routeNumber}`
-  }  
+  }
 
 }
 
@@ -122,3 +122,21 @@ class RailGTFSRoute extends NewGTFSRoute {
   }
 
 }
+
+class MTMRailRoute extends GTFSRoute {
+
+  constructor(data) {
+    super(data)
+    this.routeName = 'Rail Replacement Bus'
+    this.routeNumber = null
+  }
+
+  static canProcess(routeGTFSID, mode) {
+    return !routeGTFSID.match(/^\d+-\w{1,3}/) && mode === 'metro train'
+  }
+
+  parseRouteID(routeGTFSID) {
+    return '2-RRB'
+  }  
+
+}

package/lib/gtfs-parser/GTFSTrip.mjs

@@ -48,7 +48,7 @@ export default class GTFSTrip {
    * @returns {GTFSTrip} A trip instance representing the data being passed in
    */
   static create(data, mode) {
-    let types = [ SmartrakTrip, MetroTrip, GTFSTrip ]
+    let types = [ SmartrakTrip, MetroTrip, MTMRailTrip, GTFSTrip ]
     for (let type of types) {
       if (type.canProcess(data, mode)) return new type(data)
     }
@@ -189,4 +189,26 @@ export class MetroRRBTrip extends MetroTrip {
     return super.canProcess(data, mode) && data.id.match(/^02-\w{3}-R-/)
   }
 
+}
+
+export class MTMRailTrip extends GTFSTrip {
+
+  constructor(data) {
+    if (data.headsign && data.headsign.length === 6 && data.headsign.match(/[A-Z]{3}\d{3}/)) {
+      data.block = data.headsign
+    }
+
+    super(data)
+  }
+
+  static canProcess(data, mode) {
+    return mode === TRANSIT_MODES.metroTrain && data.routeGTFSID === '2-RRB'
+  }
+
+  getTripData() {
+    return {
+      ...super.getTripData(),
+      isRailReplacementBus: true
+    }
+  }
 }

package/lib/gtfs-parser/readers/GTFSCalendarReader.mjs

@@ -21,6 +21,7 @@ export default class GTFSCalendarReader extends GTFSReader {
   async open() {
     await super.open()
 
+    if (!this.#calendarDateFile) return
     let calendarDateReader = new GTFSCalendarDateReader(this.#calendarDateFile)
     await calendarDateReader.open()
     while (calendarDateReader.available()) {

package/lib/gtfs-parser/readers/line-reader.mjs

@@ -58,12 +58,7 @@ export default class CSVLineReader {
   }
 
   #setHeaders(line) {
-    let parts
-    if (line.includes('"')) {
-      parts = line.match(/"([^"]*)"/g).map(f => f.slice(1, -1))
-    } else {
-      parts = line.split(',')
-    }
+    let parts = [ ...line.matchAll(/(?:,"|^")(""|[\w\W]*?)(?=",|"$)|(?:,(?!")|^(?!"))([^,]*?)(?=$|,)|(\r\n|\n)/gm) ].map(match => match[1] || match[2])
 
     return this.#headers.reduce((acc, header, i) => {
       acc[header] = parts[i]

package/lib/loader/TripLoader.mjs

@@ -105,6 +105,7 @@ export default class TripLoader {
 
     let stopTimings = await async.map(stops, async stop => {
       let stopData = await this.findMatchingStop(stop.stopID)
+      if (!stopData) throw new Error(`Failed to match stop ${stop.stopID} in trip ${tripData.getTripID()}`)
       let bay = stopData.bays.find(bay => bay.stopGTFSID === stop.stopID)
 
       let data = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transportme/load-ptv-gtfs",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "",
   "main": "index.mjs",
   "scripts": {

package/.github/workflows/unit-test.yml

@@ -1,46 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-  
-    - name: Cache node modules
-      id: cache-npm
-      uses: actions/cache@v4
-      env:
-        cache-name: cache-node-modules
-      with:
-        # npm cache files are stored in `~/.npm` on Linux/macOS
-        path: ~/.npm
-        key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-        restore-keys: |
-          ${{ runner.os }}-build-${{ env.cache-name }}-
-          ${{ runner.os }}-build-
-          ${{ runner.os }}-
-    
-    - name: Use Node.js 20.x
-      uses: actions/setup-node@v4
-      with:
-        node-version: '20.x'
-        cache: 'npm'
-        
-    - name: Install dependencies
-      run: npm install
-
-    - name: Run test
-      run: npm test

package/test/gtfs-calendar.test.mjs

@@ -1,182 +0,0 @@
-import { expect } from 'chai'
-import GTFSCalendarReader from '../lib/gtfs-parser/readers/GTFSCalendarReader.mjs'
-import GTFSCalendarDateReader from '../lib/gtfs-parser/readers/GTFSCalendarDatesReader.mjs'
-import GTFSCalendar from '../lib/gtfs-parser/GTFSCalendar.mjs'
-import GTFSCalendarDate from '../lib/gtfs-parser/GTFSCalendarDate.mjs'
-import path from 'path'
-import url from 'url'
-import { CALENDAR_DATES } from '../lib/constants.mjs'
-import { dateUtils } from '@transportme/transportvic-utils'
-
-const __filename = url.fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-const calendarFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar.txt')
-const calendarDatesFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar_dates.txt')
-
-describe('The GTFSCalendar class', () => {
-  it('Should process the calendar data to a list of operation days', () => {
-    expect(new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241122',
-      endDay: '20241129',
-      daysOfWeek: ["0","0","0","0","1","1","0"]
-    }).getOperationDays()).to.have.members([
-      "20241122", "20241123", "20241129"
-    ])
-
-    expect(new GTFSCalendar({
-      id: 'T2',
-      startDay: '20241123',
-      endDay: '20241130',
-      daysOfWeek: ["1","1","1","1","1","0","0"]
-    }).getOperationDays()).to.have.members([
-      "20241125", "20241126", "20241127", "20241128", "20241129"
-    ])
-  })
-
-  it('Be inclusive of the end date', () => {
-    expect(new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241122',
-      endDay: '20241122',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }).getOperationDays()).to.have.members([
-      "20241122"
-    ])
-  })
-
-  it('Should allow adding of an extra date into the calendar', () => {
-    let cal = new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241122',
-      endDay: '20241122',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }, [new GTFSCalendarDate({
-      id: 'T1',
-      date: '20241125',
-      type: CALENDAR_DATES.ADDED
-    })])
-    
-    expect(cal.getOperationDays()).to.have.members([
-      "20241122", "20241125"
-    ])
-  })
-
-  it('Should allow removing of a specific date from the calendar', () => {
-    let cal = new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241224',
-      endDay: '20241226',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }, [new GTFSCalendarDate({
-      id: 'T1',
-      date: '20241225',
-      type: CALENDAR_DATES.REMOVED
-    })])
-
-    expect(cal.getOperationDays()).to.deep.equal([
-      "20241224", "20241226"
-    ])
-  })
-
-  it('Should ensure that adding an extra date into the calendar does not introduce duplicates', () => {
-    let cal = new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241122',
-      endDay: '20241122',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }, [new GTFSCalendarDate({
-      id: 'T1',
-      date: '20241122',
-      type: CALENDAR_DATES.ADDED
-    })])
-
-    expect(cal.getOperationDays()).to.deep.equal([
-      "20241122"
-    ])
-  })
-
-  it('Should ensure that duplicate extra dates do not introduce duplicates', () => {
-    let calendarDate = new GTFSCalendarDate({
-      id: 'T1',
-      date: '20241122',
-      type: CALENDAR_DATES.ADDED
-    })
-
-    let cal = new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241122',
-      endDay: '20241122',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }, [calendarDate, calendarDate, calendarDate])
-
-    expect(cal.getOperationDays()).to.deep.equal([
-      "20241122"
-    ])
-  })
-
-  it('Should ensure that the date exists when removing a specific date from the calendar, and not do anything otherwise', () => {
-    let cal = new GTFSCalendar({
-      id: 'T1',
-      startDay: '20241224',
-      endDay: '20241226',
-      daysOfWeek: ["1","1","1","1","1","1","1"]
-    }, [new GTFSCalendarDate({
-      id: 'T1',
-      date: '20241227',
-      type: CALENDAR_DATES.REMOVED
-    })])
-
-    expect(cal.getOperationDays()).to.deep.equal([
-      "20241224", "20241225", "20241226"
-    ])
-  })
-})
-
-describe('The GTFSCalendarDate class', () => {
-  it('Should convert the CSV data into a proper date object', () => {
-    expect(new GTFSCalendarDate({
-      id: 'T6',
-      date: '20241125',
-      type: CALENDAR_DATES.ADDED
-    }).date.toUTC().toISO()).to.equal('2024-11-24T13:00:00.000Z')
-  })
-})
-
-describe('The GTFSCalendarDatesReader class', () => {
-  it('Should read a calendar dates and return a GTFSCalendarDate object', async () => {
-    let reader = new GTFSCalendarDateReader(calendarDatesFile)
-    await reader.open()
-
-    let date = await reader.getNextEntity()
-    expect(date.id).to.equal('T3_2')
-    expect(dateUtils.toGTFSDate(date.date)).to.equal('20250126')
-    expect(date.type).to.equal(CALENDAR_DATES.REMOVED)
-
-    let date2 = await reader.getNextEntity()
-    expect(date2.id).to.equal('T5_2')
-    expect(dateUtils.toGTFSDate(date2.date)).to.equal('20241225')
-    expect(date2.type).to.equal(CALENDAR_DATES.REMOVED)
-  })
-})
-
-describe('The GTFSCalendarReader class', () => {
-  it('Should read both a calendar dates and calendar file and return a GTFSCalendar object with the appropriate exceptions filled', async () => {
-    let reader = new GTFSCalendarReader(calendarFile, calendarDatesFile)
-    await reader.open()
-
-    let allCalendars = {}
-    while (reader.available()) {
-      let calendar = await reader.getNextEntity()
-      allCalendars[calendar.id] = calendar
-    }
-
-    expect(allCalendars['T2'].getOperationDays()).to.deep.equal(["20241109"])
-
-    expect(allCalendars['T3_2'].getOperationDays()).to.contain("20241124")
-    expect(allCalendars['T3_2'].getOperationDays()).to.contain("20241201")
-    expect(allCalendars['T3_2'].getOperationDays()).to.contain("20250209")
-    expect(allCalendars['T3_2'].getOperationDays()).to.not.contain("20250126")
-  })
-})

package/test/gtfs-route-loader.test.mjs

@@ -1,208 +0,0 @@
-import { LokiDatabaseConnection } from '@transportme/database'
-import RouteLoader from '../lib/loader/RouteLoader.mjs'
-import GTFSAgencyReader from '../lib/gtfs-parser/readers/GTFSAgencyReader.mjs'
-
-import { TRANSIT_MODES } from '../lib/constants.mjs'
-
-import path from 'path'
-import url from 'url'
-import { expect } from 'chai'
-import GTFSAgency from '../lib/gtfs-parser/GTFSAgency.mjs'
-
-const __filename = url.fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-const regionalRoutesFile = path.join(__dirname, 'sample-data', 'routes', 'regional_bus_routes.txt')
-const metroRoutesFile = path.join(__dirname, 'sample-data', 'routes', 'metro_bus_routes.txt')
-const metroLinesFile = path.join(__dirname, 'sample-data', 'routes', 'metro_lines.txt')
-const agencyFile = path.join(__dirname, 'sample-data', 'routes', 'agency.txt')
-const wgtFile = path.join(__dirname, 'sample-data', 'routes', 'west_gipp_transit.txt')
-const vlineFile = path.join(__dirname, 'sample-data', 'routes', 'vline.txt')
-
-const badRoutesFile_NoAgency = path.join(__dirname, 'sample-data', 'routes', 'bad_routes.txt')
-
-describe('The GTFS Agency Reader', () => {
-  it('Should read the agencies one line at a time', async () => {
-    let reader = new GTFSAgencyReader(agencyFile)
-    await reader.open()
-    let operator = await reader.getNextEntity()
-
-    expect(operator.id).to.equal('43')
-    expect(operator.name).to.equal('CDC Ballarat')
-    expect(operator.website).to.equal('https://www.ptv.vic.gov.au/footer/customer-service/operator-contact-details/?utm_source=open_data_click_agency&utm_medium=open_data_agency_click&utm_campaign=open_data_click')
-    expect(operator.phone).to.equal('1800 800 007')
-  })
-})
-
-describe('The GTFS Routes Loader', () => {
-  it('Should process the routes and add them to the database', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(regionalRoutesFile, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadRoutes()
-
-    let bal10 = await routes.findDocument({
-      routeGTFSID: '6-10x'
-    })
-
-    expect(bal10).to.not.be.null
-    expect(bal10.routeNumber).to.equal('10')
-    expect(bal10.operators).to.deep.equal(['CDC Ballarat'])
-  })
-
-  it('Should open the agency.txt file and load all operators', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(regionalRoutesFile, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadAgencies()
-    
-    let paynesville = loader.getOperator('99')
-
-    expect(paynesville).to.not.be.undefined
-    expect(paynesville.name).to.equal('Paynesville Bus Lines')
-  })
-
-  it('Should handle smartrak routes', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(metroRoutesFile, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadRoutes()
-
-    let smart900 = await routes.findDocument({
-      routeGTFSID: '4-900'
-    })
-
-    expect(smart900).to.not.be.null
-    expect(smart900.mode).to.equal(TRANSIT_MODES.bus)
-    expect(smart900.routeNumber).to.equal('900')
-    expect(smart900.operators).to.have.members(['CDC', 'Ventura Bus Lines'])
-  })
-
-  it('Should handle metro train routes', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(metroLinesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
-    await loader.loadRoutes()
-
-    let stony = await routes.findDocument({
-      routeGTFSID: '2-STY'
-    })
-
-    expect(stony).to.not.be.null
-    expect(stony.mode).to.equal('metro train')
-    expect(stony.routeNumber).to.be.null
-    expect(stony.routeName).to.equal('Stony Point')
-    expect(stony.operators).to.have.members(['Metro'])
-  })
-
-  it('Should allow for custom route rewriting', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(wgtFile, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadRoutes({
-      processRoute: route => {
-        if (route.routeGTFSID.match(/6-w\d\d/)) {
-          route.routeGTFSID = '6-WGT'
-          route.routeName = 'West Gippsland Transit'
-        }
-
-        return route
-      }
-    })
-
-    let wgt = await routes.findDocument({
-      routeGTFSID: '6-WGT'
-    })
-
-    expect(wgt, 'Expected West Gippsland Transit route 6-WGT to be created').to.not.be.null
-    expect(wgt.mode).to.equal('bus')
-    expect(wgt.routeNumber).to.be.null
-    expect(wgt.routeName).to.equal('West Gippsland Transit')
-    expect(wgt.operators).to.have.members(['Warragul Bus Lines'])
-
-    expect(await routes.findDocument({
-      routeGTFSID: '6-w40'
-    }), 'Expected 6-w40 Moe - Garfield to not exist').to.be.null
-
-    expect(await routes.findDocument({
-      routeGTFSID: '6-w41'
-    }), 'Expected 6-w41 Warragul - Pakenham to not exist').to.be.null
-
-    let nojee = await routes.findDocument({
-      routeGTFSID: '6-W89'
-    })
-    expect(nojee, 'Expected 6-W89 Warragul - Nojee to exist and not be modified').to.not.be.null
-    expect(nojee.mode).to.equal('bus')
-    expect(nojee.routeNumber).to.equal('89')
-    expect(nojee.routeName).to.equal('Noojee - Warragul Station Via Buln Buln')
-    expect(nojee.operators).to.have.members(['Warragul Bus Lines'])
-  })
-
-
-  it('Should return a route ID map', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(wgtFile, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadRoutes({
-      processRoute: route => {
-        if (route.routeGTFSID.match(/6-w\d\d/)) {
-          route.routeGTFSID = '6-WGT'
-          route.routeName = 'West Gippsland Transit'
-        }
-
-        return route
-      }
-    })
-
-    let map = loader.getRouteIDMap()
-    expect(map['6-w19-mjp-1']).to.equal('6-WGT')
-    expect(map['6-W89-mjp-1']).to.equal('6-W89')
-  })
-
-  it('Should allow for dropping of unwanted routes', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(vlineFile, agencyFile, TRANSIT_MODES.regionalTrain, database)
-    await loader.loadRoutes({
-      processRoute: route => {
-        if (route.routeGTFSID === '1-vPK') return null
-        return route
-      }
-    })
-
-    expect(await routes.findDocument({
-      routeGTFSID: '1-vPK'
-    }), 'Expected 1-vPK V/Line Dandenong Metro Services to not exist').to.be.null
-
-    let traralgon = await routes.findDocument({
-      routeGTFSID: '1-TRN'
-    })
-    expect(traralgon, 'Expected 1-TRN Traralgon to exist and not be modified').to.not.be.null
-    expect(traralgon.mode).to.equal('regional train')
-    expect(traralgon.routeNumber).to.be.null
-    expect(traralgon.routeName).to.equal('Traralgon - Melbourne Via Pakenham, Moe & Morwell')
-    expect(traralgon.operators).to.have.members(['V/Line'])
-  })
-
-  it('Should handle invalid agency references', async () => {
-    let database = new LokiDatabaseConnection('test-db')
-    let routes = await database.createCollection('gtfs-routes')
-
-    let loader = new RouteLoader(badRoutesFile_NoAgency, agencyFile, TRANSIT_MODES.bus, database)
-    await loader.loadRoutes()
-
-    let skybus = await routes.findDocument({
-      routeGTFSID: '11-SKY'
-    })
-
-    expect(skybus).to.not.be.null
-    expect(skybus.operators).to.deep.equal([GTFSAgency.UNKNOWN_AGENCY.name]) 
-  })
-})

package/test/gtfs-routes.test.mjs

@@ -1,77 +0,0 @@
-import { expect } from 'chai'
-import GTFSRouteReader from '../lib/gtfs-parser/readers/GTFSRouteReader.mjs'
-import { TRANSIT_MODES } from '../lib/constants.mjs'
-import path from 'path'
-import url from 'url'
-
-const __filename = url.fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-const regionalRoutesFile = path.join(__dirname, 'sample-data', 'routes', 'regional_bus_routes.txt')
-const metroRoutesFile = path.join(__dirname, 'sample-data', 'routes', 'metro_bus_routes.txt')
-
-let regionalBusRoute = {
-  route_id: '6-10x-mjp-1',
-  agency_id: '43',
-  route_short_name: '10',
-  route_long_name: 'Alfredton - Ballarat Station Via Wendouree'
-}
-
-describe('The GTFSRouteReader class', () => {
-  describe('The processRoute function', () => {
-    it('Should take in the raw CSV line and process it', () => {
-      let routeData = new GTFSRouteReader('', TRANSIT_MODES.bus).processEntity(regionalBusRoute)
-
-      expect(routeData.routeGTFSID).to.equal('6-10x')
-      expect(routeData.agencyID).to.equal(regionalBusRoute.agency_id)
-      expect(routeData.routeNumber).to.equal(regionalBusRoute.route_short_name)
-      expect(routeData.routeName).to.equal(regionalBusRoute.route_long_name)
-    })
-  })
-
-  describe('The getNextEntity function', () => {
-    it('Should read the CSV file and return the next stop', async () => {
-      let routeReader = new GTFSRouteReader(regionalRoutesFile, TRANSIT_MODES.bus)
-      await routeReader.open()
-
-      await routeReader.getNextEntity()
-      let routeData = await routeReader.getNextEntity()
-
-      expect(routeData.agencyID).to.equal('99')
-      expect(routeData.routeNumber).to.equal('13')
-      expect(routeData.routeName).to.equal('Paynesville - Bairnsdale Via Paynesville')
-    })
-  })
-})
-
-describe('The GTFSRoute class', () => {
-  describe('The route ID parsing', () => {
-    it('Should parse a regular route ID and remove the -mjp- portion', async () => {
-      let routeReader = new GTFSRouteReader(regionalRoutesFile, TRANSIT_MODES.bus)
-      await routeReader.open()
-
-      let routeData = await routeReader.getNextEntity()
-      
-      expect(routeData.routeGTFSID).to.equal('6-10x')
-    })
-
-    it('Should parse a regular route ID and pad with 0s as needed', async () => {
-      let routeReader = new GTFSRouteReader(regionalRoutesFile, TRANSIT_MODES.bus)
-      await routeReader.open()
-
-      await routeReader.getNextEntity()
-      let routeData = await routeReader.getNextEntity()
-      
-      expect(routeData.routeGTFSID).to.equal('6-013')
-    })
-
-    it('Should detect a smartrak route ID and convert to a legacy 4-XXX trip', async () => {
-      let routeReader = new GTFSRouteReader(metroRoutesFile, TRANSIT_MODES.bus)
-      await routeReader.open()
-
-      expect((await routeReader.getNextEntity()).routeGTFSID).to.equal('4-900')
-      expect((await routeReader.getNextEntity()).routeGTFSID).to.equal('4-900')
-      expect((await routeReader.getNextEntity()).routeGTFSID).to.equal('4-601')
-    })
-  })
-})