db-vendo-client/test/insa.js

'use strict'

const tapePromise = require('tape-promise').default
const tape = require('tape')
const isRoughlyEqual = require('is-roughly-equal')
const validateFptf = require('validate-fptf')

const co = require('./co')
const createClient = require('..')
const insaProfile = require('../p/insa')
const {allProducts} = require('../p/insa/products')
const {
	assertValidStation,
	assertValidPoi,
	assertValidAddress,
	assertValidLocation,
	assertValidLine,
	assertValidStopover,
	hour,
	createWhen,
	assertValidWhen
} = require('./util.js')

const when = createWhen('Europe/Berlin', 'de-DE')

const assertValidStationProducts = (t, p) => {
	t.ok(p)
	t.equal(typeof p.nationalExp, 'boolean')
	t.equal(typeof p.national, 'boolean')
	t.equal(typeof p.regional, 'boolean')
	t.equal(typeof p.suburban, 'boolean')
	t.equal(typeof p.tram, 'boolean')
	t.equal(typeof p.bus, 'boolean')
	t.equal(typeof p.tourismTrain, 'boolean')
}

const isMagdeburgHbf = s => {
	return (
		s.type === 'station' &&
		(s.id === '8010224' || s.id === '008010224') &&
		s.name === 'Magdeburg Hbf' &&
		s.location &&
		isRoughlyEqual(s.location.latitude, 52.130352, 0.001) &&
		isRoughlyEqual(s.location.longitude, 11.626891, 0.001)
	)
}

const assertIsMagdeburgHbf = (t, s) => {
	t.equal(s.type, 'station')
	t.ok(s.id === '8010224' || s.id === '008010224', 'id should be 8010224')
	t.equal(s.name, 'Magdeburg Hbf')
	t.ok(s.location)
	t.ok(isRoughlyEqual(s.location.latitude, 52.130352, 0.001))
	t.ok(isRoughlyEqual(s.location.longitude, 11.626891, 0.001))
}

// todo: DRY with assertValidStationProducts
// todo: DRY with other tests
const assertValidProducts = (t, p) => {
	for (let product of allProducts) {
		product = product.product // wat
		t.equal(typeof p[product], 'boolean', 'product ' + p + ' must be a boolean')
	}
}

const test = tapePromise(tape)
const client = createClient(insaProfile)

test('Magdeburg Hbf to Magdeburg-Buckau', co(function*(t) {
	const magdeburgHbf = '8010224'
	const magdeburgBuckau = '8013456'
	const journeys = yield client.journeys(magdeburgHbf, magdeburgBuckau, {
		when,
		passedStations: true
	})

	t.ok(Array.isArray(journeys))
	t.ok(journeys.length > 0, 'no journeys')
	for (let journey of journeys) {
		assertValidStation(t, journey.origin)
		assertValidStationProducts(t, journey.origin.products)
		if (journey.origin.products) {
			assertValidProducts(t, journey.origin.products)
		}
		assertValidWhen(t, journey.departure, when)

		assertValidStation(t, journey.destination)
		assertValidStationProducts(t, journey.origin.products)
		if (journey.destination.products) {
			assertValidProducts(t, journey.destination.products)
		}
		assertValidWhen(t, journey.arrival, when)

		t.ok(Array.isArray(journey.legs))
		t.ok(journey.legs.length > 0, 'no legs')
		const leg = journey.legs[0]

		assertValidStation(t, leg.origin)
		assertValidStationProducts(t, leg.origin.products)
		assertValidWhen(t, leg.departure, when)
		t.equal(typeof leg.departurePlatform, 'string')

		assertValidStation(t, leg.destination)
		assertValidStationProducts(t, leg.origin.products)
		assertValidWhen(t, leg.arrival, when)
		t.equal(typeof leg.arrivalPlatform, 'string')

		assertValidLine(t, leg.line)

		t.ok(Array.isArray(leg.passed))
		for (let stopover of leg.passed) assertValidStopover(t, stopover)
	}

	t.end()
}))

