Hopp til hovedinnhold
Versjon: Neste

Jest-objektet

Unofficial Beta Translation

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

jest-objektet er automatisk tilgjengelig i hver testfil. Metodene i jest-objektet hjelper til med å lage mocks og lar deg kontrollere Jests generelle oppførsel. Det kan også importeres eksplisitt via import {jest} from '@jest/globals'.

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​

Mocke moduler​

jest.disableAutomock()​

Deaktiverer automatisk mocking i modullasteren.

info

Automatisk mocking må være aktivert via automock-konfigurasjonsvalget for at denne metoden skal ha noen effekt. Se også dokumentasjonen for konfigurasjonsvalget for flere detaljer.

/** @type {import('jest').Config} */
const config = {
  automock: true,
};

module.exports = config;

Etter at disableAutomock() er kalt, vil alle require()-kall returnere de faktiske versjonene av hver modul (i stedet for en mocket versjon).

utils.js
export default {
  authorize: () => {
    return 'token';
  },
};
__tests__/disableAutomocking.js
import utils from '../utils';

jest.disableAutomock();

test('original implementation', () => {
  // now we have the original implementation,
  // even if we set the automocking in a jest configuration
  expect(utils.authorize()).toBe('token');
});

Dette er vanligvis nyttig når du har et scenario der antallet avhengigheter du ønsker å mocke er langt færre enn de du ikke vil mocke. For eksempel, hvis du skriver en test for en modul som bruker mange avhengigheter som rimelig kan klassifiseres som modulens "implementasjonsdetaljer", vil du sannsynligvis ikke mocke dem.

Eksempler på avhengigheter som kan betraktes som "implementasjonsdetaljer" inkluderer alt fra språkets innebygde funksjoner (f.eks. Array.prototype-metoder) til svært vanlige hjelpeverktøy (f.eks. underscore, lodash, array-verktøy osv.) og hele biblioteker som React.js.

Returnerer jest-objektet for kjeding.

tips

Når du bruker babel-jest, vil kall til disableAutomock() automatisk bli heist til toppen av kodeblokken. Bruk autoMockOff() hvis du eksplisitt vil unngå denne oppførselen.

jest.enableAutomock()​

Aktiverer automatisk mocking i modullasteren.

info

For flere detaljer om automatisk mocking, se dokumentasjonen for automock-konfigurasjonsvalget.

Eksempel:

utils.js
export default {
  authorize: () => {
    return 'token';
  },
  isAuthorized: secret => secret === 'wizard',
};
__tests__/enableAutomocking.js
jest.enableAutomock();

import utils from '../utils';

test('original implementation', () => {
  // now we have the mocked implementation,
  expect(utils.authorize._isMockFunction).toBeTruthy();
  expect(utils.isAuthorized._isMockFunction).toBeTruthy();
});

Returnerer jest-objektet for kjeding.

tips

Når du bruker babel-jest, vil kall til enableAutomock automatisk bli heist til toppen av kodeblokken. Bruk autoMockOn hvis du eksplisitt vil unngå denne oppførselen.

jest.createMockFromModule(moduleName)​

Gitt navnet på en modul, bruker dette automatiske mockingssystemet til å generere en mocket versjon av modulen for deg.

Dette er nyttig når du ønsker å lage en manuell mock som utvider den automatiske mockens oppførsel:

utils.js
module.exports = {
  authorize: () => {
    return 'token';
  },
  isAuthorized: secret => secret === 'wizard',
};
__tests__/createMockFromModule.test.js
const utils = jest.createMockFromModule('../utils');

utils.isAuthorized = jest.fn(secret => secret === 'not wizard');

test('implementation created by jest.createMockFromModule', () => {
  expect(jest.isMockFunction(utils.authorize)).toBe(true);
  expect(utils.isAuthorized('not wizard')).toBe(true);
});

Slik vil createMockFromModule mocke følgende datatyper:

Function​

Oppretter en ny mockfunksjon. Den nye funksjonen har ingen formelle parametere og vil returnere undefined når den kalles. Denne funksjonaliteten gjelder også for async-funksjoner.

Class​

Oppretter en ny klasse. Grensesnittet til den originale klassen beholdes, og alle klasses medlemsfunksjoner og egenskaper vil bli mocket.

Object​

Oppretter et nytt dypt klonet objekt. Objektets nøkler beholdes og verdiene mockes.

Array​

Oppretter en ny tom array, og ignorerer originalen.

