Jelentéskészítők kiterjesztése

A jelentéskészítőket importálhatod a vitest/reporters modulból, és kiterjesztheted őket egyéni jelentéskészítők létrehozására.

Beépített jelentéskészítők kiterjesztése

Általában nem kell a jelentéskészítődet nulláról létrehoznod. A vitest több alapértelmezett jelentéskészítő modullal érkezik, amelyeket kiterjeszthetsz.

import { DefaultReporter } from 'vitest/reporters';

export default class MyDefaultReporter extends DefaultReporter {
  // valamilyen egyéni logika
}

Természetesen a jelentéskészítődet nulláról is létrehozhatod. Csak örökítsd a BaseReporter osztályt, és implementáld a szükséges metódusokat.

És itt van egy példa egy egyéni jelentéskészítőre:

// ./custom-reporter.js
import { BaseReporter } from 'vitest/reporters';

export default class CustomReporter extends BaseReporter {
  onCollected() {
    const files = this.ctx.state.getFiles(this.watchFilters);
    this.reportTestSummary(files);
  }
}

Vagy implementáld a Reporter interfészt:

// ./custom-reporter.js
import { Reporter } from 'vitest/reporters';

export default class CustomReporter implements Reporter {
  onCollected() {
    // valamilyen egyéni logika
  }
}

Ezután használhatod az egyéni jelentéskészítődet a vitest.config.ts fájlban:

import { defineConfig } from 'vitest/config';
import CustomReporter from './custom-reporter.js';

export default defineConfig({
  test: {
    reporters: [new CustomReporter()],
  },
});

Jelentett entitások

WARNING

Ez kísérleti API. A kompatibilitást törő változások nem feltétlenül követik a SemVer-t. Kérjük, rögzítse a Vitest verzióját, amikor használja.

Ezt az API-t a vitest.state.getReportedEntity(runnerTask) hívásával érheted el:

import type { Vitest } from 'vitest/node';
import type { RunnerTestFile } from 'vitest';
import type { Reporter, TestModule } from 'vitest/reporters';

class MyReporter implements Reporter {
  ctx!: Vitest;

  onInit(ctx: Vitest) {
    this.ctx = ctx;
  }

  onFinished(files: RunnerTestFile[]) {
    for (const fileTask of files) {
      // figyelembe véve, hogy a régi feladat-implementáció "file"-t használt "module" helyett
      const testModule = this.ctx.state.getReportedEntity(
        fileTask
      ) as TestModule;
      for (const task of testModule.children) {
        //                          ^?
        console.log('finished', task.type, task.fullName);
      }
    }
  }
}

Tervezzük stabilizálni ezt az API-t a Vitest 2.1-ben.

TestCase

A TestCase egyetlen tesztet jelöl.

declare class TestCase {
  readonly type = 'test' | 'custom';
  /**
   * Feladatpéldány.
   * @experimental A nyilvános feladat-API kísérleti, és nem követi a SemVer verziózást.
   */
  readonly task: RunnerTestCase | RunnerCustomCase;
  /**
   * A tesztet tartalmazó projekt.
   */
  readonly project: TestProject;
  /**
   * Közvetlen referencia a tesztmodulra, ahol a teszt definiálva van.
   */
  readonly module: TestModule;
  /**
   * A teszt neve.
   */
  readonly name: string;
  /**
   * A teszt teljes neve, beleértve az összes szülő suite-ot, ">" jellel elválasztva.
   */
  readonly fullName: string;
  /**
   * Egyedi azonosító.
   * Ez az azonosító determinisztikus, és ugyanaz lesz ugyanazon teszt futtatásakor több futtatás során is.
   * Az azonosító a projekt nevén, a modul azonosítóján és a teszt pozícióján alapul.
   */
  readonly id: string;
  /**
   * Pozíció a modulban, ahol a teszt definiálva volt.
   * A helyek csak akkor gyűjtésre kerülnek, ha a `includeTaskLocation` engedélyezve van a konfigurációban.
   */
  readonly location: { line: number; column: number } | undefined;
  /**
   * Szülő suite. Ha a teszt közvetlenül a modulon belül lett definiálva, a szülő maga a modul lesz.
   */
  readonly parent: TestSuite | TestModule;
  /**
   * Opciók, amelyekkel a tesztet inicializálták.
   */
  readonly options: TaskOptions;
  /**
   * Megállapítja, hogy a teszt nem hibázott-e.
   * Ha a teszt még nem fejeződött be, vagy átugrásra került, `true` értéket ad vissza.
   */
  ok(): boolean;
  /**
   * Egyedi metaadatok, amelyek a teszthez lettek csatolva a végrehajtás során.
   */
  meta(): TaskMeta;
  /**
   * A teszt eredményei. `undefined` lesz, ha a teszt még nem fejeződött be, vagy csak most gyűjtötték össze.
   */
  result(): TestResult | undefined;
  /**
   * Diagnosztikai információk a tesztről, például időtartam, memóriahasználat stb.
   */
  diagnostic(): TestDiagnostic | undefined;
}

