Teszt API Referencia

Az alábbi típusok a következő típus-aláírásokban használatosak:

type Awaitable<T> = T | PromiseLike<T>;
type TestFunction = () => Awaitable<void>;

interface TestOptions {
  /**
   * A teszt sikertelen lesz, ha túl sokáig tart a végrehajtása.
   */
  timeout?: number;
  /**
   * A tesztet a megadott számú alkalommal próbálja újra, ha sikertelen.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Ugyanazt a tesztet többször is megismétli, még ha minden alkalommal sikertelen is.
   * Ha van "retry" opció, és a teszt sikertelen, akkor minden ciklusban felhasználja az összes újrapróbálkozást.
   * Hasznos a véletlenszerű hibák hibakereséséhez.
   *
   * @default 0
   */
  repeats?: number;
}

Amikor egy tesztfüggvény ígéretet ad vissza, a futtató megvárja, amíg az fel nem oldódik, hogy összegyűjtse az aszinkron elvárásokat. Ha az ígéret elutasításra kerül, a teszt sikertelen lesz.

TIP

A Jestben a TestFunction típusa lehet (done: DoneCallback) => void is. Ha ezt a formát használják, a teszt addig nem fejeződik be, amíg a done meg nem hívódik. Ugyanezt elérheti egy async függvénnyel is, lásd a Migrációs útmutató Done Callback szekcióját.

Az opciókat a függvény tulajdonságainak láncolásával definiálhatja:

import { test } from 'vitest';

test.skip('skipped test', () => {
  // valamilyen logika, ami jelenleg hibás
});

test.concurrent.skip('skipped concurrent test', () => {
  // valamilyen logika, ami jelenleg hibás
});

De megadhat egy objektumot is második argumentumként:

import { test } from 'vitest';

test('skipped test', { skip: true }, () => {
  // valamilyen logika, ami jelenleg hibás
});

test('skipped concurrent test', { skip: true, concurrent: true }, () => {
  // valamilyen logika, ami jelenleg hibás
});

Mindkettő pontosan ugyanúgy működik. Használatuk csupán stilisztikai választás.

Vegye figyelembe, hogy ha az időtúllépést utolsó argumentumként adja meg, akkor az opciók már nem használhatók:

import { test } from 'vitest';

// ✅ ez működik
test.skip('heavy test', () => {
  // ...
}, 10_000);

// ❌ ez nem működik
test(
  'heavy test',
  { skip: true },
  () => {
    // ...
  },
  10_000
);

Azonban megadhatja az időtúllépést az objektumon belül:

import { test } from 'vitest';

// ✅ ez működik
test('heavy test', { skip: true, timeout: 10_000 }, () => {
  // ...
});

test

Alias: it

A test egy kapcsolódó elvárások halmazát definiálja. Paraméterként megkapja a teszt nevét és egy függvényt, amely a tesztelendő elvárásokat tartalmazza.

Opcionálisan megadhat egy időtúllépést (milliszekundumban) annak meghatározására, hogy mennyi ideig várjon a leállás előtt. Az alapértelmezett érték 5 másodperc, és globálisan konfigurálható a testTimeout segítségével.

import { expect, test } from 'vitest';

test('should work as expected', () => {
  expect(Math.sqrt(4)).toBe(2);
});

test.extend

Alias: it.extend

Használja a test.extend függvényt a tesztkörnyezet kiterjesztéséhez egyéni fixture-ökkel. Ez egy új test függvényt ad vissza, és ez is kiterjeszthető, így több fixture-t is összeállíthat, vagy felülírhatja a meglévőket a kiterjesztésével, ahogy szüksége van rá. További információkért lásd a Tesztkörnyezet kiterjesztése című részt.

import { expect, test } from 'vitest';

const todos = [];
const archive = [];

const myTest = test.extend({
  todos: async ({ task }, use) => {
    todos.push(1, 2, 3);
    await use(todos);
    todos.length = 0;
  },
  archive,
});

myTest('add item', ({ todos }) => {
  expect(todos.length).toBe(3);

  todos.push(4);
  expect(todos.length).toBe(4);
});

test.skip

Alias: it.skip

Ha bizonyos tesztek futtatását ki szeretné hagyni, de valamilyen okból nem szeretné törölni a kódot, használhatja a test.skip parancsot a teszt futtatásának elkerülésére.

