Funkciók

• Vite konfiguráció, transzformátorok, feloldók és bővítmények támogatása.
• Ugyanazt a konfigurációt használhatod a tesztek futtatásához, mint az alkalmazásodban!
• Intelligens és gyors figyelő mód, hasonlóan a HMR-hez a tesztekhez!
• Komponens tesztelés Vue, React, Svelte, Lit és más keretrendszerekhez
• Beépített TypeScript / JSX támogatás
• ESM elsődleges, legfelső szintű await támogatás
• Többszálú végrehajtás a Tinypool segítségével
• Benchmarking támogatás a Tinybench segítségével
• Szűrés, időkorlátok és párhuzamos futtatás tesztcsomagok és tesztek esetén
• Munkaterület támogatás
• Jest-kompatibilis pillanatfelvétel készítés
• Chai beépítve az állításokhoz, valamint Jest expect kompatibilis API-k
• Tinyspy beépítve a mocking-hoz
• happy-dom vagy jsdom a DOM mocking-hoz
• Kódfedés a v8 vagy istanbul segítségével
• Rust-szerű forráskódba ágyazott tesztelés
• Típus tesztelés az expect-type segítségével

Tanuld meg, hogyan írd meg az első teszted videó segítségével

Megosztott konfiguráció a teszteléshez, fejlesztéshez és build-hez

Vite konfiguráció, transzformátorok, feloldók és bővítmények. Használd ugyanazt a beállítást, mint az alkalmazásodban a tesztek futtatásához.

Tudj meg többet a Vitest konfigurálásáról.

Figyelő mód (Watch Mode)

$ vitest

Amikor módosítod a forráskódodat vagy a tesztfájlokat, a Vitest intelligensen megkeresi a modulgráfot, és csak a kapcsolódó teszteket futtatja újra, pontosan úgy, ahogy a HMR működik a Vite-ben!

A vitest alapértelmezés szerint watch mode-ban indul fejlesztői környezetben, és run mode-ban CI környezetben (amikor a process.env.CI változó be van állítva). Használhatod a vitest watch vagy a vitest run parancsokat a kívánt mód explicit megadásához.

Gyakori webes technológiák azonnali támogatása

Azonnal használható ES Module / TypeScript / JSX támogatás / PostCSS

Szálak

Alapértelmezés szerint a Vitest több szálon futtatja a tesztfájlokat a node:worker_threads használatával a Tinypool segítségével (a Piscina egy könnyűsúlyú ága), lehetővé téve a tesztek egyidejű futtatását. Ha a tesztkódod nem kompatibilis a többszálúsággal, átválthatsz a --pool=forks lehetőségre, amely a Tinypoolon keresztül a node:child_process segítségével több folyamatban futtatja a teszteket.

A tesztek egyetlen szálon vagy folyamatban történő futtatásához lásd a poolOptions részt.

A Vitest elkülöníti minden fájl környezetét, így az egyik fájl környezeti változásai nem befolyásolják a többit. Az elkülönítés letiltható a --no-isolate paraméter átadásával a CLI-nek (a helyesség feláldozásával a futási teljesítményért cserébe).

Teszt Szűrés

A Vitest számos módszert kínál a tesztek szűkítésére, hogy felgyorsítsa a tesztelést és lehetővé tegye a fejlesztésre való koncentrálást.

Tudj meg többet a Teszt Szűrésről.

Tesztek egyidejű futtatása

Használd a .concurrent -et egymást követő tesztekben a párhuzamos futtatásukhoz.

import { describe, it } from 'vitest';

