Hopp til hovedinnhold
Versjon: 30.0

Mock Functions

Unofficial Beta Translation

This page was AI-translated by PageTurner (beta). Not officially endorsed by the project. Found an error? Report issue →

Mock-funksjoner er også kjent som "spionsfunksjoner" fordi de lar deg overvåke oppførselen til en funksjon som kalles indirekte av annen kode, i stedet for bare å teste output. Du kan opprette en mock-funksjon med jest.fn(). Hvis ingen implementering er angitt, vil mock-funksjonen returnere undefined når den kalles.

Unofficial Beta Translation

This page was AI-translated by PageTurner (beta). Not officially endorsed by the project. Found an error? Report issue →

info

TypeScript-eksemplene på denne siden vil bare fungere som dokumentert hvis du eksplisitt importerer Jest API-ene:

import {expect, jest, test} from '@jest/globals';

Se Komme i gang-guiden for detaljer om hvordan du konfigurerer Jest med TypeScript.

Metoder​

Referanse​

mockFn.getMockName()​

Returnerer mock-navnet satt ved å kalle .mockName().

mockFn.mock.calls​

En matrise som inneholder alle argumentene fra alle kall som er gjort til denne mock-funksjonen. Hvert element i matrisen er en matrise med argumenter som ble sendt under kallet.

For eksempel: En mock-funksjon f som er kalt to ganger, først med argumentene f('arg1', 'arg2') og deretter med f('arg3', 'arg4'), vil ha en mock.calls-matrise som ser slik ut:

[
  ['arg1', 'arg2'],
  ['arg3', 'arg4'],
];

mockFn.mock.results​

En matrise som inneholder resultatene av alle kall til denne mock-funksjonen. Hvert element i denne matrisen er et objekt med en type-egenskap og en value-egenskap. type vil være en av følgende:

  • 'return' - Indikerer at kallet fullførte normalt med en returverdi.

  • 'throw' - Indikerer at kallet avsluttet med å kaste en verdi.

  • 'incomplete' - Indikerer at kallet ikke er fullført. Dette skjer hvis du tester resultatet fra innsiden av mock-funksjonen selv, eller fra en funksjon som ble kalt av mocken.

value-egenskapen inneholder verdien som ble kastet eller returnert. value er udefinert når type === 'incomplete'.

For eksempel: En mock-funksjon f som er kalt tre ganger, returnerte 'result1', kastet en feil, og returnerte deretter 'result2', vil ha en mock.results-matrise som ser slik ut:

[
  {
    type: 'return',
    value: 'result1',
  },
  {
    type: 'throw',
    value: {
      /* Error instance */
    },
  },
  {
    type: 'return',
    value: 'result2',
  },
];

mockFn.mock.instances​

En matrise som inneholder alle objektinstansene som er opprettet fra denne mock-funksjonen ved bruk av new.

For eksempel: En mock-funksjon som er instansiert to ganger vil ha følgende mock.instances-matrise:

const mockFn = jest.fn();

const a = new mockFn();
const b = new mockFn();

mockFn.mock.instances[0] === a; // true
mockFn.mock.instances[1] === b; // true

mockFn.mock.contexts​

En matrise som inneholder kontekstene for alle kall til mock-funksjonen.

En kontekst er this-verdien som en funksjon mottar når den kalles. Konteksten kan settes med Function.prototype.bind, Function.prototype.call eller Function.prototype.apply.

For eksempel:

const mockFn = jest.fn();

const boundMockFn = mockFn.bind(thisContext0);
boundMockFn('a', 'b');
mockFn.call(thisContext1, 'a', 'b');
mockFn.apply(thisContext2, ['a', 'b']);

mockFn.mock.contexts[0] === thisContext0; // true
mockFn.mock.contexts[1] === thisContext1; // true
mockFn.mock.contexts[2] === thisContext2; // true

mockFn.mock.lastCall​