Primitives​

Oppretter en ny egenskap med samme primitive verdi som den originale egenskapen.

Eksempel:

example.js
module.exports = {
  function: function square(a, b) {
    return a * b;
  },
  asyncFunction: async function asyncSquare(a, b) {
    const result = (await a) * b;
    return result;
  },
  class: new (class Bar {
    constructor() {
      this.array = [1, 2, 3];
    }
    foo() {}
  })(),
  object: {
    baz: 'foo',
    bar: {
      fiz: 1,
      buzz: [1, 2, 3],
    },
  },
  array: [1, 2, 3],
  number: 123,
  string: 'baz',
  boolean: true,
  symbol: Symbol.for('a.b.c'),
};
__tests__/example.test.js
const example = jest.createMockFromModule('../example');

test('should run example code', () => {
  // creates a new mocked function with no formal arguments.
  expect(example.function.name).toBe('square');
  expect(example.function).toHaveLength(0);

  // async functions get the same treatment as standard synchronous functions.
  expect(example.asyncFunction.name).toBe('asyncSquare');
  expect(example.asyncFunction).toHaveLength(0);

  // creates a new class with the same interface, member functions and properties are mocked.
  expect(example.class.constructor.name).toBe('Bar');
  expect(example.class.foo.name).toBe('foo');
  expect(example.class.array).toHaveLength(0);

  // creates a deeply cloned version of the original object.
  expect(example.object).toEqual({
    baz: 'foo',
    bar: {
      fiz: 1,
      buzz: [],
    },
  });

  // creates a new empty array, ignoring the original array.
  expect(example.array).toHaveLength(0);

  // creates a new property with the same primitive value as the original property.
  expect(example.number).toBe(123);
  expect(example.string).toBe('baz');
  expect(example.boolean).toBe(true);
  expect(example.symbol).toEqual(Symbol.for('a.b.c'));
});

jest.mock(moduleName, factory, options)​

Lager en mock av en modul med en automatisk generert mockversjon når den kreves. factory og options er valgfrie. For eksempel:

banana.js
module.exports = () => 'banana';
__tests__/test.js
jest.mock('../banana');

const banana = require('../banana'); // banana will be explicitly mocked.

banana(); // will return 'undefined' because the function is auto-mocked.

Det andre argumentet kan brukes til å spesifisere en eksplisitt modulfabrikk som kjøres i stedet for Jest automock-funksjonalitet:

jest.mock('../moduleName', () => {
  return jest.fn(() => 42);
});

// This runs the function specified as second argument to `jest.mock`.
const moduleName = require('../moduleName');
moduleName(); // Will return '42';

Når du bruker factory-parameteren for en ES6-modul med standard eksport, må __esModule: true-egenskapen angis. Denne egenskapen genereres normalt av Babel/TypeScript, men her må den settes manuelt. Ved import av standard eksport er dette en instruks om å importere default-egenskapen fra eksportobjektet:

import moduleName, {foo} from '../moduleName';

jest.mock('../moduleName', () => {
  return {
    __esModule: true,
    default: jest.fn(() => 42),
    foo: jest.fn(() => 43),
  };
});

moduleName(); // Will return 42
foo(); // Will return 43

Det tredje argumentet kan brukes til å lage virtuelle mocks – mocks av moduler som ikke finnes noe sted i systemet:

jest.mock(
  '../moduleName',
  () => {
    /*
     * Custom implementation of a module that doesn't exist in JS,
     * like a generated module or a native module in react-native.
     */
  },
  {virtual: true},
);

Import av en modul i en oppsettsfil (som spesifisert av setupFilesAfterEnv) vil forhindre mocking for den aktuelle modulen samt alle modulene den importerer.

Moduler som er mocket med jest.mock er kun mocket for filen som kaller jest.mock. En annen fil som importerer modulen vil få den opprinnelige implementasjonen selv om den kjører etter testfilen som mocket modulen.

Returnerer jest-objektet for kjeding.

Skriver du tester i TypeScript? Bruk hjelpetypen jest.Mocked eller hjelpemetoden jest.mocked() for å få typede mockmoduler.

jest.Mocked<Source>​

Se kapittelet TypeScript-bruk på Mock Functions-siden for dokumentasjon.

jest.mocked(source, options?)​

Se kapittelet TypeScript-bruk på Mock Functions-siden for dokumentasjon.

jest.unmock(moduleName)​

