Version: Nächste

Globale APIs

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

In deinen Testdateien stellt Jest alle diese Methoden und Objekte im globalen Kontext bereit. Du musst nichts importieren oder einbinden, um sie zu verwenden. Wenn du explizite Importe bevorzugst, kannst du jedoch import {describe, expect, test} from '@jest/globals' verwenden.

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Hinweis

Die TypeScript-Beispiele auf dieser Seite funktionieren nur wie dokumentiert, wenn Sie die Jest-APIs explizit importieren:

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

Weitere Details zur Einrichtung von Jest mit TypeScript finden Sie im Leitfaden Erste Schritte.

Referenz

`afterAll(fn, timeout)`

Führt eine Funktion aus, nachdem alle Tests in dieser Datei abgeschlossen wurden. Wenn die Funktion einen Promise oder Generator zurückgibt, wartet Jest auf dessen Auflösung, bevor fortgefahren wird.

Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Dies ist besonders nützlich, um globale Testzustände zu bereinigen, die für mehrere Tests gemeinsam genutzt werden.

Beispiel:

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();
  });
});

Hier stellt afterAll sicher, dass cleanUpDatabase nach Ausführung aller Tests aufgerufen wird.

Befindet sich afterAll in einem describe-Block, wird es am Ende dieses Blocks ausgeführt.

Wenn du nach jedem einzelnen Test aufräumen möchtest, verwende stattdessen afterEach.

`afterEach(fn, timeout)`

Führt eine Funktion nach jedem einzelnen Test in dieser Datei aus. Wenn die Funktion einen Promise oder Generator zurückgibt, wartet Jest auf dessen Auflösung, bevor fortgefahren wird.

Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Dies ist besonders nützlich, um temporäre Zustände zu bereinigen, die durch einzelne Tests erzeugt wurden.

Beispiel:

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();
  });
});

Hier stellt afterEach sicher, dass cleanUpDatabase nach jedem Testlauf aufgerufen wird.

Befindet sich afterEach in einem describe-Block, wird es nur nach Tests innerhalb dieses Blocks ausgeführt.

Wenn du nur einmalig nach allen Tests aufräumen möchtest, verwende stattdessen afterAll.

`beforeAll(fn, timeout)`

Führt eine Funktion aus, bevor irgendein Test in dieser Datei läuft. Wenn die Funktion einen Promise oder Generator zurückgibt, wartet Jest auf dessen Auflösung, bevor Tests gestartet werden.

Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Dies ist besonders nützlich, um globale Zustände einzurichten, die von vielen Tests genutzt werden.

Beispiel:

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);
  });
});

Hier stellt beforeAll sicher, dass die Datenbank vor Testbeginn eingerichtet wird. Bei synchronem Setup wäre beforeAll nicht nötig. Der entscheidende Punkt ist, dass Jest auf Promises wartet – so ist auch asynchrones Setup möglich.

Befindet sich beforeAll in einem describe-Block, wird es zu Beginn dieses Blocks ausgeführt.

Wenn du etwas vor jedem einzelnen Test ausführen möchtest, verwende stattdessen beforeEach.

`beforeEach(fn, timeout)`

Führt eine Funktion vor jedem einzelnen Test in dieser Datei aus. Wenn die Funktion einen Promise oder Generator zurückgibt, wartet Jest auf dessen Auflösung, bevor der Test startet.

Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Dies ist besonders nützlich, um globale Zustände zurückzusetzen, die von vielen Tests genutzt werden.

Beispiel:

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();
  });
});

Hier stellt beforeEach sicher, dass die Datenbank vor jedem Test zurückgesetzt wird.

Wenn sich beforeEach innerhalb eines describe-Blocks befindet, wird es für jeden Test in diesem Block ausgeführt.

Wenn Sie Setup-Code nur einmal vor allen Tests ausführen müssen, verwenden Sie stattdessen beforeAll.

`describe(name, fn)`

describe(name, fn) erstellt einen Block, der mehrere zusammengehörige Tests gruppiert. Wenn du beispielsweise ein myBeverage-Objekt hast, das lecker aber nicht sauer sein soll, könntest du es so testen:

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

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

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