En matrise som inneholder argumentene fra det siste kallet til denne mock-funksjonen. Hvis funksjonen ikke er kalt, returneres undefined.

For eksempel: En mock-funksjon f som er kalt to ganger, først med argumentene f('arg1', 'arg2') og deretter med f('arg3', 'arg4'), vil ha en mock.lastCall-matrise som ser slik ut:

['arg3', 'arg4'];

mockFn.mockClear()​

Tømmer all informasjon lagret i mockFn.mock.calls, mockFn.mock.instances, mockFn.mock.contexts og mockFn.mock.results. Dette er ofte nyttig når du vil rydde opp i en mocks bruksdata mellom to påstander.

Konfigurasjonsalternativet clearMocks er tilgjengelig for å tømme mock-er automatisk før hver test.

advarsel

Vær oppmerksom på at mockFn.mockClear() erstatter hele mockFn.mock-objektet, ikke bare tilbakestiller verdiene til egenskapene! Du bør derfor unngå å tilordne mockFn.mock til andre variabler, midlertidige eller ikke, for å sikre at du ikke får tilgang til utdaterte data.

mockFn.mockReset()​

Gjør alt det samme som mockFn.mockClear(), og erstatter i tillegg mock-implementasjonen med en tom funksjon som returnerer undefined.

Konfigurasjonsvalget resetMocks er tilgjengelig for automatisk å tilbakestille mocks før hver test.

mockFn.mockRestore()​

Gjør alt det samme som mockFn.mockReset(), og gjenoppretter i tillegg den opprinnelige (ikke-mockede) implementasjonen.

Dette er nyttig når du ønsker å mocke funksjoner i visse testtilfeller og gjenopprette originalimplementasjonen i andre.

Konfigurasjonsvalget restoreMocks er tilgjengelig for automatisk å gjenopprette mocks før hver test.

info

mockFn.mockRestore() fungerer bare når mocken ble opprettet med jest.spyOn(). Du må derfor håndtere gjenopprettingen manuelt når du tilordner jest.fn() direkte.

mockFn.mockImplementation(fn)​

Aksepterer en funksjon som skal brukes som implementasjonen til mocken. Mocken vil fortsatt registrere alle kall og instanser – den eneste forskjellen er at implementasjonen også vil kjøres når mocken kalles.

tips

jest.fn(implementation) er en forkortelse for jest.fn().mockImplementation(implementation).

const mockFn = jest.fn(scalar => 42 + scalar);

mockFn(0); // 42
mockFn(1); // 43

mockFn.mockImplementation(scalar => 36 + scalar);

mockFn(2); // 38
mockFn(3); // 39

.mockImplementation() kan også brukes til å mocke klassekonstruktører:

SomeClass.js
module.exports = class SomeClass {
  method(a, b) {}
};
SomeClass.test.js
const SomeClass = require('./SomeClass');

jest.mock('./SomeClass'); // this happens automatically with automocking

const mockMethod = jest.fn();
SomeClass.mockImplementation(() => {
  return {
    method: mockMethod,
  };
});

const some = new SomeClass();
some.method('a', 'b');

console.log('Calls to method:', mockMethod.mock.calls);

mockFn.mockImplementationOnce(fn)​

Aksepterer en funksjon som brukes som mock-implementasjon for ett enkelt kall til den mockede funksjonen. Kan lenkes slik at påfølgende funksjonskall produserer ulike resultater.

const mockFn = jest
  .fn()
  .mockImplementationOnce(cb => cb(null, true))
  .mockImplementationOnce(cb => cb(null, false));

mockFn((err, val) => console.log(val)); // true
mockFn((err, val) => console.log(val)); // false

Når den mockede funksjonen har brukt opp alle implementasjoner satt med .mockImplementationOnce(), vil den utføre standardimplementasjonen satt med jest.fn(() => defaultValue) eller .mockImplementation(() => defaultValue) hvis disse ble kalt:

