generate-jest-tests

name	generate-jest-tests
description	Analyze project code and recent changes to generate high-quality Jest unit tests that increase test coverage and follow existing project testing patterns.
argument-hint	Provide changed files, git diff, or ask to generate tests for uncovered modules.
user-invocable	true

Jest Unit Test Generator

Purpose

This skill analyzes project code and recent repository changes to generate Jest unit tests that:

• increase test coverage
• validate new features
• protect against regressions
• follow existing testing conventions

The skill generates production-quality unit tests compatible with the project’s existing Jest setup.

---

When To Use This Skill

Use this skill when:

• new features were implemented
• functions or modules changed
• components were added
• refactoring occurred
• test coverage dropped
• a pull request requires tests

Typical triggers:

• generate jest tests
• add unit tests
• write tests for modified files
• improve test coverage
• generate tests for new modules

---

Step 1 — Detect Test Environment

Identify testing stack used in the project.

Inspect:

package.json

Look for dependencies:

jest
ts-jest
@testing-library/react
@testing-library/jest-dom
vitest
babel-jest

Detect configuration:

jest.config.js
jest.config.ts
vitest.config.ts

Determine:

• test framework (Jest)
• TypeScript support
• React testing library usage
• module alias configuration

---

Step 2 — Detect Changed Code

Identify files needing tests.

Run:

git diff --name-only HEAD

or:

git diff --name-only origin/main

Focus on:

src/
components/
hooks/
utils/
services/
api/
lib/

Ignore:

*.test.ts
*.spec.ts
*.stories.tsx

Prioritize new or modified files.

---

Step 3 — Identify Test Targets

Extract testable units:

Functions Hooks Services API utilities React components

Example detection:

src/utils/priceFormatter.ts
src/hooks/useCart.ts
src/components/ProductCard.tsx
src/services/wishlistService.ts

Each should receive dedicated unit tests.

---

Step 4 — Detect Existing Test Patterns

Analyze existing test files:

*.test.ts
*.test.tsx
*.spec.ts

Extract conventions:

• test file naming
• folder placement
• mocking strategy
• use of testing-library
• snapshot usage
• jest setup imports

Generated tests must follow the same conventions.

---

Step 5 — Coverage-Aware Test Planning

Identify missing test coverage.

If coverage tools exist:

coverage/

Focus on:

• untested functions
• untested branches
• edge cases
• error handling

Generate tests that increase branch and statement coverage.

---

Step 6 — Generate Unit Tests

Generate tests that cover:

Functional Behavior

Test core logic.

Example:

expect(formatPrice(10)).toBe("$10.00")

---

Edge Cases

Test unusual inputs.

Examples:

null
undefined
empty arrays
large numbers

---

Error Handling

Ensure functions fail safely.

Example:

expect(() => parsePrice(null)).toThrow()

---

Conditional Branches

Test all logical branches.

Example:

if (user.isAdmin)
else

---

Step 7 — React Component Tests

If React components are detected:

Use React Testing Library.

Validate:

• rendering
• props behavior
• user interactions
• accessibility

Example:

render(<ProductCard product={mockProduct} />)

expect(screen.getByText("Product Name")).toBeInTheDocument()

Test interactions:

fireEvent.click(button)

---

Step 8 — Mock External Dependencies

Mock external modules when needed.

Examples:

jest.mock("next/router")
jest.mock("axios")
jest.mock("../services/api")

Ensure tests remain isolated.

---

Step 9 — API & Service Tests

Test service layers.

Validate:

• request generation
• response handling
• error handling

Example:

jest.spyOn(api, "get").mockResolvedValue(mockResponse)

---

Step 10 — Hook Tests

If hooks exist:

Use:

@testing-library/react-hooks

or React Testing Library.

Example:

const { result } = renderHook(() => useCart())

expect(result.current.items.length).toBe(0)

---

Step 11 — File Placement

Follow existing structure.

Example:

src/utils/priceFormatter.ts
src/utils/**tests**/priceFormatter.test.ts

or:

src/utils/priceFormatter.test.ts

Use the same pattern used in the repository.

---

Step 12 — Test Naming Conventions

Follow consistent naming:

describe("priceFormatter", () => {

it("formats integer prices correctly")

it("handles decimal values")

it("throws error on invalid input")

})

Prefer behavior-based descriptions.

---

Step 13 — Snapshot Tests (Optional)

For UI components:

expect(container).toMatchSnapshot()

Use snapshots only if project already uses them.

---

Step 14 — Validate Generated Tests

Ensure tests:

• compile successfully
• follow TypeScript types
• avoid flaky behavior
• mock external dependencies
• remain deterministic

---

Output Format

Return tests grouped by file.

Example:

---

Generated Test Files

File

src/utils/priceFormatter.test.ts

import { formatPrice } from "../priceFormatter";

describe("formatPrice", () => {
  it("formats integer prices correctly", () => {
    expect(formatPrice(10)).toBe("$10.00");
  });

  it("formats decimal prices correctly", () => {
    expect(formatPrice(10.5)).toBe("$10.50");
  });

  it("throws error on invalid input", () => {
    expect(() => formatPrice(null)).toThrow();
  });
});

---

Coverage Improvements

Estimated improvements:

File	Coverage Gain
priceFormatter.ts	+35%
wishlistService.ts	+28%

---

Test Strategy Summary

Explain what behaviors are validated.

Example:

• formatting logic
• error handling
• edge cases
• input validation

---

Example Commands

Generate tests for modified files:

/generate-jest-tests based on git diff

Generate tests for a module:

/generate-jest-tests for src/utils/priceFormatter.ts

Improve test coverage:

/generate-jest-tests improve coverage

Generate tests for new feature:

/generate-jest-tests for new wishlist feature

---

Best Practices

Tests must:

• validate behavior, not implementation
• avoid brittle snapshots
• mock external dependencies
• cover edge cases
• follow project conventions
• remain readable and maintainable

Avoid:

• testing private implementation details
• duplicating production logic inside tests