Angir at modulsystemet aldri skal returnere en mocket versjon av den spesifiserte modulen fra require() (dvs. den skal alltid returnere den ekte modulen).

Det vanligste bruksområdet for dette APIet er å spesifisere hvilken modul en test skal teste (og dermed ikke ønsker automocket).

Returnerer jest-objektet for kjeding.

jest.deepUnmock(moduleName)​

Angir at modulsystemet aldri skal returnere en mocket versjon av den spesifiserte modulen eller dens avhengigheter.

Returnerer jest-objektet for kjeding.

jest.doMock(moduleName, factory, options)​

Når du bruker babel-jest, vil kall til mock automatisk flyttes til toppen av kodeblokken. Bruk denne metoden hvis du eksplisitt vil unngå denne oppførselen.

Et eksempel på når dette er nyttig er når du ønsker å mocke en modul annerledes i samme fil:

beforeEach(() => {
  jest.resetModules();
});

test('moduleName 1', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 1);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(1);
});

test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 2);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(2);
});

Bruk av jest.doMock() med ES6-import krever ekstra steg. Følg disse hvis du ikke vil bruke require i testene dine:

  • Vi må spesifisere __esModule: true-egenskapen (se jest.mock()-APIet for mer informasjon).

  • Statiske ES6-modulimports flyttes til toppen av filen, så vi må i stedet importere dem dynamisk med import().

  • Til slutt trenger vi et miljø som støtter dynamisk importering. Se Bruk av Babel for grunnoppsett. Legg deretter til babel-plugin-dynamic-import-node eller tilsvarende i Babel-konfigurasjonen din for å aktivere dynamisk importering i Node.

beforeEach(() => {
  jest.resetModules();
});

test('moduleName 1', () => {
  jest.doMock('../moduleName', () => {
    return {
      __esModule: true,
      default: 'default1',
      foo: 'foo1',
    };
  });
  return import('../moduleName').then(moduleName => {
    expect(moduleName.default).toBe('default1');
    expect(moduleName.foo).toBe('foo1');
  });
});

test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return {
      __esModule: true,
      default: 'default2',
      foo: 'foo2',
    };
  });
  return import('../moduleName').then(moduleName => {
    expect(moduleName.default).toBe('default2');
    expect(moduleName.foo).toBe('foo2');
  });
});

Returnerer jest-objektet for kjeding.

jest.dontMock(moduleName)​

Når du bruker babel-jest, vil kall til unmock automatisk bli heist til toppen av kodeblokken. Bruk denne metoden hvis du eksplisitt vil unngå denne oppførselen.

Returnerer jest-objektet for kjeding.

jest.setMock(moduleName, moduleExports)​

Setter eksplisitt mock-objektet som modulesystemet skal returnere for den angitte modulen.

Noen ganger er det tilfeller der den automatisk genererte mocken som modulesystemet normalt ville gitt deg, ikke er tilstrekkelig for testbehovene dine. Normalt bør du i slike tilfeller skrive en manuell mock som er mer passende for modulen. Imidlertid, i svært sjeldne tilfeller, er ikke engang en manuell mock egnet, og du må bygge mocken selv i testen din.

I disse sjeldne scenarioene kan du bruke dette APIet for manuelt å fylle plassen i modulesystemets mock-modulregister.

Returnerer jest-objektet for kjeding.

info

Det anbefales å bruke jest.mock() i stedet. jest.mock APIets andre argument er en modulfabrikk i stedet for det eksporterte modulobjektet.

jest.requireActual(moduleName)​

Returnerer den faktiske modulen i stedet for en mock, og omgår alle sjekker for om modulen skal motta en mock-implementasjon eller ikke.

jest.mock('../myModule', () => {
  // Require the original module to not be mocked...
  const originalModule = jest.requireActual('../myModule');

  return {
    __esModule: true, // Use it when dealing with esModules
    ...originalModule,
    getRandom: jest.fn(() => 10),
  };
});

const getRandom = require('../myModule').getRandom;

getRandom(); // Always returns 10

jest.requireMock(moduleName)​

Returnerer en mock-modul i stedet for den faktiske modulen, og omgår alle sjekker for om modulen skal kreves normalt eller ikke.

jest.onGenerateMock(cb)​

Registrer en tilbakekallingsfunksjon som aktiveres når Jest genererer en mock for en modul. Denne tilbakekallingen lar deg endre mocken før den returneres til resten av testene dine.