const mockFn = jest
  .fn(() => 'default')
  .mockImplementationOnce(() => 'first call')
  .mockImplementationOnce(() => 'second call');

mockFn(); // 'first call'
mockFn(); // 'second call'
mockFn(); // 'default'
mockFn(); // 'default'

mockFn.mockName(name)​

Aksepterer en streng som brukes i testresultater i stedet for 'jest.fn()' for å indikere hvilken mock-funksjon som refereres.

For eksempel:

const mockFn = jest.fn().mockName('mockedFunction');

// mockFn();
expect(mockFn).toHaveBeenCalled();

Vil resultere i denne feilen:

expect(mockedFunction).toHaveBeenCalled()

Expected number of calls: >= 1
Received number of calls:    0

mockFn.mockReturnThis()​

Forkortelse for:

jest.fn(function () {
  return this;
});

mockFn.mockReturnValue(value)​

Forkortelse for:

jest.fn().mockImplementation(() => value);

Aksepterer en verdi som returneres hver gang mock-funksjonen kalles.

const mock = jest.fn();

mock.mockReturnValue(42);
mock(); // 42

mock.mockReturnValue(43);
mock(); // 43

mockFn.mockReturnValueOnce(value)​

Forkortelse for:

jest.fn().mockImplementationOnce(() => value);

Aksepterer en verdi som returneres for ett enkelt kall til mock-funksjonen. Kan lenkes slik at påfølgende kall returnerer ulike verdier. Når det ikke er flere mockReturnValueOnce-verdier igjen, vil kall returnere verdien spesifisert av mockReturnValue.

const mockFn = jest
  .fn()
  .mockReturnValue('default')
  .mockReturnValueOnce('first call')
  .mockReturnValueOnce('second call');

mockFn(); // 'first call'
mockFn(); // 'second call'
mockFn(); // 'default'
mockFn(); // 'default'

mockFn.mockResolvedValue(value)​

Forkortelse for:

jest.fn().mockImplementation(() => Promise.resolve(value));

Nyttig for å mocke asynkrone funksjoner i asynkrone tester:

test('async test', async () => {
  const asyncMock = jest.fn().mockResolvedValue(43);

  await asyncMock(); // 43
});

mockFn.mockResolvedValueOnce(value)​

Forkortelse for:

jest.fn().mockImplementationOnce(() => Promise.resolve(value));

Nyttig for å returnere ulike verdier over flere asynkrone kall:

test('async test', async () => {
  const asyncMock = jest
    .fn()
    .mockResolvedValue('default')
    .mockResolvedValueOnce('first call')
    .mockResolvedValueOnce('second call');

  await asyncMock(); // 'first call'
  await asyncMock(); // 'second call'
  await asyncMock(); // 'default'
  await asyncMock(); // 'default'
});

mockFn.mockRejectedValue(value)​

Forkortelse for:

jest.fn().mockImplementation(() => Promise.reject(value));

Nyttig for å lage asynkrone mock-funksjoner som alltid vil avvise:

test('async test', async () => {
  const asyncMock = jest
    .fn()
    .mockRejectedValue(new Error('Async error message'));

  await asyncMock(); // throws 'Async error message'
});

mockFn.mockRejectedValueOnce(value)​

Forkortelse for:

jest.fn().mockImplementationOnce(() => Promise.reject(value));

Nyttig sammen med .mockResolvedValueOnce() eller for å avvise med ulike unntak over flere asynkrone kall:

test('async test', async () => {
  const asyncMock = jest
    .fn()
    .mockResolvedValueOnce('first call')
    .mockRejectedValueOnce(new Error('Async error message'));

  await asyncMock(); // 'first call'
  await asyncMock(); // throws 'Async error message'
});

mockFn.withImplementation(fn, callback)​

Aksepterer en funksjon som midlertidig skal brukes som implementasjonen av mocken mens tilbakekallingsfunksjonen utføres.

