Bun 测试断言 #

import { test, expect } from "bun:test";

test("toBe", () => {
  expect(1 + 1).toBe(2);
  expect("hello").toBe("hello");
  expect(true).toBe(true);
});

test("toEqual", () => {
  expect({ a: 1 }).toEqual({ a: 1 });
  expect([1, 2, 3]).toEqual([1, 2, 3]);
});

test("truthy/falsy", () => {
  expect(1).toBeTruthy();
  expect("hello").toBeTruthy();
  expect(0).toBeFalsy();
  expect("").toBeFalsy();
  expect(null).toBeFalsy();
  expect(undefined).toBeFalsy();
});

test("null/undefined", () => {
  expect(null).toBeNull();
  expect(undefined).toBeUndefined();
  expect(null).not.toBeUndefined();
  expect(undefined).not.toBeNull();
});

test("NaN", () => {
  expect(NaN).toBeNaN();
  expect(1).not.toBeNaN();
});

test("number assertions", () => {
  expect(5).toBeGreaterThan(3);
  expect(5).toBeGreaterThanOrEqual(5);
  expect(3).toBeLessThan(5);
  expect(3).toBeLessThanOrEqual(3);
  expect(0.1 + 0.2).toBeCloseTo(0.3);
});

test("string assertions", () => {
  expect("hello world").toContain("world");
  expect("hello world").toContain("hello");
  expect("hello").toHaveLength(5);
  expect("Hello World").toMatch(/world/i);
});

test("array assertions", () => {
  expect([1, 2, 3]).toContain(2);
  expect([1, 2, 3]).toHaveLength(3);
  expect([1, 2, 3]).toEqual(expect.arrayContaining([1, 2]));
});

test("object assertions", () => {
  expect({ a: 1, b: 2 }).toHaveProperty("a");
  expect({ a: 1, b: 2 }).toHaveProperty("a", 1);
  expect({ a: { b: { c: 1 } } }).toHaveProperty("a.b.c");
});

test("throws", () => {
  expect(() => {
    throw new Error("oops");
  }).toThrow();

  expect(() => {
    throw new Error("oops");
  }).toThrow("oops");

  expect(() => {
    throw new Error("oops");
  }).toThrow(Error);
});

test("not", () => {
  expect(1).not.toBe(2);
  expect(true).not.toBeFalsy();
  expect([1, 2, 3]).not.toContain(4);
});

import { expect } from "bun:test";

expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    return {
      pass,
      message: () =>
        pass
          ? `expected ${received} not to be within range ${floor}-${ceiling}`
          : `expected ${received} to be within range ${floor}-${ceiling}`,
    };
  },
});

test("custom matcher", () => {
  expect(5).toBeWithinRange(1, 10);
});