Generate Comprehensive Unit Tests

The Unit Test Generator is an autonomous testing specialist that analyzes codebases, identifies gaps in test coverage, and generates comprehensive unit tests following best practices. It works in five stages: first scanning the project structure to identify the testing framework, naming conventions, and directory structure, and locating source and existing test files with glob patterns; then assessing coverage by running existing tests and coverage reports where available, using grep to find untested functions, methods, and classes, and prioritizing high-impact areas like public APIs, business logic, and error handlers; then planning a test strategy that determines needed categories (happy path, edge cases, error conditions), mock and stub requirements for external dependencies, fixture needs, and the test pattern to use (arrange-act-assert or given-when-then); then generating comprehensive test suites that follow the project's existing patterns, covering all public methods, boundary values, error conditions, and appropriate mocks, while keeping tests isolated, deterministic, and fast; and finally validating that generated tests compile and run, actually test the intended behavior, fail when expected, and follow naming conventions.

Use it when a codebase has real coverage gaps in public APIs, business logic, or error handlers and you want tests that match the project's existing framework and conventions rather than a generic template. It is built to prioritize high-impact areas autonomously, so it fits well when you want coverage improvement targeted at what matters most rather than blanket coverage of every line. It is not meant to test implementation details - its guideline is to test behavior and public contracts, not internals - and it is not a substitute for integration or end-to-end tests, since it deliberately mocks external dependencies (databases, APIs, file systems) to keep unit tests isolated and fast.

describe('functionName', () => {
  it('should return expected result for valid input', () => {
    // Arrange
    const input = validTestData;
    // Act
    const result = functionName(input);
    // Assert
    expect(result).toBe(expectedOutput);
  });
  
  it('should throw error for invalid input', () => {
    expect(() => functionName(invalidInput)).toThrow('Expected error message');
  });
});

For each analyzed module it produces a Test Coverage Report (current coverage percentage, missing test scenarios, priority areas), complete Generated Test Files with proper imports, setup, clear scenario-describing method names, comprehensive assertions with meaningful error messages, and mock configurations where needed, and a Test Execution Summary showing total tests created, test categories, coverage improvement from X% to Y%, and execution time. Templates follow arrange-act-assert structure as shown above, with an equivalent class-based pattern for setup_method/test_method conventions in other languages.

Engineering teams with known coverage gaps who want tests generated in their existing framework's idiom rather than a one-size-fits-all template - the agent explicitly matches existing test structure, naming, and patterns instead of imposing its own. It suits teams that care about test quality signals like determinism, speed, one-assertion-per-concept, and descriptive failure messages, not just a raw coverage percentage increase.