Tesztkörnyezet

A Playwright Fixtures által inspirálva, a Vitest tesztkörnyezete lehetővé teszi segédfüggvények (utils), állapotok és fixture-ök definiálását a tesztekhez.

Használat

A teszt callback függvényének első argumentuma mindig egy tesztkörnyezet.

import { it } from 'vitest';

it('működnie fog', ctx => {
  // Kiírja a teszt nevét
  console.log(ctx.task.name);
});

Beépített tesztkörnyezet

context.task

Egy csak olvasható objektum, amely metaadatokat tartalmaz a tesztről.

context.expect

Az aktuális teszthez kötött expect API:

import { it } from 'vitest';

it('a matek könnyű', ({ expect }) => {
  expect(2 + 2).toBe(4);
});

Ez az API hasznos a pillanatkép-tesztek párhuzamos futtatásához, mert a globális expect nem tudja nyomon követni őket:

import { it } from 'vitest';

it.concurrent('a matek könnyű', ({ expect }) => {
  expect(2 + 2).toMatchInlineSnapshot();
});

it.concurrent('a matek nehéz', ({ expect }) => {
  expect(2 * 2).toMatchInlineSnapshot();
});

context.skip

Kihagyja a teszt további végrehajtását és kihagyottként jelöli:

import { expect, it } from 'vitest';

it('a matek nehéz', ({ skip }) => {
  skip();
  expect(2 + 2).toBe(5);
});

Tesztkörnyezet kiterjesztése

A Vitest két különböző módszert kínál a tesztkörnyezet kiterjesztéséhez.

test.extend

WARNING

Ez az API a Vitest 0.32.3 verziójától érhető el.

A Playwright -hez hasonlóan ezzel a módszerrel definiálhat saját test API-t egyedi fixture-ökkel, és azt bárhol felhasználhatja.

Például először létrehozunk egy myTest -et két fixture-rel, todos és archive.

// my-test.ts
import { test } from 'vitest';

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

export const myTest = test.extend({
  todos: async ({ task }, use) => {
    // A fixture inicializálása minden teszt előtt
    todos.push(1, 2, 3);

    // A fixture értékének felhasználása
    await use(todos);

    // A fixture felszabadítása minden tesztfüggvény után
    todos.length = 0;
  },
  archive,
});

Ezután importálhatjuk és használhatjuk.

import { expect } from 'vitest';
import { myTest } from './my-test.ts';

myTest('elemek hozzáadása a teendőlistához', ({ todos }) => {
  expect(todos.length).toBe(3);

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

myTest(
  'elemek áthelyezése a teendőlistából az archívumba',
  ({ todos, archive }) => {
    expect(todos.length).toBe(3);
    expect(archive.length).toBe(0);

    archive.push(todos.pop());
    expect(todos.length).toBe(2);
    expect(archive.length).toBe(1);
  }
);

A myTest kiterjesztésével további fixture-öket is hozzáadhatunk, vagy felülírhatjuk a meglévőket.

export const myTest2 = myTest.extend({
  settings: {
    // ...
  },
});

Fixture inicializálás

A Vitest futtató intelligensen inicializálja a fixture-öket, és a használat alapján illeszti be őket a tesztkörnyezetbe.

import { test } from 'vitest';

async function todosFn({ task }, use) {
  await use([1, 2, 3]);
}

const myTest = test.extend({
  todos: todosFn,
  archive: [],
});

// a todosFn nem fog végrehajtódni
myTest('', () => {});
myTest('', ({ archive }) => {});

// a todosFn végrehajtódni fog
myTest('', ({ todos }) => {});

WARNING

A test.extend() használatakor fixture-ökkel, a { todos } objektum destrukturálási mintát kell alkalmazni a környezet eléréséhez a fixture és a teszt függvényekben is.

Automatikus fixture

WARNING

Ez a funkció a Vitest 1.3.0 verziójától érhető el.

A Vitest a tuple szintaxist is támogatja a fixture-ökhöz, lehetővé téve, hogy opciókat adj meg minden egyes fixture-höz. Például használhatod arra, hogy explicit módon inicializálj egy fixture-t, még akkor is, ha azt nem használják tesztekben.

import { test as base } from 'vitest';

const test = base.extend({
  fixture: [
    async ({}, use) => {
      // ez a függvény le fog futni
      setup();
      await use();
      teardown();
    },
    { auto: true }, // Megjelölés automatikus fixture-ként
  ],
});

test('', () => {});

TypeScript

Fixture típusok megadásához az összes egyéni környezetéhez, átadhatja a fixture típust általános típusként.

interface MyFixtures {
  todos: number[];
  archive: number[];
}

const myTest = test.extend<MyFixtures>({
  todos: [],
  archive: [],
});

myTest('', context => {
  expectTypeOf(context.todos).toEqualTypeOf<number[]>();
  expectTypeOf(context.archive).toEqualTypeOf<number[]>();
});

beforeEach és afterEach

Minden teszt külön környezetet kap. Hozzáférhet és kiterjesztheti őket a beforeEach és afterEach hook-okon belül.

import { beforeEach, it } from 'vitest';

beforeEach(async context => {
  // környezet kiterjesztése
  context.foo = 'bar';
});

it('működnie fog', ({ foo }) => {
  console.log(foo); // 'bar'
});

TypeScript

Ahhoz, hogy tulajdonság típusokat definiáljon az egyéni környezetekhez, bővítse a TestContext típust a következő hozzáadásával:

declare module 'vitest' {
  export interface TestContext {
    foo?: string;
  }
}

Ha csak bizonyos beforeEach, afterEach, it és test hook-okhoz szeretne tulajdonság típusokat definiálni, akkor a típust általánosként adhatja át.

interface LocalTestContext {
  foo: string;
}

beforeEach<LocalTestContext>(async context => {
  // a context típusa 'TestContext & LocalTestContext'
  context.foo = 'bar';
});

it<LocalTestContext>('működnie fog', ({ foo }) => {
  // a foo típusa 'string'
  console.log(foo); // 'bar'
});