Jelentők

WARNING

Ez egy haladó API. Ha csak a beépített jelentőket szeretné konfigurálni, olvassa el a "Jelentők" útmutatót.

A Vitest saját tesztfuttatási életciklussal rendelkezik. Ezeket a jelentő (reporter) metódusai képviselik:

• onInit
• onTestRunStart
  • onTestModuleQueued
  • onTestModuleCollected
  • onTestModuleStart
    • onTestSuiteReady
      • onHookStart(beforeAll)
      • onHookEnd(beforeAll)
        • onTestCaseReady
          • onTestAnnotate 3.2.0+
          • onHookStart(beforeEach)
          • onHookEnd(beforeEach)
          • onHookStart(afterEach)
          • onHookEnd(afterEach)
        • onTestCaseResult
      • onHookStart(afterAll)
      • onHookEnd(afterAll)
    • onTestSuiteResult
  • onTestModuleEnd
• onTestRunEnd

Egy modulon belüli tesztek és tesztcsomagok sorrendben kerülnek jelentésre, kivéve, ha kihagyták őket. Minden kihagyott teszt a tesztcsomag/modul végén kerül jelentésre.

Ne feledje, hogy mivel a tesztmodulok párhuzamosan futhatnak, a Vitest párhuzamosan fogja őket jelenteni.

Ez az útmutató felsorolja az összes támogatott jelentő metódust. Azonban ne feledje, hogy ahelyett, hogy saját jelentőt hozna létre, kiterjesztheti a meglévőt is:

import { BaseReporter } from 'vitest/reporters';

export default class CustomReporter extends BaseReporter {
  onTestRunEnd(testModules, errors) {
    console.log(testModules.length, 'tests finished running');
    super.onTestRunEnd(testModules, errors);
  }
}

onInit

function onInit(vitest: Vitest): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor a Vitest inicializálódott vagy elindult, de még a tesztek szűrése előtt.

INFO

Belsőleg ez a metódus a vitest.start, vitest.init vagy vitest.mergeReports metódusokon belül hívódik meg. Ha programozott API-t használ, győződjön meg róla, hogy az igényeinek megfelelően hívja meg valamelyiket, mielőtt például a vitest.runTestSpecifications metódust hívná. A beépített CLI mindig a megfelelő sorrendben fogja futtatni a metódusokat.

Ne feledje, hogy a vitest példányhoz a tesztesetekből, tesztcsomagokból és tesztmodulokból is hozzáférhet a project tulajdonságon keresztül, de hasznos lehet a vitest referenciáját ebben a metódusban tárolni.

Példa

import type { Reporter, TestSpecification, Vitest } from 'vitest/node';

class MyReporter implements Reporter {
  private vitest!: Vitest;

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

  onTestRunStart(specifications: TestSpecification[]) {
    console.log(
      specifications.length,
      'test files will run in',
      this.vitest.config.root
    );
  }
}

export default new MyReporter();

onBrowserInit kísérleti

function onBrowserInit(project: TestProject): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor a böngésző példány inicializálódik. Megkapja annak a projektnek a példányát, amelyhez a böngésző inicializálódott. A project.browser mindig definiálva lesz, amikor ez a metódus meghívásra kerül.

onTestRunStart

function onTestRunStart(specifications: TestSpecification[]): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor egy új tesztfuttatás elindult. Egy tömböt kap a futtatásra ütemezett teszt specifikációkról. Ez a tömb csak olvasható és csak információs célokra használható.

Ha a Vitest nem talált futtatandó tesztfájlokat, ez az esemény egy üres tömbbel hívódik meg, majd azonnal utána meghívódik az onTestRunEnd.

Példa

import type { Reporter, TestSpecification } from 'vitest/node';

class MyReporter implements Reporter {
  onTestRunStart(specifications: TestSpecification[]) {
    console.log(specifications.length, 'test files will run');
  }
}

export default new MyReporter();

ELAVULÁSI ÉRTESÍTÉS

Ez a metódus a Vitest 3-ban került hozzáadásra, felváltva az onPathsCollected és onSpecsCollected metódusokat, amelyek most már elavultak.

onTestRunEnd

function onTestRunEnd(
  testModules: ReadonlyArray<TestModule>,
  unhandledErrors: ReadonlyArray<SerializedError>,
  reason: TestRunEndReason
): Awaitable<void>;