Parametere for tilbakekalling:

  1. modulePath: string - Den absolutte banen til modulen som mocks.

  2. moduleMock: T - Mock-objektet som Jest har generert for modulen. Dette objektet kan endres eller erstattes før retur.

Oppførsel:

  • Hvis flere tilbakekallinger registreres via påfølgende onGenerateMock-kall, vil de aktiveres i rekkefølgen de ble lagt til.

  • Hver tilbakekalling mottar forrige tilbakekalings output som sin moduleMock. Dette gjør det mulig å legge til flere lag med transformasjoner på samme mock.

jest.onGenerateMock((modulePath, moduleMock) => {
  // Inspect the module name and decide how to transform the mock
  if (modulePath.includes('Database')) {
    // For demonstration, let's replace a method with our own custom mock
    moduleMock.connect = jest.fn().mockImplementation(() => {
      console.log('Connected to mock DB');
    });
  }

  // Return the (potentially modified) mock
  return moduleMock;
});

// Apply mock for module
jest.mock('./Database');

// Later in your tests
import Database from './Database';
// The `Database` mock now has any transformations applied by our callback
notat

onGenerateMock-tilbakekallingen kalles ikke for manuelt opprettede mocker, som:

  • Mocker definert i en __mocks__-mappe
  • Eksplisitte fabrikker gitt via jest.mock('moduleName', () => { ... })

jest.resetModules()​

Tilbakestiller modulregisteret - cachen for alle påkrevde moduler. Dette er nyttig for å isolere moduler der lokal tilstand kan skape konflikt mellom tester.

Eksempel:

const sum1 = require('../sum');
jest.resetModules();
const sum2 = require('../sum');
sum1 === sum2;
// > false (Both sum modules are separate "instances" of the sum module.)

Eksempel i en test:

beforeEach(() => {
  jest.resetModules();
});

test('works', () => {
  const sum = require('../sum');
});

test('works too', () => {
  const sum = require('../sum');
  // sum is a different copy of the sum module from the previous test.
});

Returnerer jest-objektet for kjeding.

jest.isolateModules(fn)​

jest.isolateModules(fn) går et skritt lenger enn jest.resetModules() og oppretter et sandkasseregister for moduler som lastes inn i tilbakekallingsfunksjonen. Dette er nyttig for å isolere spesifikke moduler for hver test slik at lokal modultilstand ikke konflikterer mellom tester.

let myModule;
jest.isolateModules(() => {
  myModule = require('myModule');
});

const otherCopyOfMyModule = require('myModule');

jest.isolateModulesAsync(fn)​

jest.isolateModulesAsync() er ekvivalenten til jest.isolateModules(), men for asynkrone tilbakekallinger. Kalleren forventes å await fullføringen av isolateModulesAsync.

let myModule;
await jest.isolateModulesAsync(async () => {
  myModule = await import('myModule');
  // do async stuff here
});

const otherCopyOfMyModule = await import('myModule');

Mock-funksjoner​

jest.fn(implementation?)​

Returnerer en ny, ubrukt mock-funksjon. Kan eventuelt ta en mock-implementasjon.

const mockFn = jest.fn();
mockFn();
expect(mockFn).toHaveBeenCalled();

// With a mock implementation:
const returnsTrue = jest.fn(() => true);
console.log(returnsTrue()); // true;
tips

Se siden om Mockfunksjoner for detaljer om TypeScript-bruk.

jest.isMockFunction(fn)​

Avgjør om en gitt funksjon er en mockfunksjon.

jest.replaceProperty(object, propertyKey, value)​

Erstatter object[propertyKey] med en value. Egenskapen må allerede eksistere på objektet. Samme egenskap kan erstattes flere ganger. Returnerer en Jest-erstattet egenskap.

notat

For å mocke egenskaper definert som gettere eller settere, bruk jest.spyOn(object, methodName, accessType) i stedet. For å mocke funksjoner, bruk jest.spyOn(object, methodName) i stedet.

tips

Alle egenskaper erstattet med jest.replaceProperty kan gjenopprettes til originalverdien ved å kalle jest.restoreAllMocks i afterEach-metoden.

Eksempel:

const utils = {
  isLocalhost() {
    return process.env.HOSTNAME === 'localhost';
  },
};

module.exports = utils;

Eksempeltest:

const utils = require('./utils');

afterEach(() => {
  // restore replaced property
  jest.restoreAllMocks();
});

