test(express-wrapper): replace ava with node:test

Author: ericcrosson-bitgo

packages/express-wrapper/package.json

@@ -14,7 +14,7 @@
     "clean": "rm -rf -- dist",
     "format": "prettier --check .",
     "format:fix": "prettier --write .",
-    "test": "c8 --all ava"
+    "test": "c8 --all node --loader tsx --test test/*.ts"
   },
   "dependencies": {
     "@api-ts/io-ts-http": "0.0.0-semantically-released",
@@ -25,23 +25,10 @@
   "devDependencies": {
     "@api-ts/superagent-wrapper": "0.0.0-semantically-released",
     "@api-ts/typed-express-router": "0.0.0-semantically-released",
-    "@ava/typescript": "3.0.1",
     "@types/express": "4.17.17",
-    "ava": "5.2.0",
     "c8": "7.13.0",
-    "ts-node": "10.9.1",
-    "typescript": "4.7.4"
-  },
-  "ava": {
-    "typescript": {
-      "compile": false,
-      "extensions": [
-        "ts"
-      ],
-      "rewritePaths": {
-        "test/": "dist/test/"
-      }
-    }
+    "typescript": "4.7.4",
+    "tsx": "3.12.7"
   },
   "publishConfig": {
     "access": "public"

packages/express-wrapper/test/middleware.test.ts

@@ -1,4 +1,6 @@
-import test from 'ava';
+import test from 'node:test';
+import { strict as assert } from 'node:assert';
+
 import express from 'express';
 
 import { middlewareFn, runMiddlewareChain } from '../src/middleware';
@@ -27,65 +29,65 @@ const addAltParamMiddleware = middlewareFn(async () => ({
   addedValue: 'hello',
 }));
 
-test('should work with normal express middleware', async (t) => {
+test('should work with normal express middleware', async () => {
   const result = await runMiddlewareChain({ foo: 'test' }, [noopMiddleware], REQ, RES);
-  t.deepEqual(result, { foo: 'test' });
+  assert.deepEqual(result, { foo: 'test' });
 });
 
-test('should handle errors passed to next()', async (t) => {
-  await t.throwsAsync(
+test('should handle errors passed to next()', async () => {
+  await assert.rejects(
     runMiddlewareChain({ foo: 'test' }, [errorMiddleware], null as any, null as any),
   );
 });
 
-test('should work with middleware that return values', async (t) => {
+test('should work with middleware that return values', async () => {
   const result = await runMiddlewareChain(
     { foo: 'test' },
     [addParamMiddleware],
     REQ,
     RES,
   );
-  t.deepEqual(result, { foo: 'test', addedValue: 1337 });
+  assert.deepEqual(result, { foo: 'test', addedValue: 1337 });
 });
 
-test('express and value-producing middleware should work together in any order', async (t) => {
+test('express and value-producing middleware should work together in any order', async () => {
   const result = await runMiddlewareChain(
     { foo: 'test' },
     [noopMiddleware, addParamMiddleware],
     REQ,
     RES,
   );
-  t.deepEqual(result, { foo: 'test', addedValue: 1337 });
+  assert.deepEqual(result, { foo: 'test', addedValue: 1337 });
 
   const resultB = await runMiddlewareChain(
     { foo: 'test' },
     [addParamMiddleware, noopMiddleware],
     REQ,
     RES,
   );
-  t.deepEqual(resultB, { foo: 'test', addedValue: 1337 });
+  assert.deepEqual(resultB, { foo: 'test', addedValue: 1337 });
 });
 
-test('middlewares that set the same value should use the last one in the chain', async (t) => {
+test('middlewares that set the same value should use the last one in the chain', async () => {
   const result = await runMiddlewareChain(
     { foo: 'test' },
     [addParamMiddleware, addAltParamMiddleware],
     REQ,
     RES,
   );
-  t.deepEqual(result, { foo: 'test', addedValue: 'hello' });
+  assert.deepEqual(result, { foo: 'test', addedValue: 'hello' });
 
   const resultB = await runMiddlewareChain(
     { foo: 'test' },
     [addAltParamMiddleware, addParamMiddleware],
     REQ,
     RES,
   );
-  t.deepEqual(resultB, { foo: 'test', addedValue: 1337 });
+  assert.deepEqual(resultB, { foo: 'test', addedValue: 1337 });
 });
 
-test('error-producing middleware should not run subsequent middleware', async (t) => {
-  await t.throwsAsync(
+test('error-producing middleware should not run subsequent middleware', async () => {
+  await assert.rejects(
     runMiddlewareChain(
       { foo: 'test' },
       [errorMiddleware, altErrorMiddleware],

packages/express-wrapper/test/server.test.ts

@@ -1,4 +1,5 @@
-import test from 'ava';
+import test from 'node:test';
+import { strict as assert } from 'node:assert';
 
 import * as t from 'io-ts';
 import express from 'express';
@@ -101,7 +102,7 @@ const GetHelloWorld = async (params: { id: string }) =>
     payload: params,
   } as const);
 
-test('should offer a delightful developer experience', async (t) => {
+test('should offer a delightful developer experience', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -128,10 +129,10 @@ test('should offer a delightful developer experience', async (t) => {
     .decodeExpecting(200)
     .then((res) => res.body);
 
-  t.like(response, { message: "Who's there?" });
+  assert.equal(response.message, "Who's there?");
 });
 
-test('should handle io-ts-http formatted path parameters', async (t) => {
+test('should handle io-ts-http formatted path parameters', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     app.use(express.json());
     app.use(appMiddleware);
@@ -151,10 +152,10 @@ test('should handle io-ts-http formatted path parameters', async (t) => {
     .decodeExpecting(200)
     .then((res) => res.body);
 
-  t.like(response, { id: '1337' });
+  assert.equal(response.id, '1337');
 });
 
-test('should invoke app-level middleware', async (t) => {
+test('should invoke app-level middleware', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -175,10 +176,11 @@ test('should invoke app-level middleware', async (t) => {
     .decodeExpecting(200)
     .then((res) => res.body);
 
-  t.like(response, { message: "Who's there?", appMiddlewareRan: true });
+  assert.equal(response.message, "Who's there?");
+  assert.equal(response.appMiddlewareRan, true);
 });
 
-test('should invoke route-level middleware', async (t) => {
+test('should invoke route-level middleware', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -198,10 +200,11 @@ test('should invoke route-level middleware', async (t) => {
     .decodeExpecting(200)
     .then((res) => res.body);
 
-  t.like(response, { message: "Who's there?", routeMiddlewareRan: true });
+  assert.equal(response.message, "Who's there?");
+  assert.equal(response.routeMiddlewareRan, true);
 });
 
-test('should not add parameters from middleware unless routeHandler() is used', async (t) => {
+test('should not add parameters from middleware unless routeHandler() is used', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -221,10 +224,11 @@ test('should not add parameters from middleware unless routeHandler() is used',
     .decodeExpecting(200)
     .then((res) => res.body);
 
-  t.like(response, { message: "Who's there?", routeMiddlewareRan: false });
+  assert.equal(response.message, "Who's there?");
+  assert.equal(response.routeMiddlewareRan, false);
 });
 
-test('should infer status code from response type', async (t) => {
+test('should infer status code from response type', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -244,10 +248,10 @@ test('should infer status code from response type', async (t) => {
     .decodeExpecting(400)
     .then((res) => res.body);
 
-  t.like(response, { errors: 'Please do not tell me zero! I will now explode' });
+  assert.equal(response.errors, 'Please do not tell me zero! I will now explode');
 });
 
-test('should return a 400 when request fails to decode', async (t) => {
+test('should return a 400 when request fails to decode', async () => {
   const app = createServer(ApiSpec, (app: express.Application) => {
     // Configure app-level middleware
     app.use(express.json());
@@ -264,5 +268,5 @@ test('should return a 400 when request fails to decode', async (t) => {
     .set('Content-Type', 'application/json')
     .expect(400);
 
-  t.true(response.body.error.startsWith('Invalid value undefined supplied to'));
+  assert(response.body.error.startsWith('Invalid value undefined supplied to'));
 });