feat!: replace ava with vitest (#554)

BREAKING CHANGE: Requires Node.js >=18.0.0

Author: eduardoboucas

.github/workflows/workflow.yml

@@ -13,12 +13,12 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
-        node-version: [14.0.0, '*']
+        node-version: [18.0.0, '*']
         exclude:
           - os: macOS-latest
-            node-version: 14.0.0
+            node-version: 18.0.0
           - os: windows-latest
-            node-version: 14.0.0
+            node-version: 18.0.0
       fail-fast: false
     steps:
       - name: Git checkout

package-lock.json

@@ -50,21 +50,15 @@
     "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
     "test:dev": "run-s build test:dev:*",
     "test:ci": "run-s test:ci:*",
-    "test:dev:ava": "ava",
+    "test:dev:vitest": "vitest",
     "test:dev:tsd": "tsd",
     "test:publish": "publint && attw --pack",
-    "test:ci:ava": "nyc -r lcovonly -r text -r json ava"
+    "test:ci:vitest": "vitest run --coverage"
   },
   "config": {
     "eslint": "--ignore-pattern README.md --ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,scripts,.github,test}/**/*.{ts,js,md,html}\" \"*.{ts,js,md,html}\" \".*.{ts,js,md,html}\"",
     "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,scripts,.github}/**/*.{ts,js,md,yml,json,html}\" \"*.{ts,js,yml,json,html}\" \".*.{ts,js,yml,json,html}\" \"!**/package-lock.json\" \"!package-lock.json\""
   },
-  "ava": {
-    "files": [
-      "test/unit/*.js"
-    ],
-    "verbose": true
-  },
   "tsd": {
     "directory": "test/types/"
   },
@@ -86,17 +80,18 @@
     "@commitlint/cli": "^17.0.0",
     "@commitlint/config-conventional": "^17.0.0",
     "@netlify/eslint-config-node": "^7.0.1",
-    "ava": "^2.4.0",
+    "@types/semver": "^7.5.8",
+    "@vitest/coverage-v8": "^2.1.8",
     "husky": "^7.0.4",
     "npm-run-all2": "^5.0.0",
-    "nyc": "^15.0.0",
     "publint": "^0.2.7",
     "semver": "^7.5.4",
     "tsd": "^0.31.0",
     "tsup": "^8.0.2",
-    "typescript": "^4.4.4"
+    "typescript": "^4.4.4",
+    "vitest": "^2.1.8"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   }
 }

package.json

@@ -1,15 +1,19 @@
-const test = require('ava')
+import { expect, test } from 'vitest'
 
-const { builder } = require('../../dist/lib/builder')
-const { invokeLambda } = require('../helpers/main')
+import { invokeLambda } from '../../test/helpers/main.mjs'
+import { BaseHandler } from '../function/handler.js'
+import { HandlerEvent } from '../main.js'
+
+import { builder } from './builder.js'
 
 const METADATA_OBJECT = { metadata: { version: 1, builder_function: true, ttl: 0 } }
 