test('Magdeburg Hbf to 39104 Magdeburg, Sternstr. 10', co(function*(t) {
	const magdeburgHbf = '8010224'
	const sternStr = {
		type: 'location',
		latitude: 52.118414,
		longitude: 11.422332,
		address: 'Magdeburg - Altenstadt, Sternstraße 10'
	}

	const journeys = yield client.journeys(magdeburgHbf, sternStr, {
		when
	})

	t.ok(Array.isArray(journeys))
	t.ok(journeys.length >= 1, 'no journeys')
	const journey = journeys[0]
	const firstLeg = journey.legs[0]
	const lastLeg = journey.legs[journey.legs.length - 1]

	assertValidStation(t, firstLeg.origin)
	assertValidStationProducts(t, firstLeg.origin.products)
	if (firstLeg.origin.products)
		assertValidProducts(t, firstLeg.origin.products)
	assertValidWhen(t, firstLeg.departure, when)
	assertValidWhen(t, firstLeg.arrival, when)
	assertValidWhen(t, lastLeg.departure, when)
	assertValidWhen(t, lastLeg.arrival, when)

	const d = lastLeg.destination
	assertValidAddress(t, d)
	t.equal(d.address, 'Magdeburg - Altenstadt, Sternstraße 10')
	t.ok(isRoughlyEqual(0.0001, d.latitude, 52.118414))
	t.ok(isRoughlyEqual(0.0001, d.longitude, 11.422332))

	t.end()
}))

test('Kloster Unser Lieben Frauen to Magdeburg Hbf', co(function*(t) {
	const kloster = {
		type: 'location',
		latitude: 52.127601,
		longitude: 11.636437,
		name: 'Magdeburg, Kloster Unser Lieben Frauen (Denkmal)',
		id: '970012223'
	}
	const magdeburgHbf = '8010224'
	const journeys = yield client.journeys(kloster, magdeburgHbf, {
		when
	})

	t.ok(Array.isArray(journeys))
	t.ok(journeys.length >= 1, 'no journeys')
	const journey = journeys[0]
	const firstLeg = journey.legs[0]
	const lastLeg = journey.legs[journey.legs.length - 1]

	const o = firstLeg.origin
	assertValidPoi(t, o)
	t.equal(o.name, 'Magdeburg, Kloster Unser Lieben Frauen (Denkmal)')
	t.ok(isRoughlyEqual(0.0001, o.latitude, 52.127601))
	t.ok(isRoughlyEqual(0.0001, o.longitude, 11.636437))

	assertValidWhen(t, firstLeg.departure, when)
	assertValidWhen(t, firstLeg.arrival, when)
	assertValidWhen(t, lastLeg.departure, when)
	assertValidWhen(t, lastLeg.arrival, when)

	assertValidStation(t, lastLeg.destination)
	assertValidStationProducts(t, lastLeg.destination.products)
	if (lastLeg.destination.products)
		assertValidProducts(t, lastLeg.destination.products)

	t.end()
}))

test('Magdeburg-Buckau to Magdeburg-Neustadt with stopover at Magdeburg Hbf', co(function*(t) {
	const magdeburgBuckau = '8013456'
	const magdeburgNeustadt = '8010226'
	const magdeburgHbf = '8010224'
	const [journey] = yield client.journeys(magdeburgBuckau, magdeburgNeustadt, {
		via: magdeburgHbf,
		results: 1,
		when
	})

	const i1 = journey.legs.findIndex(leg => leg.destination.id === magdeburgHbf)
	t.ok(i1 >= 0, 'no leg with Magdeburg Hbf as destination')

	const i2 = journey.legs.findIndex(leg => leg.origin.id === magdeburgHbf)
	t.ok(i2 >= 0, 'no leg with Magdeburg Hbf as origin')
	t.ok(i2 > i1, 'leg with Magdeburg Hbf as origin must be after leg to it')

	t.end()
}))

test('departures at Magdeburg Hbf', co(function*(t) {
	const magdeburgHbf = '8010224'
	const deps = yield client.departures(magdeburgHbf, {
		duration: 5,
		when
	})

	t.ok(Array.isArray(deps))
	for (let dep of deps) {
		assertValidStation(t, dep.station)
		assertValidStationProducts(t, dep.station.products)
		if (dep.station.products) {
			assertValidProducts(t, dep.station.products)
		}
		assertValidWhen(t, dep.when, when)
	}

	t.end()
}))