Dies ist nicht verpflichtend – du kannst test-Blöcke auch direkt auf oberster Ebene schreiben. Aber es ist praktisch, wenn du deine Tests lieber in Gruppen organisiert haben möchtest.

Du kannst describe-Blöcke auch verschachteln, wenn du eine Test-Hierarchie benötigst:

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)`

Verwende describe.each, wenn du dieselben Test-Suiten mit unterschiedlichen Daten wiederholst. describe.each erlaubt dir, die Test-Suite einmal zu schreiben und Daten einzuspielen.

describe.each ist in zwei Varianten verfügbar:

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

table: Array von Arrays mit Argumenten, die für jede Zeile in fn übergeben werden. Bei 1D-Arrays primitiver Werte wird intern eine Tabelle erzeugt: [1, 2, 3] -> [[1], [2], [3]].
name: String für den Titel der Test-Suite.
- Erzeuge eindeutige Testtitel durch positionsbasierte Parameter mit printf-Formatierung:
  - %p - pretty-format.
  - %s- String.
  - %d- Zahl.
  - %i - Ganzzahl.
  - %f - Fließkommawert.
  - %j - JSON.
  - %o - Objekt.
  - %# - Index des Testfalls.
  - %$ - Nummer des Testfalls.
  - %% - einzelnes Prozentzeichen ('%'). Verbraucht kein Argument.
- Oder erzeuge eindeutige Testtitel durch Eigenschaften des Testfall-Objekts mit $variable:
  - Für verschachtelte Werte verwende einen KeyPath wie $variable.path.to.value (funktioniert nur bei "eigenen" Eigenschaften, z.B. $variable.constructor.name würde nicht funktionieren)
  - $# fügt den Index des Testfalls ein
  - $variable kann nicht mit printf-Formatierung kombiniert werden (außer %%)
fn: Function enthält die auszuführenden Tests und erhält die Zeilenparameter als Funktionsargumente.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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
- Erste Zeile mit Variablennamen als Spaltenüberschriften, getrennt durch |
- Eine oder mehrere nachfolgende Datenzeilen als Template-Literal-Ausdrücke mit ${value}-Syntax.
name: String für den Titel der Test-Suite. Verwende $variable zur Dateninjektion und $# für die Zeilennummer:
- Für verschachtelte Werte verwende einen KeyPath wie $variable.path.to.value (funktioniert nur bei "eigenen" Eigenschaften, z.B. würde $variable.constructor.name nicht funktionieren)
fn: Function enthält die Tests und erhält ein Testdaten-Objekt.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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)`

Auch unter dem Alias: fdescribe(name, fn)

