@transportme/load-ptv-gtfs 1.0.0

package/test/gtfs-stops.test.mjs

@@ -0,0 +1,290 @@
+import { expect } from 'chai'
+import GTFSStopsReader from '../lib/gtfs-parser/readers/GTFSStopsReader.mjs'
+import path from 'path'
+import url from 'url'
+import suburbs from './sample-data/suburbs.json' with { type: 'json' }
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const stopsFile = path.join(__dirname, 'sample-data', 'gtfs-splitting', 'line_reader_test.txt')
+
+let stopInput = {
+  stop_id: '1000',
+  stop_name: 'Dole Ave/Cheddar Rd (Reservoir)',
+  stop_lat: '-37.7007748061827',
+  stop_lon: '145.018951051008'
+}
+
+let stopInput2 = {
+  stop_id: '10001',
+  stop_name: 'Rex St/Taylors Rd (Kings Park)',
+  stop_lat: '-37.7269752097338',
+  stop_lon: '144.776152425766'
+}
+
+let stopInput3 = {
+  stop_id: '13486',
+  stop_name: 'Narre Warren, Fountain Gate Primary School/Victoria Rd',
+  stop_lat: '-38.0093755011572',
+  stop_lon: '145.296182027229'
+}
+
+describe('The GTFSStopReader class', () => {
+  describe('The initialProcess function', () => {
+    it('Should take in the raw CSV line and process it', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput)
+
+      expect(stopData.originalName).to.equal(stopInput.stop_name)
+      expect(stopData.stopGTFSID).to.equal(stopInput.stop_id)
+      expect(stopData.location).to.deep.equal({
+        type: 'Point',
+        coordinates: [145.018951051008, -37.7007748061827]
+      })
+    })
+
+    it('Should populate the suburb and stop number', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput2,
+        stop_name: '51a-Rex St/Taylors Rd (Kings Park)'
+      })
+
+      expect(stopData.suburb).to.equal('Kings Park')
+      expect(stopData.stopNumber).to.equal('51A')
+    })
+  })
+
+  describe('The getNextEntity function', () => {
+    it('Should read the CSV file and return the next stop', async () => {
+      let stopReader = new GTFSStopsReader(stopsFile)
+      await stopReader.open()
+
+      let stopData = await stopReader.getNextEntity()
+
+      expect(stopData.rawStopName).to.equal('Dole Ave/Cheddar Rd')
+      expect(stopData.stopGTFSID).to.equal('1000')
+    })
+  })
+
+  describe('The available function', () => {
+    it('Should return true if there is more data, and false otherwise', async () => {
+      let stopReader = new GTFSStopsReader(stopsFile)
+      await stopReader.open()
+
+      for (let i = 0; i < 6; i++) await stopReader.getNextEntity()
+      expect(stopReader.available()).to.be.true
+    
+      await stopReader.getNextEntity()
+      expect(stopReader.available()).to.be.false
+    })
+  })
+})
+
+describe('The GTFSStop class', () => {
+  describe('The requiresSuburb function', () => {
+    it('Should return false if the stop name already has a suburb', async () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput)
+      expect(stopData.requiresSuburb()).to.be.false
+    })
+
+    it('Should return false if the stop name is missing the suburb', async () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: 'Dole Ave/Cheddar Rd'
+      })
+      expect(stopData.requiresSuburb()).to.be.true
+    })
+  })
+
+  describe('The getSuburbFromName function', () => {
+    it('Should extract the stop suburb from its name in brackets', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput)
+      expect(stopData.getSuburbFromName()).to.equal('Reservoir')
+    })
+
+    it('Should extract the stop suburb from its name if it appears at the front', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput3)
+      expect(stopData.suburbIsInFront()).to.be.true
+      expect(stopData.getSuburbFromName()).to.equal('Narre Warren')
+    })
+  })
+
+  describe('The getSuburbState function', () => {
+    it('Should extract the state form a suburb in the form (Suburb (State))', () => {
+      let stopName = 'Albury Botanic Gardens/Wodonga Pl (Albury (NSW))'
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: stopName
+      })
+
+      expect(stopData.getSuburbState(stopName.lastIndexOf('('))).to.equal('NSW')
+    })
+  })
+
+  it('Should process interstate suburbs in the format (Suburb (State))', () => {
+    let stopData = new GTFSStopsReader('', suburbs).processEntity({
+      ...stopInput,
+      stop_name: 'Albury Botanic Gardens/Wodonga Pl (Albury (NSW))'
+    })
+    expect(stopData.getSuburbFromName()).to.equal('Albury, NSW')
+  })
+
+  it('Should process interstate suburbs in the format (Suburb (Local Area - State))', () => {
+    let stopData = new GTFSStopsReader('', suburbs).processEntity({
+      ...stopInput,
+      stop_name: 'Emma Way/Wright St (Glenroy (Albury - NSW))'
+    })
+    expect(stopData.getSuburbFromName()).to.equal('Glenroy, NSW')
+  })
+
+  it('Should expand St in the suburb name', () => {
+    let stopData = new GTFSStopsReader('', suburbs).processEntity({
+      ...stopInput,
+      stop_name: 'Dundas St/Market St (St Arnaud)'
+    })
+    expect(stopData.getSuburbFromName()).to.equal('St. Arnaud')
+  })
+
+  it('Should expand Mt in the suburb name', () => {
+    let stopData = new GTFSStopsReader('', suburbs).processEntity({
+      ...stopInput,
+      stop_name: 'Tourist Information Centre/Jubilee Hwy East (Mt Gambier (SA))'
+    })
+    expect(stopData.getSuburbFromName()).to.equal('Mount Gambier, SA')
+  })
+
+  describe('The getSuburbFromLocation function', () => {
+    it('Should expand St in the suburb name', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        stop_id: '912',
+        stop_name: 'Princes St/Barkly St',
+        stop_lat: '-37.8597466731382',
+        stop_lon: '144.98247799877'
+      })
+      expect(stopData.getSuburbFromLocation(suburbs)).to.equal('St. Kilda')
+    })
+
+    it('Should return a generic Interstate suburb if it cannot identify the suburb', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        stop_id: '20815',
+        stop_name: '85 Franklin St',
+        stop_lat: '-34.9274852283649',
+        stop_lon: '138.595751207359'
+      })
+      expect(stopData.getSuburbFromLocation(suburbs)).to.equal('Interstate')
+    })
+  })
+
+  describe('The getStopNameWithoutSuburb function', () => {
+    it('Should strip the suburb from the stop name if the suburb appears behind', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput)
+
+      expect(stopData.getStopNameWithoutSuburb()).to.equal('Dole Ave/Cheddar Rd')
+    })
+
+    it('Should strip the suburb from the stop name for NSW/SA stops', () => {
+      let stopName = 'Albury Railway Station (Albury (NSW))'
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: stopName
+      })
+
+      expect(stopData.getStopNameWithoutSuburb()).to.equal('Albury Railway Station')
+    })
+
+    it('Should strip the suburb from the stop name if the suburb is in front', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput3)
+
+      expect(stopData.getStopNameWithoutSuburb()).to.equal('Fountain Gate Primary School/Victoria Rd')
+    })
+  })
+
+  describe('The matchStopNumber function', () => {
+    it('Should match stop numbers in the format XXX-STOPNAME', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: '125-Yuille St/Centenary Ave (Melton)'
+      })
+
+      expect(stopData.matchStopNumber()).to.deep.equal({
+        stopNumber: '125',
+        stopName: 'Yuille St/Centenary Ave'
+      })
+    })
+
+    // Can randomly happen when PTV exports the data without suburb names or secondary street names
+    // See 25 Jan 2021 archive
+    // Seems to be caused when they set some flag incorrectly as this seems to match the stop names on the printed timetables.
+    // Weird huh.
+    it('Should match stop numbers in the format STOPNAME - Stop XXX', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: 'Yuille St - Stop D99'
+      })
+
+      expect(stopData.matchStopNumber()).to.deep.equal({
+        stopNumber: 'D99',
+        stopName: 'Yuille St'
+      })
+    })
+
+    it('Should ensure the stop numbers are all uppercase', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: '125a-Southbank Tram Depot (South Melbourne)'
+      })
+
+      expect(stopData.matchStopNumber()).to.deep.equal({
+        stopNumber: '125A',
+        stopName: 'Southbank Tram Depot'
+      })
+    })
+
+    it('Should return null if there is no stop number', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: 'Southbank Tram Depot (South Melbourne)'
+      })
+
+      expect(stopData.matchStopNumber()).to.deep.equal({
+        stopNumber: null,
+        stopName: 'Southbank Tram Depot'
+      })
+    })
+
+    it('Should not match street numbers spanning multiple units', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: '227-243 Wellington Rd (Mulgrave)'
+      })
+
+      expect(stopData.matchStopNumber()).to.deep.equal({
+        stopNumber: null,
+        stopName: '227-243 Wellington Rd'
+      })
+    })
+  })
+
+  describe('The getFullStopName function', () => {
+    it('Should expand the stop name', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity(stopInput2)
+      expect(stopData.getFullStopName()).to.equal('Rex Street/Taylors Road')
+    })
+
+    it('Should handle stops with only a primary name', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: 'Knox City SC (Knoxfield)'
+      })
+      expect(stopData.getFullStopName()).to.equal('Knox City Shopping Centre')      
+    })
+
+    it('Should handle the direction appearing as well', () => {
+      let stopData = new GTFSStopsReader('', suburbs).processEntity({
+        ...stopInput,
+        stop_name: 'Newman Cres (north side)/east of Pechell St (Made Up Suburb)'
+      })
+      expect(stopData.getFullStopName()).to.equal('Newman Crescent - North/Pechell Street - East')      
+    })
+  })
+})

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

