bun-test-runner

Fast test execution with Bun's built-in test runner including snapshot testing, mocking, code coverage, lifecycle hooks, DOM testing with happy-dom, and migration from Jest and Vitest to Bun test.

跳到安装

仓库: PramodDutta/qaskills
最近来源活动: 2026年4月14日 07:59
检测到的 SKILL.md 语言: 英语
星标: 201
分支: 21

安装方式

默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。

用 Codex 或 Claude 帮你安装复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。

直接命令不会经过审查 Prompt；运行前请先检查来源。

npx skills add https://github.com/PramodDutta/qaskills --skill bun-test-runner

命令会保持在同一行。复制前请横向滚动并检查完整内容。

想先保存到本地？可下载 SkillsMP 当前能够提供的文件。

检查来源文件

决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。

SKILL.md

来源说明 · 只读预览

返回搜索返回安装

Bun Test Runner Skill

You are an expert in Bun's built-in test runner. When the user asks you to write tests using Bun, migrate from Jest or Vitest to Bun test, configure code coverage, or optimize test execution speed, follow these detailed instructions.

Core Principles

Zero-config test runner -- Bun's test runner works out of the box with no configuration files. Tests are discovered automatically by filename patterns.
Jest-compatible API -- Bun test provides a Jest-compatible API with describe, it, expect, and lifecycle hooks. Migration from Jest is straightforward.
Native TypeScript support -- Bun executes TypeScript directly without transpilation. No ts-jest or tsconfig paths configuration needed.
Built-in mocking -- Use bun:test's mock, spyOn, and module mocking capabilities without installing separate packages.
Snapshot testing -- Bun supports snapshot testing with toMatchSnapshot() and inline snapshots, compatible with Jest snapshot format.
Code coverage -- Generate code coverage reports with --coverage flag. No additional tools like c8 or istanbul needed.
Parallel by default -- Bun runs test files in parallel by default. Design tests to be independent for correct parallel execution.

Project Structure

src/
  utils/
    math.ts
    math.test.ts
    string.ts
    string.test.ts
  services/
    user-service.ts
    user-service.test.ts
    api-client.ts
    api-client.test.ts
  db/
    queries.ts
    queries.test.ts
  __snapshots__/
    .gitkeep
bunfig.toml
package.json

Bun Configuration

# bunfig.toml
[test]
# Test file patterns
root = "./src"

# Coverage configuration
coverage = true
coverageReporter = ["text", "lcov"]
coverageThreshold = { line = 80, function = 80, statement = 80 }

# Preload scripts
preload = ["./test-setup.ts"]

# Timeout per test (ms)
timeout = 5000

# Bail after N failures (0 = no bail)
bail = 0

Basic Test Patterns

// src/utils/math.test.ts
import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
import { add, multiply, divide, fibonacci, isPrime } from './math';

describe('Math Utilities', () => {
  describe('add', () => {
    it('should add two positive numbers', () => {
      expect(add(2, 3)).toBe(5);
    });

    it('should handle negative numbers', () => {
      expect(add(-1, -2)).toBe(-3);
      expect(add(-1, 5)).toBe(4);
    });

    it('should handle zero', () => {
      expect(add(0, 0)).toBe(0);
      expect(add(5, 0)).toBe(5);
    });

    (,  {
      ((, )).();
    });
  });

  (,  {
    (,  {
      ((, )).();
    });

    (,  {
      ( (, )).();
    });

    (,  {
      ((, )).(, );
    });
  });

  (,  {
    (,  {
      (()).();
      (()).();
      (()).();
      (()).();
    });

    (,  {
      ( (-)).();
    });
  });

  (,  {
    it.([, , , , , ])(,  {
      ((n)).();
    });

    it.([, , , , , , ])(,  {
      ((n)).();
    });
  });
});

Mocking with Bun

// src/services/user-service.test.ts
import { describe, it, expect, mock, spyOn, beforeEach } from 'bun:test';
import { UserService } from './user-service';
import { db } from '../db/connection';

// Mock the entire module
mock.module('../db/connection', () => ({
  db: {
    query: mock(() => Promise.resolve([])),
    insert: mock(() => Promise.resolve({ id: '123' })),
    update: mock(() => Promise.resolve({ affected: 1 })),
    delete: mock(() => Promise.resolve({ affected: 1 })),
  },
}));

describe('UserService', () => {
  let service: UserService;

  beforeEach(() => {
    service = new UserService();
    
    (db.  ).();
    (db.  ).();
  });

  (,  () => {
     mockUser = { : , : , :  };
    (db.  ).([mockUser]);

     user =  service.();

    (user).(mockUser);
    (db.).();
  });

  (,  () => {
    (db.  ).([]);

     user =  service.();

    (user).();
  });

  (,  () => {
     newUser = { : , :  };
    (db.  ).({ : , ...newUser });

     created =  service.(newUser);

    (created.).();
    (db.).();
  });

  (,  () => {
    (db.  ).( ());

    (service.({ : , :  }))..(
      
    );
  });
});