Du kannst describe.only verwenden, wenn du nur einen bestimmten describe-Block ausführen möchtest:

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)`

Auch unter den Aliases: fdescribe.each(table)(name, fn) und fdescribe.each`table`(name, fn)

Verwende describe.only.each, wenn du nur bestimmte Testsuiten für datengetriebene Tests ausführen möchtest.

describe.only.each ist in zwei APIs verfügbar:

`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)`

Auch unter dem Alias: xdescribe(name, fn)

Du kannst describe.skip verwenden, wenn du die Tests eines bestimmten describe-Blocks nicht ausführen möchtest:

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
});

Die Verwendung von describe.skip ist oft eine sauberere Alternative zum temporären Auskommentieren von Tests. Beachte, dass der describe-Block trotzdem ausgeführt wird. Wenn du Setup-Code überspringen möchtest, platziere ihn in einem beforeAll oder beforeEach Block.

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

Auch unter den Aliases: xdescribe.each(table)(name, fn) und xdescribe.each`table`(name, fn)

Verwende describe.skip.each, wenn du die Ausführung einer Suite für datengetriebene Tests überspringen möchtest.

describe.skip.each ist in zwei APIs verfügbar:

`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)`

Auch unter dem Alias: it(name, fn, timeout)

Alles, was du in einer Testdatei benötigst, ist die test-Methode, die einen Test ausführt. Angenommen, eine Funktion inchesOfRain() sollte null zurückgeben. Dein gesamter Test könnte so aussehen:

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

Das erste Argument ist der Testname, das zweite Argument eine Funktion, die die zu testenden Assertions enthält. Das dritte Argument (optional) ist timeout (in Millisekunden), um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Wenn in test ein Promise zurückgegeben wird, wartet Jest auf dessen Auflösung, bevor der Test abgeschlossen wird. Angenommen, fetchBeverageList() gibt ein Promise zurück, das eine Liste mit lemon enthalten sollte. Du kannst dies testen mit:

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

Obwohl der test-Aufruf sofort zurückkehrt, wird der Test erst abgeschlossen, wenn das Promise aufgelöst ist. Weitere Details findest du auf der Seite Asynchronen Code testen.

Tipp

Jest wartet auch, wenn du ein Argument an die Testfunktion übergibst, üblicherweise done genannt. Dies ist nützlich, wenn du Callbacks testen möchtest.

`test.concurrent(name, fn, timeout)`

Auch unter dem Alias: it.concurrent(name, fn, timeout)

Vorsicht

test.concurrent gilt als experimentell - siehe hier für Details zu fehlenden Funktionen und bekannten Problemen.

Verwende test.concurrent, wenn der Test gleichzeitig (concurrent) ausgeführt werden soll.

Der erste Parameter ist der Testname; der zweite Parameter ist eine asynchrone Funktion, die die zu testenden Erwartungen enthält. Der dritte Parameter (optional) ist timeout (in Millisekunden), der angibt, wie lange gewartet werden soll, bevor abgebrochen wird. Die Standard-Timeout-Dauer beträgt 5 Sekunden.

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

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

Tipp

Verwende die Konfigurationsoption maxConcurrency, um zu verhindern, dass Jest mehr als die angegebene Anzahl von Tests gleichzeitig ausführt.

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

Auch unter dem Alias: it.concurrent.each(table)(name, fn, timeout)

Verwende test.concurrent.each, wenn du denselben Test mit unterschiedlichen Daten wiederholst. test.each ermöglicht dir, den Test einmal zu schreiben und Daten einzufügen. Alle Tests werden asynchron ausgeführt.

test.concurrent.each ist in zwei APIs verfügbar:

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

table: Array von Arrays mit den Argumenten, die für jede Zeile in die Test-fn übergeben werden. Wenn ein 1D-Array von Primitiven übergeben wird, wird es intern in eine Tabelle umgewandelt, z.B. [1, 2, 3] -> [[1], [2], [3]]
name: String für den Titel des Testblocks.
- Erzeuge eindeutige Testtitel durch positionelle Einspeisung von Parametern mit printf-Formatierung:
  - %p - pretty-format.
  - %s- String.
  - %d- Zahl.
  - %i - Ganzzahl.
  - %f - Fließkommawert.
  - %j - JSON.
  - %o - Objekt.
  - %# - Index des Testfalls.
  - %$ - Nummer des Testfalls.
  - %% - einzelnes Prozentzeichen ('%'). Verbraucht kein Argument.
fn: Function der auszuführende Test. Diese Funktion erhält die Parameter jeder Zeile als Funktionsargumente. Diese muss eine asynchrone Funktion sein.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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
- Erste Zeile mit Variablennamen als Spaltenüberschriften, getrennt durch |
- Eine oder mehrere nachfolgende Datenzeilen als Template-Literal-Ausdrücke mit ${value}-Syntax.
name: String für den Testtitel, verwende $variable um Testdaten aus den Template-Ausdrücken in den Titel zu injizieren.
- Für verschachtelte Objektwerte kannst du einen KeyPath angeben, z.B. $variable.path.to.value (funktioniert nur für "eigene" Eigenschaften, z. B. $variable.constructor.name würde nicht funktionieren)
fn: Function der auszuführende Test. Diese Funktion erhält das Testdatenobjekt. Diese muss eine asynchrone Funktion sein.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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)`