export type TestResult =
  | TestResultPassed
  | TestResultFailed
  | TestResultSkipped;

export interface TestResultPassed {
  /**
   * A teszt sikeres volt.
   */
  state: 'passed';
  /**
   * A tesztfuttatás során keletkezett hibák.
   *
   * **Megjegyzés**: Ha a teszt sikeresen újrapróbálkozott, a hibák továbbra is jelentésre kerülnek.
   */
  errors: TestError[] | undefined;
}

export interface TestResultFailed {
  /**
   * A teszt végrehajtása sikertelen volt.
   */
  state: 'failed';
  /**
   * A teszt végrehajtása során keletkezett hibák.
   */
  errors: TestError[];
}

export interface TestResultSkipped {
  /**
   * A tesztet átugrották `only`, `skip` vagy `todo` jelzővel.
   * A `mode` opcióban láthatod, melyiket használták.
   */
  state: 'skipped';
  /**
   * Az átugrott tesztek hibamentesek.
   */
  errors: undefined;
}

export interface TestDiagnostic {
  /**
   * Ha a teszt időtartama meghaladja a `slowTestThreshold` értéket.
   */
  slow: boolean;
  /**
   * A teszt memóriahasználata bájtban.
   * Ez az érték csak akkor érhető el, ha a tesztet a `logHeapUsage` flag-gel futtatták.
   */
  heap: number | undefined;
  /**
   * A teszt végrehajtásához szükséges idő ms-ban.
   */
  duration: number;
  /**
   * Az idő ms-ban, amikor a teszt elindult.
   */
  startTime: number;
  /**
   * A teszt újrapróbálkozásainak száma.
   */
  retryCount: number;
  /**
   * A teszt ismétléseinek száma a `repeats` opció szerint konfigurált.
   * Ez az érték alacsonyabb lehet, ha a teszt az ismétlés során sikertelen volt, és nincs beállítva újrapróbálkozás.
   */
  repeatCount: number;
  /**
   * Ha a teszt sikeres volt a második próbálkozásra.
   */
  flaky: boolean;
}

TestSuite

A TestSuite egyetlen suite-ot jelöl, amely teszteket és más suite-okat tartalmaz.

declare class TestSuite {
  readonly type = 'suite';
  /**
   * Feladatpéldány.
   * @experimental A nyilvános feladat-API kísérleti, és nem követi a SemVer verziózást.
   */
  readonly task: RunnerTestSuite;
  /**
   * A tesztet tartalmazó projekt.
   */
  readonly project: TestProject;
  /**
   * Közvetlen referencia a tesztmodulra, ahol a suite definiálva van.
   */
  readonly module: TestModule;
  /**
   * A suite neve.
   */
  readonly name: string;
  /**
   * A suite teljes neve, beleértve az összes szülő suite-ot, ">" jellel elválasztva.
   */
  readonly fullName: string;
  /**
   * Egyedi azonosító.
   * Ez az azonosító determinisztikus, és ugyanaz lesz ugyanazon teszt futtatásakor több futtatás során is.
   * Az azonosító a projekt nevén, a modul azonosítóján és a teszt pozícióján alapul.
   */
  readonly id: string;
  /**
   * Pozíció a modulban, ahol a suite definiálva volt.
   * A helyek csak akkor gyűjtésre kerülnek, ha a `includeTaskLocation` engedélyezve van a konfigurációban.
   */
  readonly location: { line: number; column: number } | undefined;
  /**
   * A suite-ban található suite-ok és tesztek gyűjteménye.
   */
  readonly children: TaskCollection;
  /**
   * Opciók, amelyekkel a suite-ot inicializálták.
   */
  readonly options: TaskOptions;
}

TestModule

A TestModule egyetlen fájlt jelöl, amely suite-okat és teszteket tartalmaz.

declare class TestModule extends SuiteImplementation {
  readonly type = 'module';
  /**
   * Feladatpéldány.
   * @experimental A nyilvános feladat-API kísérleti, és nem követi a SemVer verziózást.
   */
  readonly task: RunnerTestFile;
  /**
   * A modulban lévő suite-ok és tesztek gyűjteménye.
   */
  readonly children: TestCollection;
  /**
   * Ez általában egy abszolút Unix fájlútvonal.
   * Lehet virtuális azonosító, ha a fájl nincs a lemezen.
   * Ez az érték megfelel a Vite `ModuleGraph` azonosítójának.
   */
  readonly moduleId: string;
  /**
   * Hasznos információk a modulról, például időtartam, memóriahasználat stb.
   * Ha a modult még nem futtatták, minden diagnosztikai érték `0` lesz.
   */
  diagnostic(): ModuleDiagnostic;
}

