0Pricing
TypeScript Academy · Lektion

Typisierung von Tests und Mocks; expectTypeOf

Verwenden Sie expectTypeOf für statische Prüfungen und typsichere Mocks in Vitest/Jest, um fragile Tests zu vermeiden.

Typisierung von Tests und Mocks; expectTypeOf ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Einführung

Ziel: Prüfen Sie Typen mit expectTypeOf und schreiben Sie typsichere Mocks, damit Refactorings nicht unbemerkt Tests beschädigen.

Grundlagen von expectTypeOf

expectTypeOf prüft Typen zur Compile-Zeit in Vitest. Das verursacht keine Kosten zur Laufzeit, erkennt aber Inkonsistenzen frühzeitig.

// Vitest provides expectTypeOf
import { expectTypeOf } from "vitest";

function fullName(first: string, last: string) {
  return `${first} ${last}`
}

// static checks (compile-time)
expectTypeOf(fullName).toBeFunction()
expectTypeOf(fullName("Ada","Lovelace")).toBeString()

Erweiterte Assertions

Nützliche Muster: Rückgabetypen mit Awaited<ReturnType<...>> auflösen sowie Literal- und Union-Vergleiche.

import { expectTypeOf } from "vitest";

interface User { id: number; name: string }
function getUser(): Promise<User> { return Promise.resolve({ id:1, name:"A" }) }

// unwrap Promise
type Resolved = Awaited<ReturnType<typeof getUser>>
expectTypeOf<Resolved>().toMatchTypeOf<User>()

// literal + union
const status = "ok" as const
expectTypeOf(status).toEqualTypeOf<"ok">()

Vitest-Mocks

Typisieren Sie den Mock korrekt, indem Sie eine Signatur für vi.fn bereitstellen. Falsche Argumente werden beim Kompilieren erkannt.

import { vi, describe, it, expect } from "vitest";

function fetchUser(id: number): Promise<string> {
  return Promise.resolve(`user-${id}`)
}

// typed mock
const mockFetch: ReturnType<typeof vi.fn<[(id: number), Promise<string>]>> = vi.fn(async (id: number) => `user-${id}`)

it("uses typed mock", async () => {
  const name = await mockFetch(5)
  expect(name).toBe("user-5")
  // mockFetch("x") // TS error: id must be number
})

Jest-Mocks

Erzwingen Sie in Jest die Aufrufsignatur, indem Sie jest.fn<Signature>(); schreiben. Präzisieren Sie den Mock-Typ mit MockedFunction.

import { jest } from "@jest/globals";

function times(a: number, b: number) { return a * b }

const mul = jest.fn<(a:number,b:number)=>number>((a,b)=>a*b)

mul(2,3) // ok
// mul("2",3) // TS error

// MockedFunction utility
type MulMock = jest.MockedFunction<typeof mul>
const _check: MulMock = mul

Tipps

Trennen Sie die Validierung von Werten (zur Laufzeit) von der Typvalidierung (zur Compile-Zeit); dies sind unterschiedliche Ebenen.

// value assertions
import { expect } from "vitest";
expect(2 + 3).toBe(5)

// type assertions (compile-time)
import { expectTypeOf } from "vitest";
expectTypeOf(2 + 3).toBeNumber()

// don't confuse with runtime validators like zod

Frage

Kurztest: Was prüft expectTypeOf während der Ausführung eines Tests?

Zusammenfassung

Zusammenfassung: expectTypeOf – Typgarantie zur Compile-Zeit; vi.fn/jest.fn – typsichere Mocks mit Signatur.

Häufig gestellte Fragen

Ist die Lektion „Typisierung von Tests und Mocks; expectTypeOf“ kostenlos?

Ja — der vollständige Text von „Typisierung von Tests und Mocks; expectTypeOf“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Typisierung von Tests und Mocks; expectTypeOf“?

Verwenden Sie expectTypeOf für statische Prüfungen und typsichere Mocks in Vitest/Jest, um fragile Tests zu vermeiden. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Typisierung von Tests und Mocks; expectTypeOf“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Vitest-/Jest-Einrichtung für TS
  2. Typisierung von Tests und Mocks; expectTypeOf
  3. Einblicke in die E2E-Typisierung (Playwright/Cypress)
← Zurück zu TypeScript Academy