Ez a metódus akkor hívódik meg, miután az összes teszt befejezte a futását, és a lefedettség egyesítette az összes jelentést, ha engedélyezve van. Ne feledje, hogy a lefedettségi információkat az onCoverage hookban kaphatja meg.

Egy csak olvasható listát kap a tesztmodulokról. A testModule.children tulajdonságon keresztül iterálhat rajta az állapot és az esetleges hibák jelentéséhez.

A második argumentum egy csak olvasható lista a kezeletlen hibákról, amelyeket a Vitest nem tudott egyetlen teszthez sem hozzárendelni. Ezek a tesztfuttatáson kívül is előfordulhatnak egy plugin hibája miatt, vagy a tesztfuttatáson belül egy nem várt függvény mellékhatásaként (például egy időtúllépés, amely hibát dobott, miután a teszt befejezte a futását).

A harmadik argumentum azt jelzi, hogy miért fejeződött be a tesztfuttatás:

• passed: a tesztfuttatás normálisan befejeződött, és nincsenek hibák
• failed: a tesztfuttatásnak legalább egy hibája van (gyűjtés közbeni szintaktikai hiba vagy tényleges hiba a teszt végrehajtása során)
• interrupted: a tesztet megszakította a vitest.cancelCurrentRun hívás, vagy a Ctrl+C billentyűt nyomták meg a terminálban (vegye figyelembe, hogy ebben az esetben is lehetnek sikertelen tesztek)

Ha a Vitest nem talált futtatandó tesztfájlokat, ez az esemény üres modul- és hibatömbökkel hívódik meg, és az állapot a config.passWithNoTests értékétől függ.

Példa

import type {
  Reporter,
  SerializedError,
  TestModule,
  TestRunEndReason,
  TestSpecification,
} from 'vitest/node';

class MyReporter implements Reporter {
  onTestRunEnd(
    testModules: ReadonlyArray<TestModule>,
    unhandledErrors: ReadonlyArray<SerializedError>,
    reason: TestRunEndReason
  ) {
    if (reason === 'passed') {
      testModules.forEach(module => console.log(module.moduleId, 'succeeded'));
    } else if (reason === 'failed') {
      // vegye figyelembe, hogy ez kihagyhatja a tesztcsomagokban előforduló esetleges hibákat
      // ezeket a testSuite.errors() metódusból kaphatja meg
      for (const testCase of testModules.children.allTests()) {
        if (testCase.result().state === 'failed') {
          console.log(
            testCase.fullName,
            'in',
            testCase.module.moduleId,
            'failed'
          );
          console.log(testCase.result().errors);
        }
      }
    } else {
      console.log('test run was interrupted, skipping report');
    }
  }
}

export default new MyReporter();

ELAVULÁSI ÉRTESÍTÉS

Ez a metódus a Vitest 3-ban került hozzáadásra, felváltva az onFinished metódust, amely most már elavult.

onCoverage

function onCoverage(coverage: unknown): Awaitable<void>;

Ez a hook akkor hívódik meg, miután a lefedettségi eredmények feldolgozásra kerültek. A lefedettségi szolgáltató jelentői ezen hook után hívódnak meg. A coverage típusai a coverage.provider-től függenek. A Vitest alapértelmezett beépített szolgáltatóihoz az istanbul-lib-coverage csomagból importálhatja a típusokat:

import type { CoverageMap } from 'istanbul-lib-coverage';

declare function onCoverage(coverage: CoverageMap): Awaitable<void>;

Ha a Vitest nem végzett lefedettséget, ez a hook nem hívódik meg.

onTestModuleQueued

function onTestModuleQueued(testModule: TestModule): Awaitable<void>;

Ez a metódus közvetlenül azelőtt hívódik meg, hogy a Vitest importálná a beállítási fájlt és magát a tesztmodult. Ez azt jelenti, hogy a testModule-nek még nem lesznek children elemei, de elkezdheti jelenteni, mint a következő futtatásra kerülő tesztet.

onTestModuleCollected

function onTestModuleCollected(testModule: TestModule): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor a fájlban lévő összes teszt összegyűjtésre került, ami azt jelenti, hogy a testModule.children gyűjtemény feltöltésre került, de a teszteknek még nincsenek eredményei.

