Interaktivitás API

A Vitest a @testing-library/user-event API-k egy részhalmazát valósítja meg a Chrome DevTools Protocol vagy a webdriver használatával, ahelyett, hogy eseményeket szimulálna. Ezáltal a böngésző viselkedése megbízhatóbbá és következetesebbé válik a felhasználók oldalra való interakciójával.

import { userEvent } from '@vitest/browser/context';

await userEvent.click(document.querySelector('.button'));

Szinte minden userEvent metódus örökli a szolgáltató beállításait. Az összes elérhető opció megtekintéséhez az IDE-ben adja hozzá a webdriver vagy playwright típusokat (a használt szolgáltatótól függően) a tsconfig.json fájlhoz:

playwright

{
  "compilerOptions": {
    "types": ["@vitest/browser/providers/playwright"]
  }
}

webdriverio

{
  "compilerOptions": {
    "types": ["@vitest/browser/providers/webdriverio"]
  }
}

userEvent.setup

function setup(): UserEvent;

Létrehoz egy új felhasználói esemény példányt. Ez akkor hasznos, ha meg kell őriznie a billentyűzet állapotát a gombok helyes lenyomásához és felengedéséhez.

WARNING

Ellentétben a @testing-library/user-event-tel, a @vitest/browser/context alapértelmezett userEvent példánya egyszer jön létre, nem minden metódushíváskor! A működésbeli különbséget ebben a kódrészletben láthatja:

import { userEvent as vitestUserEvent } from '@vitest/browser/context';
import { userEvent as originalUserEvent } from '@testing-library/user-event';

await vitestUserEvent.keyboard('{Shift}'); // lenyomja a Shift-et felengedés nélkül
await vitestUserEvent.keyboard('{/Shift}'); // felengedi a Shift-et

await originalUserEvent.keyboard('{Shift}'); // lenyomja a Shift-et felengedés nélkül
await originalUserEvent.keyboard('{/Shift}'); // NEM engedte fel a Shift-et, mert az állapot más

Ez a viselkedés hasznosabb, mert nem emuláljuk a billentyűzetet, hanem ténylegesen lenyomjuk a Shift billentyűt, így az eredeti viselkedés megtartása váratlan problémákat okozhat a mezőbe való gépeléskor.

userEvent.click

function click(
  element: Element | Locator,
  options?: UserEventClickOptions
): Promise<void>;

Kattintás egy elemre. Örökli a szolgáltató opcióit. Kérjük, tekintse meg a szolgáltató dokumentációját a metódus működésének részletes magyarázatáért.

import { page, userEvent } from '@vitest/browser/context';

test('clicks on an element', async () => {
  const logo = page.getByRole('img', { name: /logo/ });

  await userEvent.click(logo);
  // vagy közvetlenül elérheti a lokátoron
  await logo.click();
});

Hivatkozások:

• Playwright locator.click API
• WebdriverIO element.click API
• testing-library click API

userEvent.dblClick

function dblClick(
  element: Element | Locator,
  options?: UserEventDoubleClickOptions
): Promise<void>;

Kettős kattintást hajt végre egy elemen.

Kérjük, tekintse meg a szolgáltató dokumentációját a metódus működésének részletes magyarázatáért.

import { page, userEvent } from '@vitest/browser/context';

test('triggers a double click on an element', async () => {
  const logo = page.getByRole('img', { name: /logo/ });

  await userEvent.dblClick(logo);
  // vagy közvetlenül elérheti a lokátoron
  await logo.dblClick();
});

Hivatkozások:

• Playwright locator.dblclick API
• WebdriverIO element.doubleClick API
• testing-library dblClick API

userEvent.tripleClick

function tripleClick(
  element: Element | Locator,
  options?: UserEventTripleClickOptions
): Promise<void>;

Hármas kattintást hajt végre egy elemen. Mivel nincs tripleclick a böngésző API-ban, ez a metódus három kattintás eseményt fog egymás után kiváltani, ezért ellenőriznie kell a kattintás esemény részleteit az esemény szűréséhez: evt.detail === 3.

Kérjük, tekintse meg a szolgáltató dokumentációját a metódus működésének részletes magyarázatáért.

import { page, userEvent } from '@vitest/browser/context';

test('triggers a triple click on an element', async () => {
  const logo = page.getByRole('img', { name: /logo/ });
  let tripleClickFired = false;
  logo.addEventListener('click', evt => {
    if (evt.detail === 3) {
      tripleClickFired = true;
    }
  });

  await userEvent.tripleClick(logo);
  // vagy közvetlenül elérheti a lokátoron
  await logo.tripleClick();

  expect(tripleClickFired).toBe(true);
});

Hivatkozások:

• Playwright locator.click API: click segítségével valósul meg clickCount: 3 opcióval.
• WebdriverIO browser.action API: actions api segítségével valósul meg move plusz három down + up + pause esemény egymás után
• testing-library tripleClick API

userEvent.fill

function fill(element: Element | Locator, text: string): Promise<void>;

Értéket állít be az input/textarea/conteneditable mezőnek. Ez eltávolítja a meglévő szöveget a beviteli mezőből, mielőtt beállítja az új értéket.

