测试与类型测试

import { test, describe, before, after, mock } from "node:test";
import { strict as assert } from "node:assert";
 
describe("加法", () => {
  before(() => console.log("准备"));
  after(() => console.log("清理"));
 
  test("正数相加", () => {
    assert.equal(1 + 2, 3);
  });
 
  test("处理浮点误差", () => {
    assert.ok(Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON);
  });
 
  test("异步", async () => {
    const v = await Promise.resolve(7);
    assert.equal(v, 7);
  });
});

# Node 22.6+ 可以直接跑 .ts 文件
node --experimental-transform-types --test "src/**/*.test.ts"
 
# 或者先编译再跑
tsc && node --test dist/

import { strict as assert } from "node:assert";
 
type TestCase = { name: string; fn: () => void | Promise<void> };
 
const suite: TestCase[] = [];
 
function it(name: string, fn: () => void | Promise<void>): void {
  suite.push({ name, fn });
}
 
async function run(): Promise<void> {
  let pass = 0;
  let fail = 0;
  for (const t of suite) {
    try {
      await t.fn();
      pass += 1;
      console.log("  ok   " + t.name);
    } catch (e) {
      fail += 1;
      const msg = e instanceof Error ? e.message : String(e);
      console.log("  FAIL " + t.name);
      console.log("       " + msg);
    }
  }
  console.log("结果: 通过 " + pass + " 条，失败 " + fail + " 条");
}
 
// ---- 被测代码 ----
function slugify(input: string): string {
  return input.trim().toLowerCase().split(" ").filter(Boolean).join("-");
}
 
function chunk<T>(items: readonly T[], size: number): T[][] {
  if (size <= 0) throw new RangeError("size 必须为正数");
  const out: T[][] = [];
  for (let i = 0; i < items.length; i += size) {
    out.push(items.slice(i, i + size));
  }
  return out;
}
 
// ---- 测试用例 ----
it("slugify 基本用法", () => {
  assert.equal(slugify("Hello TypeScript World"), "hello-typescript-world");
});
 
it("slugify 去掉多余空格", () => {
  assert.equal(slugify("  a   b  "), "a-b");
});
 
it("chunk 正常切分", () => {
  assert.deepEqual(chunk([1, 2, 3, 4, 5], 2), [[1, 2], [3, 4], [5]]);
});
 
it("chunk 非法 size 抛错", () => {
  assert.throws(() => chunk([1], 0), RangeError);
});
 
it("故意失败的用例", () => {
  assert.equal(slugify("A B"), "a_b");
});
 
it("异步用例", async () => {
  const v = await Promise.resolve(21);
  assert.equal(v * 2, 42);
});
 
void run();

type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 
type Expect<T extends true> = T;

// @ts-expect-error 参数类型不匹配
add("1", 2);

// 严格相等判定
type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 
type Expect<T extends true> = T;
type ExpectFalse<T extends false> = T;
 
// ---- 被测的类型工具 ----
type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
type Head<T extends readonly unknown[]> = T extends readonly [infer H, ...unknown[]] ? H : never;
 
// ---- 类型断言集合 ----
type Cases = [
  Expect<Equal<Head<[1, 2, 3]>, 1>>,
  Expect<Equal<Head<[]>, never>>,
  Expect<Equal<DeepPartial<{ a: number; b: string }>, { a?: number; b?: string }>>,
  Expect<Equal<Awaited<Promise<Promise<string>>>, string>>,
  Expect<Equal<Capitalize<"ab">, "Ab">>,
  ExpectFalse<Equal<string, "a">>,
  // Equal 能区分 any 与 unknown，简单的 extends 做不到
  ExpectFalse<Equal<unknown, string>>,
];
 
// 只要上面任何一行不成立，这里就编译不过
const cases: Cases = [true, true, true, true, true, false, false];
console.log("类型测试全部通过，共 " + cases.length + " 条");
 
// ---- 运行时侧：验证「该报错的确实报错」----
function add(a: number, b: number): number {
  return a + b;
}
 
// @ts-expect-error 字符串不能作为 number 参数
const wrong = add("1", 2);
console.log("虽然类型错误被断言，运行时仍会执行:", wrong);
console.log("正确调用:", add(1, 2));
 
// 检验函数签名的推导
function identity<T>(v: T): T {
  return v;
}
type IdReturn = ReturnType<typeof identity<string>>;
const idCheck: Expect<Equal<IdReturn, string>> = true;
console.log("identity 返回类型断言:", idCheck);

- run: npm ci
- run: npx tsc --noEmit          # 类型检查（含类型测试）
- run: npx eslint .              # 代码规范
- run: node --test --experimental-transform-types "src/**/*.test.ts"
- run: npm run build