test('isLocalhost returns true when HOSTNAME is localhost', () => {
  jest.replaceProperty(process, 'env', {HOSTNAME: 'localhost'});
  expect(utils.isLocalhost()).toBe(true);
});

test('isLocalhost returns false when HOSTNAME is not localhost', () => {
  jest.replaceProperty(process, 'env', {HOSTNAME: 'not-localhost'});
  expect(utils.isLocalhost()).toBe(false);
});

jest.spyOn(object, methodName)​

Oppretter en mockfunksjon lik jest.fn, men sporer også kall til object[methodName]. Returnerer en Jest-mockfunksjon.

notat

Som standard kaller jest.spyOn også den sporede metoden. Dette skiller seg fra de fleste andre testbiblioteker. Hvis du vil overstyre originalfunksjonen, kan du bruke jest.spyOn(object, methodName).mockImplementation(() => customImplementation) eller object[methodName] = jest.fn(() => customImplementation).

tips

Siden jest.spyOn er en mock, kan du gjenopprette opprinnelig tilstand ved å kalle jest.restoreAllMocks i callback-funksjonen sendt til afterEach-hooken.

Eksempel:

const video = {
  play() {
    return true;
  },
};

module.exports = video;

Eksempeltest:

const video = require('./video');

afterEach(() => {
  // restore the spy created with spyOn
  jest.restoreAllMocks();
});

test('plays video', () => {
  const spy = jest.spyOn(video, 'play');
  const isPlaying = video.play();

  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
});

Sporede metoder og using-nøkkelordet​

Hvis kodebasen din er satt opp til å transpilere "eksplisitt ressurshåndtering" (f.eks. hvis du bruker TypeScript >= 5.2 eller @babel/plugin-proposal-explicit-resource-management-pluginen), kan du bruke spyOn i kombinasjon med using-nøkkelordet:

test('logs a warning', () => {
  using spy = jest.spyOn(console, 'warn');
  doSomeThingWarnWorthy();
  expect(spy).toHaveBeenCalled();
});

Denne koden er semantisk lik

test('logs a warning', () => {
  let spy;
  try {
    spy = jest.spyOn(console, 'warn');
    doSomeThingWarnWorthy();
    expect(spy).toHaveBeenCalled();
  } finally {
    spy.mockRestore();
  }
});

På den måten vil spionen din automatisk gjenopprettes til originalverdien når gjeldende kodeblokk forlates.

Du kan gå et skritt videre og bruke en kodeblokk for å begrense mocken din til bare en del av testen uten å skade lesbarheten.

test('testing something', () => {
  {
    using spy = jest.spyOn(console, 'warn');
    setupStepThatWillLogAWarning();
  }
  // here, console.warn is already restored to the original value
  // your test can now continue normally
});
notat

Hvis du får en advarsel om at Symbol.dispose ikke finnes, kan det hende du må bruke en polyfill, for eksempel med denne koden:

if (!Symbol.dispose) {
  Object.defineProperty(Symbol, 'dispose', {
    get() {
      return Symbol.for('nodejs.dispose');
    },
  });
}

jest.spyOn(object, methodName, accessType?)​

Fra Jest 22.1.0+ tar jest.spyOn-metoden et valgfritt tredje argument accessType som kan være enten 'get' eller 'set'. Dette er nyttig når du ønsker å spore henholdsvis en getter eller setter.

Eksempel:

const video = {
  // it's a getter!
  get play() {
    return true;
  },
};

module.exports = video;

const audio = {
  _volume: false,
  // it's a setter!
  set volume(value) {
    this._volume = value;
  },
  get volume() {
    return this._volume;
  },
};

module.exports = audio;

Eksempeltest:

const audio = require('./audio');
const video = require('./video');

afterEach(() => {
  // restore the spy created with spyOn
  jest.restoreAllMocks();
});

test('plays video', () => {
  const spy = jest.spyOn(video, 'play', 'get'); // we pass 'get'
  const isPlaying = video.play;

  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
});

test('plays audio', () => {
  const spy = jest.spyOn(audio, 'volume', 'set'); // we pass 'set'
  audio.volume = 100;

  expect(spy).toHaveBeenCalled();
  expect(audio.volume).toBe(100);
});

jest.Replaced<Source>​

Se dokumentasjonen i TypeScript-bruk-kapittelet på Mockfunksjoner-siden.

jest.Spied<Source>​

Se dokumentasjonen i TypeScript-bruk-kapittelet på Mockfunksjoner-siden.

jest.clearAllMocks()​

