Praktische Hinweise: Node’s Native Test Runner gegen Jest gegen Vitest – Ein Suite, Drei

Nutzen Sie dies als für Operator zugängliche Neuformulierung der Ideen aus „Node’s Native Test Runner vs Jest vs Vitest: One Suite, Three Runners, Real Timings“: klare Phasen, geordnete Codeabschnitte sowie Wiederherstellungshinweise, die auch bei Übergaben erhalten bleiben. Die Überblicksphase funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie die Notizen zur Rücksetzung. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Ehrlich gesagt: die drei Testläufer

Für die drei Ausführungsstufen sollten vor dem Ändern des Codes ehrlich gesagt die Eingabedaten, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erfassen Sie die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Legen Sie den Zustand zusammen mit dem Komponenten ab, der die Mutation verantwortet. Wenn alles in einem globalen Speicher gespeichert wird, fällt es schwerer, Fehler bezüglich der Laufzeiten zu erkennen.

1. node:test, die langweilige, aber funktionierende Wahl

Für den Test mit 1 Node sollten Sie vor dem Ändern des Codes die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den die Operator überprüfen können, ohne den gesamten Ablaufverlauf durchlesen zu müssen. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Mutation verantwortet. Wenn alles in einem globalen Speicher abgelegt wird, fällt es schwerer, Zeitprobleme zu erkennen.

// node-test/test/string-utils.test.js
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { slugify } from '../../src/string-utils.js';

describe('slugify', () => {
  it('converts a basic sentence', () => {
    assert.equal(slugify('Hello World'), 'hello-world');
  });

  it('strips diacritics', () => {
    assert.equal(slugify('Café résumé'), 'cafe-resume');
  });

  it('throws TypeError on non-string input', () => {
    assert.throws(() => slugify(123), TypeError);
  });
});

# Run it, no install step
node --test node-test/test/*.test.js

# Watch mode
node --test --watch node-test/test/*.test.js
# Coverage (still experimental, but the numbers are real V8 counts)
node --test --experimental-test-coverage \
  --test-coverage-include='src/**/*.js' \
  node-test/test/*.test.js

2. Jest – die Standardlösung, die Sie bereits verwenden

Für die Standardphase von 2 Jest sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Änderung verantwortet. Das Hochladen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen. Für die Standardphase von 2 Jest sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

// jest/test/string-utils.test.js
import { slugify } from '../../src/string-utils.js';

describe('slugify', () => {
  it('converts a basic sentence', () => {
    expect(slugify('Hello World')).toBe('hello-world');
  });

  it('strips diacritics', () => {
    expect(slugify('Café résumé')).toBe('cafe-resume');
  });

  it('throws TypeError on non-string input', () => {
    expect(() => slugify(123)).toThrow(TypeError);
  });
});

// jest/jest.config.js, minimal. Run it with NODE_OPTIONS=--experimental-vm-modules
export default {
  rootDir: '.',
  testMatch: ['<rootDir>/test/**/*.test.js'],
  testEnvironment: 'node',
  verbose: true,
};

# Run (the flag is required for native ESM)
NODE_OPTIONS=--experimental-vm-modules npx jest --config jest/jest.config.js
# Watch
NODE_OPTIONS=--experimental-vm-modules npx jest --config jest/jest.config.js --watch

3. Vitest – die neue Standardlösung mit einem Kompromiss

Beim Arbeiten mit der neuen Phase von 3 Vitest sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Betrachten Sie Auswirkungen als Synchronisierung mit der Außenwelt und nicht als Ersatz für berechnete Werte während der Darstellung.

// vitest/test/string-utils.test.js
import { describe, it, expect } from 'vitest';
import { slugify } from '../../src/string-utils.js';

describe('slugify', () => {
  it('converts a basic sentence', () => {
    expect(slugify('Hello World')).toBe('hello-world');
  });

  it('strips diacritics', () => {
    expect(slugify('Café résumé')).toBe('cafe-resume');
  });

  it('throws TypeError on non-string input', () => {
    expect(() => slugify(123)).toThrow(TypeError);
  });
});

// vitest/vitest.config.mjs
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    include: ['test/**/*.test.js'],
    environment: 'node',
    coverage: { provider: 'v8', include: ['../src/**/*.js'] },
  },
});

# Run
cd vitest && npx vitest run
# Watch (this is the killer feature)
cd vitest && npx vitest
# Coverage
cd vitest && npx vitest run --coverage

Die Methodik – damit Sie BS nennen können

Wenn Sie die Methodik durchgehen, um den Ablauf zu planen, schreiben Sie zunächst den Vertrag auf: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems prüfen können. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt und nicht als Ersatz für berechnete Werte während der Darstellung.

# Reproduce on your own machine
git clone https://github.com/manisuec/techinsights-tutorials
cd techinsights-tutorials/nodejs-test-runner
npm install
bash shared/bench.sh 5      # cold runs
WARM=1 bash shared/bench.sh 5   # warm runs

Die tatsächlichen Zahlen

Beim Arbeiten an der Phase „Reelle Zahlen“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Betrachten Sie Auswirkungen als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung. Beim Arbeiten an der Phase „Reelle Zahlen“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgsprüfungen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab.

