unit-test-generator

Unit Test Generator

Analyzes code changes in the current branch and generates detailed unit test coverage proposals, comparing against the default branch to identify coverage gaps.

Use When

• You want to generate comprehensive unit tests for new or modified code
• You need to ensure test coverage includes positive, negative, edge case, and default scenarios
• You're reviewing code changes and want test suggestions aligned with existing test patterns
• You need a detailed implementation plan for unit tests

Overview

This skill reviews staged and committed code changes in your current branch, identifies test coverage gaps by comparing against the default branch, and produces a detailed implementation plan for comprehensive unit tests. It analyzes existing test patterns in your repository to maintain consistency.

Prerequisites

• Git repository with code changes staged or committed in the current branch
• Default branch available for comparison
• Existing unit test files following repository conventions
• Code changes focused on functions, components, or business logic requiring test coverage

Workflow

Step 1: Review Changed Code

• Retrieve all staged and committed changes from the current branch
• Extract modified functions, components, and logic
• Identify scope of changes (new code vs. modifications)

Step 2: Compare Against Default Branch

• Calculate diff between current branch and default branch
• Determine which code modifications lack test coverage
• Identify areas where existing tests may need updates

Step 3: Analyze Existing Test Patterns

Search repository for unit test files using patterns:

.(test|spec).(ts|js|tsx|jsx)$      /* TypeScript/JavaScript test files */
^test_.*\.py$                       /* Python test files (prefix) */
.*\_test\.(py|go)$                  /* Python/Go test files (suffix) */
.*Test\.java$                       /* Java test files */
.*_(spec|test)\.rb$                 /* Ruby test files */

Extract and document:

• Test framework and libraries used
• Test naming conventions
• Test structure and organization
• Assertion patterns
• Setup/teardown or fixture patterns

Step 4: Identify Coverage Gaps

Analyze modified code for missing test coverage:

• Functions & Methods: Are return values, parameters, and logic tested?
• Components: Are props, state changes, and lifecycle events tested?
• Error Handling: Are exceptions and error paths covered?
• Edge Cases: Are boundary conditions and special values tested?

Step 5: Generate Test Proposals

For each coverage gap, propose unit tests covering:

Test Scenario Types

Scenario	Description	Example
Positive	Valid inputs produce expected outputs	Call function with valid data, verify correct result
Negative	Invalid/error inputs handled properly	Call function with null/undefined, verify error handling
Edge Case	Boundary conditions and special values	Zero, empty arrays, max/min values, special characters
Default	Default parameters and fallback behavior	Function called without optional params, default values used

For Each Proposed Test, Include:

• Test name and description
• Scenario type (positive/negative/edge case/default)
• Input data or conditions
• Expected behavior and assertions
• Setup/teardown requirements if any

Step 6: Create Implementation Plan

Document:

• File location for new tests
• Test framework and libraries to use
• Number of tests and organization
• Priority for implementation (e.g., critical path first)
• Estimated complexity for each test
• Any setup or configuration needed

Inputs

• Current Branch: Must have staged or committed code changes
• Repository Access: To read both current and default branch code
• Existing Tests: To analyze patterns and conventions

Outputs

1. Code Change Analysis

Files Modified: [list]
Functions/Components Changed: [list]
Lines Added/Modified: [count]

2. Existing Test Patterns

Framework: [e.g., Jest, Pytest, RSpec]
Test Directory: [path]
Naming Convention: [pattern]
Average Tests Per File: [number]

3. Coverage Gap Analysis

Uncovered Functions: [list with reason]
Uncovered Scenarios: [list by type]
Total Coverage Gaps: [count]

4. Unit Test Proposals

Test Suite: [name]
├── Test 1: [name] (Positive)
│   ├── Input: [description]
│   ├── Expected: [description]
│   └── Assertions: [list]
├── Test 2: [name] (Negative)
│   ├── Input: [description]
│   ├── Expected: [description]
│   └── Assertions: [list]
├── Test 3: [name] (Edge Case)
│   ├── Input: [description]
│   ├── Expected: [description]
│   └── Assertions: [list]
└── Test 4: [name] (Default)
    ├── Input: [description]
    ├── Expected: [description]
    └── Assertions: [list]

5. Implementation Plan

Phase 1 (High Priority):
  - Test: [name]
    File: [location]

Phase 2 (Medium Priority):
  - Test: [name]
    File: [location]

Setup Required:
  - [list any test fixtures, mocks, or configuration]

Example Output

Given Code Change

// New function in user service
export function calculateMembershipDiscount(
  memberLevel: string,
  purchaseAmount: number,
): number {
  const discountMap: Record<string, number> = {
    gold: 0.2,
    silver: 0.1,
    bronze: 0.05,
  };

  const discount = discountMap[memberLevel] || 0;
  return Math.round(purchaseAmount * discount * 100) / 100;
}

Generated Test Proposals

Test Suite: calculateMembershipDiscount

1. Test: should return correct discount for gold member (Positive)
   Input: memberLevel = 'gold', purchaseAmount = 100
   Expected: 20
   Assertions: result === 20

2. Test: should return correct discount for silver member (Positive)
   Input: memberLevel = 'silver', purchaseAmount = 200
   Expected: 20
   Assertions: result === 20

3. Test: should return zero discount for unknown member level (Negative)
   Input: memberLevel = 'invalid', purchaseAmount = 100
   Expected: 0
   Assertions: result === 0

4. Test: should handle zero purchase amount (Edge Case)
   Input: memberLevel = 'gold', purchaseAmount = 0
   Expected: 0
   Assertions: result === 0

5. Test: should return zero discount when no member level provided (Default)
   Input: memberLevel = '', purchaseAmount = 100
   Expected: 0
   Assertions: result === 0

6. Test: should round discount correctly (Edge Case)
   Input: memberLevel = 'gold', purchaseAmount = 33
   Expected: 6.60
   Assertions: result === 6.60

Implementation Checklist

• Retrieve current branch changes (staged + committed)
• Fetch default branch code for comparison
• Scan repository for existing test files
• Analyze test framework and patterns
• Identify all coverage gaps
• Generate test proposals for each gap
• Organize proposals by scenario type
• Create prioritized implementation plan
• Document setup/configuration needs
• Provide detailed descriptions for each test

Notes

• Tests should follow the existing test patterns found in the repository
• Include both happy path and error handling scenarios
• Consider performance implications for each test
• Group related tests into logical test suites
• Ensure test names clearly describe what is being tested