Tømmer mock.calls, mock.instances, mock.contexts og mock.results-egenskapene for alle mocks. Tilsvarer å kalle .mockClear() på hver mockede funksjon.

Returnerer jest-objektet for kjeding.

jest.resetAllMocks()​

Tilbakestiller tilstanden for alle mocks. Tilsvarer å kalle .mockReset() på hver mockede funksjon.

Returnerer jest-objektet for kjeding.

jest.restoreAllMocks()​

Gjenoppretter alle mocks og erstattede egenskaper til deres opprinnelige verdi. Tilsvarer å kalle .mockRestore() på hver mockede funksjon og .restore() på hver erstattet egenskap. Vær oppmerksom på at jest.restoreAllMocks() kun fungerer for mocks opprettet med jest.spyOn() og egenskaper erstattet med jest.replaceProperty(); andre mocks må gjenopprettes manuelt.

Falske klokker​

jest.useFakeTimers(fakeTimersConfig?)​

Instruerer Jest til å bruke falske versjoner av globale dato-, ytelse-, tid- og tidsutløser-APIer. Implementeringen av falske klokker er basert på @sinonjs/fake-timers.

Falske klokker vil erstatte Date, performance.now(), queueMicrotask(), setImmediate(), clearImmediate(), setInterval(), clearInterval(), setTimeout(), clearTimeout() med en implementasjon som henter tid fra den falske klokken.

I Node-miljø vil process.hrtime, process.nextTick() og i JSDOM-miljø requestAnimationFrame(), cancelAnimationFrame(), requestIdleCallback(), cancelIdleCallback() også bli erstattet.

Konfigurasjonsalternativer:

type FakeableAPI =
  | 'Date'
  | 'hrtime'
  | 'nextTick'
  | 'performance'
  | 'queueMicrotask'
  | 'requestAnimationFrame'
  | 'cancelAnimationFrame'
  | 'requestIdleCallback'
  | 'cancelIdleCallback'
  | 'setImmediate'
  | 'clearImmediate'
  | 'setInterval'
  | 'clearInterval'
  | 'setTimeout'
  | 'clearTimeout';

type FakeTimersConfig = {
  /**
   * If set to `true` all timers will be advanced automatically by 20 milliseconds
   * every 20 milliseconds. A custom time delta may be provided by passing a number.
   * The default is `false`.
   */
  advanceTimers?: boolean | number;
  /**
   * List of names of APIs that should not be faked. The default is `[]`, meaning
   * all APIs are faked.
   */
  doNotFake?: Array<FakeableAPI>;
  /**
   * Use the old fake timers implementation instead of one backed by `@sinonjs/fake-timers`.
   * The default is `false`.
   */
  legacyFakeTimers?: boolean;
  /** Sets current system time to be used by fake timers, in milliseconds. The default is `Date.now()`. */
  now?: number | Date;
  /**
   * The maximum number of recursive timers that will be run when calling `jest.runAllTimers()`.
   * The default is `100_000` timers.
   */
  timerLimit?: number;
};

Å kalle jest.useFakeTimers() vil bruke falske klokker for alle tester i filen, inntil opprinnelige klokker gjenopprettes med jest.useRealTimers().

Du kan kalle jest.useFakeTimers() eller jest.useRealTimers() hvor som helst: toppnivå, inne i et test-blokk, osv. Husk at dette er en global operasjon og vil påvirke andre tester i samme fil. Å kalle jest.useFakeTimers() på nytt i samme testfil vil tilbakestille intern tilstand (f.eks. teller for tidsutløsere) og reinstallere falske klokker med de angitte alternativene:

test('advance the timers automatically', () => {
  jest.useFakeTimers({advanceTimers: true});
  // ...
});

test('do not advance the timers and do not fake `performance`', () => {
  jest.useFakeTimers({doNotFake: ['performance']});
  // ...
});

test('uninstall fake timers for the rest of tests in the file', () => {
  jest.useRealTimers();
  // ...
});
Foreldede falske klokker

Av en eller annen grunn må du kanskje bruke foreldet implementering av falske klokker. Dette kan aktiveres slik (tilleggsalternativer støttes ikke):

jest.useFakeTimers({
  legacyFakeTimers: true,
});

Foreldede falske klokker vil erstatte setImmediate(), clearImmediate(), setInterval(), clearInterval(), setTimeout(), clearTimeout() med Jest mock-funksjoner. I Node-miljø vil process.nextTick() og i JSDOM-miljø requestAnimationFrame(), cancelAnimationFrame() også bli erstattet.

