Hopp til hovedinnhold
Versjon: 29.7

Globale

Unofficial Beta Translation

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

I testfilene dine plasserer Jest alle disse metodene og objektene i det globale miljøet. Du trenger ikke å bruke require eller importere noe for å bruke dem. Men hvis du foretrekker eksplisitte importeringer, kan du gjøre import {describe, expect, test} 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​

Referanse​

afterAll(fn, timeout)​

Kjører en funksjon etter at alle testene i denne filen er fullført. Hvis funksjonen returnerer et promise eller er en generator, venter Jest til løftet er oppfylt før den fortsetter.

Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente før avbrudd. Standard timeout er 5 sekunder.

Dette er ofte nyttig hvis du vil rydde opp i global tilstand som deles på tvers av tester.

For eksempel:

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterAll(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

Her sikrer afterAll at cleanUpDatabase kalles etter at alle testene er kjørt.

Hvis afterAll er inne i en describe-blokk, kjøres den på slutten av describe-blokken.

Hvis du vil kjøre opprydding etter hver test i stedet for etter alle tester, bruk afterEach i stedet.

afterEach(fn, timeout)​

Kjører en funksjon etter at hver enkelt test i denne filen er fullført. Hvis funksjonen returnerer et promise eller er en generator, venter Jest til løftet er oppfylt før den fortsetter.

Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente før avbrudd. Standard timeout er 5 sekunder.

Dette er ofte nyttig hvis du vil rydde opp i midlertidig tilstand som opprettes av hver test.

For eksempel:

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterEach(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

Her sikrer afterEach at cleanUpDatabase kalles etter at hver test er kjørt.

Hvis afterEach er inne i en describe-blokk, kjøres den bare etter testene som er inne i denne describe-blokken.

Hvis du vil kjøre opprydding bare en gang etter at alle testene er kjørt, bruk afterAll i stedet.

beforeAll(fn, timeout)​

Kjører en funksjon før noen av testene i denne filen kjøres. Hvis funksjonen returnerer et promise eller er en generator, venter Jest til løftet er oppfylt før testene kjøres.

Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente før avbrudd. Standard timeout er 5 sekunder.

Dette er ofte nyttig hvis du vil sette opp global tilstand som skal brukes av mange tester.

For eksempel:

const globalDatabase = makeGlobalDatabase();

beforeAll(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

// Since we only set up the database once in this example, it's important
// that our tests don't modify it.
test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

Her sikrer beforeAll at databasen settes opp før testene kjøres. Hvis oppsettet var synkront, kunne du gjort dette uten beforeAll. Poenget er at Jest venter på at et promise skal oppfylles, så du kan også ha asynkront oppsett.

Hvis beforeAll er inne i en describe-blokk, kjøres den ved begynnelsen av describe-blokken.

Hvis du vil kjøre noe før hver test i stedet for før noen test kjøres, bruk beforeEach i stedet.

beforeEach(fn, timeout)​

Kjører en funksjon før hver av testene i denne filen kjøres. Hvis funksjonen returnerer et promise eller er en generator, venter Jest til løftet er oppfylt før testen kjøres.

Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente før avbrudd. Standard timeout er 5 sekunder.

Dette er ofte nyttig hvis du vil tilbakestille global tilstand som skal brukes av mange tester.

For eksempel:

const globalDatabase = makeGlobalDatabase();

beforeEach(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

Her sikrer beforeEach at databasen tilbakestilles for hver test.

Hvis beforeEach er inne i et describe-blokk, kjører den for hver test i describe-blokken.

Hvis du kun trenger å kjøre oppsettskode én gang, før noen tester kjører, bruk beforeAll i stedet.

describe(name, fn)​

describe(name, fn) oppretter en blokk som grupperer relaterte tester. For eksempel, hvis du har et myBeverage-objekt som skal være deilig men ikke surt, kan du teste det med:

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

Dette er ikke påkrevd - du kan skrive test-blokker direkte på toppnivå. Men dette er nyttig hvis du foretrekker å organisere testene i grupper.

Du kan også nøste describe-blokker hvis du har et hierarki av tester:

const binaryStringToNumber = binString => {
  if (!/^[01]+$/.test(binString)) {
    throw new CustomError('Not a binary number.');
  }

  return parseInt(binString, 2);
};

describe('binaryStringToNumber', () => {
  describe('given an invalid binary string', () => {
    test('composed of non-numbers throws CustomError', () => {
      expect(() => binaryStringToNumber('abc')).toThrow(CustomError);
    });

    test('with extra whitespace throws CustomError', () => {
      expect(() => binaryStringToNumber('  100')).toThrow(CustomError);
    });
  });

  describe('given a valid binary string', () => {
    test('returns the correct number', () => {
      expect(binaryStringToNumber('100')).toBe(4);
    });
  });
});

describe.each(table)(name, fn, timeout)​

Bruk describe.each hvis du dupliserer de samme testgruppene med forskjellige data. describe.each lar deg skrive testgruppen én gang og sende inn data.

describe.each er tilgjengelig med to API-er:

1. describe.each(table)(name, fn, timeout)​

  • table: Array av arrays med argumentene som sendes til fn for hver rad. Hvis du sender en 1D-array av primitiver, mappes den internt til en tabell, f.eks. [1, 2, 3] -> [[1], [2], [3]].

  • name: String tittelen på testsuiten.

    • Generer unike testtitler ved å injisere parametere posisjonelt med printf-formatering:
      • %p - pretty-format.
      • %s- String (tekststreng).
      • %d- Number (tall).
      • %i - Integer (heltall).
      • %f - Floating point value (flyttall).
      • %j - JSON.
      • %o - Object (objekt).
      • %# - Index of the test case (indeksen til testtilfellet).
      • %% - enkelt prosenttegn ('%'). Dette bruker ikke et argument.
    • Eller generer unike testtitler ved å injisere egenskaper fra testtilfellet-objektet med $variable
      • For å injisere verdier fra nøstede objekter kan du angi en nøkkelsti f.eks. $variable.path.to.value (fungerer kun for "egne" egenskaper, f.eks. $variable.constructor.name vil ikke fungere)
      • Du kan bruke $# for å injisere indeksen til testtilfellet
      • Du kan ikke bruke $variable med printf-formateringen bortsett fra %%

  • fn: Function testgruppen som skal kjøres, funksjonen som mottar parameterne for hver rad som argumenter.

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});
describe.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

2. describe.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal

    • Første rad med variabelnavn som kolonneoverskrifter separert med |
    • En eller flere påfølgende rader med data levert som malstrenguttrykk ved bruk av ${value}-syntaks.

  • name: String tittelen på testgruppen, bruk $variable for å injisere testdata i tittelen fra de taggde maluttrykkene, og $# for radindeksen.

    • For å injisere nestede objektverdier kan du angi en keyPath f.eks. $variable.path.to.value (fungerer kun for "egne" egenskaper, f.eks. vil $variable.constructor.name ikke fungere)

  • fn: Function testgruppen som skal kjøres, funksjonen som mottar testdata-objektet.

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

describe.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('$a + $b', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

describe.only(name, fn)​

Også kjent under aliaset: fdescribe(name, fn)

Du kan bruke describe.only hvis du kun vil kjøre én describe-blokk:

describe.only('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

describe('my other beverage', () => {
  // ... will be skipped
});

describe.only.each(table)(name, fn)​

Også under aliasene: fdescribe.each(table)(name, fn) og fdescribe.each`table`(name, fn)

Bruk describe.only.each hvis du bare vil kjøre bestemte testsuiter for datadrevne tester.

Bruk describe.only.each hvis du kun vil kjøre spesifikke testsuite for datadrevne tester.

describe.only.each(table)(name, fn)​

describe.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.only.each`table`(name, fn)​

describe.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('passes', () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip(name, fn)​

Også under aliaset: xdescribe(name, fn)

Du kan bruke describe.skip hvis du ikke vil kjøre testene i en bestemt describe-blokk:

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

describe.skip('my other beverage', () => {
  // ... will be skipped
});

Å bruke describe.skip er ofte et ryddigere alternativ til å midlertidig kommentere ut tester. Vær oppmerksom på at describe-blokken fortsatt vil kjøres. Hvis du har noe oppsett som også bør hoppes over, gjør dette i en beforeAll eller beforeEach-blokk.

describe.skip.each(table)(name, fn)​

Også kjent under aliasene: xdescribe.each(table)(name, fn) og xdescribe.each`table`(name, fn)

Bruk describe.skip.each hvis du vil stoppe kjøring av en suite med datadrevne tester.

describe.skip.each er tilgjengelig med to API-er:

describe.skip.each(table)(name, fn)​

describe.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip.each`table`(name, fn)​

describe.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('will not be run', () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test(name, fn, timeout)​

Også kjent under aliaset: it(name, fn, timeout)

Alt du trenger i en testfil er test-metoden som kjører en test. La oss si en funksjon inchesOfRain() skal returnere null. Hele testen din kan være:

test('did not rain', () => {
  expect(inchesOfRain()).toBe(0);
});

Første argument er testnavnet, andre argument er en funksjon som inneholder forventningene som skal testes. Tredje argument (valgfritt) er timeout (i millisekunder) som angir hvor lenge du vil vente før avbrytelse. Standard timeout er 5 sekunder.

Hvis test returnerer en promise, vil Jest vente på at promise løses før testen fullføres. La oss si fetchBeverageList() returnerer en promise som skal løses til en liste som inneholder lemon. Du kan teste dette med:

test('has lemon in it', () => {
  return fetchBeverageList().then(list => {
    expect(list).toContain('lemon');
  });
});

Selv om test-kallet returnerer umiddelbart, fullføres ikke testen før promise er løst. Se Testing av asynkron kode for detaljer.

tips

Jest vil også vente hvis du gir et argument til testfunksjonen, vanligvis kalt done. Dette kan være nyttig når du tester callbacks.

test.concurrent(name, fn, timeout)​

Også kjent under aliaset: it.concurrent(name, fn, timeout)

advarsel

test.concurrent regnes som eksperimentell - se her for manglende funksjoner og kjente problemer.

Bruk test.concurrent hvis du vil at testen skal kjøres samtidig.

Første argument er testnavnet; andre argument er en asynkron funksjon som inneholder forventningene som skal testes. Tredje argument (valgfritt) er timeout (i millisekunder) for å angi hvor lenge man skal vente før avbrytelse. Standard timeout er 5 sekunder.

test.concurrent('addition of 2 numbers', async () => {
  expect(5 + 3).toBe(8);
});

test.concurrent('subtraction 2 numbers', async () => {
  expect(5 - 3).toBe(2);
});

Bruk konfigurasjonsalternativet maxConcurrency for å hindre Jest i å utføre flere tester enn angitt samtidig.

test.concurrent.each(table)(name, fn, timeout)​

Også kjent som: it.concurrent.each(table)(name, fn, timeout)

Bruk test.concurrent.each hvis du stadig dupliserer samme test med ulike data. test.each lar deg skrive testen én gang og sende inn data, og alle testene kjøres asynkront.

test.concurrent.each finnes i to API-varianter:

1. test.concurrent.each(table)(name, fn, timeout)​

  • table: Array av arrayer med argumentene som sendes til testfunksjonen fn for hver rad. Hvis du sender en 1D-array av primitiver, vil den internt bli kartlagt til en tabell, f.eks. [1, 2, 3] -> [[1], [2], [3]]

  • name: String tittelen på testblokken.

    • Generer unike testtitler ved å injisere parametere posisjonelt med printf-formatering:
      • %p - pretty-format.
      • %s- String (tekststreng).
      • %d- Number (tall).
      • %i - Integer (heltall).
      • %f - Floating point value (flyttall).
      • %j - JSON.
      • %o - Object (objekt).
      • %# - Index of the test case (indeksen til testtilfellet).
      • %% - enkelt prosenttegn ('%'). Dette bruker ikke et argument.

  • fn: Function testen som skal kjøres, funksjonen som mottar parametrene fra hver rad som argumenter. Denne må være asynkron

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

test.concurrent.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

2. test.concurrent.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal

    • Første rad med variabelnavn som kolonneoverskrifter separert med |
    • En eller flere påfølgende rader med data levert som malstrenguttrykk ved bruk av ${value}-syntaks.

  • name: String testens tittel, bruk $variable for å injisere testdata i testtittelen fra de merkede malstrenguttrykkene.

    • For å injisere nestede objektverdier kan du angi en nøkkelsti, f.eks. $variable.path.to.value (fungerer kun for "egne" egenskaper, f.eks. $variable.constructor.name vil ikke fungere)

  • fn: Function testen som skal kjøres, funksjonen som mottar testdata-objektet. Denne må være asynkron

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

test.concurrent.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.concurrent.only.each(table)(name, fn)​

Også kjent som: it.concurrent.only.each(table)(name, fn)

Bruk test.concurrent.only.each hvis du kun vil kjøre spesifikke tester med ulike testdata samtidig

test.concurrent.only.each finnes i to API-varianter:

test.concurrent.only.each(table)(name, fn)​

test.concurrent.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.concurrent.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each(table)(name, fn)​

Også under aliaset: it.concurrent.skip.each(table)(name, fn)

Bruk test.concurrent.skip.each hvis du vil stoppe kjøringen av en samling asynkrone datadrevne tester.

test.concurrent.skip.each er tilgjengelig med to API-er:

test.concurrent.skip.each(table)(name, fn)​

test.concurrent.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each`table`(name, fn)​

test.concurrent.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.each(table)(name, fn, timeout)​

Også under aliasene: it.each(table)(name, fn) og it.each`table`(name, fn)

Bruk test.each hvis du stadig dupliserer den samme testen med ulike data. test.each lar deg skrive testen én gang og sende inn data.

test.each er tilgjengelig med to API-er:

1. test.each(table)(name, fn, timeout)​

  • table: Array av arrayer med argumentene som sendes til testfunksjonen fn for hver rad. Hvis du sender en 1D-array av primitiver, vil den internt bli kartlagt til en tabell, f.eks. [1, 2, 3] -> [[1], [2], [3]]

  • name: String tittelen på testblokken.

    • Generer unike testtitler ved å injisere parametere posisjonelt med printf-formatering:
      • %p - pretty-format.
      • %s- String (tekststreng).
      • %d- Number (tall).
      • %i - Integer (heltall).
      • %f - Floating point value (flyttall).
      • %j - JSON.
      • %o - Object (objekt).
      • %# - Index of the test case (indeksen til testtilfellet).
      • %% - enkelt prosenttegn ('%'). Dette bruker ikke et argument.
    • Eller generer unike testtitler ved å injisere egenskaper fra testtilfellet-objektet med $variable
      • For å injisere verdier fra nøstede objekter kan du angi en nøkkelsti f.eks. $variable.path.to.value (fungerer kun for "egne" egenskaper, f.eks. $variable.constructor.name vil ikke fungere)
      • Du kan bruke $# for å injisere indeksen til testtilfellet
      • Du kan ikke bruke $variable med printf-formateringen bortsett fra %%

  • fn: Function testen som skal kjøres, funksjonen som mottar parameterne i hver rad som funksjonsargumenter.

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});
test.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

2. test.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal

    • Første rad med variabelnavn som kolonneoverskrifter separert med |
    • En eller flere påfølgende rader med data levert som malstrenguttrykk ved bruk av ${value}-syntaks.

  • name: String testens tittel, bruk $variable for å injisere testdata i testtittelen fra de merkede malstrenguttrykkene.

    • For å injisere nestede objektverdier kan du angi en nøkkelsti, f.eks. $variable.path.to.value (fungerer kun for "egne" egenskaper, f.eks. $variable.constructor.name vil ikke fungere)

  • fn: Function testen som skal kjøres, funksjonen som mottar testdata-objektet.

  • Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente på hver rad før den avbrytes. Standard timeout er 5 sekunder.

Eksempel:

test.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.failing(name, fn, timeout)​

Også tilgjengelig under aliaset: it.failing(name, fn, timeout)

notat

Dette er kun tilgjengelig med standard testkjører jest-circus.

Bruk test.failing når du skriver en test og forventer at den skal feile. Disse testene vil oppføre seg motsatt av vanlige tester. Hvis en failing-test kaster en feil, vil den bestå. Hvis den ikke kaster feil, vil den feile.

tips

Du kan bruke denne testtypen f.eks. når du koder i BDD-stil. Da vil testene ikke vises som feilede før de består. Deretter kan du fjerne failing-modifikatoren for å få dem til å bestå.

Det kan også være en fin måte å bidra med feilende tester til et prosjekt, selv om du ikke vet hvordan du skal fikse feilen.

Eksempel:

test.failing('it is not equal', () => {
  expect(5).toBe(6); // this test will pass
});

test.failing('it is equal', () => {
  expect(10).toBe(10); // this test will fail
});

test.failing.each(name, fn, timeout)​

Også tilgjengelig under aliasene: it.failing.each(table)(name, fn) og it.failing.each`table`(name, fn)

notat

Dette er kun tilgjengelig med standard testkjører jest-circus.

Du kan også kjøre flere tester samtidig ved å legge til each etter failing.

Eksempel:

test.failing.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.only.failing(name, fn, timeout)​

Også tilgjengelig under aliasene: it.only.failing(name, fn, timeout), fit.failing(name, fn, timeout)

notat

Dette er kun tilgjengelig med standard testkjører jest-circus.

Bruk test.only.failing hvis du kun vil kjøre en spesifikk feilende test.

test.skip.failing(name, fn, timeout)​

Også tilgjengelig under aliasene: it.skip.failing(name, fn, timeout), xit.failing(name, fn, timeout), xtest.failing(name, fn, timeout)

notat

Dette er kun tilgjengelig med standard testkjører jest-circus.

Bruk test.skip.failing hvis du vil hoppe over en spesifikk feilende test.

test.only(name, fn, timeout)​

Også tilgjengelig under aliasene: it.only(name, fn, timeout), og fit(name, fn, timeout)

Når du feilsøker en stor testfil, vil du ofte kun kjøre en delmengde av testene. Du kan bruke .only for å spesifisere hvilke tester som skal være de eneste som kjøres i den testfilen.

Du kan også angi en timeout (i millisekunder) for å spesifisere hvor lenge du vil vente før avbrudd. Standard timeout er 5 sekunder.

La oss si du har disse testene som eksempel:

test.only('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Kun testen "det regner" vil kjøre i denne testfilen, siden den kjøres med test.only.

Vanligvis vil du ikke sjekke inn kode som bruker test.only i kildekontroll - du bruker det kun for feilsøking, og fjerner det når du har fikset de ødelagte testene.

test.only.each(table)(name, fn)​

Også tilgjengelig under aliasene: it.only.each(table)(name, fn), fit.each(table)(name, fn), it.only.each`table`(name, fn) og fit.each`table`(name, fn)

Bruk test.only.each hvis du kun vil kjøre spesifikke tester med ulike testdata.

test.only.each er tilgjengelig med to API-er:

test.only.each(table)(name, fn)​

test.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip(name, fn)​

Også tilgjengelig under aliasene: it.skip(name, fn), xit(name, fn) og xtest(name, fn)

Når du vedlikeholder en stor kodebase, kan du av og til oppdage en test som midlertidig ikke fungerer. Hvis du vil hoppe over denne testen uten å slette koden, kan du bruke test.skip for å angi hvilke tester som skal hoppes over.

La oss si du har disse testene som eksempel:

test('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test.skip('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Bare "it is raining"-testen vil kjøre, siden den andre testen bruker test.skip.

Du kunne kommentert ut testen, men det er ofte mer praktisk å bruke test.skip fordi det bevarer innrykk og syntaksfremheving.

test.skip.each(table)(name, fn)​

Også tilgjengelig under aliasene: it.skip.each(table)(name, fn), xit.each(table)(name, fn), xtest.each(table)(name, fn), it.skip.each`table`(name, fn), xit.each`table`(name, fn) og xtest.each`table`(name, fn)

Bruk test.skip.each hvis du vil stoppe kjøring av en samling datadrevne tester.

test.skip.each er tilgjengelig med to API-er:

test.skip.each(table)(name, fn)​

test.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip.each`table`(name, fn)​

test.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.todo(name)​

Også tilgjengelig under aliaset: it.todo(name)

Bruk test.todo når du planlegger å skrive tester. Disse vil fremheves i sammendraget på slutten, slik at du vet hvor mange tester du fortsatt må lage.

const add = (a, b) => a + b;

test.todo('add should be associative');
tips

test.todo vil gi feil hvis du sender inn en test-callback-funksjon. Bruk test.skip istedenfor hvis testen allerede er implementert, men ikke skal kjøres.

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.

.each​

Modifikatoren .each tilbyr flere måter å definere testtilfellene på. Noen API-er har begrensninger i typeinferensen for argumentene som sendes til describe eller test-callbackfunksjoner. La oss se på hver av dem.

notat

Eksemplene bruker test.each for enkelhet, men typeinferensen er identisk i alle tilfeller hvor .each-modifikatoren kan brukes: describe.each, test.concurrent.only.each, test.skip.each, osv.

Array av objekter​

Array-av-objekter-API-et er mest utførlig, men gjør typeinferens enkelt. En table kan skrives inline:

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

test.each([
  {name: 'a', path: 'path/to/a', count: 1, write: true},
  {name: 'b', path: 'path/to/b', count: 3},
])('inline table', ({name, path, count, write}) => {
  // arguments are typed as expected, e.g. `write: boolean | undefined`
});

Eller deklareres separat som variabel:

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

const table = [
  {a: 1, b: 2, expected: 'three', extra: true},
  {a: 3, b: 4, expected: 'seven', extra: false},
  {a: 5, b: 6, expected: 'eleven'},
];

test.each(table)('table as a variable', ({a, b, expected, extra}) => {
  // again everything is typed as expected, e.g. `extra: boolean | undefined`
});

Array av arrays​

Array-av-arrays-stilen fungerer problemfritt med inline-tabeller:

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

test.each([
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
])('inline table example', (a, b, expected, extra) => {
  // arguments are typed as expected, e.g. `extra: boolean | undefined`
});

Men hvis tabellen deklareres som separat variabel, må den typen som en array av tupler for korrekt typeinferens (kun unødvendig hvis alle elementer i raden har samme type):

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

const table: Array<[number, number, string, boolean?]> = [
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
];

test.each(table)('table as a variable example', (a, b, expected, extra) => {
  // without the annotation types are incorrect, e.g. `a: number | string | boolean`
});

Template literal​

Hvis alle verdiene er av samme type, vil malstreng-API-en typetilordne argumentene korrekt:

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

test.each`
  a    | b    | expected
  ${1} | ${2} | ${3}
  ${3} | ${4} | ${7}
  ${5} | ${6} | ${11}
`('template literal example', ({a, b, expected}) => {
  // all arguments are of type `number`
});

Ellers vil den kreve et generisk typeargument:

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

test.each<{a: number; b: number; expected: string; extra?: boolean}>`
  a    | b    | expected    | extra
  ${1} | ${2} | ${'three'}  | ${true}
  ${3} | ${4} | ${'seven'}  | ${false}
  ${5} | ${6} | ${'eleven'}
`('template literal example', ({a, b, expected, extra}) => {
  // without the generic argument in this case types would default to `unknown`
});