Vitest 알아보기

npm install -D vitest

yarn add -D vitest

{
  "scripts": {
    "test": "vitest"
  }
}

{
  "scripts": {
    "test": "vitest run"
  }
}

npm run test

yarn test

vitest foobar

export function sum(a, b) {
  return a + b;
}

import { expect, test } from 'vitest'
import { sum } from './sum'

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
})

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    // ...
  },
});

/// <reference types="vitest" />
import { defineConfig } from 'vite';

export default defineConfig({
  test: {
    // ...
  },
});

import { defineConfig, mergeConfig } from 'vitest/config'
import viteConfig from './vite.config.mjs'

export default mergeConfig(
  viteConfig,
  defineConfig({
    test: {
      // ...
    },
  })
)

import { expect, test } from 'vitest'

test('should work as expected', () => {
  expect(Math.sqrt(4)).toBe(2)
})

import { expect } from 'vitest'

const value = 5

test('값이 5와 같아야 함', () => {
  expect(value).toBe(5)
})

import { expect, test } from 'vitest'

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3) // 테스트를 실패로 표시하고 계속 진행
  expect.soft(1 + 2).toBe(4) // 테스트를 실패로 표시하고 계속 진행
})
// 테스트가 끝나면, 위의 에러들이 출력됩니다.

import { expect, test } from 'vitest'

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3) // 테스트를 실패로 표시하고 계속 진행
  expect(1 + 2).toBe(4) // 실패하고 테스트를 종료하며 이전의 모든 에러가 출력됨
  expect.soft(1 + 3).toBe(5) // 실행되지 않음
})

import { expect, test } from 'vitest'

const value = 8

test('값이 10과 같지 않아야 함', () => {
  expect(value).not.toBe(10)
})

import { expect, test } from 'vitest'

function add(a, b) {
  return a + b
}

test('add function should correctly add two numbers', () => {
  const result = add(2, 3)
  expect(result).toBe(5)
})

import { expect, test } from 'vitest'

test.fails('decimals are not equal in javascript', () => {
  expect(0.2 + 0.1).toBe(0.3) // 0.2 + 0.1 is 0.30000000000000004
})

test('decimals are rounded to 5 after the point', () => {
  // 0.2 + 0.1 is 0.30000 | "000000000004" removed
  expect(0.2 + 0.1).toBeCloseTo(0.3, 5)
  // nothing from 0.30000000000000004 is removed
  expect(0.2 + 0.1).not.toBeCloseTo(0.3, 50)
})

import { expect, test } from 'vitest'

function getStock(name) {
  if (name === 'APPLE') {
    return { name: 'APPLE', price: 200 }
  }
}

test('getStock returned something', () => {
  const stock = getStock('APPLE')
  expect(stock).toBeDefined()
})

test('getStock returns undefined', () => {
  const stock = getStock('GOOGLE')
  expect(stock).toBeUndefined()
})

import { expect, test } from 'vitest'
import { hasData } from './hasData.ts'

test('hasData should return truthy for non-empty data', () => {
  // 실제 반환 값 자체보다는 반환 값이 truthy한 값인지, falsy한 값인지에 따라 진행
  expect(hasData([1, 2, 3])).toBeTruthy()
  expect(hasData([])).toBeFalsy()
})

import { expect, test } from 'vitest'

function apples() {
  return null
}

test("we don't have apples", () => {
  expect(apples()).toBeNull()
})

import { expect, test } from 'vitest'

let i = 0

function getApplesCount() {
  i++
  return i > 1 ? Number.NaN : i
}

test('getApplesCount has some unusual side effects...', () => {
  expect(getApplesCount()).not.toBeNaN()
  expect(getApplesCount()).toBeNaN()
})

import { expect, test } from 'vitest'

const price = 10000

test('price is type of number', () => {
  expect(actual).toBeTypeOf('number')
})

import { expect, test } from 'vitest'
import { getApples } from './stocks.js'

test('have more then 10 apples', () => {
  expect(getApples()).toBeGreaterThan(10)
})

test('have 11 apples or more', () => {
  expect(getApples()).toBeGreaterThanOrEqual(11)
})

test('have less then 20 apples', () => {
  expect(getApples()).toBeLessThan(20)
})

test('have 11 apples or less', () => {
  expect(getApples()).toBeLessThanOrEqual(11)
})

import { expect, test } from 'vitest'

const personA = {
  name: 'John',
  age: 30,
}

const personB = {
  name: 'John',
  age: 30,
}

test('They have the same properties', () => {
  expect(personA).toEqual(personB)
})

test('They are not the same', () => {
  expect(personA).not.toBe(personB)
})

import { expect, test } from 'vitest'

test('Check if a value is included in an array', () => {
  const numbers = [1, 2, 3, 4, 5]

  expect(numbers).toContain(3)
})

import { expect, test } from 'vitest'

test('Check if a string is a substring of another string', () => {
  const sentence = 'check string'

  expect(sentence).toContain('check')
})

import { expect, test } from 'vitest'

const dog = {
  name: 'Max',
  age: 5,
  feature: {
    species: 'Shepherd',
    from: 'Germany',
  },
}

test('Check properties of the dog object', () => {
  // 'name' 속성이 dog 객체에 존재하는지 확인
  expect(dog).toHaveProperty('name')

  // 'feature.species' 속성이 dog 객체에 존재하는지 확인
  expect(dog).toHaveProperty('feature.species')

  // 'color' 속성이 dog 객체에 존재하지 않는지 확인
  expect(dog).not.toHaveProperty('color')

  // 'feature' 안의 'from' 속성이 특정 값과 일치하는지 확인
  expect(dog).toHaveProperty('feature.from', 'Germany')
})

import { expect, test } from 'vitest'

test('top fruits', () => {
  expect('top fruits include apple, orange and grape').toMatch(/apple/)
  expect('applefruits').toMatch('fruit')
})

import { expect, test } from 'vitest'

const johnInvoice = {
  isActive: true,
  customer: {
    first_name: 'John',
    last_name: 'Doe',
  },
  items: [
    {
      type: 'apples',
      quantity: 10,
    },
    {
      type: 'oranges',
      quantity: 5,
    },
  ],
}

const johnDetails = {
  customer: {
    first_name: 'John',
    last_name: 'Doe',
  },
}

test('invoice has john personal details', () => {
  expect(johnInvoice).toMatchObject(johnDetails)
})

import { expect, test } from 'vitest'

test('the number of elements must match exactly', () => {
  const expectedArray = [
    { id: 1, name: 'Apple' },
    { id: 2, name: 'Orange' },
    { id: 3, name: 'Grape' },
  ]

  const actualArray = [
    { id: 1, name: 'Apple' },
    { id: 2, name: 'Orange' },
    { id: 3, name: 'Grape' },
  ]

  expect(actualArray).toMatchObject(expectedArray)
})

function getFruitStock(type) {
  if (type === 'pineapples') throw new Error('Pineapples are not in stock')

  // ...
}

test('throws on pineapples', () => {
  // 에러 메시지에 "stock"이라는 단어가 포함되어 있는지 테스트
  // 다음의 두 테스트 케이스는 동일합니다.

  expect(() => getFruitStock('pineapples')).toThrowError(/stock/)
  expect(() => getFruitStock('pineapples')).toThrowError('stock')

  // 정확한 에러 메시지를 테스트
  expect(() => getFruitStock('pineapples')).toThrowError(/^Pineapples are not in stock$/)
})

function getAsyncFruitStock() {
  return Promise.reject(new Error('empty'))
}

test('throws on pineapples', async () => {
  await expect(() => getAsyncFruitStock()).rejects.toThrowError('empty')
})