Rozšiřování reportérů

Reportéry můžete importovat z vitest/reporters a rozšířit je pro vytvoření vlastních reportérů.

Rozšíření vestavěných reportérů

Obecně nemusíte vytvářet svůj reportér od základu. vitest obsahuje několik výchozích reportérů, které můžete rozšířit.

import { DefaultReporter } from 'vitest/reporters';

export default class MyDefaultReporter extends DefaultReporter {
  // proveďte nějakou akci
}

Samozřejmě si můžete vytvořit svůj reportér od základu. Stačí rozšířit třídu BaseReporter a implementovat metody, které potřebujete.

A zde je příklad vlastního reportéra:

// ./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);
  }
}

Nebo implementujte rozhraní Reporter:

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

export default class CustomReporter implements Reporter {
  onCollected() {
    // vypište něco
  }
}

Poté můžete použít svůj vlastní reportér v souboru vitest.config.ts:

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

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

Reportované úlohy

WARNING

Toto je experimentální API. Změny, které mohou porušit zpětnou kompatibilitu, nemusí dodržovat SemVer. Při jeho používání prosím zafixujte verzi Vitestu.

K tomuto API se dostanete voláním vitest.state.getReportedEntity(runnerTask):

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) {
      // poznámka: stará implementace úlohy používá "file" místo "modulu"
      const testModule = this.ctx.state.getReportedEntity(
        fileTask
      ) as TestModule;
      for (const task of testModule.children) {
        //                          ^?
        console.log('finished', task.type, task.fullName);
      }
    }
  }
}

Plánujeme stabilizovat toto API ve Vitestu 2.1.

TestCase

TestCase představuje jeden test.

declare class TestCase {
  readonly type = 'test' | 'custom';
  /**
   * Instance úlohy.
   * @experimental Veřejné API pro úlohy je experimentální a nedodržuje semver.
   */
  readonly task: RunnerTestCase | RunnerCustomCase;
  /**
   * Projekt spojený s testem.
   */
  readonly project: TestProject;
  /**
   * Přímý odkaz na testovací modul, kde je test definován.
   */
  readonly module: TestModule;
  /**
   * Název testu.
   */
  readonly name: string;
  /**
   * Úplný název testu včetně všech nadřazených sad oddělený znakem `>`.
   */
  readonly fullName: string;
  /**
   * Jedinečný identifikátor.
   * Toto ID je deterministické a bude stejné pro stejný test při více spuštěních.
   * ID je založeno na názvu projektu, ID modulu a pozici testu.
   */
  readonly id: string;
  /**
   * Umístění v modulu, kde byl test definován.
   * Umístění se shromažďují pouze tehdy, je-li v konfiguraci povoleno `includeTaskLocation`.
   */
  readonly location: { line: number; column: number } | undefined;
  /**
   * Nadřazená sada. Pokud byl test volán přímo uvnitř modulu, nadřazeným bude samotný modul.
   */
  readonly parent: TestSuite | TestModule;
  /**
   * Možnosti, se kterými byl test inicializován.
   */
  readonly options: TaskOptions;
  /**
   * Zkontroluje, zda test nezpůsobil selhání sady.
   * Pokud test ještě není dokončen nebo byl přeskočen, vrátí `true` hodnotu.
   */
  ok(): boolean;
  /**
   * Vlastní metadata, která byla k testu připojena během jeho provádění.
   */
  meta(): TaskMeta;
  /**
   * Výsledky testu. Bude `undefined`, pokud test ještě není dokončen nebo byl právě shromážděn.
   */
  result(): TestResult | undefined;
  /**
   * Užitečné informace o testu, jako je doba trvání, využití paměti atd.
   */
  diagnostic(): TestDiagnostic | undefined;
}

export type TestResult =
  | TestResultPassed
  | TestResultFailed
  | TestResultSkipped;

export interface TestResultPassed {
  /**
   * Test úspěšně prošel.
   */
  state: 'passed';
  /**
   * Chyby, které byly vyvolány během provádění testu.
   *
   * **Poznámka**: Pokud byl test úspěšně opakován, chyby budou stále reportovány.
   */
  errors: TestError[] | undefined;
}

