1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import { expectTypeOf, assertType, test } from "vitest";

test("pick 的类型", () => {
  const result = pick({ a: 1, b: "x" }, ["a"]);

  // 精确相等（最严格）
  expectTypeOf(result).toEqualTypeOf<{ a: number }>();

  // 可赋值性（较宽松）
  expectTypeOf(result).toMatchTypeOf<{ a: number }>();

  // 属性级断言
  expectTypeOf(result.a).toBeNumber();
  expectTypeOf(result).toHaveProperty("a");

  // 函数签名
  expectTypeOf(pick).parameters.toEqualTypeOf<[object, string[]]>();
  expectTypeOf(pick).returns.toEqualTypeOf<object>();
});

test("assertType 简写", () => {
  const n = 1;
  assertType<number>(n);       // ✅
  // assertType<string>(n);    // ❌ 编译失败
});

1
2
3
4
5
6
7
8

// 测「不能赋值」也要覆盖
test("错误用法应当编译失败", () => {
  // @ts-expect-error 键不存在
  pick({ a: 1 }, ["typo"]);

  // @ts-expect-error 参数类型不对
  pick({ a: 1 }, [1]);
});

1
2

npx vitest --typecheck          # 跑类型测试
npx vitest --typecheck.only     # 只跑类型测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// vitest.config.ts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    typecheck: {
      enabled: true,
      include: ["**/*.test-d.ts"],   // 类型测试单独命名
    },
  },
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// test-d/index.test-d.ts
import { expectType, expectError, expectAssignable } from "tsd";
import { pick } from "../src/index.js";

// 精确返回类型
expectType<{ a: number }>(pick({ a: 1, b: 2 }, ["a"]));

// 可赋值
expectAssignable<{ a: number }>(pick({ a: 1 }, ["a"]));

// 断言某个用法应当报错
expectError(pick({ a: 1 }, ["nope"]));

// 测泛型推断位置
expectType<number>(pick({ a: 1 }, ["a"]).a);

1
2
3
4
5

// package.json
{
  "scripts": { "test:types": "tsd" },
  "tsd": { "directory": "test-d" }
}

1
2
3
4

import { expectTypeOf } from "expect-type";

expectTypeOf<{ a: number }>().toEqualTypeOf<{ a: number }>();
expectTypeOf(pick({ a: 1 }, ["a"])).toEqualTypeOf<{ a: number }>();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 类型相等判断
type Eq<A, B> =
  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
    ? true
    : false;

// 编译期断言：只有为 true 才通过
type Expect<T extends true> = T;

// 用法
type _1 = Expect<Eq<ReturnType<typeof pick<{ a: number }, "a">>, { a: number }>>;
// ✅ 编译通过

type _2 = Expect<Eq<ReturnType<typeof pick<{ a: number }, "a">>, { a?: number }>>;
// ❌ TS2344: Type 'false' does not satisfy the constraint 'true'.

1
2

// ❌ 报 Cannot find name 'describe'
describe("x", () => { it("y", () => {}); });

1
2

// ✅ Vitest 开 globals 的配置
{ "compilerOptions": { "types": ["vitest/globals"] } }

1
2

// ✅ 更推荐：显式导入，不依赖全局
import { describe, it, expect, vi } from "vitest";

1
2

// ✅ Jest 的显式导入形式
import { describe, it, expect, jest } from "@jest/globals";

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// ✅ node:test（Node 内置，无需框架）
import { test, describe, it, before, beforeEach, mock } from "node:test";
import assert from "node:assert/strict";