=== node:test  (Node v24.14.0) [cold] ===
  run 1: 91 ms
  run 2: 93 ms
  run 3: 89 ms
  run 4: 90 ms
  run 5: 90 ms
  median: 90 ms

=== Jest  (30.4.1) [cold] ===
  run 1: 817 ms
  run 2: 689 ms
  run 3: 718 ms
  run 4: 711 ms
  run 5: 685 ms
  median: 711 ms

=== Vitest  (4.1.11) [cold] ===
  run 1: 548 ms
  run 2: 648 ms
  run 3: 534 ms
  run 4: 531 ms
  run 5: 535 ms
  median: 535 ms

Funktionsmatrix, 2026, zuletzt überprüft

Die Feature-Matrix der letzten Phase für 2026 funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie die Rollback-Anmerkung, bevor Sie den Umfang erweitern. Notieren Sie die Zeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo in gemeinsame Umgebungen wechselt. Halten Sie die Render-Arbeiten kostengünstig und verschieben Sie aufwändige Ableitungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Eigenschaften verbergen.

Wann welches wählen?

Um zu bestimmen, welche Phase am besten geeignet ist, sollte man sie als messbare Größe betrachten. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den Betreuer ohne das Durchlesen des gesamten Systems überprüfen können. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Anwendung von Memoisierung kann fehlerhafte Props verbergen.

Von Jest zu Vitest in 30 Minuten migrieren

Der Umstieg von Jest auf Stage funktioniert am besten, wenn er als messbarer Bereich betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Halten Sie die Render-Arbeiten kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung. Eine vorzeitige Memoisierung kann Fehler mit veralteten Eigenschaften verbergen. Der Umstieg von Jest auf Stage funktioniert am besten, wenn er als messbarer Bereich betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

# 1. Install
npm install -D vitest

# 2. Add a config (or piggyback on vite.config.ts if you have one)
# vitest.config.ts

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    globals: true,                 // makes describe/it/expect global
    environment: 'jsdom',          // or 'node' for backend
    setupFiles: ['./tests/setup.ts'],
  },
});

# 3. Swap imports, find/replace in your editor
#    jest.mock  → vi.mock
#    jest.fn    → vi.fn
#    jest.spyOn → vi.spyOn
#    require('@jest/globals') → require('vitest')
#    jest.useFakeTimers()      → vi.useFakeTimers()

# 4. Swap npm scripts
#    "test": "jest"  →  "test": "vitest run"
#    "test:watch": "jest --watch"  →  "test:watch": "vitest"

# 5. If you used babel-jest, delete it and babel.config.js

# 6. Run. Fix the 3-5 things that fail. Drink coffee.

Was Sie nicht tun sollten

Für das, was man nicht inszenieren würde, sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erfassen Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Legen Sie den Zustand zusammen mit dem Komponenten ab, der die Mutation verantwortet. Das Hinzufügen aller Daten zu einem globalen Speicher erschwert es, Timing-Fehler zu erkennen.

Das Urteil

Zur Entscheidungsphase sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchzulesen. Der Zustand sollte zusammen mit dem Komponenten gespeichert werden, der für die Mutation verantwortlich ist. Das Zusammenfassen aller Daten in einem globalen Speicher erschwert es, Zeitprobleme zu erkennen.

Anhang: Wie man die Zahlen in diesem Beitrag liest

Für das Anhangstextteil: Definieren Sie vor dem Codeändern, wie die Phase gelesen wird, welche Eingaben erforderlich sind, wer für den Schritt verantwortlich ist und welche Abbruchkriterien gelten. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Platzieren Sie den Zustand zusammen mit der Komponente, die für die Änderung verantwortlich ist. Das Hinzufügen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen. Für das Anhangstextteil: Definieren Sie vor dem Codeändern, wie die Phase gelesen wird, welche Eingaben erforderlich sind, wer für den Schritt verantwortlich ist und welche Abbruchkriterien gelten. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Betriebskontrollliste

Während der Bearbeitung der Betriebskontrollliste sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Liste sorgt dafür, dass spätere Codeänderungen transparent bleiben.

Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema.

Betrachten Sie Auswirkungen als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung.

Festlegen Sie die Versionen der Abhängigkeiten und notieren Sie den Bilddigest, mit dem die Demo ausgeführt wurde. Reproduzierbarkeit ist besser als „stammesweises Wissen“.

Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Erzeugnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Betrachten Sie Effekte als Synchronisierung mit der Außenwelt und nicht als Ersatz für berechnete Werte während der Renderung.

Vor dem Erweitern des Stacks sollten Versionen eingefroren werden, ein „goldener Transkript“ für den kritischen Pfad erstellt sowie Rollback-Schritte bestätigt werden. In gemeinsam genutzten Umgebungen sind Rate Limits, Überprüfungen der Nutzerrechte sowie ein klarer Verantwortliche für die Rotation von Geheimnissen erforderlich. Wählen Sie langweilige Zuverlässigkeit statt cleverer, einmaliger Demonstrationen.

Batch-Hinweis für b78b143fb7a9: Halten Sie Provider-Schlüssel außerhalb des Repositories, legen Sie eine Obergrenze für Session-Tokens fest und speichern Sie Transkripte neben den Eval-Fixtures, damit spätere Modellwechsel vergleichbar bleiben.