import { page, userEvent } from '@vitest/browser/context';

test('update input', async () => {
  const input = page.getByRole('input');

  await userEvent.fill(input, 'foo'); // input.value == foo
  await userEvent.fill(input, '{{a[['); // input.value == {{a[[
  await userEvent.fill(input, '{Shift}'); // input.value == {Shift}

  // vagy közvetlenül elérheti a lokátoron
  await input.fill('foo'); // input.value == foo
});

Ez a metódus fókuszálja az elemet, kitölti azt, és egy input eseményt vált ki a kitöltés után. Üres stringet használhat a mező törléséhez.

TIP

Ez az API gyorsabb, mint a userEvent.type vagy a userEvent.keyboard használata, de nem támogatja a user-event keyboard szintaxist (pl. {Shift} vagy {selectall}).

Javasoljuk ennek az API-nak a használatát a userEvent.type helyett olyan helyzetekben, amikor nincs szüksége speciális karakterek bevitelére vagy a billentyűleütési események finomhangolására.

Hivatkozások:

• Playwright locator.fill API
• WebdriverIO element.setValue API
• testing-library type API

userEvent.keyboard

function keyboard(text: string): Promise<void>;

A userEvent.keyboard lehetővé teszi a billentyűleütések kiváltását. Ha bármelyik beviteli mező fókuszban van, akkor a karaktereket abba a beviteli mezőbe írja be. Ellenkező esetben a billentyűzet eseményeket a jelenleg fókuszált elemen váltja ki (document.body, ha nincs fókuszált elem).

Ez az API támogatja a user-event keyboard szintaxist.

import { userEvent } from '@vitest/browser/context';

test('trigger keystrokes', async () => {
  await userEvent.keyboard('foo'); // lefordítja: f, o, o
  await userEvent.keyboard('{{a[['); // lefordítja: {, a, [
  await userEvent.keyboard('{Shift}{f}{o}{o}'); // lefordítja: Shift, f, o, o
  await userEvent.keyboard('{a>5}'); // lenyomja az a-t felengedés nélkül és 5 keydown-t vált ki
  await userEvent.keyboard('{a>5/}'); // lenyomja az a-t 5 keydown-ra, majd felengedi
});

Hivatkozások:

• Playwright Keyboard API
• WebdriverIO action('key') API
• testing-library type API

userEvent.tab

function tab(options?: UserEventTabOptions): Promise<void>;

Tab billentyű eseményt küld. Ez a userEvent.keyboard('{tab}') rövidítése.

import { page, userEvent } from '@vitest/browser/context';

test('tab works', async () => {
  const [input1, input2] = page.getByRole('input').elements();

  expect(input1).toHaveFocus();

  await userEvent.tab();

  expect(input2).toHaveFocus();

  await userEvent.tab({ shift: true });

  expect(input1).toHaveFocus();
});

Hivatkozások:

• Playwright Keyboard API
• WebdriverIO action('key') API
• testing-library tab API

userEvent.type

function type(
  element: Element | Locator,
  text: string,
  options?: UserEventTypeOptions
): Promise<void>;

WARNING

Ha nem támaszkodik speciális karakterekre (pl. {shift} vagy {selectall}), javasolt a userEvent.fill használata helyette a jobb teljesítmény érdekében.

A type metódus implementálja a @testing-library/user-event type segédprogramját, amely a keyboard API-ra épül.

Ez a funkció lehetővé teszi karakterek beírását egy input/textarea/conteneditable elembe. Támogatja a user-event keyboard szintaxist.

Ha csak karaktereket kell lenyomnia beviteli mező nélkül, használja a userEvent.keyboard API-t.

import { page, userEvent } from '@vitest/browser/context';

test('update input', async () => {
  const input = page.getByRole('input');

  await userEvent.type(input, 'foo'); // input.value == foo
  await userEvent.type(input, '{{a[['); // input.value == foo{a[
  await userEvent.type(input, '{Shift}'); // input.value == foo{a[
});

INFO

A Vitest nem teszi elérhetővé a .type metódust a lokátoron, mint az input.type, mert csak a userEvent könyvtárral való kompatibilitás miatt létezik. Fontolja meg a .fill használatát helyette, mivel gyorsabb.

Hivatkozások:

• Playwright locator.press API
• WebdriverIO action('key') API
• testing-library type API

userEvent.clear

function clear(element: Element | Locator): Promise<void>;

Ez a metódus törli a beviteli mező tartalmát.

import { page, userEvent } from '@vitest/browser/context';

test('clears input', async () => {
  const input = page.getByRole('input');

  await userEvent.fill(input, 'foo');
  expect(input).toHaveValue('foo');

  await userEvent.clear(input);
  // vagy közvetlenül elérheti a lokátoron
  await input.clear();

  expect(input).toHaveValue('');
});

Hivatkozások:

• Playwright locator.clear API
• WebdriverIO element.clearValue API
• testing-library clear API

userEvent.selectOptions

function selectOptions(
  element: Element | Locator,
  values: HTMLElement | HTMLElement[] | Locator | Locator[] | string | string[],
  options?: UserEventSelectOptions
): Promise<void>;

