test: use Node.js test runner (#157)

Author: coderbyheart

.github/workflows/api-tests.yaml

@@ -25,7 +25,7 @@ jobs:
           node-version: "20.x"
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - run: npm ci
-      - run: npx jest agps.spec.ts
+      - run: npx tsx --test ./api-verification/agps.spec.ts
   pgps:
     name: P-GPS Service API verification tests
     runs-on: ubuntu-22.04
@@ -35,7 +35,7 @@ jobs:
           node-version: "20.x"
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - run: npm ci
-      - run: npx jest pgps.spec.ts
+      - run: npx tsx --test ./api-verification/pgps.spec.ts
   groundfix:
     name: Ground Fix Services API verification tests
     runs-on: ubuntu-22.04
@@ -45,7 +45,7 @@ jobs:
           node-version: "20.x"
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - run: npm ci
-      - run: npx jest ground-fix.spec.ts
+      - run: npx tsx --test ./api-verification/ground-fix.spec.ts
   evaltoken:
     name: Evaluation Token Authentication verification tests
     runs-on: ubuntu-22.04
@@ -58,7 +58,9 @@ jobs:
         if: env.EVALUATION_TOKEN != ''
       - run: npm ci
         if: env.EVALUATION_TOKEN != ''
-      - run: npx jest evaluation-token-authentication.spec.ts
+      - run:
+          npx tsx --test
+          ./api-verification/evaluation-token-authentication.spec.ts
         if: env.EVALUATION_TOKEN != ''
   devicetoken:
     name: Device Token Authentication verification tests
@@ -69,4 +71,5 @@ jobs:
           node-version: "20.x"
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4
       - run: npm ci
-      - run: npx jest device-token-authentication.spec.ts
+      - run:
+          npx tsx --test ./api-verification/device-token-authentication.spec.ts

.husky/pre-commit

@@ -1,4 +1,5 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-npx lint-staged && npx jest src --onlyChanged
+npx lint-staged
+npm test

api-verification/agps.spec.ts

@@ -1,5 +1,7 @@
-import { AGPSMessage, SCHEMA_VERSION, verify } from '../src/verify-agps-data'
-import { apiClient, tokenAuthorization } from './api-client'
+import { AGPSMessage, SCHEMA_VERSION, verify } from '../src/verify-agps-data.js'
+import { apiClient, tokenAuthorization } from './api-client.js'
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
 
 const { getBinary, head } = apiClient({
 	endpoint: process.env.API_HOST,
@@ -11,9 +13,9 @@ const { getBinary, head } = apiClient({
 	}),
 })
 
-describe('AGPS', () => {
-	describe('chunking', () => {
-		describe('use HEAD request to get response size', () => {
+void describe('AGPS', () => {
+	void describe('chunking', () => {
+		void describe('use HEAD request to get response size', () => {
 			const agpsReq = {
 				deviceIdentifier: 'TestClient',
 				mcc: 242,
@@ -24,14 +26,14 @@ describe('AGPS', () => {
 			}
 			let chunkSize: number
 
-			it('should describe length of A-GPS data', async () => {
+			void it('should describe length of A-GPS data', async () => {
 				const res = await head({ resource: 'location/agps', payload: agpsReq })
-				chunkSize = parseInt(res['content-length'] ?? '0', 10)
-				expect(chunkSize).toBeGreaterThan(0)
+				chunkSize = parseInt(res.get('content-length') ?? '0', 10)
+				assert.equal(chunkSize > 0, true)
 			})
 
-			it('should return A-GPS data', async () => {
-				expect(chunkSize).toBeGreaterThan(0) // chunk size should have been set
+			void it('should return A-GPS data', async () => {
+				assert.equal(chunkSize > 0, true) // chunk size should have been set
 				const res = await getBinary({
 					resource: 'location/agps',
 					payload: agpsReq,
@@ -40,15 +42,15 @@ describe('AGPS', () => {
 						Range: `bytes=0-${chunkSize}`,
 					},
 				})
-				expect(res.length).toBe(chunkSize)
+				assert.equal(res.length, chunkSize)
 
 				// Verify response
 				const verified = verify(res)
-				expect('error' in verified).toEqual(false)
-				expect((verified as AGPSMessage).schemaVersion).toEqual(SCHEMA_VERSION)
+				assert.equal('error' in verified, false)
+				assert.equal((verified as AGPSMessage).schemaVersion, SCHEMA_VERSION)
 			})
 
-			it('should chunk large responses', async () => {
+			void it('should chunk large responses', async () => {
 				const res = await getBinary({
 					resource: 'location/agps',
 					payload: {
@@ -64,23 +66,22 @@ describe('AGPS', () => {
 						Range: `bytes=0-2000`,
 					},
 				})
-				expect(res.length).toBeLessThan(2000)
+				assert.equal(res.length < 2000, true)
 
 				// Verify response
 				const verified = verify(res)
-				expect('error' in verified).toEqual(false)
-				expect((verified as AGPSMessage).schemaVersion).toEqual(SCHEMA_VERSION)
-				expect((verified as AGPSMessage).entries).toHaveLength(1)
-				expect((verified as AGPSMessage).entries[0].type).toEqual(2)
-				expect((verified as AGPSMessage).entries[0].items).toBeGreaterThan(0)
+				assert.equal('error' in verified, false)
+				assert.equal((verified as AGPSMessage).schemaVersion, SCHEMA_VERSION)
+				assert.equal((verified as AGPSMessage).entries.length, 1)
+				assert.equal((verified as AGPSMessage).entries[0].type, 2)
+				assert.equal((verified as AGPSMessage).entries[0].items > 0, true)
 			})
 		})
 	})
 
-	describe('should support 8 types', () => {
-		it.each([[1], [2], [3], [4], [6], [7], [8], [9]])(
-			'should resolve custom type %d',
-			async (type) => {
+	void describe('should support 8 types', () => {
+		for (const type of [1, 2, 3, 4, 6, 7, 8, 9]) {
+			void it(`should resolve custom type ${type}`, async () => {
 				const agpsReq = {
 					mcc: 242,
 					mnc: 2,
@@ -94,8 +95,8 @@ describe('AGPS', () => {
 					resource: 'location/agps',
 					payload: agpsReq,
 				})
-				const chunkSize = parseInt(headRes['content-length'] ?? '0', 10)
-				expect(chunkSize).toBeGreaterThan(0)
+				const chunkSize = parseInt(headRes.get('content-length') ?? '0', 10)
+				assert.equal(chunkSize > 0, true)
 
 				const res = await getBinary({
 					resource: 'location/agps',
@@ -105,20 +106,20 @@ describe('AGPS', () => {
 						Range: `bytes=0-${chunkSize}`,
 					},
 				})
-				expect(res.length).toEqual(chunkSize)
+				assert.equal(res.length, chunkSize)
 
 				// Verify response
 				const verified = verify(res)
-				expect('error' in verified).toEqual(false)
-				expect((verified as AGPSMessage).schemaVersion).toEqual(SCHEMA_VERSION)
-				expect((verified as AGPSMessage).entries).toHaveLength(1)
-				expect((verified as AGPSMessage).entries[0].type).toEqual(type)
-				expect((verified as AGPSMessage).entries[0].items).toBeGreaterThan(0)
-			},
-		)
+				assert.equal('error' in verified, false)
+				assert.equal((verified as AGPSMessage).schemaVersion, SCHEMA_VERSION)
+				assert.equal((verified as AGPSMessage).entries.length, 1)
+				assert.equal((verified as AGPSMessage).entries[0].type, type)
+				assert.equal((verified as AGPSMessage).entries[0].items > 0, true)
+			})
+		}
 	})
 
-	it('should combine types', async () => {
+	void it('should combine types', async () => {
 		const types = new Set([1, 3, 4, 6, 7, 8, 9])
 		const agpsReq = {
 			mcc: 242,
@@ -133,8 +134,8 @@ describe('AGPS', () => {
 			resource: 'location/agps',
 			payload: agpsReq,
 		})
-		const chunkSize = parseInt(headRes['content-length'] ?? '0', 10)
-		expect(chunkSize).toBeGreaterThan(0)
+		const chunkSize = parseInt(headRes.get('content-length') ?? '0', 10)
+		assert.equal(chunkSize > 0, true)
 
 		const res = await getBinary({
 			resource: 'location/agps',
@@ -144,15 +145,16 @@ describe('AGPS', () => {
 				Range: `bytes=0-${chunkSize}`,
 			},
 		})
-		expect(res.length).toEqual(chunkSize)
+		assert.equal(res.length, chunkSize)
 
 		// Verify response
 		const verified = verify(res)
-		expect('error' in verified).toEqual(false)
-		expect((verified as AGPSMessage).schemaVersion).toEqual(SCHEMA_VERSION)
-		expect((verified as AGPSMessage).entries).toHaveLength(7)
-		expect(
+		assert.equal('error' in verified, false)
+		assert.equal((verified as AGPSMessage).schemaVersion, SCHEMA_VERSION)
+		assert.equal((verified as AGPSMessage).entries.length, 7)
+		assert.deepEqual(
 			new Set((verified as AGPSMessage).entries.map(({ type }) => type)),
-		).toEqual(types)
+			types,
+		)
 	})
 })

api-verification/api-client.ts

@@ -1,4 +1,4 @@
-import { IncomingHttpHeaders, IncomingMessage, OutgoingHttpHeaders } from 'http'
+import { IncomingMessage, OutgoingHttpHeaders } from 'http'
 import * as https from 'https'
 import * as jwt from 'jsonwebtoken'
 import { URL, URLSearchParams } from 'url'
@@ -246,39 +246,35 @@ export const apiClient = ({
 	}: {
 		resource: string
 		payload: Record<string, any>
-		headers?: OutgoingHttpHeaders
-	}) =>
-		new Promise<IncomingHttpHeaders>((resolve, reject) => {
-			const options = {
-				hostname: e.hostname,
-				port: 443,
-				path: `/v1/${resource}?${new URLSearchParams(payload).toString()}`,
-				headers: {
-					Authorization: `Bearer ${authorizationToken}`,
-					...headers,
-				},
-				method: 'HEAD',
-			}
+		headers?: Record<string, string>
+	}): Promise<Headers> => {
+		const url = new URL(
+			`https://${e.hostname}/v1/${resource}?${new URLSearchParams(
+				payload,
+			).toString()}`,
+		)
 
-			const req = https.request(options, (res) => {
-				console.debug(
-					[
-						`> HEAD https://${e.hostname}/v1/${resource}?${new URLSearchParams(
-							payload,
-						).toString()}`,
-						`< ${res.statusCode} ${res.statusMessage}`,
-						...Object.entries(res.headers).map(([k, v]) => `< ${k}: ${v}`),
-					].join('\n'),
-				)
-
-				if ((res.statusCode ?? -1) > 399)
-					return reject(new Error(`Request failed: ${res.statusCode}`))
-				return resolve(res.headers)
-			})
-			req.on('error', reject)
-			req.end()
+		const res = await fetch(url, {
+			method: 'HEAD',
+			headers: {
+				Authorization: `Bearer ${authorizationToken}`,
+				...headers,
+			},
 		})
 
+		console.debug(
+			[
+				`> HEAD ${url.toString()}`,
+				`< ${res.status} ${res.statusText}`,
+				...[...new Set(res.headers.entries())].map(([k, v]) => `< ${k}: ${v}`),
+			].join('\n'),
+		)
+
+		if ((res.status ?? -1) > 399)
+			throw new Error(`Request failed: ${res.status}`)
+		return res.headers
+	}
+
 	return {
 		head,
 		getJSON,

api-verification/device-token-authentication.spec.ts

@@ -1,7 +1,9 @@
 import { spawn } from 'child_process'
 import { randomUUID } from 'node:crypto'
 import * as os from 'os'
-import { apiClient, tokenAuthorization } from './api-client'
+import { apiClient, tokenAuthorization } from './api-client.js'
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert/strict'
 
 const endpoint = process.env.API_HOST
 
@@ -10,13 +12,13 @@ const apiKeyClient = apiClient({
 	authorizationToken: process.env.API_KEY as string,
 })
 
-describe('authenticate using device keys', () => {
+void describe('authenticate using device keys', () => {
 	let privateKey: string
 	let publicKey: string
 	let deviceId: string
 	let bulkOpsRequestId: string
 
-	beforeAll(async () => {
+	before(async () => {
 		// Generate a globally uniqe device ID
 		deviceId = randomUUID()
 
@@ -72,16 +74,16 @@ describe('authenticate using device keys', () => {
 		})
 	})
 
-	it('should register a new device key', async () => {
+	void it('should register a new device key', async () => {
 		const { bulkOpsRequestId: rid } = await apiKeyClient.postBinary({
 			resource: 'devices/public-keys',
 			payload: `${deviceId},"${publicKey}"`,
 		})
 		bulkOpsRequestId = rid
-		expect(bulkOpsRequestId).not.toBeUndefined()
+		assert.notEqual(bulkOpsRequestId, undefined)
 	})
 
-	it('should process the request', async () => {
+	void it('should process the request', async () => {
 		const getStatus = async () =>
 			apiKeyClient
 				.getJSON({
@@ -103,10 +105,10 @@ describe('authenticate using device keys', () => {
 				reject(new Error(`Timeout`))
 			}, 30000)
 		})
-		expect(status).toEqual('SUCCEEDED')
+		assert.equal(status, 'SUCCEEDED')
 	})
 
-	it('should accept the device-key based JWT', async () => {
+	void it('should accept the device-key based JWT', async () => {
 		const { getJSON } = apiClient({
 			endpoint,
 			authorizationToken: tokenAuthorization({
@@ -123,7 +125,7 @@ describe('authenticate using device keys', () => {
 				predictionIntervalMinutes: 120,
 			},
 		})
-		expect(res.host).not.toBeUndefined()
-		expect(res.path).not.toBeUndefined()
+		assert.notEqual(res.host, undefined)
+		assert.notEqual(res.path, undefined)
 	})
 })

api-verification/evaluation-token-authentication.spec.ts

@@ -1,4 +1,6 @@
-import { apiClient } from './api-client'
+import { apiClient } from './api-client.js'
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
 
 const endpoint = process.env.API_HOST
 
@@ -7,16 +9,16 @@ const { getJSON } = apiClient({
 	authorizationToken: process.env.EVALUATION_TOKEN as string,
 })
 
-describe('authenticate using evaluation token', () => {
-	it('should accept the evaluation token', async () => {
+void describe('authenticate using evaluation token', () => {
+	void it('should accept the evaluation token', async () => {
 		const res = await getJSON<{ host: string; path: string }>({
 			resource: 'location/pgps',
 			payload: {
 				predictionCount: 6,
 				predictionIntervalMinutes: 120,
 			},
 		})
-		expect(res.host).not.toBeUndefined()
-		expect(res.path).not.toBeUndefined()
+		assert.notEqual(res.host, undefined)
+		assert.notEqual(res.path, undefined)
 	})
 })