test('test', () => {
  const mock = jest.fn(() => 'outside callback');

  mock.withImplementation(
    () => 'inside callback',
    () => {
      mock(); // 'inside callback'
    },
  );

  mock(); // 'outside callback'
});

mockFn.withImplementation kan brukes uavhengig av om tilbakekallingsfunksjonen er asynkron (returnerer en thenable) eller ikke. Hvis tilbakekallingsfunksjonen er asynkron, returneres et promise. Å vente på dette promise vil vente på tilbakekallingsfunksjonen og deretter tilbakestille implementasjonen.

test('async test', async () => {
  const mock = jest.fn(() => 'outside callback');

  // We await this call since the callback is async
  await mock.withImplementation(
    () => 'inside callback',
    async () => {
      mock(); // 'inside callback'
    },
  );

  mock(); // 'outside callback'
});

Erstattede egenskaper​

replacedProperty.replaceValue(value)​

Endrer verdien til en allerede erstattet egenskap. Dette er nyttig når du ønsker å erstatte en egenskap og deretter justere verdien i spesifikke tester. Som et alternativ kan du kalle jest.replaceProperty() flere ganger på samme egenskap.

replacedProperty.restore()​

Gjenoppretter objektets egenskap til originalverdien.

Vær oppmerksom på at replacedProperty.restore() kun fungerer når egenskapsverdien ble erstattet med jest.replaceProperty().

Konfigurasjonsalternativet restoreMocks er tilgjengelig for automatisk å gjenopprette erstattede egenskaper før hver test.

Bruk med TypeScript​

Unofficial Beta Translation

This page was AI-translated by PageTurner (beta). Not officially endorsed by the project. Found an error? Report issue →

info

TypeScript-eksemplene på denne siden vil bare fungere som dokumentert hvis du eksplisitt importerer Jest API-ene:

import {expect, jest, test} from '@jest/globals';

Se Komme i gang-guiden for detaljer om hvordan du konfigurerer Jest med TypeScript.

jest.fn(implementation?)​

Riktige mock-typer vil bli inferert hvis en implementasjon sendes til jest.fn(). Det er mange brukstilfeller der implementasjonen utelates. For å sikre typesikkerhet kan du sende et generisk typeargument (se også eksemplene ovenfor for mer referanse):

import {expect, jest, test} from '@jest/globals';
import type add from './add';
import calculate from './calc';

test('calculate calls add', () => {
  // Create a new mock that can be used in place of `add`.
  const mockAdd = jest.fn<typeof add>();

  // `.mockImplementation()` now can infer that `a` and `b` are `number`
  // and that the returned value is a `number`.
  mockAdd.mockImplementation((a, b) => {
    // Yes, this mock is still adding two numbers but imagine this
    // was a complex function we are mocking.
    return a + b;
  });

  // `mockAdd` is properly typed and therefore accepted by anything
  // requiring `add`.
  calculate(mockAdd, 1, 2);

  expect(mockAdd).toHaveBeenCalledTimes(1);
  expect(mockAdd).toHaveBeenCalledWith(1, 2);
});

jest.Mock<T>​

Konstruerer typen til en mock-funksjon, f.eks. returtypen til jest.fn(). Dette kan være nyttig hvis du må definere en rekursiv mock-funksjon:

import {jest} from '@jest/globals';

const sumRecursively: jest.Mock<(value: number) => number> = jest.fn(value => {
  if (value === 0) {
    return 0;
  } else {
    return value + fn(value - 1);
  }
});

jest.Mocked<Source>​

Hjelpertypen jest.Mocked<Source> returnerer Source-typen pakket med typedefinisjonene til Jest mock-funksjoner.

import {expect, jest, test} from '@jest/globals';
import type {fetch} from 'node-fetch';

jest.mock('node-fetch');

let mockedFetch: jest.Mocked<typeof fetch>;