describe("suite", () => {
  beforeEach(() => { /* 准备 */ });

  it("基本断言", () => {
    assert.equal(1 + 1, 2);
  });

  test("mock 用法", () => {
    const fn = mock.fn((x: number) => x * 2);
    fn(2);
    assert.equal(fn.mock.callCount(), 1);
    assert.equal(fn.mock.calls[0]?.arguments[0], 2);   // ⚠️ 注意 ?. 
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Playwright：类型从 @playwright/test 显式导入
import { test, expect, type Page } from "@playwright/test";

test("登录流程", async ({ page }) => {
  await page.goto("/login");
  await page.getByLabel("邮箱").fill("a@b.c");
  await page.getByRole("button", { name: "登录" }).click();

  await expect(page.getByRole("heading")).toHaveText("欢迎");
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import { type Page, type Locator, expect } from "@playwright/test";

export class LoginPage {
  readonly email: Locator;
  readonly password: Locator;
  readonly submit: Locator;

  constructor(private readonly page: Page) {
    this.email = page.getByLabel("邮箱");
    this.password = page.getByLabel("密码");
    this.submit = page.getByRole("button", { name: "登录" });
  }

  async login(email: string, password: string): Promise<void> {
    await this.email.fill(email);
    await this.password.fill(password);
    await this.submit.click();
  }

  async expectError(msg: string): Promise<void> {
    await expect(this.page.getByRole("alert")).toHaveText(msg);
  }
}

1
2
3
4
5
6
7
8
9

export class LoginPage {
  readonly email: Locator;
  private readonly page: Page;

  constructor(page: Page) {
    this.page = page;
    this.email = page.getByLabel("邮箱");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import { vi, expect, test } from "vitest";

test("部分 mock", () => {
  const logger = {
    info: vi.fn(),
    error: vi.fn(),
    debug: (msg: string) => console.debug(msg),   // 保留真实实现
  };

  doWork(logger);

  expect(logger.info).toHaveBeenCalled();
  expect(logger.error).not.toHaveBeenCalled();
});

1
2
3
4
5
6
7
8

import { vi, expect, test, afterEach } from "vitest";

test("spy 会调用真实实现", () => {
  const spy = vi.spyOn(console, "warn").mockImplementation(() => {});   // 静音
  riskyOperation();
  expect(spy).toHaveBeenCalledWith(expect.stringContaining("deprecated"));
  spy.mockRestore();      // ✅ 必须还原！
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import { expect, test } from "vitest";

interface Logger {
  info(msg: string): void;
  error(msg: string, err?: unknown): void;
}

test("部分 mock 的对象", () => {
  // ✅ satisfies 保证 mock 对象符合接口，同时保留 mock 的具体类型
  const logger = {
    info: vi.fn(),
    error: vi.fn(),
  } satisfies Logger;

  doWork(logger);

  expect(logger.info).toHaveBeenCalledWith("started");
  // logger.info 仍是 Mock 类型，有 toHaveBeenCalledWith ✅
});

1
2
3
4

// 🛑 常见但危险：mock 与真实类型脱节，接口改了测试还能过
const mockRepo = {
  findById: vi.fn().mockResolvedValue({ id: 1 } as any),
} as any as Repository;

1
2
3
4
5
6
7

// ✅ 方案 1：satisfies + 明确返回值类型
import { vi } from "vitest";

const mockRepo = {
  findById: vi.fn(async (id: string): Promise<User | null> => ({ id, name: "a", email: "a@b.c" })),
  save: vi.fn(async (u: User): Promise<void> => {}),
} satisfies Repository;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ✅ 方案 2：用测试数据工厂，保证数据符合类型
function makeUser(overrides: Partial<User> = {}): User {
  return {
    id: 1,
    name: "测试用户",
    email: "test@example.com",
    ...overrides,     // ✅ 覆盖也是类型安全的
  };
}

const u = makeUser({ name: "自定义" });      // ✅
const bad = makeUser({ nmae: "拼错" });      // ❌ TS2353: 拼写错误被抓到

1
2
3
4
5
6
7
8

// ✅ 方案 3：只 mock 用到的部分，用 unknown 过渡而不是 any
function fakeResponse<T>(data: T): Response {
  return {
    ok: true,
    status: 200,
    json: async () => data,
  } as unknown as Response;      // ⚠️ 这里仍需要断言，但被限制在一个地方
}