Returnerer jest-objektet for kjeding.

jest.useRealTimers()​

Instruerer Jest til å gjenopprette de originale implementeringene av globale dato-, ytelse-, tid- og tidsutløser-APIer. For eksempel kan du kalle jest.useRealTimers() i en afterEach-krok for å gjenopprette klokker etter hver test:

afterEach(() => {
  jest.useRealTimers();
});

test('do something with fake timers', () => {
  jest.useFakeTimers();
  // ...
});

test('do something with real timers', () => {
  // ...
});

Returnerer jest-objektet for kjeding.

jest.runAllTicks()​

Tømmer mikro-oppgavekøen (som vanligvis håndteres i node via process.nextTick).

Når dette APIet kalles, vil alle ventende mikrotasker som er satt i kø via process.nextTick bli utført. I tillegg, hvis disse mikrotaskene selv setter nye mikrotasker i kø, vil disse bli prosessert kontinuerlig inntil det ikke er flere mikrotasker igjen i køen.

jest.runAllTimers()​

Tømmer både makro-task-køen (dvs. alle oppgaver satt i kø av setTimeout(), setInterval() og setImmediate()) og mikro-task-køen (vanligvis håndtert i Node.js via process.nextTick).

Når dette APIet kalles, vil alle ventende makrotasker og mikrotasker bli utført. Hvis disse oppgavene selv setter nye oppgaver i kø, vil disse bli prosessert kontinuerlig inntil det ikke er flere oppgaver igjen i køen.

Dette er ofte nyttig for å utføre setTimeouts synkront under testing, for å kunne verifisere atferd som bare skjer etter at setTimeout()- eller setInterval()-tilbakekallene er utført. Se dokumentasjonen om Timer mocks for mer informasjon.

jest.runAllTimersAsync()​

Asynkron ekvivalent av jest.runAllTimers(). Lar planlagte promise-tilbakekall utføres før timerkjøringen.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.runAllImmediates()​

Tømmer alle oppgaver satt i kø av setImmediate().

info

Denne funksjonen er kun tilgjengelig når du bruker den eldre fake timers-implementasjonen.

jest.advanceTimersByTime(msToRun)​

Utfører kun makrotask-køen (dvs. alle oppgaver satt i kø av setTimeout(), setInterval() eller setImmediate()).

Når dette APIet kalles, flyttes alle timere fremover med msToRun millisekunder. Alle ventende "makrotasker" som er satt i kø via setTimeout() eller setInterval(), og som ville blitt utført innen denne tidsrammen, vil bli utført. Hvis disse makrotaskene setter nye makrotasker i kø som skal utføres innen samme tidsramme, vil også disse bli utført inntil det ikke er flere makrotasker igjen i køen som skal kjøres innen msToRun millisekunder.

jest.advanceTimersByTimeAsync(msToRun)​

Asynkron ekvivalent av jest.advanceTimersByTime(msToRun). Lar planlagte promise-tilbakekall utføres før timerkjøringen.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.runOnlyPendingTimers()​

Utfører kun makrotaskene som for øyeblikket venter (dvs. kun oppgaver satt i kø av setTimeout() eller setInterval() frem til dette tidspunktet). Hvis noen av de ventende makrotaskene setter nye makrotasker i kø, vil disse nye oppgavene ikke bli utført av dette kallet.

Dette er nyttig i scenarier der modulen som testes setter opp en setTimeout() hvis tilbakekall rekursivt setter opp en ny setTimeout() (noe som betyr at planleggingen aldri stopper). I slike tilfeller er det nyttig å kunne gå frem i tid ett steg av gangen.

jest.runOnlyPendingTimersAsync()​

Asynkron ekvivalent av jest.runOnlyPendingTimers(). Lar planlagte promise-tilbakekall utføres før timerkjøringen.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.advanceTimersToNextTimer(steps)​

Flytter alle timere fremover med nødvendige millisekunder slik at kun neste timeout-/intervall-kjøringer vil skje.

Du kan eventuelt angi steps for å kjøre steps antall neste timeout-/intervall-kjøringer.

jest.advanceTimersToNextTimerAsync(steps)​

Asynkron ekvivalent til jest.advanceTimersToNextTimer(steps). Lar planlagte løfterekall kjøre før timere utføres.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.advanceTimersToNextFrame()​