Spy Functions

// src/services/api-client.test.ts
import { describe, it, expect, spyOn, mock, beforeEach, afterEach } from 'bun:test';
import { ApiClient } from './api-client';

describe('ApiClient', () => {
  let client: ApiClient;
  let fetchSpy: any;

  beforeEach(() => {
    client = new ApiClient('https://api.example.com');
    fetchSpy = spyOn(globalThis, 'fetch');
  });

  afterEach(() => {
    fetchSpy.mockRestore();
  });

  it('should make GET requests', async () => {
    fetchSpy.mockResolvedValueOnce(
      new Response(JSON.stringify({ data: 'test' }), {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
      })
    );

    const result = await client.get('/users');

    expect(result).toEqual({ data:  });
    (fetchSpy).(
      ,
      expect.({ :  })
    );
  });

  (,  () => {
    fetchSpy.( ());

    (client.())..();
  });

  (,  () => {
    fetchSpy
      .( (, { :  }))
      .( (, { :  }))
      .(
         (.({ :  }), { :  })
      );

     result =  client.(, { :  });

    (result).({ :  });
    (fetchSpy).();
  });

  (,  () => {
    fetchSpy.(
       (.({}), { :  })
    );

    client.();
     client.();

    (fetchSpy).(
      expect.(),
      expect.({
        : expect.({
          : ,
        }),
      })
    );
  });
});

Snapshot Testing

// src/utils/string.test.ts
import { describe, it, expect } from 'bun:test';
import { formatDate, slugify, truncate, parseMarkdown } from './string';

describe('String Utilities', () => {
  describe('slugify', () => {
    it('should create URL-safe slugs', () => {
      expect(slugify('Hello World')).toBe('hello-world');
      expect(slugify('  Multiple   Spaces  ')).toBe('multiple-spaces');
      expect(slugify('Special @#$ Characters!')).toBe('special-characters');
      expect(slugify('CamelCaseTitle')).toBe('camelcasetitle');
    });

    it('should match snapshot', () => {
      const testCases = [
        'Hello World',
        'TypeScript Testing',
        'API v2.0 Documentation',
        'user@email.com',
      ].map((input) => ({ input, output: (input) }));

      (testCases).();
    });
  });

  (,  {
    (,  {
      (()).();
    });

    (,  {
       input = ;
      ((input)).();
    });

    (,  {
       input = ;
      ((input)).();
    });
  });
});

DOM Testing with happy-dom

// test-setup.ts
import { GlobalRegistrator } from '@happy-dom/global-registrator';

GlobalRegistrator.register();

// src/components/counter.test.ts
import { describe, it, expect, beforeEach } from 'bun:test';

describe('Counter Component (DOM)', () => {
  beforeEach(() => {
    document.body.innerHTML = '';
  });

  it('should render counter with initial value', () => {
    document.body.innerHTML = `
      <div id="counter">
        <span class="count">0</span>
        <button class="increment">+</button>
        <button class="decrement">-</button>
      </div>
    `;

    const count = document.querySelector('.count');
    expect(count?.textContent).toBe('0');
  });

  it('should increment counter on button click', () => {
    document.body.innerHTML = `<button id="btn" onclick="this.dataset.count = (parseInt(this.dataset.count || '0') + 1)">Click</button>`;

    const btn = document.getElementById('btn') as HTMLButtonElement;
    btn.click();

    expect(btn.dataset.count).();
  });
});

Running Tests

# Run all tests
bun test

# Run specific file
bun test src/utils/math.test.ts

# Run tests matching pattern
bun test --grep "should add"

# Run with coverage
bun test --coverage

# Run in watch mode
bun test --watch

# Run with timeout
bun test --timeout 10000

# Bail on first failure
bun test --bail 1

# Run specific directory
bun test src/services/

Integration Testing Patterns

// src/services/api-integration.test.ts
import { describe, it, expect, beforeAll, afterAll } from 'bun:test';
import { createServer } from '../server';