Auch unter dem Alias: it.concurrent.only.each(table)(name, fn)

Verwende test.concurrent.only.each, wenn du nur bestimmte Tests mit unterschiedlichen Testdaten gleichzeitig ausführen möchtest.

test.concurrent.only.each ist in zwei APIs verfügbar:

`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)`

Auch unter dem Alias: it.concurrent.skip.each(table)(name, fn)

Verwende test.concurrent.skip.each, wenn du die Ausführung einer Sammlung asynchroner datengetriebener Tests beenden möchtest.

test.concurrent.skip.each ist in zwei APIs verfügbar:

`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)`

Auch unter den Aliassen: it.each(table)(name, fn) und it.each`table`(name, fn)

Verwende test.each, wenn du denselben Test mit unterschiedlichen Daten wiederholst. test.each ermöglicht dir, den Test einmal zu schreiben und die Daten zu übergeben.

test.each ist in zwei APIs verfügbar:

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

table: Array von Arrays mit den Argumenten, die für jede Zeile in die Test-fn übergeben werden. Wenn ein 1D-Array von Primitiven übergeben wird, wird es intern in eine Tabelle umgewandelt, z.B. [1, 2, 3] -> [[1], [2], [3]]
name: String für den Titel des Testblocks.
- Generiere eindeutige Testtitel durch positionelles Injizieren von Parametern mit printf-Formatierung:
  - %p - pretty-format.
  - %s- String.
  - %d- Number.
  - %i - Integer.
  - %f - Floating point value.
  - %j - JSON.
  - %o - Object.
  - %# - Index des Testfalls.
  - %$ - Nummer des Testfalls.
  - %% - einzelnes Prozentzeichen ('%'). Verbraucht kein Argument.
- Oder generiere eindeutige Testtitel durch Injizieren von Eigenschaften des Testfallobjekts mit $variable
  - Für verschachtelte Objektwerte kannst du einen KeyPath angeben, z.B. $variable.path.to.value (funktioniert nur für "eigene" Eigenschaften, z.B. würde $variable.constructor.name nicht funktionieren)
  - Verwende $# um den Index des Testfalls einzufügen
  - $variable kann nicht mit printf-Formatierung kombiniert werden, außer für %%
fn: Function der auszuführende Test, erhält die Parameter jeder Zeile als Funktionsargumente.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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
- Erste Zeile mit Variablennamen als Spaltenüberschriften, getrennt durch |
- Eine oder mehrere nachfolgende Datenzeilen als Template-Literal-Ausdrücke mit ${value}-Syntax.
name: String für den Testtitel, verwende $variable um Testdaten aus den Template-Ausdrücken in den Titel zu injizieren.
- Für verschachtelte Objektwerte kannst du einen KeyPath angeben, z.B. $variable.path.to.value (funktioniert nur für "eigene" Eigenschaften, z. B. $variable.constructor.name würde nicht funktionieren)
fn: Function der auszuführende Test, erhält das Testdatenobjekt.
Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange für jede Zeile gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Beispiel:

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)`

Auch unter dem Alias: it.failing(name, fn, timeout)

Hinweis

Dies ist nur mit dem Standard-Runner jest-circus verfügbar.

Verwenden Sie test.failing, wenn Sie einen Test schreiben und erwarten, dass er fehlschlägt. Diese Tests verhalten sich umgekehrt zu normalen Tests: Wenn ein failing-Test einen Fehler auslöst, gilt er als bestanden. Löst er keinen Fehler aus, gilt er als fehlgeschlagen.

Tipp

Sie können diese Art von Test beispielsweise verwenden, wenn Sie Code im BDD-Stil schreiben. In diesem Fall werden die Tests erst als bestanden angezeigt, wenn sie tatsächlich erfolgreich sind. Anschließend können Sie einfach den failing-Modifikator entfernen.

Dies eignet sich auch gut, um fehlschlagende Tests zu einem Projekt beizutragen, selbst wenn Sie den Fehler nicht beheben können.

Beispiel:

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)`