@@ -0,0 +1,142 @@
+import { expect } from 'chai'
+import path from 'path'
+import url from 'url'
+import { TRANSIT_MODES } from '../lib/constants.mjs'
+import { LokiDatabaseConnection } from '@transportme/database'
+import StopsLoader from '../lib/loader/StopsLoader.mjs'
+import RouteLoader from '../lib/loader/RouteLoader.mjs'
+import TripLoader from '../lib/loader/TripLoader.mjs'
+import suburbs from './sample-data/suburbs.json' with { type: 'json' }
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const routesFile = path.join(__dirname, 'sample-data', 'routes', 'metro_lines.txt')
+const agencyFile = path.join(__dirname, 'sample-data', 'routes', 'agency.txt')
+
+const calendarFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar.txt')
+const calendarDatesFile = path.join(__dirname, 'sample-data', 'calendar', 'calendar_dates.txt')
+
+const stopsFile = path.join(__dirname, 'sample-data', 'trips', 'stops.txt')
+const stopTimesFile = path.join(__dirname, 'sample-data', 'trips', 'stop_times.txt')
+const tripsFile = path.join(__dirname, 'sample-data', 'trips', 'trips.txt')
+
+const newStopTimesFile = path.join(__dirname, 'sample-data', 'trips', 'stop_times_new.txt')
+const newTripsFile = path.join(__dirname, 'sample-data', 'trips', 'trips_new.txt')
+
+describe('The TripLoader class', () => {
+  it('Should process the trip and add it to the database', async () => {
+    let database = new LokiDatabaseConnection('test-db')
+    let stops = await database.createCollection('stops')
+    let routes = await database.createCollection('routes')
+    let trips = await database.createCollection('gtfs timetables')
+
+    let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+    await stopLoader.loadStops()
+
+    let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+    await routeLoader.loadRoutes()
+
+    let routeIDMap = routeLoader.getRouteIDMap()
+
+    let tripLoader = new TripLoader({
+      tripsFile, stopTimesFile,
+      calendarFile, calendarDatesFile
+    }, TRANSIT_MODES.metroTrain, database)
+    await tripLoader.loadTrips({
+      routeIDMap
+    })
+
+    let trip = await trips.findDocument({ tripID: '1.T2.2-ALM-vpt-1.1.R' })
+    expect(trip).to.not.be.null
+    
+    expect(trip.routeName).to.equal('Alamein')
+    expect(trip.routeNumber).to.be.null
+    expect(trip.operationDays.length).to.equal(12)
+    expect(trip.operationDays[0]).to.equal('20241123')
+
+    expect(trip.shapeID).to.equal('2-ALM-vpt-1.1.R')
+    expect(trip.block).to.be.null
+    expect(trip.gtfsDirection).to.equal(1)
+
+    expect(trip.stopTimings.length).to.equal(7)
+    expect(trip.stopTimings[0].stopName).to.equal('Alamein Railway Station')
+    expect(trip.stopTimings[0].arrivalTime).to.be.null
+    expect(trip.stopTimings[0].arrivalTimeMinutes).to.be.null
+    expect(trip.stopTimings[0].stopConditions.dropoff).to.equal(1)
+    expect(trip.stopTimings[0].stopConditions.pickup).to.equal(0)
+    expect(trip.stopTimings[0].departureTime).to.equal('04:57')
+    expect(trip.stopTimings[0].departureTimeMinutes).to.equal(4 * 60 + 57)
+    expect(trip.stopTimings[0].platform).to.equal('1')
+
+    expect(trip.stopTimings[5].stopName).to.equal('Riversdale Railway Station')
+    expect(trip.stopTimings[5].platform).to.equal('2')
+
+    expect(trip.stopTimings[6].stopName).to.equal('Camberwell Railway Station')
+    expect(trip.stopTimings[6].arrivalTime).to.equal('05:08')
+    expect(trip.stopTimings[6].arrivalTimeMinutes).to.equal(5 * 60 + 8)
+    expect(trip.stopTimings[6].departureTime).to.be.null
+    expect(trip.stopTimings[6].departureTimeMinutes).to.be.null
+    expect(trip.stopTimings[6].stopConditions.dropoff).to.equal(0)
+    expect(trip.stopTimings[6].stopConditions.pickup).to.equal(1)
+    expect(trip.stopTimings[6].platform).to.equal('3')
+
+    expect(trip.origin).to.equal('Alamein Railway Station')
+    expect(trip.destination).to.equal('Camberwell Railway Station')
+
+    expect(trip.departureTime).to.equal('04:57')
+    expect(trip.destinationArrivalTime).to.equal('05:08')
+  })
+
+  it('It should return a mapping of Shape IDs to Route IDs', async () => {
+    let database = new LokiDatabaseConnection('test-db')
+    let stops = await database.createCollection('stops')
+    let routes = await database.createCollection('routes')
+    let trips = await database.createCollection('gtfs timetables')
+
+    let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+    await stopLoader.loadStops()
+
+    let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+    await routeLoader.loadRoutes()
+
+    let routeIDMap = routeLoader.getRouteIDMap()
+
+    let tripLoader = new TripLoader({
+      tripsFile, stopTimesFile,
+      calendarFile, calendarDatesFile
+    }, TRANSIT_MODES.metroTrain, database)
+    
+    await tripLoader.loadTrips({ routeIDMap })
+    let shapeIDMap = tripLoader.getShapeIDMap()
+
+    expect(shapeIDMap['2-ALM-vpt-1.1.R']).to.equal('2-ALM')
+  })
+
+  it('It should accept trip IDs in the new format and extract the TDN from there', async () => {
+    let database = new LokiDatabaseConnection('test-db')
+    let stops = await database.createCollection('stops')
+    let routes = await database.createCollection('routes')
+    let trips = await database.createCollection('gtfs timetables')
+
+    let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+    await stopLoader.loadStops()
+
+    let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+    await routeLoader.loadRoutes()
+
+    let routeIDMap = routeLoader.getRouteIDMap()
+
+    let tripLoader = new TripLoader({
+      tripsFile: newTripsFile, stopTimesFile: newStopTimesFile,
+      calendarFile, calendarDatesFile
+    }, TRANSIT_MODES.metroTrain, database)
+    
+    await tripLoader.loadTrips({ routeIDMap })
+
+    let trip = await trips.findDocument({ tripID: '02-ALM--1-T2-2302' })
+
+    expect(trip).to.not.be.null
+    expect(trip.runID).to.equal('2302')
+  })
+})

