unit-test

When to use this skill

Use this skill when:

• User asks to create or write unit tests
• User mentions testing, test coverage, or Bun test
• User wants to test specific functions, modules, or components
• User asks to add test files or improve test coverage
• User mentions test frameworks, mocking, or assertions

What this skill does

This skill provides expertise in creating comprehensive, well-structured unit tests using Bun's built-in testing framework. It covers test file creation, Bun test features, best practices, and RestMan-specific testing guidelines.

Core capabilities

1. Test File Creation

• Create test files with proper naming conventions: *.test.ts, *_test.ts, *.spec.ts, *_spec.ts
• Use TypeScript with proper types from bun:test
• Follow the project's code style guidelines (single quotes, camelCase, etc.)

2. Bun Test Framework Features

Basic Testing

import { test, expect, describe } from 'bun:test';

describe('feature name', () => {
  test('should do something', () => {
    expect(result).toBe(expected);
  });
});

Lifecycle Hooks

• beforeAll - Setup before all tests
• beforeEach - Setup before each test
• afterEach - Cleanup after each test
• afterAll - Cleanup after all tests

Mocking

import { test, expect, mock } from 'bun:test';

const mockFn = mock(() => 'mocked value');
// or
const mockFn = jest.fn(() => 'mocked value');

Snapshot Testing

test('snapshot', () => {
  expect(data).toMatchSnapshot();
});

Concurrent Testing

test.concurrent('async test 1', async () => {
  // runs in parallel
});

test.serial('sequential test', () => {
  // runs sequentially even with --concurrent flag
});

3. Test Organization Best Practices

• Group related tests with describe blocks
• Use descriptive test names that explain behavior
• Follow AAA pattern: Arrange, Act, Assert
• Test edge cases and error conditions
• Use beforeEach/afterEach for test isolation
• Mock external dependencies and side effects

4. RestMan-Specific Testing Guidelines

When testing RestMan code:

• Follow TypeScript strict mode requirements
• Handle noUncheckedIndexedAccess: true (indexed access can be undefined)
• Use async/await for asynchronous operations
• Mock file system operations (fs/promises)
• Mock terminal UI components when testing business logic
• Test error handling with instanceof Error checks
• Use proper types from the codebase

5. Running Tests

Available test commands:

• bun test - Run all tests
• bun test <filter> - Run tests matching filter
• bun test --watch - Watch mode
• bun test --coverage - Generate coverage report
• bun test --timeout 20 - Set timeout (default 5000ms)
• bun test --bail - Exit after first failure
• bun test --update-snapshots - Update snapshots

Workflow

When asked to create tests:

1. Understand the code - Read and analyze the source file to test
2. Identify test scenarios - Determine what needs to be tested:
   • Happy path functionality
   • Edge cases
   • Error conditions
   • Async behavior
   • Side effects (mocking needed)
3. Create test file - Use proper naming convention matching source file
4. Write comprehensive tests - Cover identified scenarios
5. Follow project conventions - Match RestMan code style
6. Run tests - Execute with bun test to verify they pass
7. Report results - Explain what was tested and any issues found

Key principles

• Test behavior, not implementation - Focus on what the code does, not how
• Keep tests simple and readable - Tests are documentation
• One assertion per test when possible - Makes failures clear
• Mock external dependencies - File I/O, network, terminal UI
• Test edge cases - null, undefined, empty arrays, errors
• Maintain test isolation - Tests should not depend on each other
• Use descriptive names - Test names should read like documentation

Example test structure

See test structure reference for detailed examples.

Remember

• Always ask clarifying questions if the testing scope is unclear
• Suggest additional test scenarios if you identify gaps
• Follow RestMan's code style guidelines strictly
• Use TypeScript types properly
• Mock side effects appropriately
• Run tests after creating them to ensure they pass
• Be proactive about testing edge cases and error conditions