Auch unter den Aliasen: it.failing.each(table)(name, fn) und it.failing.each`table`(name, fn)

Hinweis

Dies ist nur mit dem Standard-Runner jest-circus verfügbar.

Sie können auch mehrere Tests gleichzeitig ausführen, indem Sie each nach failing hinzufügen.

Beispiel:

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)`

Auch unter den Aliasen: it.only.failing(name, fn, timeout), fit.failing(name, fn, timeout)

Hinweis

Dies ist nur mit dem Standard-Runner jest-circus verfügbar.

Verwenden Sie test.only.failing, wenn Sie nur einen bestimmten fehlschlagenden Test ausführen möchten.

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

Auch unter den Aliasen: it.skip.failing(name, fn, timeout), xit.failing(name, fn, timeout), xtest.failing(name, fn, timeout)

Hinweis

Dies ist nur mit dem Standard-Runner jest-circus verfügbar.

Verwenden Sie test.skip.failing, wenn Sie das Ausführen eines bestimmten fehlschlagenden Tests überspringen möchten.

`test.only(name, fn, timeout)`

Auch unter den Aliasen: it.only(name, fn, timeout) und fit(name, fn, timeout)

Beim Debuggen einer großen Testdatei möchten Sie oft nur eine Teilmenge der Tests ausführen. Mit .only legen Sie fest, welche Tests in dieser Datei ausgeführt werden sollen.

Optional können Sie ein timeout (in Millisekunden) angeben, um festzulegen, wie lange gewartet werden soll, bevor abgebrochen wird. Das Standard-Timeout beträgt 5 Sekunden.

Angenommen, Sie haben diese Tests:

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

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

In dieser Testdatei wird nur der Test "it is raining" ausgeführt, da er mit test.only markiert ist.

Normalerweise sollten Sie Code mit test.only nicht in die Versionskontrolle einchecken – verwenden Sie es nur zum Debuggen und entfernen Sie es nach der Fehlerbehebung.

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

Auch unter den Aliassen: it.only.each(table)(name, fn), fit.each(table)(name, fn), it.only.each`table`(name, fn) und fit.each`table`(name, fn)

Verwenden Sie test.only.each, wenn Sie nur bestimmte Tests mit verschiedenen Testdaten ausführen möchten.

test.only.each ist mit zwei APIs verfügbar:

`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)`

Auch unter den Aliassen: it.skip(name, fn), xit(name, fn) und xtest(name, fn)

Bei der Pflege einer großen Codebasis können Ihnen gelegentlich Tests begegnen, die vorübergehend aus bestimmten Gründen fehlerhaft sind. Wenn Sie diese Tests überspringen möchten, ohne den Code zu löschen, können Sie test.skip verwenden.

Angenommen, Sie haben diese Tests:

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

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

Nur der Test "es regnet" wird ausgeführt, da der andere mit test.skip markiert ist.

Sie könnten den Test auskommentieren, aber test.skip ist oft eleganter, da es die Einrückung und Syntaxhervorhebung beibehält.

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

Auch unter den Aliassen: 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) und xtest.each`table`(name, fn)

Verwenden Sie test.skip.each, wenn Sie eine Sammlung datengesteuerter Tests überspringen möchten.

test.skip.each ist mit zwei APIs verfügbar:

`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)`

Auch unter dem Alias: it.todo(name)

Verwenden Sie test.todo für geplante Tests. Diese werden im Zusammenfassungsoutput hervorgehoben, sodass Sie sehen, wie viele Tests noch implementiert werden müssen.

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

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

Tipp

test.todo löst einen Fehler aus, wenn Sie eine Callback-Funktion übergeben. Verwenden Sie stattdessen test.skip, wenn der Test bereits implementiert ist, aber nicht ausgeführt werden soll.

TypeScript-Verwendung

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Hinweis

Die TypeScript-Beispiele auf dieser Seite funktionieren nur wie dokumentiert, wenn Sie die Jest-APIs explizit importieren:

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

Weitere Details zur Einrichtung von Jest mit TypeScript finden Sie im Leitfaden Erste Schritte.

`.each`

Der .each-Modifizierer bietet mehrere Möglichkeiten, Testfalltabellen zu definieren. Einige APIs haben Einschränkungen bei der Typinferenz für Callback-Parameter in describe oder test.

Hinweis

Der Einfachheit halber zeigen wir Beispiele mit test.each, aber die Typinferenz funktioniert identisch bei allen .each-Varianten: describe.each, test.concurrent.only.each, test.skip.each usw.

Objekt-Arrays

Objekt-Arrays sind ausführlicher, ermöglichen aber problemlose Typinferenz. Eine table kann inline definiert werden:

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`
});