package/test/gtfs-trips.test.mjs

@@ -0,0 +1,109 @@
+import { expect } from 'chai'
+import path from 'path'
+import url from 'url'
+import GTFSCalendar from '../lib/gtfs-parser/GTFSCalendar.mjs'
+import GTFSTrip, { SmartrakTrip } from '../lib/gtfs-parser/GTFSTrip.mjs'
+import GTFSTripReader from '../lib/gtfs-parser/readers/GTFSTripReader.mjs'
+import { TRANSIT_MODES } from '../lib/constants.mjs'
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const tripsFile = path.join(__dirname, 'sample-data', 'trips', 'trips.txt')
+const busTripsFile = path.join(__dirname, 'sample-data', 'trips', 'bus_trips.txt')
+
+describe('The GTFSTrip class', () => {
+  it('Should process the skeleton trip data and populate the operation days', () => {
+    let calendar = new GTFSCalendar({
+      id: 'T1',
+      startDay: '20241122',
+      endDay: '20241129',
+      daysOfWeek: ["0","0","0","0","1","1","0"]
+    })
+
+    // route_id,service_id,trip_id,shape_id,trip_headsign,direction_id,block_id
+    // "6-452-mjp-1","T0_16","1.T0.6-452-mjp-1.1.H","6-452-mjp-1.1.H","Eynesbury","0",""
+    let trip = new GTFSTrip({
+      routeGTFSID: '6-452',
+      calendar: calendar,
+      id: '1.T0.6-452-mjp-1.1.H',
+      shapeID: '6-452-mjp-1.1.H',
+      headsign: 'Eynesbury',
+      direction: '0',
+      block: ''
+    })
+
+    expect(trip.getOperationDays()).to.have.members([
+      '20241122', '20241123', '20241129'
+    ])
+  })
+})
+
+describe('The GTFSTripReader class', () => {
+  it('Should read the trips.txt file and return a GTFSTrip object', async () => {
+    let calendars = {
+      'T2_2': new GTFSCalendar({
+        id: 'T2_2',
+        startDay: '20241122',
+        endDay: '20241122',
+        daysOfWeek: ["0","0","0","0","1","0","0"]
+      })
+    }
+
+    let routeMappings = { '2-ALM-vpt-1': '2-ALM' }
+
+    let reader = new GTFSTripReader(tripsFile, calendars, routeMappings, TRANSIT_MODES.metroTrain)
+    await reader.open()
+
+    let trip = await reader.getNextEntity()
+
+    expect(trip.getTripID()).to.equal('1.T2.2-ALM-vpt-1.1.R')
+    expect(trip.getRouteGTFSID()).to.equal('2-ALM')
+    expect(trip.getHeadsign()).to.equal('Camberwell')
+    expect(trip.getOperationDays()).to.deep.equal(['20241122'])
+  })
+
+  it('Should return a Smartrak bus trip instance where appropriate', async () => {
+    let calendars = {
+      'T2_2': new GTFSCalendar({
+        id: 'T2_2',
+        startDay: '20241122',
+        endDay: '20241122',
+        daysOfWeek: ["0","0","0","0","1","0","0"]
+      })
+    }
+
+    let routeMappings = { '43-490-aus-1': '4-490', '6-wr9-mjp-1': '6-wr9' }
+
+    let reader = new GTFSTripReader(busTripsFile, calendars, routeMappings, TRANSIT_MODES.bus)
+    await reader.open()
+
+    let trip = await reader.getNextEntity()
+
+    expect(trip).to.be.instanceOf(SmartrakTrip)
+    expect(trip.getTripID()).to.equal('43-490--1-MF4-1111914')
+    expect(trip.getRouteGTFSID()).to.equal('4-490')
+    expect(trip.getDepotID()).to.equal(43)
+
+    trip = await reader.getNextEntity()
+
+    expect(trip).to.not.be.instanceOf(SmartrakTrip)
+    expect(trip.getTripID()).to.equal('5.T3.6-wr9-mjp-1.2.R')
+    expect(trip.getRouteGTFSID()).to.equal('6-wr9')
+
+    // EXPERIMENTAL DATA:
+    trip = await reader.getNextEntity()
+
+    expect(trip).to.be.instanceOf(SmartrakTrip)
+    expect(trip.getTripID()).to.equal('58-G01--1-MF1-9942214')
+    expect(trip.getDepotID()).to.equal(58)
+    // expect(trip.getRouteGTFSID()).to.equal('6-G01') // Not entirely sure how to handle duplicates
+
+    trip = await reader.getNextEntity()
+
+    expect(trip).to.be.instanceOf(SmartrakTrip)
+    expect(trip.getTripID()).to.equal('57-83--1-MF2-57586310')
+    expect(trip.getDepotID()).to.equal(57)
+    // expect(trip.getRouteGTFSID()).to.equal('6-083')
+  })
+})