import { assert, test } from 'vitest';

test.skip('skipped test', () => {
  // Teszt kihagyva, nincs hiba
  assert.equal(Math.sqrt(4), 3);
});

A tesztet dinamikusan is kihagyhatja a kontextusán lévő skip hívásával:

import { assert, test } from 'vitest';

test('skipped test', context => {
  context.skip();
  // Teszt kihagyva, nincs hiba
  assert.equal(Math.sqrt(4), 3);
});

Vitest 3.1 óta, ha a feltétel ismeretlen, megadhatja azt a skip metódus első argumentumaként:

import { assert, test } from 'vitest';

test('skipped test', context => {
  context.skip(Math.random() < 0.5, 'optional message');
  // Teszt kihagyva, nincs hiba
  assert.equal(Math.sqrt(4), 3);
});

test.skipIf

Alias: it.skipIf

Bizonyos esetekben többször is futtathat teszteket különböző környezetekben, és néhány teszt környezetfüggő lehet. Ahelyett, hogy a tesztkódot if feltétellel burkolná, használhatja a test.skipIf parancsot a teszt kihagyására, amikor a feltétel igaz.

import { assert, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

test.skipIf(isDev)('prod only test', () => {
  // ez a teszt csak éles környezetben fut
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

test.runIf

Alias: it.runIf

A test.skipIf ellentéte.

import { assert, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

test.runIf(isDev)('dev only test', () => {
  // ez a teszt csak fejlesztői környezetben fut
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

test.only

Alias: it.only

Használja a test.only parancsot, hogy csak bizonyos teszteket futtasson egy adott tesztcsomagban. Ez hasznos lehet hibakeresés során.

import { assert, test } from 'vitest';

test.only('test', () => {
  // Csak ez a teszt (és a többi, "only" jelöléssel ellátott) fut le
  assert.equal(Math.sqrt(4), 2);
});

Néha nagyon hasznos, ha csak bizonyos fájlokban futtatunk only teszteket, figyelmen kívül hagyva a teljes tesztcsomag összes többi tesztjét, amelyek szennyezik a kimenetet.

Ehhez futtassa a vitest parancsot a kérdéses teszteket tartalmazó specifikus fájllal.

# vitest interesting.test.ts

test.concurrent

Alias: it.concurrent

A test.concurrent egymást követő teszteket jelöl meg párhuzamos futtatásra. Megkapja a teszt nevét, egy aszinkron függvényt a gyűjtendő tesztekkel, és egy opcionális időtúllépést (milliszekundumban).

import { describe, test } from 'vitest';

// A két, concurrent jelöléssel ellátott teszt párhuzamosan fog futni
describe('suite', () => {
  test('serial test', async () => {
    /* ... */
  });
  test.concurrent('concurrent test 1', async () => {
    /* ... */
  });
  test.concurrent('concurrent test 2', async () => {
    /* ... */
  });
});

A test.skip, test.only és test.todo működik a párhuzamos tesztekkel. Az alábbi kombinációk mindegyike érvényes:

test.concurrent(/* ... */);
test.skip.concurrent(/* ... */); // vagy test.concurrent.skip(/* ... */)
test.only.concurrent(/* ... */); // vagy test.concurrent.only(/* ... */)
test.todo.concurrent(/* ... */); // vagy test.concurrent.todo(/* ... */)

Párhuzamos tesztek futtatásakor a pillanatképeknek és az állításoknak a helyi Tesztkörnyezetből származó expect függvényt kell használniuk a megfelelő teszt felismerésének biztosításához.

test.concurrent('test 1', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});
test.concurrent('test 2', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

test.sequential

Alias: it.sequential

A test.sequential egy tesztet szekvenciális futtatásra jelöl. Ez akkor hasznos, ha a teszteket sorrendben szeretné futtatni a describe.concurrent blokkon belül, vagy a --sequence.concurrent parancssori opcióval.

import { describe, test } from 'vitest';

// a { sequence: { concurrent: true } } konfigurációs opcióval
test('concurrent test 1', async () => {
  /* ... */
});
test('concurrent test 2', async () => {
  /* ... */
});

test.sequential('sequential test 1', async () => {
  /* ... */
});
test.sequential('sequential test 2', async () => {
  /* ... */
});

// párhuzamos tesztcsomagon belül
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  test('concurrent test 2', async () => {
    /* ... */
  });

  test.sequential('sequential test 1', async () => {
    /* ... */
  });
  test.sequential('sequential test 2', async () => {
    /* ... */
  });
});

test.todo

Alias: it.todo

Használja a test.todo parancsot a később megvalósítandó tesztek csonkolására. A jelentésben megjelenik egy bejegyzés a tesztekhez, így tudni fogja, hány tesztet kell még megvalósítania.

// Egy bejegyzés fog megjelenni a jelentésben ehhez a teszthez
test.todo('unimplemented test');

test.fails

Alias: it.fails

Használja a test.fails parancsot annak jelzésére, hogy egy állítás explicit módon sikertelen lesz.

import { expect, test } from 'vitest';

function myAsyncFunc() {
  return new Promise(resolve => resolve(1));
}
test.fails('fail test', async () => {
  await expect(myAsyncFunc()).rejects.toBe(1);
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

test.each

Alias: it.each

TIP

Míg a test.each a Jest kompatibilitás érdekében van biztosítva, a Vitest rendelkezik a test.for funkcióval is, amely további funkciókat kínál a TestContext integrálásához.

Használja a test.each parancsot, ha ugyanazt a tesztet különböző változókkal kell futtatnia. A teszt nevében a printf formázással injektálhat paramétereket a tesztfüggvény paramétereinek sorrendjében.

%s: string
%d: szám
%i: egész szám
%f: lebegőpontos érték
%j: json
%o: objektum
%#: a teszteset 0-alapú indexe
%$: a teszteset 1-alapú indexe
%%: egyetlen százalékjel ('%')

import { expect, test } from 'vitest';

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

// ez a következő kimenetet adja:
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Objektumtulajdonságokat és tömbelemeket is elérhet a $ előtaggal:

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

// ez a következő kimenetet adja:
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

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

// ez a következő kimenetet adja:
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Objektumattribútumokat is elérhet a . segítségével, ha objektumokat használ argumentumként:

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

// ez a következő kimenetet adja:
// ✓ add(1, b) -> 1b
// ✓ add(2, b) -> 2b
// ✓ add(3, b) -> 3b

Vitest 0.25.3-tól kezdve sablon string táblázatot is használhat.

Az első sornak oszlopneveket kell tartalmaznia, | jellel elválasztva;
Egy vagy több további adatsor, sablon literál kifejezésekkel megadva ${value} szintaxis használatával.

import { expect, test } from 'vitest';

test.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('returns $expected when $a is added $b', ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

TIP

A Vitest a $values értékeket a Chai format metódusával dolgozza fel. Ha az érték túlságosan csonkolt, növelheti a chaiConfig.truncateThreshold értékét a konfigurációs fájlban.

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

test.for

Alias: it.for

Alternatíva a test.each helyett a TestContext biztosítására.

A test.each-től való különbség az argumentumokban megadott tömbök kezelésében rejlik. A test.for nem tömb argumentumai (beleértve a sablon string használatát is) pontosan ugyanúgy működnek, mint a test.each esetében.

// az `each` szétteríti a tömböket
test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', (a, b, expected) => { 
  expect(a + b).toBe(expected);
});

// a `for` nem teríti szét a tömböket (figyelje meg a szögletes zárójeleket az argumentumok körül)
test.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', ([a, b, expected]) => { 
  expect(a + b).toBe(expected);
});

A 2. argumentum a TestContext, és használható például párhuzamos pillanatképekhez:

test.concurrent.for([
  [1, 1],
  [1, 2],
  [2, 1],
])('add(%i, %i)', ([a, b], { expect }) => {
  expect(a + b).matchSnapshot();
});

bench

Típus: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

A bench egy benchmarkot definiál. Vitest terminológiában a benchmark egy olyan függvény, amely műveletek sorozatát definiálja. A Vitest többször futtatja ezt a függvényt, hogy különböző teljesítményeredményeket jelenítsen meg.

A Vitest a tinybench könyvtárat használja a háttérben, örökölve annak összes opcióját, amelyek harmadik argumentumként megadhatók.

import { bench } from 'vitest';

bench(
  'normal sorting',
  () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  },
  { time: 1000 }
);

export interface Options {
  /**
   * a benchmark feladat futtatásához szükséges idő (milliszekundumban)
   * @default 500
   */
  time?: number;

  /**
   * hányszor fusson le egy feladat, még akkor is, ha az idő opció lejárt
   * @default 10
   */
  iterations?: number;

  /**
   * függvény az aktuális időbélyeg milliszekundumban történő lekéréséhez
   */
  now?: () => number;

  /**
   * Egy AbortSignal a benchmark megszakításához
   */
  signal?: AbortSignal;

  /**
   * Hiba dobása, ha egy feladat sikertelen (az események nem fognak működni, ha igaz)
   */
  throws?: boolean;

  /**
   * bemelegítési idő (milliszekundumban)
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * bemelegítési iterációk
   * @default 5
   */
  warmupIterations?: number;

  /**
   * beállítási függvény, amely minden benchmark feladat (ciklus) előtt fut
   */
  setup?: Hook;

  /**
   * lebontási függvény, amely minden benchmark feladat (ciklus) után fut
   */
  teardown?: Hook;
}

A teszteset futtatása után a kimeneti struktúra a következő információkat tartalmazza:

  name                      hz     min     max    mean     p75     p99    p995    p999     rme  samples
· normal sorting  6,526,368.12  0.0001  0.3638  0.0002  0.0002  0.0002  0.0002  0.0004  ±1.41%   652638

export interface TaskResult {
  /*
   * az utolsó hiba, amely a feladat futtatása közben dobódott
   */
  error?: unknown;

  /**
   * A benchmark feladat (ciklus) futtatásához szükséges idő milliszekundumban.
   */
  totalTime: number;

  /**
   * a minták minimális értéke
   */
  min: number;
  /**
   * a minták maximális értéke
   */
  max: number;

  /**
   * műveletek száma másodpercenként
   */
  hz: number;

  /**
   * mennyi ideig tart minden művelet (ms)
   */
  period: number;

  /**
   * az egyes feladat iterációs idők mintái (ms)
   */
  samples: number[];

  /**
   * minták átlaga/átlagértéke (a populáció átlagának becslése)
   */
  mean: number;

  /**
   * minták varianciája (a populáció varianciájának becslése)
   */
  variance: number;

  /**
   * minták szórása (a populáció szórásának becslése)
   */
  sd: number;

  /**
   * az átlag standard hibája (más néven a mintaátlag mintavételi eloszlásának szórása)
   */
  sem: number;

  /**
   * szabadságfokok
   */
  df: number;

  /**
   * a minták kritikus értéke
   */
  critical: number;

  /**
   * hibahatár
   */
  moe: number;

  /**
   * relatív hibahatár
   */
  rme: number;

  /**
   * medián abszolút eltérés
   */
  mad: number;

  /**
   * p50/medián percentilis
   */
  p50: number;

  /**
   * p75 percentilis
   */
  p75: number;

  /**
   * p99 percentilis
   */
  p99: number;

  /**
   * p995 percentilis
   */
  p995: number;

  /**
   * p999 percentilis
   */
  p999: number;
}

bench.skip

Típus: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

A bench.skip szintaxist használhatja bizonyos benchmarkok futtatásának kihagyására.

import { bench } from 'vitest';

bench.skip('normal sorting', () => {
  const x = [1, 5, 4, 2, 3];
  x.sort((a, b) => {
    return a - b;
  });
});

bench.only

Típus: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

Használja a bench.only parancsot, hogy csak bizonyos benchmarkokat futtasson egy adott tesztcsomagban. Ez hasznos lehet hibakereséskor.

import { bench } from 'vitest';

bench.only('normal sorting', () => {
  const x = [1, 5, 4, 2, 3];
  x.sort((a, b) => {
    return a - b;
  });
});

bench.todo

Típus: (name: string | Function) => void

Használja a bench.todo parancsot a később megvalósítandó benchmarkok csonkolására.

import { bench } from 'vitest';

bench.todo('unimplemented test');

describe

Amikor test vagy bench parancsot használ egy fájl legfelső szintjén, azok az implicit tesztcsomag részét képezik. A describe segítségével új tesztcsomagot definiálhat az aktuális kontextusban, amely kapcsolódó teszteket vagy benchmarkokat, valamint más beágyazott tesztcsomagokat tartalmaz. Egy tesztcsomag lehetővé teszi a tesztek és benchmarkok rendszerezését, így a jelentések áttekinthetőbbek lesznek.

// basic.spec.ts
// tesztek rendszerezése

import { describe, expect, test } from 'vitest';

const person = {
  isActive: true,
  age: 32,
};

describe('person', () => {
  test('person is defined', () => {
    expect(person).toBeDefined();
  });

  test('is active', () => {
    expect(person.isActive).toBeTruthy();
  });

  test('age limit', () => {
    expect(person.age).toBeLessThanOrEqual(32);
  });
});

// basic.bench.ts
// benchmarkok rendszerezése

import { bench, describe } from 'vitest';

describe('sort', () => {
  bench('normal', () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  });

  bench('reverse', () => {
    const x = [1, 5, 4, 2, 3];
    x.reverse().sort((a, b) => {
      return a - b;
    });
  });
});

Beágyazhat describe blokkokat is, ha tesztek vagy benchmarkok hierarchiájával rendelkezik:

import { describe, expect, test } from 'vitest';

function numberToCurrency(value: number | string) {
  if (typeof value !== 'number') {
    throw new TypeError('Value must be a number');
  }

  return value
    .toFixed(2)
    .toString()
    .replace(/\B(?=(\d{3})+(?!\d))/g, ',');
}

describe('numberToCurrency', () => {
  describe('given an invalid number', () => {
    test('composed of non-numbers to throw error', () => {
      expect(() => numberToCurrency('abc')).toThrowError();
    });
  });

  describe('given a valid number', () => {
    test('returns the correct currency format', () => {
      expect(numberToCurrency(10000)).toBe('10,000.00');
    });
  });
});

describe.skip

Alias: suite.skip

Használja a describe.skip parancsot egy tesztcsomagban, hogy elkerülje egy adott describe blokk futtatását.

import { assert, describe, test } from 'vitest';

describe.skip('skipped suite', () => {
  test('sqrt', () => {
    // Tesztcsomag kihagyva, nincs hiba
    assert.equal(Math.sqrt(4), 3);
  });
});

describe.skipIf

Alias: suite.skipIf

Bizonyos esetekben többször is futtathat tesztcsomagokat különböző környezetekben, és néhány tesztcsomag környezetfüggő lehet. Ahelyett, hogy a tesztcsomagot if feltétellel burkolná, használhatja a describe.skipIf parancsot a tesztcsomag kihagyására, amikor a feltétel igaz.

import { describe, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

describe.skipIf(isDev)('prod only test suite', () => {
  // ez a tesztcsomag csak éles környezetben fut
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

describe.runIf

Alias: suite.runIf

A describe.skipIf ellentéte.

import { assert, describe, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

describe.runIf(isDev)('dev only test suite', () => {
  // ez a tesztcsomag csak fejlesztői környezetben fut
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

describe.only

Típus: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void

Használja a describe.only parancsot, hogy csak bizonyos tesztcsomagokat futtasson.

import { assert, describe, test } from 'vitest';

// Csak ez a tesztcsomag (és a többi, "only" jelöléssel ellátott) fut le
describe.only('suite', () => {
  test('sqrt', () => {
    assert.equal(Math.sqrt(4), 3);
  });
});

describe('other suite', () => {
  // ... kihagyásra kerül
});

Néha nagyon hasznos, ha csak bizonyos fájlokban futtatunk only teszteket, figyelmen kívül hagyva az összes többi tesztet a teljes tesztcsomagból, amelyek szennyezik a kimenetet.

Ehhez futtassa a vitest parancsot a kérdéses teszteket tartalmazó specifikus fájllal.

# vitest interesting.test.ts

describe.concurrent

Alias: suite.concurrent

A describe.concurrent az összes belső tesztcsomagot és tesztet párhuzamosan futtatja.

import { describe, test } from 'vitest';

// Az összes tesztcsomag és teszt ezen a tesztcsomagon belül párhuzamosan fog futni
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  describe('concurrent suite 2', async () => {
    test('concurrent test inner 1', async () => {
      /* ... */
    });
    test('concurrent test inner 2', async () => {
      /* ... */
    });
  });
  test.concurrent('concurrent test 3', async () => {
    /* ... */
  });
});

A .skip, .only és .todo működik a párhuzamos tesztcsomagokkal. Az alábbi kombinációk mindegyike érvényes:

describe.concurrent(/* ... */);
describe.skip.concurrent(/* ... */); // vagy describe.concurrent.skip(/* ... */)
describe.only.concurrent(/* ... */); // vagy describe.concurrent.only(/* ... */)
describe.todo.concurrent(/* ... */); // vagy describe.concurrent.todo(/* ... */)

describe.concurrent('suite', () => {
  test('concurrent test 1', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
  test('concurrent test 2', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

describe.sequential

Alias: suite.sequential

A describe.sequential egy tesztcsomagban minden tesztet szekvenciálisnak jelöl. Ez akkor hasznos, ha a teszteket sorrendben szeretné futtatni a describe.concurrent blokkon belül, vagy a --sequence.concurrent parancssori opcióval.

import { describe, test } from 'vitest';

describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  test('concurrent test 2', async () => {
    /* ... */
  });

  describe.sequential('', () => {
    test('sequential test 1', async () => {
      /* ... */
    });
    test('sequential test 2', async () => {
      /* ... */
    });
  });
});

describe.shuffle

Alias: suite.shuffle

A Vitest lehetőséget biztosít az összes teszt véletlenszerű sorrendben történő futtatására a CLI zászló --sequence.shuffle vagy a konfigurációs opció sequence.shuffle segítségével. Ha azonban csak a tesztcsomag egy részét szeretné véletlenszerű sorrendben futtatni, akkor megjelölheti ezt a zászlót.

import { describe, test } from 'vitest';

// vagy describe('suite', { shuffle: true }, ...)
describe.shuffle('suite', () => {
  test('random test 1', async () => {
    /* ... */
  });
  test('random test 2', async () => {
    /* ... */
  });
  test('random test 3', async () => {
    /* ... */
  });

  // a `shuffle` öröklődik
  describe('still random', () => {
    test('random 4.1', async () => {
      /* ... */
    });
    test('random 4.2', async () => {
      /* ... */
    });
  });

  // disable shuffle inside
  describe('not random', { shuffle: false }, () => {
    test('in order 5.1', async () => {
      /* ... */
    });
    test('in order 5.2', async () => {
      /* ... */
    });
  });
});
// a sorrend a konfigurációban lévő sequence.seed opciótól függ (alapértelmezetten Date.now())

A .skip, .only és .todo működik a véletlenszerű tesztcsomagokkal.

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

describe.todo

Alias: suite.todo

Használja a describe.todo parancsot a később megvalósítandó tesztcsomagok csonkolására. A jelentésben megjelenik egy bejegyzés a tesztekhez, így tudni fogja, hány tesztet kell még megvalósítania.

// Egy bejegyzés fog megjelenni a jelentésben ehhez a tesztcsomaghoz
describe.todo('unimplemented suite');

describe.each

Alias: suite.each

TIP

Míg a describe.each a Jest kompatibilitás érdekében van biztosítva, a Vitest rendelkezik a describe.for funkcióval is, amely egyszerűsíti az argumentumtípusokat és illeszkedik a test.for funkcióhoz.

Használja a describe.each parancsot, ha több tesztje is ugyanazoktól az adatoktól függ.

import { describe, expect, test } from 'vitest';

describe.each([
  { a: 1, b: 1, expected: 2 },
  { a: 1, b: 2, expected: 3 },
  { a: 2, b: 1, expected: 3 },
])('describe object 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);
  });
});

Vitest 0.25.3-tól kezdve sablon string táblázatot is használhat.

Az első sornak oszlopneveket kell tartalmaznia, | jellel elválasztva;
Egy vagy több további adatsor, sablon literál kifejezésekkel megadva ${value} szintaxis használatával.

import { describe, expect, test } from 'vitest';

describe.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('describe template string add($a, $b)', ({ a, b, expected }) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

WARNING

Ezt a szintaxist nem használhatja, ha a Vitestet típusellenőrzőként használja.

describe.for

Alias: suite.for

A describe.each-től való különbség a tömbös eset argumentumokban való megadásának módjában rejlik. Más nem tömbös eset (beleértve a sablon string használatát is) pontosan ugyanúgy működik.

// az `each` szétteríti a tömbös esetet
describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', (a, b, expected) => { 
  test('test', () => {
    expect(a + b).toBe(expected);
  });
});

// a `for` nem teríti szét a tömbös esetet
describe.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', ([a, b, expected]) => { 
  test('test', () => {
    expect(a + b).toBe(expected);
  });
});

Beállítás és lebontás

Ezek a funkciók lehetővé teszik, hogy bekapcsolódjon a tesztek életciklusába, elkerülve a beállítási és lebontási kód ismétlését. Az aktuális kontextusra vonatkoznak: a fájlra (ha a legfelső szinten használják őket), vagy az aktuális tesztcsomagra (ha egy describe blokkon belül vannak). Ezek a hookok nem aktiválódnak, ha a Vitest típusellenőrző módban fut.

beforeEach

Típus: beforeEach(fn: () => Awaitable<void>, timeout?: number)

Regisztráljon egy visszahívást, amelyet az aktuális kontextusban lévő minden teszt futtatása előtt meg kell hívni. Ha a függvény ígéretet ad vissza, a Vitest megvárja, amíg az ígéret feloldódik, mielőtt futtatja a tesztet.

Opcionálisan megadhat egy időtúllépést (milliszekundumban), amely meghatározza, mennyi ideig várjon a leállás előtt. Az alapértelmezett érték 5 másodperc.

import { beforeEach } from 'vitest';

beforeEach(async () => {
  // Törölje a mockokat és adjon hozzá néhány tesztadatot minden tesztfutás előtt
  await stopMocking();
  await addUser({ name: 'John' });
});

Itt a beforeEach biztosítja, hogy a felhasználó minden teszthez hozzáadódjon.

A beforeEach opcionális tisztítófüggvényt is elfogad (ami egyenértékű az afterEach-el).

import { beforeEach } from 'vitest';

beforeEach(async () => {
  // egyszer hívódik meg minden tesztfutás előtt
  await prepareSomething();

  // tisztítófüggvény, egyszer hívódik meg minden tesztfutás után
  return async () => {
    await resetSomething();
  };
});

afterEach

Típus: afterEach(fn: () => Awaitable<void>, timeout?: number)

Regisztráljon egy visszahívást, amelyet az aktuális kontextusban lévő minden teszt befejezése után meg kell hívni. Ha a függvény ígéretet ad vissza, a Vitest megvárja, amíg az ígéret feloldódik, mielőtt folytatja.

Opcionálisan megadhat egy időtúllépést (milliszekundumban) annak meghatározására, hogy mennyi ideig várjon a leállás előtt. Az alapértelmezett érték 5 másodperc.

import { afterEach } from 'vitest';

afterEach(async () => {
  await clearTestingData(); // tesztadatok törlése minden tesztfutás után
});

Itt az afterEach biztosítja, hogy a tesztadatok törlődjenek minden teszt futtatása után.

TIP

A Vitest 1.3.0 hozzáadta az onTestFinished hookot. Ezt a teszt végrehajtása során hívhatja meg, hogy a teszt befejezése után megtisztítsa az állapotot.

beforeAll

Típus: beforeAll(fn: () => Awaitable<void>, timeout?: number)

Regisztráljon egy visszahívást, amelyet egyszer kell meghívni az aktuális kontextusban lévő összes teszt futtatásának megkezdése előtt. Ha a függvény ígéretet ad vissza, a Vitest megvárja, amíg az ígéret feloldódik, mielőtt futtatja a teszteket.

Opcionálisan megadhat egy időtúllépést (milliszekundumban) annak meghatározására, hogy mennyi ideig várjon a leállás előtt. Az alapértelmezett érték 5 másodperc.

import { beforeAll } from 'vitest';

beforeAll(async () => {
  await startMocking(); // egyszer hívódik meg az összes teszt futtatása előtt
});

Itt a beforeAll biztosítja, hogy a mock adatok beállítása megtörténjen a tesztek futtatása előtt.

A beforeAll opcionális tisztítófüggvényt is elfogad (ami egyenértékű az afterAll-lal).

import { beforeAll } from 'vitest';

beforeAll(async () => {
  // egyszer hívódik meg az összes teszt futtatása előtt
  await startMocking();

  // tisztítófüggvény, egyszer hívódik meg az összes teszt futtatása után
  return async () => {
    await stopMocking();
  };
});

afterAll

Típus: afterAll(fn: () => Awaitable<void>, timeout?: number)

Regisztráljon egy visszahívást, amelyet egyszer kell meghívni az összes teszt befejezése után az aktuális kontextusban. Ha a függvény ígéretet ad vissza, a Vitest megvárja, amíg az ígéret feloldódik, mielőtt folytatja.

Opcionálisan megadhat egy időtúllépést (milliszekundumban) annak meghatározására, hogy mennyi ideig várjon a leállás előtt. Az alapértelmezett érték 5 másodperc.

import { afterAll } from 'vitest';

afterAll(async () => {
  await stopMocking(); // ez a metódus az összes teszt futtatása után hívódik meg
});

Itt az afterAll biztosítja, hogy a stopMocking metódus az összes teszt futtatása után meghívódjon.

Teszt Hookok

A Vitest néhány hookot biztosít, amelyeket a teszt végrehajtása közben hívhat meg az állapot tisztítására, amikor a teszt befejeződött.

WARNING

Ezek a hookok hibát dobnak, ha a teszt törzsén kívül hívják meg őket.

onTestFinished

Ez a hook mindig meghívódik, miután a teszt befejeződött. Az afterEach hookok után hívódik meg, mivel azok befolyásolhatják a teszt eredményét. Egy ExtendedContext objektumot kap, hasonlóan a beforeEach és az afterEach hookokhoz.

import { onTestFinished, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

WARNING

Ha párhuzamosan futtat teszteket, mindig a tesztkörnyezetből származó onTestFinished hookot kell használnia, mivel a Vitest nem követi a párhuzamos teszteket a globális hookokban:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFinished }) => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