Flytter alle timere fremover med nødvendige millisekunder for å utføre tilbakekall planlagt med requestAnimationFrame. advanceTimersToNextFrame() er nyttig for å utføre kode planlagt med requestAnimationFrame.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.clearAllTimers()​

Fjerner alle ventende timere fra timersystemet.

Dette betyr at hvis noen timere er planlagt (men ikke utført ennå), vil de bli fjernet og aldri få mulighet til å kjøre.

jest.getTimerCount()​

Returnerer antall falske timere som gjenstår å kjøre.

jest.now()​

Returnerer gjeldende klokketid i millisekunder. Tilsvarer Date.now() ved bruk av ekte timere, eller hvis Date er mocket. Ved bruk av eldre timere kan det være nyttig for å lage egne mock-implementasjoner av Date.now(), performance.now(), etc.

jest.setSystemTime(now?: number | Date)​

Setter gjeldende systemtid for falske timere. Simulerer at en bruker endrer systemklokken mens programmet kjører. Påvirker gjeldende tid, men utløser ikke timere - de vil fortsatt utløses som de ellers ville gjort uten kall til jest.setSystemTime().

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.setTimerTickMode(mode)​

Gir mulighet til å konfigurere hvordan falske timere fremskynder tid.

Konfigurasjonsalternativer:

type TimerTickMode =
  | {mode: 'manual'}
  | {mode: 'nextAsync'}
  | {mode: 'interval'; delta?: number};

  • manual: Timere fremskynder ikke uten eksplisitte, manuelle kall til tick-APIene (jest.advanceTimersByTime(ms), jest.runAllTimers(), etc).

  • nextAsync: Klokken vil kontinuerlig bryte hendelsesløkken og deretter kjøre neste timer til modusen endres.

  • interval: Tilsvarer å spesifisere advanceTimers: true med en advanceTimeDelta. Hvis delta ikke spesifiseres, brukes 20 som standard.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

jest.getRealSystemTime()​

Når tid mockes, vil også Date.now() bli mocket. Hvis du trenger tilgang til ekte systemtid, kan du bruke denne funksjonen.

info

Denne funksjonen er ikke tilgjengelig når du bruker gammel fake timers-implementering.

Diverse​

jest.getSeed()​

Hver gang Jest kjører genereres en tilfeldig seed-verdi som du kan bruke i pseudotilfeldige tallgeneratorer eller andre steder.

tips

Bruk --showSeed-flagget for å vise seed-verdien i testrapporten. For å manuelt sette seed-verdien, bruk --seed=<num> CLI-argument.

jest.isEnvironmentTornDown()​

Returnerer true hvis testmiljøet er ryddet opp.

jest.retryTimes(numRetries, options?)​

Kjører feilede tester på nytt inntil de passerer eller maks antall forsøk er brukt opp.

jest.retryTimes(3);

test('will fail', () => {
  expect(true).toBe(false);
});

Hvis logErrorsBeforeRetry er aktivert, vil feil som forårsaket testfeil logges til konsollen.

jest.retryTimes(3, {logErrorsBeforeRetry: true});

test('will fail', () => {
  expect(true).toBe(false);
});

waitBeforeRetry er antall millisekunder som ventes før nytt forsøk.

jest.retryTimes(3, {waitBeforeRetry: 1000});

test('will fail', () => {
  expect(true).toBe(false);
});

retryImmediately brukes for å prøve feilede tester umiddelbart. Hvis ikke angitt, prøves testene på nytt etter at alle andre tester i filen er kjørt.

jest.retryTimes(3, {retryImmediately: true});

test('will fail', () => {
  expect(true).toBe(false);
});

Returnerer jest-objektet for kjeding.

advarsel

jest.retryTimes() må deklareres på toppnivå i testfilen eller i et describe-blokk.

info

Denne funksjonen er kun tilgjengelig med standard jest-circus-kjøringsmotor.

jest.setTimeout(timeout)​

Setter standard timeout-intervallet (i millisekunder) for alle tester og before/after-hooks i testfilen. Dette gjelder kun testfilen der denne funksjonen kalles. Standard timeout-intervall er 5 sekunder hvis denne metoden ikke kalles.

Eksempel:

jest.setTimeout(1000); // 1 second
tips

For å sette timeout-intervaller for ulike tester i samme fil, bruk alternativet timeout på hver enkelt test.

Hvis du vil sette timeout for alle testfiler, bruk konfigurasjonsalternativet testTimeout.