export interface TestResultFailed {
  /**
   * Test se nepodařilo provést.
   */
  state: 'failed';
  /**
   * Chyby, které byly vyvolány během provádění testu.
   */
  errors: TestError[];
}

export interface TestResultSkipped {
  /**
   * Test byl přeskočen s příznakem `only`, `skip` nebo `todo`.
   * Který byl použit, můžete vidět v možnosti `mode`.
   */
  state: 'skipped';
  /**
   * Přeskočené testy nemají chyby.
   */
  errors: undefined;
}

export interface TestDiagnostic {
  /**
   * Pokud je doba trvání testu nad `slowTestThreshold`.
   */
  slow: boolean;
  /**
   * Množství paměti použité testem v bajtech.
   * Tato hodnota je k dispozici pouze, pokud byl test proveden s příznakem `logHeapUsage` povoleným.
   */
  heap: number | undefined;
  /**
   * Čas potřebný k provedení testu v ms.
   */
  duration: number;
  /**
   * Čas v ms, kdy test začal.
   */
  startTime: number;
  /**
   * Počet opakování testu.
   */
  retryCount: number;
  /**
   * Počet opakování testu, jak je nakonfigurováno možností `repeats`.
   * Tato hodnota může být nižší, pokud test selhal během opakování a není nakonfigurováno `retry`.
   */
  repeatCount: number;
  /**
   * Pokud test prošel při druhém opakování.
   */
  flaky: boolean;
}

TestSuite

TestSuite představuje jednu sadu, která obsahuje testy a další sady.

declare class TestSuite {
  readonly type = 'suite';
  /**
   * Instance úlohy.
   * @experimental Veřejné API pro úlohy je experimentální a nedodržuje semver.
   */
  readonly task: RunnerTestSuite;
  /**
   * Projekt spojený s testem.
   */
  readonly project: TestProject;
  /**
   * Přímý odkaz na testovací modul, kde je sada definována.
   */
  readonly module: TestModule;
  /**
   * Název sady.
   */
  readonly name: string;
  /**
   * Úplný název sady včetně všech nadřazených sad oddělený znakem `>`.
   */
  readonly fullName: string;
  /**
   * Jedinečný identifikátor.
   * Toto ID je deterministické a bude stejné pro stejný test při více spuštěních.
   * ID je založeno na názvu projektu, ID modulu a pozici testu.
   */
  readonly id: string;
  /**
   * Umístění v modulu, kde byla sada definována.
   * Umístění se shromažďují pouze tehdy, je-li v konfiguraci povoleno `includeTaskLocation`.
   */
  readonly location: { line: number; column: number } | undefined;
  /**
   * Kolekce sad a testů, které jsou součástí této sady.
   */
  readonly children: TaskCollection;
  /**
   * Možnosti, se kterými byla sada inicializována.
   */
  readonly options: TaskOptions;
}

TestModule

TestModule představuje jeden soubor, který obsahuje sady a testy.

declare class TestModule extends SuiteImplementation {
  readonly type = 'module';
  /**
   * Instance úlohy.
   * @experimental Veřejné API pro úlohy je experimentální a nedodržuje semver.
   */
  readonly task: RunnerTestFile;
  /**
   * Kolekce sad a testů, které jsou součástí tohoto modulu.
   */
  readonly children: TestCollection;
  /**
   * Toto je obvykle absolutní Unixová cesta k souboru.
   * Může to být virtuální ID, pokud soubor není uložen na disku.
   * Tato hodnota odpovídá ID `ModuleGraph` v rámci Vite.
   */
  readonly moduleId: string;
  /**
   * Užitečné informace o modulu, jako je doba trvání, využití paměti atd.
   * Pokud modul ještě nebyl proveden, všechny diagnostické hodnoty vrátí `0`.
   */
  diagnostic(): ModuleDiagnostic;
}