export interface ModuleDiagnostic {
  /**
   * Az idő, amely a környezet importálásához és inicializálásához szükséges.
   */
  environmentSetupDuration: number;
  /**
   * Az idő, amely a Vitest számára szükséges a tesztkörnyezet (futtató, mockok stb.) beállításához.
   */
  prepareDuration: number;
  /**
   * Az idő, amely a tesztmodul importálásához szükséges.
   * Ez magában foglalja az összes importálást a modulban és a suite visszahívások végrehajtását.
   */
  collectDuration: number;
  /**
   * Az idő, amely a beállítási modul importálásához szükséges.
   */
  setupDuration: number;
  /**
   * Az összes teszt és hook összesített időtartama a modulban.
   */
  duration: number;
}

TestCollection

A TestCollection suite-ok és tesztek gyűjteményét képviseli. Hasznos metódusokat is biztosít az iteráláshoz.

declare class TestCollection {
  /**
   * Visszaadja a tesztet vagy suite-ot a tömb adott indexén.
   */
  at(index: number): TestCase | TestSuite | undefined;
  /**
   * A gyűjteményben lévő tesztek és suite-ok száma.
   */
  size: number;
  /**
   * Visszaadja a gyűjteményt tömb formában a könnyebb manipuláció érdekében.
   */
  array(): (TestCase | TestSuite)[];
  /**
   * Szűri az összes suite-ot, amely része ennek a gyűjteménynek és gyermekeinek.
   */
  allSuites(): IterableIterator<TestSuite>;
  /**
   * Szűri az összes tesztet, amely része ennek a gyűjteménynek és gyermekeinek.
   */
  allTests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
  /**
s   * Csak azokat a teszteket szűri, amelyek részei ennek a gyűjteménynek.
   */
  tests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
  /**
   * Csak azokat a suite-okat szűri, amelyek részei ennek a gyűjteménynek.
   */
  suites(): IterableIterator<TestSuite>;
  [Symbol.iterator](): IterableIterator<TestSuite | TestCase>;
}

Például iterálhatsz egy modulon belüli összes teszten a testModule.children.allTests() hívásával:

function onFileCollected(testModule: TestModule): void {
  console.log('collecting tests in', testModule.moduleId);

  // végigiterálás a modul összes tesztjén és suite-ján
  for (const task of testModule.children.allTests()) {
    console.log('collected', task.type, task.fullName);
  }
}

TestProject

A TestProject a modulhoz kapcsolódó projekt. Minden teszt és suite a modulon belül ugyanarra a projektre referál.

A projekt segítségével kérhető le a konfiguráció vagy a biztosított kontextus.

declare class TestProject {
  /**
   * A globális Vitest példány.
   * @experimental A nyilvános Vitest API kísérleti, és nem követi a SemVer verziózást.
   */
  readonly vitest: Vitest;
  /**
   * A munkaterület-projekt, amelyhez ez a tesztprojekt kapcsolódik.
   * @experimental A nyilvános Vitest API kísérleti, és nem követi a SemVer verziózást.
   */
  readonly workspaceProject: WorkspaceProject;
  /**
   * A Vite fejlesztői szerver példánya. Minden munkaterület projektnek saját szervere van.
   */
  readonly vite: ViteDevServer;
  /**
   * Feloldott projekt konfiguráció.
   */
  readonly config: ResolvedProjectConfig;
  /**
   * Feloldott globális konfiguráció. Ha nincsenek munkaterület projektek, ez megegyezik a `config`-gal.
   */
  readonly globalConfig: ResolvedConfig;
  /**
   * Szerializált projekt konfiguráció. Ez a konfiguráció, amelyet a tesztek kapnak.
   */
  get serializedConfig(): SerializedConfig;
  /**
   * A projekt neve, vagy üres string, ha nincs beállítva.
   */
  name(): string;
  /**
   * Egyéni kontextus, amelyet a projekthez biztosítottak.
   */
  context(): ProvidedContext;
  /**
   * Biztosíthatsz egyéni szerializálható kontextust a projekthez. Ez a kontextus elérhető lesz a tesztek számára, amint futnak.
   */
  provide<T extends keyof ProvidedContext & string>(
    key: T,
    value: ProvidedContext[T]
  ): void;
}

Exportált jelentéskészítők

A vitest néhány beépített jelentéskészítővel érkezik, amelyeket azonnal használhatsz.

Beépített jelentéskészítők:

1. BasicReporter
2. DefaultReporter
3. DotReporter
4. JsonReporter
5. VerboseReporter
6. TapReporter
7. JUnitReporter
8. TapFlatReporter
9. HangingProcessReporter

Alap absztrakt jelentéskészítők:

1. BaseReporter

Interfész jelentéskészítők:

1. Reporter