0Pricing
TypeScript Academy · Aula

Tipagem de testes e mocks; expectTypeOf

Use expectTypeOf para verificações estáticas e mocks tipados com segurança em Vitest/Jest para evitar testes frágeis.

Tipagem de testes e mocks; expectTypeOf é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 3 aulas no total.

Introdução

Objetivo: verificar tipos com expectTypeOf e escrever simulações seguras quanto aos tipos para que refatorações não quebrem os testes silenciosamente.

Fundamentos de expectTypeOf

expectTypeOf verifica tipos durante a compilação no Vitest; não há custo em tempo de execução, mas as incompatibilidades são detectadas cedo.

// 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()

Verificações avançadas

Padrões úteis: resolver tipos de retorno com Awaited<ReturnType<...>> e fazer comparações entre literais e uniões.

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">()

Simulações do Vitest

Tipifique a simulação corretamente fornecendo uma assinatura para vi.fn; argumentos incorretos serão detectados durante a compilação.

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
})

Simulações do Jest

No Jest, imponha a assinatura da chamada escrevendo jest.fn<Signature>(); diferencie o tipo da simulação com 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

Dicas

Separe a validação de valores (em tempo de execução) da validação de tipos (em tempo de compilação); são camadas diferentes.

// 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

Pergunta

Verificação rápida: o que expectTypeOf verifica durante a execução de um teste?

Recapitulação

Recapitulação: expectTypeOf — garantia de tipos em tempo de compilação; vi.fn/jest.fn — simulações seguras quanto aos tipos, com uma assinatura.

Perguntas Frequentes

A aula “Tipagem de testes e mocks; expectTypeOf” é grátis?

Sim — o texto completo de “Tipagem de testes e mocks; expectTypeOf” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 3 aulas no total.

O que vou aprender em “Tipagem de testes e mocks; expectTypeOf”?

Use expectTypeOf para verificações estáticas e mocks tipados com segurança em Vitest/Jest para evitar testes frágeis. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Tipagem de testes e mocks; expectTypeOf”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configuração de Vitest/Jest para TS
  2. Tipagem de testes e mocks; expectTypeOf
  3. Vislumbres de tipagem E2E (Playwright/Cypress)
← Voltar para TypeScript Academy