export interface ModuleDiagnostic {
  /**
   * Čas potřebný k importu a inicializaci prostředí.
   */
  environmentSetupDuration: number;
  /**
   * Čas potřebný Vitestu k nastavení testovacího prostředí (runner, mocky atd.).
   */
  prepareDuration: number;
  /**
   * Čas potřebný k importu testovacího modulu.
   * To zahrnuje import všeho v modulu a provádění callbacků sady.
   */
  collectDuration: number;
  /**
   * Čas potřebný k importu modulu nastavení.
   */
  setupDuration: number;
  /**
   * Akumulovaná doba trvání všech testů a hooků v modulu.
   */
  duration: number;
}

TestCollection

TestCollection představuje kolekci sad a testů. Poskytuje také užitečné metody pro iteraci přes sebe.

declare class TestCollection {
  /**
   * Vrátí test nebo sadu na konkrétním indexu v poli.
   */
  at(index: number): TestCase | TestSuite | undefined;
  /**
   * Počet testů a sad v kolekci.
   */
  size: number;
  /**
   * Vrátí kolekci ve formě pole pro snazší manipulaci.
   */
  array(): (TestCase | TestSuite)[];
  /**
   * Filtruje všechny sady, které jsou součástí této kolekce a jejích dětí.
   */
  allSuites(): IterableIterator<TestSuite>;
  /**
   * Filtruje všechny testy, které jsou součástí této kolekce a jejích dětí.
   */
  allTests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
  /**
   * Filtruje pouze testy, které jsou součástí této kolekce.
   */
  tests(state?: TestResult['state'] | 'running'): IterableIterator<TestCase>;
  /**
   * Filtruje pouze sady, které jsou součástí této kolekce.
   */
  suites(): IterableIterator<TestSuite>;
  [Symbol.iterator](): IterableIterator<TestSuite | TestCase>;
}

Například můžete iterovat přes všechny testy uvnitř modulu voláním testModule.children.allTests():

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

  // iterovat přes všechny testy a sady v modulu
  for (const task of testModule.children.allTests()) {
    console.log('collected', task.type, task.fullName);
  }
}

TestProject

TestProject je projekt spojený s modulem. Každý test a sada uvnitř tohoto modulu bude odkazovat na stejný projekt.

Projekt je užitečný pro získání konfigurace nebo poskytnutého kontextu.

declare class TestProject {
  /**
   * Globální instance vitestu.
   * @experimental Veřejné API Vitestu je experimentální a nedodržuje semver.
   */
  readonly vitest: Vitest;
  /**
   * Projekt pracovního prostoru, se kterým je tento testovací projekt spojen.
   * @experimental Veřejné API Vitestu je experimentální a nedodržuje semver.
   */
  readonly workspaceProject: WorkspaceProject;
  /**
   * Instance dev serveru Vite. Každý projekt pracovního prostoru má svůj vlastní server.
   */
  readonly vite: ViteDevServer;
  /**
   * Vyřešená konfigurace projektu.
   */
  readonly config: ResolvedProjectConfig;
  /**
   * Vyřešená globální konfigurace. Pokud nejsou žádné projekty pracovního prostoru, bude to stejné jako `config`.
   */
  readonly globalConfig: ResolvedConfig;
  /**
   * Serializovaná konfigurace projektu. Toto je konfigurace, kterou testy obdrží.
   */
  get serializedConfig(): SerializedConfig;
  /**
   * Název projektu nebo prázdný řetězec, pokud není nastaven.
   */
  name(): string;
  /**
   * Vlastní kontext poskytnutý projektu.
   */
  context(): ProvidedContext;
  /**
   * Poskytněte vlastní serializovatelný kontext projektu. Tento kontext bude k dispozici pro testy, jakmile se spustí.
   */
  provide<T extends keyof ProvidedContext & string>(
    key: T,
    value: ProvidedContext[T]
  ): void;
}

Exportované reportéry

vitest obsahuje několik vestavěných reportérů, které můžete použít ihned po instalaci.

Vestavěné reportéry:

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

Základní abstraktní reportéry:

1. BaseReporter

Rozhraní reportérů:

1. Reporter