Writing Tests

import { describe, it, expect } from 'vitest'

describe('Math utilities', () => {
  it('adds two numbers', () => {
    expect(1 + 1).toBe(2)
  })

  it('subtracts two numbers', () => {
    expect(5 - 3).toBe(2)
  })
})

describe('User service', () => {
  describe('create', () => {
    it('returns a new user', () => { /* ... */ })
    it('throws on duplicate email', () => { /* ... */ })
  })

  describe('delete', () => {
    it('removes the user', () => { /* ... */ })
  })
})

it.skip('not implemented yet', () => { /* ... */ })
it.todo('handle edge case')
it.fails('known regression', () => {
  expect(brokenFn()).toBe('correct') // this must throw/fail
})

it.each([
  [1, 1, 2],
  [2, 3, 5],
  [0, -1, -1],
])('adds %i + %i = %i', (a, b, expected) => {
  expect(a + b).toBe(expected)
})

it.each([
  { a: 1, b: 1, expected: 2 },
  { a: 2, b: 3, expected: 5 },
])('adds $a + $b = $expected', ({ a, b, expected }) => {
  expect(a + b).toBe(expected)
})

it.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${2} | ${3} | ${5}
`('adds $a + $b', ({ a, b, expected }) => {
  expect(a + b).toBe(expected)
})

describe.each([
  { role: 'admin', canDelete: true },
  { role: 'viewer', canDelete: false },
])('$role permissions', ({ role, canDelete }) => {
  it(`can${canDelete ? '' : 'not'} delete`, () => {
    expect(checkPermission(role, 'delete')).toBe(canDelete)
  })
})

describe.concurrent('parallel suite', () => {
  it('test 1', async () => { /* runs in parallel */ })
  it('test 2', async () => { /* runs in parallel */ })
})

// Or per-test:
it.concurrent('parallel test', async () => { /* ... */ })

const isCI = process.env.CI === 'true'

it.skipIf(isCI)('skipped in CI', () => { /* ... */ })
it.runIf(!isCI)('runs only locally', () => { /* ... */ })

import { it } from 'vitest'

it('has context', (ctx) => {
  // ctx.task — current task metadata
  // ctx.expect — isolated expect instance
  // ctx.skip() — skip from inside the test
  ctx.expect(1 + 1).toBe(2)
})

import { test } from 'vitest'

const myTest = test.extend<{ db: Database }>({
  db: async ({}, use) => {
    const db = await Database.connect()
    await use(db)
    await db.close()
  },
})

myTest('reads from db', async ({ db }) => {
  const row = await db.find(1)
  expect(row).toBeDefined()
})

it('flaky network call', { retry: 3 }, async () => {
  const data = await fetchWithRetry()
  expect(data).toBeDefined()
})

// vitest.config.ts
export default defineConfig({
  test: { retry: 2 }
})

it('slow operation', { timeout: 10_000 }, async () => {
  await longRunningTask()
})

// A bare number as the last argument still works:
it('also slow', async () => {
  await longRunningTask()
}, 10_000)

// Or globally:
// test: { testTimeout: 10_000 }

import { expect } from 'vitest'

it('checks multiple things', () => {
  expect.soft(1 + 1).toBe(2)
  expect.soft('hello').toBe('world') // records failure but continues
  expect.soft(true).toBe(true)
  // all soft failures reported at end
})