onTestModuleStart

function onTestModuleStart(testModule: TestModule): Awaitable<void>;

Ez a metódus közvetlenül az onTestModuleCollected után hívódik meg, kivéve, ha a Vitest gyűjtési módban fut (vitest.collect() vagy vitest collect a CLI-ben), ebben az esetben egyáltalán nem hívódik meg, mert nincsenek futtatandó tesztek.

onTestModuleEnd

function onTestModuleEnd(testModule: TestModule): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor a modulban minden teszt befejezte a futását. Ez azt jelenti, hogy a testModule.children minden tesztjének lesz egy test.result() értéke, amely nem pending állapotú.

onHookStart

function onHookStart(context: ReportedHookContext): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor az alábbi hookok bármelyike elkezdett futni:

• beforeAll
• afterAll
• beforeEach
• afterEach

Ha a beforeAll vagy afterAll elindult, az entity akár TestSuite akár TestModule lesz.

Ha a beforeEach vagy afterEach elindult, az entity mindig TestCase lesz.

WARNING

Az onHookStart metódus nem hívódik meg, ha a hook nem futott a tesztfuttatás során.

onHookEnd

function onHookEnd(context: ReportedHookContext): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor az alábbi hookok bármelyike befejezte a futását:

• beforeAll
• afterAll
• beforeEach
• afterEach

Ha a beforeAll vagy afterAll befejeződött, az entity akár TestSuite akár TestModule lesz.

Ha a beforeEach vagy afterEach befejeződött, az entity mindig TestCase lesz.

WARNING

Az onHookEnd metódus nem hívódik meg, ha a hook nem futott a tesztfuttatás során.

onTestSuiteReady

function onTestSuiteReady(testSuite: TestSuite): Awaitable<void>;

Ez a metódus azelőtt hívódik meg, hogy a tesztcsomag elkezdené futtatni a tesztjeit. Ez a metódus akkor is hívódik, ha a tesztcsomagot átugrották.

Ha a fájlnak nincsenek tesztcsomagjai, ez a metódus nem hívódik meg. Fontolja meg az onTestModuleStart használatát ennek az esetnek a lefedésére.

onTestSuiteResult

function onTestSuiteResult(testSuite: TestSuite): Awaitable<void>;

Ez a metódus azután hívódik meg, hogy a tesztcsomag befejezte a tesztek futtatását. Ez a metódus akkor is hívódik, ha a tesztcsomagot átugrották.

Ha a fájlnak nincsenek tesztcsomagjai, ez a metódus nem hívódik meg. Fontolja meg az onTestModuleEnd használatát ennek az esetnek a lefedésére.

onTestCaseReady

function onTestCaseReady(testCase: TestCase): Awaitable<void>;

Ez a metódus azelőtt hívódik meg, hogy a teszt elkezdene futni, vagy ha átugrották. Ne feledje, hogy a beforeEach és afterEach hookok a teszt részének tekintendők, mert befolyásolhatják az eredményt.

WARNING

Vegye figyelembe, hogy lehetséges, hogy a testCase.result() már passed vagy failed állapotban van, amikor az onTestCaseReady meghívásra kerül. Ez akkor fordulhat elő, ha a teszt túl gyorsan futott, és az onTestCaseReady és az onTestCaseResult is ugyanabban a mikrotaszkban került ütemezésre.

onTestCaseResult

function onTestCaseResult(testCase: TestCase): Awaitable<void>;

Ez a metódus akkor hívódik meg, amikor a teszt befejezte a futását, vagy ha csak átugrották. Ne feledje, hogy ez az afterEach hook befejezése után hívódik meg, ha van ilyen.

Ezen a ponton a testCase.result() nem pending állapotú lesz.

onTestAnnotate 3.2.0+

function onTestAnnotate(
  testCase: TestCase,
  annotation: TestAnnotation
): Awaitable<void>;

Az onTestAnnotate hook a context.annotate metódushoz kapcsolódik. Amikor az annotate meghívásra kerül, a Vitest szerializálja azt, és ugyanazt a mellékletet küldi a fő szálnak, ahol a jelentő kezelheti.

Ha az útvonal meg van adva, a Vitest egy külön könyvtárban tárolja (a attachmentsDir által konfigurálva), és módosítja az path tulajdonságot, hogy arra mutasson.