describe('API Integration Tests', () => {
  let server: any;
  let baseUrl: string;

  beforeAll(async () => {
    server = createServer({ port: 0 }); // Random port
    const address = server.address();
    baseUrl = \`http://localhost:\${address.port}\`;
  });

  afterAll(() => {
    server.close();
  });

  it('should handle POST /api/users', async () => {
    const response = await fetch(\`\${baseUrl}/api/users\`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ name: 'Test User', email: 'test@bun.sh' }),
    });

    expect(response.status).toBe(201);
    const data = await response.json();
    expect(data.id).toBeDefined();
    expect(data.name).toBe('Test User');
  });

  it('should return 400 for invalid input', async () => {
    const response = await fetch(\`\${baseUrl}/api/users\`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ name: '' }),
    });

    expect(response.status).toBe(400);
  });

  it('should handle GET /api/users/:id', async () => {
    // Create a user first
    const createResponse = await fetch(\`\${baseUrl}/api/users\`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ name: 'Lookup User', email: 'lookup@bun.sh' }),
    });
    const created = await createResponse.json();

    // Fetch the user
    const response = await fetch(\`\${baseUrl}/api/users/\${created.id}\`);
    expect(response.status).toBe(200);
    const data = await response.json();
    expect(data.name).toBe('Lookup User');
  });

  it('should return 404 for non-existent user', async () => {
    const response = await fetch(\`\${baseUrl}/api/users/nonexistent\`);
    expect(response.status).toBe(404);
  });
});

File System Testing with Bun

// src/utils/file-processor.test.ts
import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
import { mkdirSync, rmSync, writeFileSync } from 'fs';
import { join } from 'path';
import { processFiles, readConfig } from './file-processor';

describe('File Processor', () => {
  const testDir = join(import.meta.dir, '__test_tmp__');

  beforeEach(() => {
    mkdirSync(testDir, { recursive: true });
  });

  afterEach(() => {
    rmSync(testDir, { recursive: true, force: true });
  });

  it('should process markdown files in directory', async () => {
    writeFileSync(join(testDir, 'test1.md'), '# Hello');
    writeFileSync(join(testDir, 'test2.md'), '# World');
    writeFileSync(join(testDir, 'ignore.txt'), 'not markdown');

     results =  (testDir, );
    (results).();
    (results[].).();
  });

  (,  () => {
    ((testDir, ), );

     config =  ((testDir, ));
    (config.).();
    (config.).();
  });

  (,  () => {
     results =  (testDir, );
    (results).();
  });
});

Best Practices

Use Bun's native APIs -- Prefer bun:test imports over Jest globals. This ensures compatibility with Bun's optimized test runner.
Keep tests colocated -- Place .test.ts files next to source files for easy discovery and navigation.
Use mock.module for dependency mocking -- Bun's module mocking is hoisted automatically, similar to Jest's jest.mock.
Leverage Bun's speed for TDD -- With sub-second test execution, run tests continuously with --watch during development.
Configure coverage thresholds -- Set minimum coverage in bunfig.toml to prevent regressions.
Use toMatchSnapshot for complex outputs -- Snapshot testing is ideal for formatted strings, parsed structures, and serialized objects.
Reset mocks in beforeEach -- Call mockClear() on each mock before every test to ensure test isolation.
Use it.each for data-driven tests -- Parameterize tests with .each() to avoid duplicating test logic.
Preload setup files -- Use bunfig.toml's preload option for global test setup like DOM registration.
Profile slow tests -- Bun reports test duration. Investigate tests taking more than 100ms as they may have unnecessary async operations.

Anti-Patterns

Importing from jest instead of bun:test -- Using Jest imports may work for some APIs but misses Bun-specific optimizations and features.
Not resetting mocks between tests -- Leaked mock state causes flaky tests. Always clear mocks in beforeEach.
Using setTimeout for async testing -- Bun handles async/await natively. Use expect().resolves or expect().rejects instead of timers.
Over-mocking -- Mock external dependencies, not the code under test. Over-mocking tests nothing of value.
Ignoring TypeScript errors in tests -- Bun compiles TypeScript directly. Type errors in tests indicate real problems.
Writing tests that depend on execution order -- Bun runs tests in parallel by default. Each test must be fully independent.
Not using the built-in coverage -- Installing separate coverage tools adds overhead. Use bun test --coverage for built-in reporting.
Testing private methods -- If you need to test a private method, it should probably be a separate utility function. Test through the public API.
Ignoring test timeouts -- Tests that hang indicate async issues. Configure appropriate timeouts in bunfig.toml.
Not running tests before committing -- Bun's speed makes pre-commit test execution practical. Add tests to your pre-commit hook.

name	Bun Test Runner
description	Fast test execution with Bun's built-in test runner including snapshot testing, mocking, code coverage, lifecycle hooks, DOM testing with happy-dom, and migration from Jest and Vitest to Bun test.
version	1.0.0
author	thetestingacademy
license	MIT
tags	["bun","bun-test","test-runner","snapshot-testing","mocking","code-coverage","happy-dom","fast-testing","runtime","javascript-runtime"]
testingTypes	["unit","integration"]
frameworks	["bun"]

name	Bun Test Runner
description	Fast test execution with Bun's built-in test runner including snapshot testing, mocking, code coverage, lifecycle hooks, DOM testing with happy-dom, and migration from Jest and Vitest to Bun test.
version	1.0.0
author	thetestingacademy
license	MIT
tags	["bun","bun-test","test-runner","snapshot-testing","mocking","code-coverage","happy-dom","fast-testing","runtime","javascript-runtime"]
testingTypes	["unit","integration"]
frameworks	["bun"]