-test('Injects the metadata object into an asynchronous handler', async (t) => {
+test('Injects the metadata object into an asynchronous handler', async () => {
+  const ttl = 3600
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
-    ttl: 3600,
+    ttl,
   }
   const myHandler = async () => {
     const asyncTask = new Promise((resolve) => {
@@ -22,23 +26,25 @@ test('Injects the metadata object into an asynchronous handler', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler))
 
-  t.deepEqual(response, { ...originalResponse, metadata: { version: 1, builder_function: true, ttl: 3600 } })
+  expect(response).toStrictEqual({ ...originalResponse, metadata: { version: 1, builder_function: true, ttl } })
 })
 
-test('Injects the metadata object into a synchronous handler', async (t) => {
+test('Injects the metadata object into a synchronous handler', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
   }
-  const myHandler = (event, context, callback) => {
-    callback(null, originalResponse)
+  // eslint-disable-next-line promise/prefer-await-to-callbacks
+  const myHandler: BaseHandler = (event, context, callback) => {
+    // eslint-disable-next-line n/callback-return, promise/prefer-await-to-callbacks
+    callback?.(null, originalResponse)
   }
   const response = await invokeLambda(builder(myHandler))
 
-  t.deepEqual(response, { ...originalResponse, ...METADATA_OBJECT })
+  expect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT })
 })
 
-test('Injects the metadata object for non-200 responses', async (t) => {
+test('Injects the metadata object for non-200 responses', async () => {
   const originalResponse = {
     body: ':thumbsdown:',
     statusCode: 404,
@@ -54,10 +60,10 @@ test('Injects the metadata object for non-200 responses', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler))
 
-  t.deepEqual(response, { ...originalResponse, ...METADATA_OBJECT })
+  expect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT })
 })
 
-test('Returns a 405 error for requests using the POST method', async (t) => {
+test('Returns a 405 error for requests using the POST method', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
@@ -73,10 +79,10 @@ test('Returns a 405 error for requests using the POST method', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler), { method: 'POST' })
 
-  t.deepEqual(response, { body: 'Method Not Allowed', statusCode: 405 })
+  expect(response).toStrictEqual({ body: 'Method Not Allowed', statusCode: 405 })
 })
 
-test('Returns a 405 error for requests using the PUT method', async (t) => {
+test('Returns a 405 error for requests using the PUT method', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
@@ -92,10 +98,10 @@ test('Returns a 405 error for requests using the PUT method', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler), { method: 'PUT' })
 
-  t.deepEqual(response, { body: 'Method Not Allowed', statusCode: 405 })
+  expect(response).toStrictEqual({ body: 'Method Not Allowed', statusCode: 405 })
 })
 
-test('Returns a 405 error for requests using the DELETE method', async (t) => {
+test('Returns a 405 error for requests using the DELETE method', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
@@ -111,10 +117,10 @@ test('Returns a 405 error for requests using the DELETE method', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler), { method: 'DELETE' })
 
-  t.deepEqual(response, { body: 'Method Not Allowed', statusCode: 405 })
+  expect(response).toStrictEqual({ body: 'Method Not Allowed', statusCode: 405 })
 })
 
-test('Returns a 405 error for requests using the PATCH method', async (t) => {
+test('Returns a 405 error for requests using the PATCH method', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
@@ -130,12 +136,13 @@ test('Returns a 405 error for requests using the PATCH method', async (t) => {
   }
   const response = await invokeLambda(builder(myHandler), { method: 'PATCH' })
 
-  t.deepEqual(response, { body: 'Method Not Allowed', statusCode: 405 })
+  expect(response).toStrictEqual({ body: 'Method Not Allowed', statusCode: 405 })
 })
 
-test('Preserves errors thrown inside the wrapped handler', async (t) => {
+test('Preserves errors thrown inside the wrapped handler', async () => {
   const error = new Error('Uh-oh!')
 
+  // @ts-expect-error There's no type for this custom property.
   error.someProperty = ':thumbsdown:'
 
   const myHandler = async () => {
@@ -148,27 +155,32 @@ test('Preserves errors thrown inside the wrapped handler', async (t) => {
     throw error
   }
 
-  await t.throwsAsync(invokeLambda(builder(myHandler)), { is: error })
+  try {
+    await invokeLambda(builder(myHandler))
+
+    throw new Error('Invocation should have failed')
+  } catch {}
 })
 
-test('Does not pass query parameters to the wrapped handler', async (t) => {
+test('Does not pass query parameters to the wrapped handler', async () => {
   const originalResponse = {
     body: ':thumbsup:',
     statusCode: 200,
   }
   // eslint-disable-next-line require-await
-  const myHandler = async (event) => {
-    t.deepEqual(event.multiValueQueryStringParameters, {})
-    t.deepEqual(event.queryStringParameters, {})
+  const myHandler = async (event: HandlerEvent) => {
+    expect(event.multiValueQueryStringParameters).toStrictEqual({})
+    expect(event.queryStringParameters).toStrictEqual({})
 
     return originalResponse
   }
   const multiValueQueryStringParameters = { foo: ['bar'], bar: ['baz'] }
   const queryStringParameters = { foo: 'bar', bar: 'baz' }
   const response = await invokeLambda(builder(myHandler), {
+    // @ts-expect-error TODO: Fic types.
     multiValueQueryStringParameters,
     queryStringParameters,
   })
 
-  t.deepEqual(response, { ...originalResponse, ...METADATA_OBJECT })
+  expect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT })
 })

test/unit/builder.js src/lib/builder.test.ts

@@ -1,30 +1,31 @@
-const process = require('process')
+import process from 'node:process'
 
-const test = require('ava')
-const semver = require('semver')
+import semver from 'semver'
+import { beforeEach, afterEach, expect, test } from 'vitest'
 
-const { purgeCache } = require('../../dist/lib/purge_cache')
-const { invokeLambda } = require('../helpers/main')
-const MockFetch = require('../helpers/mock_fetch')
+import { invokeLambda } from '../../test/helpers/main.mjs'
+import { MockFetch } from '../../test/helpers/mock_fetch.mjs'
+
+import { purgeCache } from './purge_cache.js'
 
 const globalFetch = globalThis.fetch
 const hasFetchAPI = semver.gte(process.version, '18.0.0')
 
-test.beforeEach(() => {
+beforeEach(() => {
   delete process.env.NETLIFY_PURGE_API_TOKEN
   delete process.env.SITE_ID
   delete process.env.NETLIFY_LOCAL
 })
 
-test.afterEach(() => {
+afterEach(() => {
   globalThis.fetch = globalFetch
 })
 
-test.serial('Calls the purge API endpoint and returns `undefined` if the operation was successful', async (t) => {
+test('Calls the purge API endpoint and returns `undefined` if the operation was successful', async () => {
   if (!hasFetchAPI) {
     console.warn('Skipping test requires the fetch API')
 
-    return t.pass()
+    return
   }
 
   const mockSiteID = '123456789'
@@ -34,16 +35,17 @@ test.serial('Calls the purge API endpoint and returns `undefined` if the operati
   process.env.SITE_ID = mockSiteID
 
   const mockAPI = new MockFetch().post({
-    body: (payload) => {
+    body: (payload: string) => {
       const data = JSON.parse(payload)
 
-      t.is(data.site_id, mockSiteID)
+      expect(data.site_id).toBe(mockSiteID)
     },
     headers: { Authorization: `Bearer ${mockToken}` },
     method: 'post',
     response: new Response(null, { status: 202 }),
     url: `https://api.netlify.com/api/v1/purge`,
   })
+  // eslint-disable-next-line unicorn/consistent-function-scoping
   const myFunction = async () => {
     await purgeCache()
   }
@@ -52,15 +54,13 @@ test.serial('Calls the purge API endpoint and returns `undefined` if the operati
 
   const response = await invokeLambda(myFunction)
 
-  t.is(response, undefined)
-  t.true(mockAPI.fulfilled)
+  expect(response).toBeUndefined()
+  expect(mockAPI.fulfilled).toBeTruthy()
 })
 
-test.serial('Throws if the API response does not have a successful status code', async (t) => {
+test('Throws if the API response does not have a successful status code', async () => {
   if (!hasFetchAPI) {
     console.warn('Skipping test requires the fetch API')
-
-    return t.pass()
   }
 
   const mockSiteID = '123456789'
@@ -70,42 +70,49 @@ test.serial('Throws if the API response does not have a successful status code',
   process.env.SITE_ID = mockSiteID
 
   const mockAPI = new MockFetch().post({
-    body: (payload) => {
+    body: (payload: string) => {
       const data = JSON.parse(payload)
 
-      t.is(data.site_id, mockSiteID)
+      expect(data.site_id).toBe(mockSiteID)
     },
     headers: { Authorization: `Bearer ${mockToken}` },
     method: 'post',
     response: new Response(null, { status: 500 }),
     url: `https://api.netlify.com/api/v1/purge`,
   })
+  // eslint-disable-next-line unicorn/consistent-function-scoping
   const myFunction = async () => {
     await purgeCache()
   }
 
   globalThis.fetch = mockAPI.fetcher
 
-  await t.throwsAsync(
-    async () => await invokeLambda(myFunction),
-    'Cache purge API call returned an unexpected status code: 500',
-  )
+  try {
+    await invokeLambda(myFunction)
+
+    throw new Error('Invocation should have failed')
+  } catch (error) {
+    expect((error as NodeJS.ErrnoException).message).toBe(
+      'Cache purge API call returned an unexpected status code: 500',
+    )
+  }
 })
 
-test.serial('Ignores purgeCache if in local dev with no token or site', async (t) => {
+test('Ignores purgeCache if in local dev with no token or site', async () => {
   if (!hasFetchAPI) {
     console.warn('Skipping test requires the fetch API')
 
-    return t.pass()
+    return
   }
 
   process.env.NETLIFY_LOCAL = '1'
 
   const mockAPI = new MockFetch().post({
     body: () => {
-      t.fail()
-    }
+      throw new Error('Unexpected request')
+    },
   })
+  // eslint-disable-next-line unicorn/consistent-function-scoping
   const myFunction = async () => {
     await purgeCache()
   }
@@ -114,5 +121,5 @@ test.serial('Ignores purgeCache if in local dev with no token or site', async (t
 
   const response = await invokeLambda(myFunction)
 
-  t.is(response, undefined)
+  expect(response).toBeUndefined()
 })

test/unit/purge_cache.js src/lib/purge_cache.test.ts

@@ -1,57 +1,57 @@
-const process = require("process")
+import process from 'node:process'
 
-const test = require('ava')
+import { expect, test } from 'vitest'
 
-const { systemLogger, LogLevel } = require('../../dist/internal')
+import { LogLevel, systemLogger } from '../internal.js'
 
-test('Log Level', (t) => {
+test('Log Level', () => {
   const originalDebug = console.debug
 
   const debugLogs = []
   console.debug = (...message) => debugLogs.push(message)
 
   systemLogger.debug('hello!')
-  t.is(debugLogs.length, 0)
+  expect(debugLogs.length).toBe(0)
 
   systemLogger.withLogLevel(LogLevel.Debug).debug('hello!')
-  t.is(debugLogs.length, 1)
+  expect(debugLogs.length).toBe(1)
 
   systemLogger.withLogLevel(LogLevel.Log).debug('hello!')
-  t.is(debugLogs.length, 1)
+  expect(debugLogs.length).toBe(1)
 
   console.debug = originalDebug
 })
 
-test('Fields', (t) => {
+test('Fields', () => {
   const originalLog = console.log
-  const logs = []
+  const logs: string[][] = []
   console.log = (...message) => logs.push(message)
   systemLogger.withError(new Error('boom')).withFields({ foo: 'bar' }).log('hello!')
-  t.is(logs.length, 1)
-  t.is(logs[0][0], '__nfSystemLog')
+  expect(logs.length).toBe(1)
+  expect(logs[0][0]).toBe('__nfSystemLog')
   const log = JSON.parse(logs[0][1])
-  t.is(log.msg, 'hello!')
-  t.is(log.fields.foo, 'bar')
-  t.is(log.fields.error, 'boom')
-  t.is(log.fields.error_stack.split('\n').length > 2, true)
+  expect(log.msg).toBe('hello!')
+  expect(log.fields.foo).toBe('bar')
+  expect(log.fields.error).toBe('boom')
+  expect(log.fields.error_stack.split('\n').length > 2).toBe(true)
 
   console.log = originalLog
 })
 
-test('Local Dev', (t) => {
+test('Local Dev', () => {
   const originalLog = console.log
   const logs = []
   console.log = (...message) => logs.push(message)
   systemLogger.log('hello!')
-  t.is(logs.length, 1)
+  expect(logs.length).toBe(1)
 
-  process.env.NETLIFY_DEV= "true"
+  process.env.NETLIFY_DEV = 'true'
   systemLogger.log('hello!')
-  t.is(logs.length, 1)
+  expect(logs.length).toBe(1)
 
-  process.env.NETLIFY_ENABLE_SYSTEM_LOGGING= "true"
+  process.env.NETLIFY_ENABLE_SYSTEM_LOGGING = 'true'
   systemLogger.log('hello!')
-  t.is(logs.length, 2)
+  expect(logs.length).toBe(2)
 
   delete process.env.NETLIFY_DEV
   delete process.env.NETLIFY_ENABLE_SYSTEM_LOGGING

test/unit/system_logger.js src/lib/system_logger.test.ts

@@ -1,4 +1,4 @@
-const invokeLambda = (handler, { method = 'GET', ...options } = {}) => {
+export const invokeLambda = (handler, { method = 'GET', ...options } = {}) => {
   const event = {
     ...options,
     httpMethod: method,
@@ -17,4 +17,3 @@ const invokeLambda = (handler, { method = 'GET', ...options } = {}) => {
   })
 }
 
-module.exports = { invokeLambda }

test/helpers/main.js test/helpers/main.mjs

@@ -1,6 +1,6 @@
-const assert = require('assert')
+import assert from "node:assert"
 
-module.exports = class MockFetch {
+export class MockFetch {
   constructor() {
     this.requests = []
   }

test/helpers/mock_fetch.js test/helpers/mock_fetch.mjs

@@ -25,7 +25,7 @@
 
     /* Modules */
     "module": "commonjs" /* Specify what module code is generated. */,
-    "rootDir": "./src" /* Specify the root folder within your source files. */,
+    "rootDir": "./" /* Specify the root folder within your source files. */,
     // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */