Mock 함수

vi.fn 메서드를 사용하여 스파이 함수(모의 함수)를 생성하고 실행을 추적할 수 있습니다. 기존 객체의 메서드를 추적하려면 vi.spyOn 메서드를 사용하면 됩니다.

import { vi } from 'vitest';

const fn = vi.fn();
fn('hello world');
fn.mock.calls[0] === ['hello world'];

const market = {
  getApples: () => 100,
};

const getApplesSpy = vi.spyOn(market, 'getApples');
market.getApples();
getApplesSpy.mock.calls.length === 1;

스파이 결과를 검증하려면 expect에서 제공하는 스파이 검증 메서드(예: toHaveBeenCalled)를 사용해야 합니다. 이 API 참조는 스파이 동작을 조작할 수 있는 속성과 메서드를 설명합니다.

getMockName

• 타입: () => string

  .mockName(name) 메서드로 mock에 지정된 이름을 반환합니다.

mockClear

• 타입: () => MockInstance

  모든 호출 정보를 삭제합니다. 호출 후 spy.mock.calls와 spy.mock.results는 빈 배열이 됩니다. 서로 다른 검증 사이에 스파이를 초기화해야 할 경우 유용합니다.

  이 메서드를 각 테스트 전에 자동으로 호출하려면 구성에서 clearMocks 설정을 활성화할 수 있습니다.

mockName

• 타입: (name: string) => MockInstance

  내부 mock 이름을 설정합니다. 어떤 mock이 검증에 실패했는지 확인하는 데 도움이 됩니다.

mockImplementation

• 타입: (fn: Function) => MockInstance

  mock의 구현으로 사용될 함수를 지정합니다.

  예를 들어:

  const mockFn = vi.fn().mockImplementation(apples => apples + 1);
  // 또는: vi.fn(apples => apples + 1);
  
  const NelliesBucket = mockFn(0);
  const BobsBucket = mockFn(1);
  
  NelliesBucket === 1; // true
  BobsBucket === 2; // true
  
  mockFn.mock.calls[0][0] === 0; // true
  mockFn.mock.calls[1][0] === 1; // true

mockImplementationOnce

• 타입: (fn: Function) => MockInstance

  mock된 함수에 대한 단 한 번의 호출에 대해 mock의 구현으로 사용될 함수를 지정합니다. 여러 함수 호출이 서로 다른 결과를 생성하도록 체이닝할 수 있습니다.

  const myMockFn = vi
    .fn()
    .mockImplementationOnce(() => true)
    .mockImplementationOnce(() => false);
  
  myMockFn(); // true
  myMockFn(); // false

  mock된 함수가 더 이상 사용할 구현이 없으면 vi.fn(() => defaultValue) 또는 .mockImplementation(() => defaultValue)로 설정된 기본 구현을 호출합니다 (설정된 경우).

  const myMockFn = vi
    .fn(() => 'default')
    .mockImplementationOnce(() => 'first call')
    .mockImplementationOnce(() => 'second call');
  
  // 'first call', 'second call', 'default', 'default'
  console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

withImplementation

• 타입: (fn: Function, callback: () => void) => MockInstance

• 타입: (fn: Function, callback: () => Promise<unknown>) => Promise<MockInstance>

  콜백이 실행되는 동안 원래 mock 구현을 임시로 대체합니다.

  const myMockFn = vi.fn(() => 'original');
  
  myMockFn.withImplementation(
    () => 'temp',
    () => {
      myMockFn(); // 'temp'
    }
  );
  
  myMockFn(); // 'original'

  비동기 콜백과 함께 사용할 수 있습니다. 원래 구현을 다시 사용하려면 이 메서드가 완료될 때까지 기다려야 합니다.

  test('async callback', () => {
    const myMockFn = vi.fn(() => 'original');
  
    // 콜백이 비동기이므로 이 호출을 await해야 합니다.
    await myMockFn.withImplementation(
      () => 'temp',
      async () => {
        myMockFn(); // 'temp'
      }
    );
  
    myMockFn(); // 'original'
  });

  또한 mockImplementationOnce보다 우선합니다.

mockRejectedValue

• 타입: (value: any) => MockInstance

  비동기 함수가 호출될 때 거부될 값을 지정합니다.

  const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'));
  
  await asyncMock(); // "Async error" 오류를 발생시킵니다.

mockRejectedValueOnce

• 타입: (value: any) => MockInstance

  mock 함수에 대한 단 한 번의 호출에 대해 거부될 값을 지정합니다. 체이닝하면 이후의 모든 연속 호출이 전달된 값을 거부합니다.

  const asyncMock = vi
    .fn()
    .mockResolvedValueOnce('first call')
    .mockRejectedValueOnce(new Error('Async error'));
  
  await asyncMock(); // first call
  await asyncMock(); // "Async error" 오류를 발생시킵니다.

mockReset

• 타입: () => MockInstance

  mockClear가 수행하는 작업을 수행하고 내부 구현을 빈 함수로 만듭니다 (호출할 때 undefined를 반환합니다.). mock을 초기 상태로 되돌리려는 경우에 유용합니다.

  이 메서드를 각 테스트 전에 자동으로 호출하려면 구성에서 mockReset 설정을 활성화해야 합니다.

mockRestore

• 타입: () => MockInstance

  mockReset이 수행하는 작업을 수행하고 내부 구현을 원래 함수로 복원합니다.

  vi.fn()으로 생성된 mock을 복원하면 구현이 undefined를 반환하는 빈 함수로 설정됩니다. vi.fn(impl)을 복원하면 구현이 impl로 복원됩니다.

  이 메서드를 각 테스트 전에 자동으로 호출하려면 구성에서 restoreMocks 설정을 활성화할 수 있습니다.

mockResolvedValue

• 타입: (value: any) => MockInstance

  비동기 함수가 호출될 때 resolve될 값을 지정합니다.

  const asyncMock = vi.fn().mockResolvedValue(43);
  
  await asyncMock(); // 43

mockResolvedValueOnce

• 타입: (value: any) => MockInstance

  mock 함수에 대한 단 한 번의 호출에 대해 resolve될 값을 지정합니다. 체이닝하면 이후의 모든 연속 호출이 전달된 값을 resolve합니다.

  const asyncMock = vi
    .fn()
    .mockResolvedValue('default')
    .mockResolvedValueOnce('first call')
    .mockResolvedValueOnce('second call');
  
  await asyncMock(); // first call
  await asyncMock(); // second call
  await asyncMock(); // default
  await asyncMock(); // default

mockReturnThis

• 타입: () => MockInstance

  내부 구현을 this 컨텍스트를 반환하도록 설정합니다.

mockReturnValue

• 타입: (value: any) => MockInstance

  mock 함수가 호출될 때마다 반환될 값을 지정합니다.

  const mock = vi.fn();
  mock.mockReturnValue(42);
  mock(); // 42
  mock.mockReturnValue(43);
  mock(); // 43

mockReturnValueOnce

• 타입: (value: any) => MockInstance

  mock 함수에 대한 단 한 번의 호출에 대해 반환될 값을 지정합니다. 체이닝하면 이후의 모든 연속 호출이 전달된 값을 반환합니다. mockReturnValueOnce로 설정된 값이 모두 사용되면 mockImplementation 또는 다른 mockReturn* 메서드로 설정된 함수가 호출됩니다.

  const myMockFn = vi
    .fn()
    .mockReturnValue('default')
    .mockReturnValueOnce('first call')
    .mockReturnValueOnce('second call');
  
  // 'first call', 'second call', 'default', 'default'
  console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

mock.calls

이 속성은 각 호출에 대한 모든 인수를 포함하는 배열입니다. 배열의 각 항목은 해당 호출의 인수 목록입니다.

const fn = vi.fn();

fn('arg1', 'arg2');
fn('arg3', 'arg4');

fn.mock.calls ===
  [
    ['arg1', 'arg2'], // 첫 번째 호출
    ['arg3', 'arg4'], // 두 번째 호출
  ];

mock.lastCall

이 속성에는 마지막 호출의 인수가 포함됩니다. 스파이가 호출되지 않은 경우 undefined를 반환합니다.

mock.results

이 배열은 함수에서 반환된 모든 값을 담고 있습니다. 배열의 각 항목은 type 및 value 속성이 있는 객체입니다. 사용 가능한 타입은 다음과 같습니다.

• 'return' - 함수가 예외를 발생시키지 않고 반환되었습니다.
• 'throw' - 함수가 값을 throw했습니다.

value 속성에는 반환된 값 또는 throw된 오류가 포함됩니다. 함수가 Promise를 반환한 경우, Promise가 resolve되면 value 속성은 resolve된 값이 됩니다.

const fn = vi.fn();

const result = fn(); // 'result' 반환

try {
  fn(); // Error를 throw합니다.
} catch {}

fn.mock.results ===
  [
    // 첫 번째 결과
    {
      type: 'return',
      value: 'result',
    },
    // 마지막 결과
    {
      type: 'throw',
      value: Error,
    },
  ];

mock.instances

이 배열은 mock이 new 키워드로 호출될 때 생성된 모든 인스턴스를 포함합니다. 이는 반환 값이 아닌 함수가 실행될 때의 컨텍스트(this)를 나타냅니다.

WARNING

mock이 new MyClass()로 인스턴스화된 경우 mock.instances는 하나의 값을 가진 배열이 됩니다.

const MyClass = vi.fn();
const a = new MyClass();

MyClass.mock.instances[0] === a;

생성자에서 값을 반환하면 해당 값은 instances 배열이 아닌 results 배열에 포함됩니다.

const Spy = vi.fn(() => ({ method: vi.fn() }));
const a = new Spy();

Spy.mock.instances[0] !== a;
Spy.mock.results[0] === a;