A userEvent.selectOptions lehetővé teszi érték kiválasztását egy <select> elemben.

WARNING

Ha a select elemnek nincs multiple attribútuma, a Vitest csak a tömb első elemét fogja kiválasztani.

Ellentétben a @testing-library-vel, a Vitest jelenleg nem támogatja a listbox-ot, de a jövőben tervezzük a támogatás hozzáadását.

import { page, userEvent } from '@vitest/browser/context';

test('clears input', async () => {
  const select = page.getByRole('select');

  await userEvent.selectOptions(select, 'Option 1');
  // vagy közvetlenül elérheti a lokátoron
  await select.selectOptions('Option 1');

  expect(select).toHaveValue('option-1');

  await userEvent.selectOptions(select, 'option-1');
  expect(select).toHaveValue('option-1');

  await userEvent.selectOptions(select, [
    page.getByRole('option', { name: 'Option 1' }),
    page.getByRole('option', { name: 'Option 2' }),
  ]);
  expect(select).toHaveValue(['option-1', 'option-2']);
});

WARNING

A webdriverio szolgáltató nem támogatja több elem kiválasztását, mert nem biztosít API-t ehhez.

Hivatkozások:

• Playwright locator.selectOption API
• WebdriverIO element.selectByIndex API
• testing-library selectOptions API

userEvent.hover

function hover(
  element: Element | Locator,
  options?: UserEventHoverOptions
): Promise<void>;

Ez a metódus a kurzor pozícióját a kiválasztott elem fölé mozgatja. Kérjük, tekintse meg a szolgáltató dokumentációját a metódus működésének részletes magyarázatáért.

WARNING

Ha a webdriverio szolgáltatót használja, a kurzor alapértelmezés szerint az elem közepére mozog.

Ha a playwright szolgáltatót használja, a kurzor az elem "valamilyen" látható pontjára mozog.

import { page, userEvent } from '@vitest/browser/context';

test('hovers logo element', async () => {
  const logo = page.getByRole('img', { name: /logo/ });

  await userEvent.hover(logo);
  // vagy közvetlenül elérheti a lokátoron
  await logo.hover();
});

Hivatkozások:

• Playwright locator.hover API
• WebdriverIO element.moveTo API
• testing-library hover API

userEvent.unhover

function unhover(
  element: Element | Locator,
  options?: UserEventHoverOptions
): Promise<void>;

Ez ugyanúgy működik, mint a userEvent.hover, de a kurzort a document.body elemre mozgatja.

WARNING

Alapértelmezés szerint a kurzor pozíciója "valamilyen" látható helyen van (a playwright szolgáltatóban) vagy a középen (a webdriverio szolgáltatóban) a body elemen, így ha a jelenleg lebegtetett elem már ugyanabban a pozícióban van, ennek a metódusnak nincs hatása.

import { page, userEvent } from '@vitest/browser/context';

test('unhover logo element', async () => {
  const logo = page.getByRole('img', { name: /logo/ });

  await userEvent.unhover(logo);
  // vagy közvetlenül elérheti a lokátoron
  await logo.unhover();
});

Hivatkozások:

• Playwright locator.hover API
• WebdriverIO element.moveTo API
• testing-library hover API

userEvent.upload

function upload(
  element: Element | Locator,
  files: string[] | string | File[] | File
): Promise<void>;

Beállítja a fájlfeltöltő elem tartalmát a megadott fájlokra.

import { page, userEvent } from '@vitest/browser/context';

test('can upload a file', async () => {
  const input = page.getByRole('button', { name: /Upload files/ });

  const file = new File(['file'], 'file.png', { type: 'image/png' });

  await userEvent.upload(input, file);
  // or you can access it directly on the locator
  await input.upload(file);

  // használhat fájl elérési utakat is a tesztfájlhoz képest
  await userEvent.upload(input, '../fixtures/file.png');
});

WARNING

A webdriverio szolgáltató csak a chrome és edge böngészőkben támogatja ezt a parancsot. Jelenleg csak string típusokat támogat.

Hivatkozások:

• Playwright locator.setInputFiles API
• WebdriverIO browser.uploadFile API
• testing-library upload API

userEvent.dragAndDrop

function dragAndDrop(
  source: Element | Locator,
  target: Element | Locator,
  options?: UserEventDragAndDropOptions
): Promise<void>;

A forrás elemet áthúzza a cél elem fölé. Ne feledje, hogy a source elemnek rendelkeznie kell a draggable attribútummal, amely true értékre van állítva.

import { page, userEvent } from '@vitest/browser/context';

test('drag and drop works', async () => {
  const source = page.getByRole('img', { name: /logo/ });
  const target = page.getByTestId('logo-target');

  await userEvent.dragAndDrop(source, target);
  // or you can access it directly on the locator
  await source.dropTo(target);

  await expect.element(target).toHaveTextContent('Logo is processed');
});

WARNING

Ezt az API-t az alapértelmezett preview szolgáltató nem támogatja.

Hivatkozások:

• Playwright frame.dragAndDrop API
• WebdriverIO element.dragAndDrop API