afterEach(() => {
  mockedFetch.mockClear();
});

test('makes correct call', () => {
  mockedFetch = getMockedFetch();
  // ...
});

test('returns correct data', () => {
  mockedFetch = getMockedFetch();
  // ...
});

Typer av klasser, funksjoner eller objekter kan sendes som typeargument til jest.Mocked<Source>. Hvis du foretrekker å begrense inndatatypen, bruk: jest.MockedClass<Source>, jest.MockedFunction<Source> eller jest.MockedObject<Source>.

jest.Replaced<Source>​

Hjelpertypen jest.Replaced<Source> returnerer Source-typen pakket med typedefinisjonene til Jest sine erstattede egenskaper.

src/utils.ts
export function isLocalhost(): boolean {
  return process.env['HOSTNAME'] === 'localhost';
}
src/__tests__/utils.test.ts
import {afterEach, expect, it, jest} from '@jest/globals';
import {isLocalhost} from '../utils';

let replacedEnv: jest.Replaced<typeof process.env> | undefined = undefined;

afterEach(() => {
  replacedEnv?.restore();
});

it('isLocalhost should detect localhost environment', () => {
  replacedEnv = jest.replaceProperty(process, 'env', {HOSTNAME: 'localhost'});

  expect(isLocalhost()).toBe(true);
});

it('isLocalhost should detect non-localhost environment', () => {
  replacedEnv = jest.replaceProperty(process, 'env', {HOSTNAME: 'example.com'});

  expect(isLocalhost()).toBe(false);
});

jest.mocked(source, options?)​

Hjelpermetoden mocked() pakker typene til source-objektet og dets dypestedte medlemmer med typedefinisjonene til Jest mock-funksjoner. Du kan sende {shallow: true} som options-argument for å deaktivere dypestubbing.

Returnerer source-objektet.

song.ts
export const song = {
  one: {
    more: {
      time: (t: number) => {
        return t;
      },
    },
  },
};
song.test.ts
import {expect, jest, test} from '@jest/globals';
import {song} from './song';

jest.mock('./song');
jest.spyOn(console, 'log');

const mockedSong = jest.mocked(song);
// or through `jest.Mocked<Source>`
// const mockedSong = song as jest.Mocked<typeof song>;

test('deep method is typed correctly', () => {
  mockedSong.one.more.time.mockReturnValue(12);

  expect(mockedSong.one.more.time(10)).toBe(12);
  expect(mockedSong.one.more.time.mock.calls).toHaveLength(1);
});

test('direct usage', () => {
  jest.mocked(console.log).mockImplementation(() => {
    return;
  });

  console.log('one more time');

  expect(jest.mocked(console.log).mock.calls).toHaveLength(1);
});

jest.Spied<Source>​

Konstruerer typen til en sporet klasse eller funksjon (dvs. returtypen til jest.spyOn()).

__utils__/setDateNow.ts
import {jest} from '@jest/globals';

export function setDateNow(now: number): jest.Spied<typeof Date.now> {
  return jest.spyOn(Date, 'now').mockReturnValue(now);
}
import {afterEach, expect, type jest, test} from '@jest/globals';
import {setDateNow} from './__utils__/setDateNow';

let spiedDateNow: jest.Spied<typeof Date.now> | undefined = undefined;

afterEach(() => {
  spiedDateNow?.mockReset();
});

test('renders correctly with a given date', () => {
  spiedDateNow = setDateNow(1_482_363_367_071);
  // ...

  expect(spiedDateNow).toHaveBeenCalledTimes(1);
});

Typer av en klasse eller funksjon kan sendes som typeargument til jest.Spied<Source>. Hvis du foretrekker å begrense inndatatypen, bruk: jest.SpiedClass<Source> eller jest.SpiedFunction<Source>.

Bruk jest.SpiedGetter<Source> eller jest.SpiedSetter<Source> for å lage typen til en sporet getter eller setter henholdsvis.