db-vendo-client/test/lib/request.js

// todo: use import assertions once they're supported by Node.js & ESLint
// https://github.com/tc39/proposal-import-assertions
import {createRequire} from 'module'
const require = createRequire(import.meta.url)

import tap from 'tap'
import forEach from 'lodash/forEach.js'
import {
	checkIfResponseIsOk as checkIfResIsOk,
	request,
} from '../../lib/request.js'
import {
	INVALID_REQUEST,
	NOT_FOUND,
	HafasError,
	HafasInvalidRequestError,
	HafasNotFoundError,
} from '../../lib/errors.js'
import {formatTripReq} from '../../format/trip-req.js'

const resParameter = require('../fixtures/error-parameter.json')
const resNoMatch = require('../fixtures/error-no-match.json')
const resH9360 = require('../fixtures/error-h9360.json')
const resLocation = require('../fixtures/error-location.json')

const USER_AGENT = 'public-transport/hafas-client:test'

const secret = Symbol('secret')

tap.test('checkIfResponseIsOk properly throws HAFAS "H9360" errors', (t) => {
	try {
		checkIfResIsOk({
			body: resH9360,
			errProps: {secret},
		})
	} catch (err) {
		t.ok(err)

		t.ok(err instanceof HafasError)
		t.equal(err.isHafasError, true)
		t.equal(err.message.slice(0, 7), 'H9360: ')
		t.ok(err.message.length > 7)

		t.ok(err instanceof HafasInvalidRequestError)
		t.equal(err.isCausedByServer, false)
		t.equal(err.code, INVALID_REQUEST)
		t.equal(err.hafasCode, 'H9360')

		t.equal(err.hafasResponseId, resH9360.id)
		t.equal(err.hafasMessage, 'HAFAS Kernel: Date outside of the timetable period.')
		t.equal(err.hafasDescription, 'Fehler bei der Datumseingabe oder Datum außerhalb der Fahrplanperiode (01.05.2022 - 10.12.2022)')
		t.equal(err.secret, secret)

		t.end()
	}
})

tap.test('checkIfResponseIsOk properly throws HAFAS "LOCATION" errors', (t) => {
	try {
		checkIfResIsOk({
			body: resLocation,
			errProps: {secret},
		})
	} catch (err) {
		t.ok(err)

		t.ok(err instanceof HafasError)
		t.equal(err.isHafasError, true)
		t.equal(err.message.slice(0, 10), 'LOCATION: ')
		t.ok(err.message.length > 10)

		t.ok(err instanceof HafasNotFoundError)
		t.equal(err.isCausedByServer, false)
		t.equal(err.code, NOT_FOUND)
		t.equal(err.hafasCode, 'LOCATION')

		t.equal(err.hafasResponseId, resLocation.id)
		t.equal(err.hafasMessage, 'HCI Service: location missing or invalid')
		t.equal(err.hafasDescription, 'Während der Suche ist ein interner Fehler aufgetreten')
		t.equal(err.secret, secret)

		t.end()
	}
})

tap.test('checkIfResponseIsOk properly throws HAFAS "NO_MATCH" errors', (t) => {
	try {
		checkIfResIsOk({
			body: resNoMatch,
			errProps: {secret},
		})
	} catch (err) {
		t.ok(err)

		t.ok(err instanceof HafasError)
		t.equal(err.isHafasError, true)
		t.equal(err.message.slice(0, 10), 'NO_MATCH: ')
		t.ok(err.message.length > 10)

		t.ok(err instanceof HafasNotFoundError)
		t.equal(err.isCausedByServer, false)
		t.equal(err.code, NOT_FOUND)
		t.equal(err.hafasCode, 'NO_MATCH')

		t.equal(err.hafasResponseId, resNoMatch.id)
		t.equal(err.hafasMessage, 'Nothing found.')
		t.equal(err.hafasDescription, 'Während der Suche ist leider ein interner Fehler aufgetreten. Bitte wenden Sie sich an unsere Serviceauskunft unter Tel. 0421 596059.')
		t.equal(err.secret, secret)

		t.end()
	}
})