// A két concurrent-tel megjelölt teszt párhuzamosan fut
describe('suite', () => {
  it('serial test', async () => {
    /* ... */
  });
  it.concurrent('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
});

Ha a .concurrent -et egy tesztcsomagon használod, akkor az abban lévő összes teszt párhuzamosan fut.

import { describe, it } from 'vitest';

// Ebben a tesztcsomagban minden teszt párhuzamosan fut
describe.concurrent('suite', () => {
  it('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 3', async ({ expect }) => {
    /* ... */
  });
});

A .skip, .only és .todo is használható párhuzamos tesztcsomagokkal és tesztekkel. Olvass többet az API Referenciában.

WARNING

Párhuzamos tesztek futtatásakor a pillanatfelvételeknek és az állításoknak a helyi tesztkörnyezetből kell használniuk az expect-et a megfelelő teszt azonosításához.

Pillanatfelvétel (Snapshot)

Jest-kompatibilis pillanatfelvétel támogatás.

import { expect, it } from 'vitest';

it('helyesen renderel', () => {
  const result = render();
  expect(result).toMatchSnapshot();
});

Tudj meg többet a Pillanatfelvételről.

Chai és Jest expect kompatibilitás

A Chai beépítve az állításokhoz, valamint Jest expect-kompatibilis API-k.

Figyeld meg, hogy ha harmadik féltől származó könyvtárakat használsz, amelyek matchereket adnak hozzá, akkor a test.globals értékét true -ra állítva jobb kompatibilitást biztosíthatsz.

Mocking (Szimuláció)

A Tinyspy beépítve a mocking-hoz jest-kompatibilis API-kkal a vi objektumon.

import { expect, vi } from 'vitest';

const fn = vi.fn();

fn('hello', 1);

expect(vi.isMockFunction(fn)).toBe(true);
expect(fn.mock.calls[0]).toEqual(['hello', 1]);

fn.mockImplementation(arg => arg);

fn('world', 2);

expect(fn.mock.results[1].value).toBe('world');

A Vitest támogatja a happy-dom és a jsdom -ot is a DOM és a böngésző API-k mocking-jához. Ezek nem tartoznak a Vitesthez, ezért telepítened kell őket:

$ npm i -D happy-dom
# vagy
$ npm i -D jsdom

Ezután módosítsd az environment opciót a konfigurációs fájlban:

// vitest.config.ts
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environment: 'happy-dom', // vagy 'jsdom', 'node'
  },
});

Tudj meg többet a Mocking-ról.

Fedés (Coverage)

A Vitest natív kódfedést támogat a v8 és műszeres kódfedést az istanbul segítségével.

{
  "scripts": {
    "test": "vitest",
    "coverage": "vitest run --coverage"
  }
}

Tudj meg többet a Fedésről.

Forráskódba ágyazott tesztelés

A Vitest egy módot is kínál a tesztek futtatására a forráskódon belül, a megvalósítással együtt, hasonlóan a Rust modul tesztjeihez.

Ez lehetővé teszi, hogy a tesztek ugyanazt a lezárást (closure) osszák meg, mint a megvalósítások, és képesek legyenek a privát állapotok tesztelésére exportálás nélkül. Eközben a fejlesztéshez közelebb hozza a visszacsatolási ciklust is.

// src/index.ts

// a megvalósítás
export function add(...args: number[]) {
  return args.reduce((a, b) => a + b, 0);
}

// forráskódba ágyazott tesztcsomagok
if (import.meta.vitest) {
  const { it, expect } = import.meta.vitest;
  it('add', () => {
    expect(add()).toBe(0);
    expect(add(1)).toBe(1);
    expect(add(1, 2, 3)).toBe(6);
  });
}

Tudj meg többet a Forráskódba ágyazott tesztelésről.

Benchmarking (Teljesítménytesztelés) experimental

A Vitest 0.23.0 óta benchmark teszteket futtathatsz a bench függvény segítségével a Tinybench -en keresztül a teljesítményeredmények összehasonlításához.

import { bench, describe } from 'vitest';

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

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

Típus Tesztelés experimental

A Vitest 0.25.0 óta írhatsz teszteket a típus regressziók (visszaesések) észlelésére. A Vitesthez tartozik az expect-type csomag, amely hasonló és könnyen érthető API-t biztosít.

import { assertType, expectTypeOf } from 'vitest';
import { mount } from './mount.js';

test('a típusaid helyesen működnek', () => {
  expectTypeOf(mount).toBeFunction();
  expectTypeOf(mount).parameter(0).toMatchTypeOf<{ name: string }>();

  // @ts-expect-error name is a string
  assertType(mount({ name: 42 }));
});