package/test/line-reader.test.mjs

@@ -0,0 +1,94 @@
+import { expect } from 'chai'
+import path from 'path'
+import url from 'url'
+import CSVLineReader from '../lib/gtfs-parser/readers/line-reader.mjs'
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const stopsFile = path.join(__dirname, 'sample-data', 'gtfs-splitting', 'line_reader_test.txt')
+const oneLineFile = path.join(__dirname, 'sample-data', 'one_line.csv')
+
+describe('The CSVLineReader class', () => {
+  it('Should open a CSV file and identify the headers', async () => {
+    let reader = new CSVLineReader(stopsFile)
+    await reader.open()
+
+    expect(reader.getHeaders()).to.deep.equal([
+      'stop_id', 'stop_name', 'stop_lat', 'stop_lon'
+    ])
+
+    await reader.close()
+  })
+
+  it('Should return the first line of the CSV, with the fields mapped to their headers', async () => {
+    let reader = new CSVLineReader(stopsFile)
+    await reader.open()
+
+    let line = await reader.nextLine()
+    expect(line).to.deep.equal({
+      stop_id: '1000',
+      stop_name: 'Dole Ave/Cheddar Rd (Reservoir)',
+      stop_lat: '-37.7007748061827',
+      stop_lon: '145.018951051008'
+    })
+
+    await reader.close()
+  })
+
+  it('Should be able to peek if a line is available', async () => {
+    let reader = new CSVLineReader(stopsFile)
+    await reader.open()
+
+    for (let i = 0; i < 6; i++) await reader.nextLine()
+
+    expect(reader.available()).to.be.true
+    expect(await reader.nextLine()).to.deep.equal({
+      stop_id: '10011',
+      stop_name: 'Moffat St/Main Rd West (St Albans)',
+      stop_lat: '-37.7423246041343',
+      stop_lon: '144.783466504334'
+    })
+    expect(reader.available()).to.be.false
+  })
+
+  it('Should be unable to unread a single line from the file', async () => {
+    let reader = new CSVLineReader(stopsFile)
+    await reader.open()
+    let expectedLine = {
+      stop_id: '1000',
+      stop_name: 'Dole Ave/Cheddar Rd (Reservoir)',
+      stop_lat: '-37.7007748061827',
+      stop_lon: '145.018951051008'
+    }
+
+    let line = await reader.nextLine()
+    expect(line).to.deep.equal(expectedLine)
+    reader.unreadLine()
+
+    expect(await reader.nextLine()).to.deep.equal(expectedLine)
+  })
+
+  it('Should be unable to unread the last line from the file, then read it again', async () => {
+    let reader = new CSVLineReader(oneLineFile)
+
+    await reader.open()
+    let expectedLine = {
+      trip_id: '1.T2.2-ALM-vpt-1.1.R'
+    }
+
+    expect(reader.available()).to.be.true
+    let line = await reader.nextLine()
+    expect(line).to.deep.equal(expectedLine)
+    
+    expect(reader.available(), 'No more data should be available').to.be.false
+
+    reader.unreadLine()
+
+    expect(reader.available(), 'More data should be available after unreading the last line').to.be.true
+
+    expect(await reader.nextLine()).to.deep.equal(expectedLine)
+
+    expect(reader.available()).to.be.false
+  })
+})