Oder separat als Variable deklariert werden:

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`
});

Arrays von Arrays

Arrays von Arrays funktionieren gut mit inline-Tabellen:

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`
});

Bei separaten Variablen muss die Tabelle jedoch als Tupel-Array typisiert werden (nur unnötig, wenn alle Zeilenelemente denselben Typ haben):

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-Literale

Wenn alle Eingabewerte denselben Typ haben, wird die Template-Literal-API die Argumente korrekt typisieren:

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

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

Wenn die Eingaben unterschiedliche Typen haben, werden die Argumente als Vereinigung aller Eingabetypen typisiert (d.h. als Typ der Variablen innerhalb des Template-Literals):

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

test.each`
  a    | b    | expected
  ${1} | ${2} | ${'three'}
  ${3} | ${4} | ${'seven'}
  ${5} | ${6} | ${'eleven'}
`('template literal example different types', ({a, b, expected}) => {
  // all arguments are of type `number | string` because some inputs (a, b) are of type `number` and some others (expected) are of type `string`
});

Andernfalls, wenn jedes Argument den richtigen Typ haben soll, müssen Sie das generische Typargument explizit angeben:

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}) => {
  // all arguments are typed as expected, e.g. `a: number`, `expected: string`, `extra: boolean | undefined`
});

Vorsicht

Beachten Sie, dass die Variablen innerhalb des Template-Literals nicht typgeprüft werden. Daher müssen Sie sicherstellen, dass ihre Typen korrekt sind.

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

test.each<{a: number; expected: string}>`
  a                            | expected
  ${1}                         | ${'one'}
  ${'will not raise TS error'} | ${'two'}
  ${3}                         | ${'three'}
`('template literal with wrongly typed input', ({a, expected}) => {
  // all arguments are typed as stated in the generic: `a: number`, `expected: string`
  // WARNING: `a` is of type `number` but will be a string in the 2nd test case.
});

Methoden​

Referenz​

afterAll(fn, timeout)​

afterEach(fn, timeout)​

beforeAll(fn, timeout)​

beforeEach(fn, timeout)​

describe(name, fn)​

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

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

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

describe.only(name, fn)​

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

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

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

describe.skip(name, fn)​

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

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

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

test(name, fn, timeout)​

test.concurrent(name, fn, timeout)​

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

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

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

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

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

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

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

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

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

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

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

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

test.failing(name, fn, timeout)​

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

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

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

test.only(name, fn, timeout)​

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

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

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

test.skip(name, fn)​

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

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

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

test.todo(name)​

TypeScript-Verwendung​

.each​

Objekt-Arrays​

Arrays von Arrays​

Template-Literale​

Methoden

Referenz

`afterAll(fn, timeout)`

`afterEach(fn, timeout)`

`beforeAll(fn, timeout)`

`beforeEach(fn, timeout)`

`describe(name, fn)`

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

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

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

`describe.only(name, fn)`

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

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

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

`describe.skip(name, fn)`

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

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

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

`test(name, fn, timeout)`

`test.concurrent(name, fn, timeout)`

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

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

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

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

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

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

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

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

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

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

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

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

`test.failing(name, fn, timeout)`

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

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

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

`test.only(name, fn, timeout)`

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

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

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

`test.skip(name, fn)`

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

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

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

`test.todo(name)`

TypeScript-Verwendung

`.each`

Objekt-Arrays

Arrays von Arrays

Template-Literale