tap.test('checkIfResponseIsOk properly throws HAFAS "PARAMETER" errors', (t) => {
	try {
		checkIfResIsOk({
			body: resParameter,
			errProps: {secret},
		})
	} catch (err) {
		t.ok(err)

		t.ok(err instanceof HafasError)
		t.equal(err.isHafasError, true)
		t.equal(err.message.slice(0, 11), 'PARAMETER: ')
		t.ok(err.message.length > 11)

		t.ok(err instanceof HafasInvalidRequestError)
		t.equal(err.isCausedByServer, false)
		t.equal(err.code, INVALID_REQUEST)
		t.equal(err.hafasCode, 'PARAMETER')

		t.equal(err.hafasResponseId, resParameter.id)
		t.equal(err.hafasMessage, 'HCI Service: parameter invalid')
		t.equal(err.hafasDescription, 'Während der Suche ist ein interner Fehler aufgetreten')
		t.equal(err.secret, secret)

		t.end()
	}
})

tap.test('checkIfResponseIsOk properly parses an unknown HAFAS errors', (t) => {
	const body = {
		ver: '1.42',
		id: '1234567890',
		err: 'FOO',
		errTxt: 'random errTxt',
		errTxtOut: 'even more random errTxtOut',
		svcResL: [],
	}

	try {
		checkIfResIsOk({
			body,
			errProps: {secret},
		})
	} catch (err) {
		t.ok(err)

		t.ok(err instanceof HafasError)
		t.equal(err.isHafasError, true)
		t.equal(err.message, `${body.err}: ${body.errTxt}`)

		t.equal(err.isCausedByServer, false)
		t.equal(err.code, null)
		t.equal(err.hafasCode, body.err)

		t.equal(err.hafasResponseId, body.id)
		t.equal(err.hafasMessage, body.errTxt)
		t.equal(err.hafasDescription, body.errTxtOut)
		t.equal(err.secret, secret)

		t.end()
	}
})

const freeze = (val) => {
	if (
		'object' === typeof val
		&& val !== null
		&& !Array.isArray(val)
	) Object.freeze(val)
}
const ctx = {
	// random but unique
	opt: {
		language: 'ga',
	},
	profile: {
		endpoint: 'https://does.not.exist',
		client: {
			type: 'FOO',
			id: 'BAR',
			name: 'baZ',
		},
		auth: {
			type: 'AID',
			aid: 'some-auth-token',
		},
		ver: '1.23.4',

		timezone: 'Europe/Amsterdam',
		locale: 'de-LU',
		defaultLanguage: 'fr',

		transformReq: (_, req) => req,
	},
}
forEach(ctx, freeze)

tap.test('lib/request calls profile.transformReqBody & profile.transformReq properly', async (t) => {
	const customTransformReqBody = (ctx, reqBody) => {
		const p = 'transformReqBody call: '
		t.same(ctx, customCtx, 'ctx should be the passed-in ctx')

		t.ok(reqBody, 'reqBody')
		t.equal(reqBody.client, ctx.profile.client, p + 'reqBody.client')
		t.equal(reqBody.ext, ctx.profile.ext, p + 'reqBody.ext')
		t.equal(reqBody.var, ctx.profile.var, p + 'reqBody.var')
		t.equal(reqBody.auth, ctx.profile.auth, p + 'reqBody.auth')
		t.equal(reqBody.lang, ctx.opt.language, p + 'reqBody.lang')

		// We test if lib/request.js handles returning a new object.
		return {
			...reqBody,
		}
	}

	const customTransformReq = (ctx, req) => {
		const p = 'transformReq call: '
		t.same(ctx, customCtx, p + 'ctx should be the passed-in ctx')

		t.equal(typeof req.body, 'string', p + 'req.body')
		t.ok(req.body, p + 'req.body')

		// We test if lib/request.js handles returning a new object.
		return {
			...req,
			// From node-fetch, used by isomorphic-fetch:
			// > req/res timeout in ms, it resets on redirect. 0 to disable (OS limit applies). Signal is recommended instead.
			timeout: 100,
		}
	}

	const customCtx = {
		...ctx,
		profile: {
			...ctx.profile,
			transformReqBody: customTransformReqBody,
			transformReq: customTransformReq,
		},
	}
	const tripReq = formatTripReq(customCtx, 'unknown-trip-id')

	// todo: set 1s timeout
	await t.rejects(async () => {
		await request(customCtx, USER_AGENT, tripReq)
	})
	t.end()
})