ava-patterns v3.2.1

ava-patterns

Some useful helpers for tests in AVA.

Usage

Install ava-patterns by running:

yarn add ava-patterns

useTemporaryDirectory()

Create a temporary directory and delete it (and its contents) at the end of the test.

Takes the following options (all of which are optional):

• prefix: The directory in which to create the temporary directory. Defaults to a suitable location based on the host system (e.g. /tmp).

Returns an object with the following members:

• path: The absolute path to the temporary directory.
• writeFile(filePath, fileContents): Write a file with path relative to the temporary directory, returning the absolute path to the file. Any leading whitespace in the file contents is stripped. If the file starts with a shebang, it is given executable permissions.

import process from 'node:process'
import test from 'ava'
import {useTemporaryDirectory} from 'ava-patterns'

test('writing files to a temporary directory', async (t) => {
  const directory = await useTemporaryDirectory(t)
  await directory.writeFile('file.txt', `
    Hello World!
  `)
  t.pass()
})

test('creating temporary directories in a specified location', async (t) => {
  const directory = await useTemporaryDirectory(t, { prefix: process.cwd() })
  await directory.writeFile('file.txt', `
    Hello World!
  `)
  t.pass()
})

runProcess()

Spawn a process and kill it at the end of the test.

The second argument supports the following options:

• command: The command line command as an array of strings.
• env: An object of environment variables.
• cwd: The working directory in which to run the command

Returns an object with the following members:

• output: A string containing all of the output from stdout and stderr.
• events: An EventEmitter that emits the following events:
  • stdout: Any output written to standard output
  • stderr: Any output written to standard error
  • output: Any output written to either standard output or error
  • exit: The exit code after the process ends
• waitForOutput(pattern, timeout = 1000): Enables waiting for a given substring or regular expression to be output, for up to a given timeout.
• waitUntilExit(): Returns a promise that will resolve with the exit code.
• childProcess: The underlying instance of ChildProcess

import test from 'ava'
import {runProcess} from 'ava-patterns'
import got from 'got'

test('running a Node server', async (t) => {
  const script = `
    import * as http from 'http'
    const server = http.createServer((request, response) => {
      response.end('Hello World!')
    })
    server.listen(10000, () => {
      console.log('Listening')
    })
  `

  const program = runProcess(t, {
    command: ['node', '--input-type', 'module', '--eval', script]
  })

  await program.waitForOutput('Listening')

  t.is(program.output, 'Listening\n')

  const response = await got('http://localhost:10000')
  t.is(response.body, 'Hello World!')
})

wait()

Wait for a given number of milliseconds.

import test from 'ava'
import {wait} from 'ava-patterns'

test('writing files', async (t) => {
  // perform action and wait for results
  await wait(500)
  // check results
})

http()

Make an HTTP request.

It takes in an object with properties method, url, optional headers, and an optional body and returns an object with properties status, headers, and body.

import {http} from 'ava-patterns'

test('sending HTTP requests', async (t) => {
  const response = await http({
    method: 'POST',
    url: 'https://httpbin.org/post',
    body: 'Hello World!'
  })
  t.like(JSON.parse(response.body), {data: 'Hello World!'})
})