Ez a hook különösen hasznos újrafelhasználható logika létrehozásakor:

// ez lehet egy külön fájlban
function getTestDb() {
  const db = connectMockedDb();
  onTestFinished(() => db.close());
  return db;
}

test('performs a user query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from users').perform()).toEqual([]);
});

test('performs an organization query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from organizations').perform()).toEqual([]);
});

TIP

Ez a hook mindig fordított sorrendben hívódik meg, és nem befolyásolja a sequence.hooks opció.

onTestFailed

Ez a hook csak akkor hívódik meg, ha a teszt sikertelen volt. Az afterEach hookok után hívódik meg, mivel azok befolyásolhatják a teszt eredményét. Egy ExtendedContext objektumot kap, hasonlóan a beforeEach és az afterEach hookokhoz. Ez a hook hasznos a hibakereséshez.

import { onTestFailed, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFailed(({ task }) => {
    console.log(task.result.errors);
  });
  db.query('SELECT * FROM users');
});

WARNING

Ha párhuzamosan futtat teszteket, mindig a tesztkörnyezetből származó onTestFailed hookot kell használnia, mivel a Vitest nem követi a párhuzamos teszteket a globális hookokban:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFailed }) => {
  const db = connectDb();
  onTestFailed(({ task }) => {
    console.log(task.result.errors);
  });
  db.query('SELECT * FROM users');
});

Teszt API Referencia ​

test ​

test.extend ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.sequential ​

test.todo ​

test.fails ​

test.each ​

test.for ​

bench ​

bench.skip ​

bench.only ​

bench.todo ​

describe ​

describe.skip ​

describe.skipIf ​

describe.runIf ​

describe.only ​

describe.concurrent ​

describe.sequential ​

describe.shuffle ​

describe.todo ​

describe.each ​

describe.for ​

Beállítás és lebontás ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Teszt Hookok ​

onTestFinished ​

onTestFailed ​

Teszt API Referencia

test

test.extend

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.sequential

test.todo

test.fails

test.each

test.for

bench

bench.skip

bench.only

bench.todo

describe

describe.skip

describe.skipIf

describe.runIf

describe.only

describe.concurrent

describe.sequential

describe.shuffle

describe.todo

describe.each

describe.for

Beállítás és lebontás

beforeEach

afterEach

beforeAll

afterAll

Teszt Hookok

onTestFinished

onTestFailed