test('nearby Magdeburg Hbf', co(function*(t) {
	const magdeburgHbfPosition = {
		type: 'location',
		latitude: 52.130352,
		longitude: 11.626891
	}
	const nearby = yield client.nearby(magdeburgHbfPosition, {
		results: 2,
		distance: 400
	})

	t.ok(Array.isArray(nearby))
	t.equal(nearby.length, 2)

	assertIsMagdeburgHbf(t, nearby[0])
	t.ok(nearby[0].distance >= 0)
	t.ok(nearby[0].distance <= 100)

	for (let n of nearby) {
		if (n.type === 'station') assertValidStation(t, n)
		else assertValidLocation(t, n)
	}

	t.end()
}))

test('journey leg details', co(function* (t) {
	const magdeburgHbf = '8010224'
	const magdeburgBuckau = '8013456'
	const [journey] = yield client.journeys(magdeburgHbf, magdeburgBuckau, {
		results: 1, when
	})

	const p = journey.legs[0]
	t.ok(p, 'missing legs[0]')
	t.ok(p.id, 'missing legs[0].id')
	t.ok(p.line, 'missing legs[0].line')
	t.ok(p.line.name, 'missing legs[0].line.name')
	const leg = yield client.journeyLeg(p.id, p.line.name, {when})

	t.equal(typeof leg.id, 'string')
	t.ok(leg.id)

	assertValidLine(t, leg.line)

	t.equal(typeof leg.direction, 'string')
	t.ok(leg.direction)

	t.ok(Array.isArray(leg.passed))
	for (let passed of leg.passed) assertValidStopover(t, passed)

	t.end()
}))

test('locations named Magdeburg', co(function*(t) {
	const locations = yield client.locations('Magdeburg', {
		results: 10
	})

	t.ok(Array.isArray(locations))
	t.ok(locations.length > 0)
	t.ok(locations.length <= 10)

	for (let l of locations) {
		if (l.type === 'station') assertValidStation(t, l)
		else assertValidLocation(t, l)
	}
	t.ok(locations.some(isMagdeburgHbf))

	t.end()
}))

test('location', co(function*(t) {
	const magdeburgBuckau = '8013456'
	const loc = yield client.location(magdeburgBuckau)

	assertValidStation(t, loc)
	t.equal(loc.id, magdeburgBuckau)

	t.end()
}))

test('radar', co(function* (t) {
	const north = 52.148364
	const west = 11.600826
	const south = 52.108486
	const east = 11.651451
	const vehicles = yield client.radar(north, west, south, east, {
		duration: 5 * 60, when, results: 10
	})

	t.ok(Array.isArray(vehicles))
	t.ok(vehicles.length > 0)
	for (let v of vehicles) {
		assertValidLine(t, v.line)

		t.equal(typeof v.location.latitude, 'number')
		t.ok(v.location.latitude <= 57, 'vehicle is too far away')
		t.ok(v.location.latitude >= 47, 'vehicle is too far away')
		t.equal(typeof v.location.longitude, 'number')
		t.ok(v.location.longitude >= 8, 'vehicle is too far away')
		t.ok(v.location.longitude <= 14, 'vehicle is too far away')

		t.ok(Array.isArray(v.nextStops))
		for (let st of v.nextStops) {
			assertValidStopover(t, st, true)

			if (st.arrival) {
				t.equal(typeof st.arrival, 'string')
				const arr = +new Date(st.arrival)
				// note that this can be an ICE train
				t.ok(isRoughlyEqual(14 * hour, +when, arr))
			}
			if (st.departure) {
				t.equal(typeof st.departure, 'string')
				const dep = +new Date(st.departure)
				// note that this can be an ICE train
				t.ok(isRoughlyEqual(14 * hour, +when, dep))
			}
		}

		t.ok(Array.isArray(v.frames))
		for (let f of v.frames) {
			// see #28
			// todo: check if this works by now
			assertValidStation(t, f.origin, true)
			assertValidStationProducts(t, f.origin.products)
			assertValidStation(t, f.destination, true)
			assertValidStationProducts(t, f.destination.products)
			t.equal(typeof f.t, 'number')
		}
	}
	t.end()
}))