Agent skill

test-generator

Generates Jest or Pytest tests following Ben's testing standards. Use when creating tests, adding test coverage, writing unit tests, mocking dependencies, or when user mentions testing, test cases, Jest, Pytest, fixtures, assertions, or coverage.

View SKILL.md on GitHub Repository
Stars 9
Forks 1

Install this agent skill to your Project

npx add-skill https://github.com/benshapyro/cadre-devkit-claude/tree/main/skills/test-generator

SKILL.md

Test Generator Skill

Generate high-quality tests using Jest (JavaScript/TypeScript) or Pytest (Python) following established best practices.

Test Frameworks

  • JavaScript/TypeScript: Jest
  • Python: Pytest

Test Directory Structure

  • Place tests in __tests__/ or tests/ directories
  • Mirror source structure in test directories
  • Use clear, descriptive test file names

JavaScript/TypeScript:

src/
  utils/
    validator.ts
__tests__/
  utils/
    validator.test.ts

Python:

src/
  utils/
    validator.py
tests/
  utils/
    test_validator.py

Test Writing Standards

Coverage Requirements

  • Include at least one negative test per feature
  • Test edge cases and boundary conditions
  • Aim for high coverage but prioritize quality over quantity

Test Structure

Follow the Arrange-Act-Assert pattern:

javascript
// Jest example
describe('functionName', () => {
  it('should handle valid input correctly', () => {
    // Arrange
    const input = 'valid';

    // Act
    const result = functionName(input);

    // Assert
    expect(result).toBe(expected);
  });

  it('should throw error for invalid input', () => {
    // Negative test case
    expect(() => functionName(null)).toThrow();
  });
});
python
# Pytest example
class TestFunctionName:
    def test_valid_input(self):
        # Arrange
        input_val = 'valid'

        # Act
        result = function_name(input_val)

        # Assert
        assert result == expected

    def test_invalid_input_raises_error(self):
        # Negative test case
        with pytest.raises(ValueError):
            function_name(None)

Test Naming

  • Use descriptive names that explain what's being tested
  • Format: test_<what>_<condition>_<expected_result>
  • Examples:
    • test_user_login_with_valid_credentials_returns_token
    • test_api_call_with_invalid_auth_raises_401

Test Quality Checklist

  • Tests are independent and can run in any order
  • Each test has a single, clear purpose
  • Mock external dependencies (APIs, databases, file systems)
  • Include both positive and negative test cases
  • Test error handling and edge cases
  • Use meaningful assertion messages
  • Tests are fast and deterministic

Common Test Patterns

Mocking (Jest)

javascript
jest.mock('../api/client');

it('should handle API errors gracefully', async () => {
  apiClient.get.mockRejectedValue(new Error('Network error'));
  await expect(fetchData()).rejects.toThrow('Network error');
});

Fixtures (Pytest)

python
@pytest.fixture
def sample_user():
    return User(name='Test User', email='test@example.com')

def test_user_creation(sample_user):
    assert sample_user.name == 'Test User'

Parameterized Tests

python
@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("", ""),
])
def test_uppercase(input, expected):
    assert uppercase(input) == expected

Async Testing Patterns

Jest - Async/Await

typescript
describe('async operations', () => {
  it('should fetch user data', async () => {
    const user = await fetchUser(1);
    expect(user.name).toBe('John');
  });

  it('should handle async errors', async () => {
    await expect(fetchUser(-1)).rejects.toThrow('Invalid ID');
  });

  it('should resolve multiple promises', async () => {
    const [users, posts] = await Promise.all([
      fetchUsers(),
      fetchPosts(),
    ]);
    expect(users).toHaveLength(10);
    expect(posts).toHaveLength(5);
  });
});

Jest - Timers and Timeouts

typescript
describe('timer operations', () => {
  beforeEach(() => {
    jest.useFakeTimers();
  });

  afterEach(() => {
    jest.useRealTimers();
  });

  it('should debounce function calls', () => {
    const callback = jest.fn();
    const debounced = debounce(callback, 500);

    debounced();
    debounced();
    debounced();

    expect(callback).not.toHaveBeenCalled();

    jest.advanceTimersByTime(500);
    expect(callback).toHaveBeenCalledTimes(1);
  });

  it('should timeout long operations', async () => {
    const slowOperation = () => new Promise(r => setTimeout(r, 10000));

    await expect(
      Promise.race([
        slowOperation(),
        new Promise((_, reject) =>
          setTimeout(() => reject(new Error('Timeout')), 1000)
        ),
      ])
    ).rejects.toThrow('Timeout');
  });
});

React Testing Library - waitFor

typescript
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';

describe('async component behavior', () => {
  it('should show loading then data', async () => {
    render(<UserProfile userId={1} />);

    // Initially shows loading
    expect(screen.getByText('Loading...')).toBeInTheDocument();

    // Wait for data to appear
    await waitFor(() => {
      expect(screen.getByText('John Doe')).toBeInTheDocument();
    });

    // Loading should be gone
    expect(screen.queryByText('Loading...')).not.toBeInTheDocument();
  });

  it('should handle user interactions', async () => {
    const user = userEvent.setup();
    render(<SearchForm />);

    await user.type(screen.getByRole('textbox'), 'search term');
    await user.click(screen.getByRole('button', { name: 'Search' }));

    await waitFor(() => {
      expect(screen.getByText('Results:')).toBeInTheDocument();
    }, { timeout: 3000 }); // Custom timeout
  });
});

Pytest - Async Tests

python
import pytest
import asyncio

@pytest.mark.asyncio
async def test_async_fetch():
    result = await fetch_data()
    assert result is not None

@pytest.mark.asyncio
async def test_concurrent_operations():
    results = await asyncio.gather(
        fetch_users(),
        fetch_posts(),
    )
    assert len(results) == 2

@pytest.mark.asyncio
async def test_async_timeout():
    with pytest.raises(asyncio.TimeoutError):
        await asyncio.wait_for(slow_operation(), timeout=1.0)

# Async fixtures
@pytest.fixture
async def async_client():
    client = await create_async_client()
    yield client
    await client.close()

Running Tests

Before committing:

bash
# JavaScript/TypeScript
npm run test

# Python
pytest -q

Generation Process

When generating tests:

  1. Analyze the code to understand functionality
  2. Identify edge cases and potential failure points
  3. Create test structure with descriptive names
  4. Write positive tests (happy path)
  5. Write negative tests (error cases)
  6. Add parameterized tests for multiple inputs
  7. Include setup/teardown if needed

Always explain what each test validates and why it's important.

Version

  • v1.1.0 (2025-12-05): Enriched trigger keywords in description
  • v1.0.0 (2025-11-15): Initial version

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

benshapyro/cadre-devkit-claude

product-discovery

Methodology for discovering and specifying new software products. Use when starting greenfield projects, exploring new ideas, or defining MVP scope.

9 1
Explore
benshapyro/cadre-devkit-claude

error-handler

Provides battle-tested error handling patterns for TypeScript and Python. Use when implementing error handling, creating try/catch blocks, or handling exceptions.

9 1
Explore
benshapyro/cadre-devkit-claude

documentation-templates

Generates README files, API documentation, and inline code comments following best practices. Use when creating project documentation, writing READMEs, documenting APIs, or explaining complex code.

9 1
Explore
benshapyro/cadre-devkit-claude

react-patterns

Modern React patterns for TypeScript applications including hooks, state management, and component composition. Use when building React components, managing state, or implementing React best practices.

9 1
Explore
benshapyro/cadre-devkit-claude

code-formatter

Formats code according to Ben's style guidelines for TypeScript, Python, and general best practices. Use when formatting code, fixing linting issues, checking naming conventions, organizing imports, or when user mentions formatting, style, linting, Prettier, Black, or ESLint.

9 1
Explore
benshapyro/cadre-devkit-claude

frontend-design

Create distinctive, memorable user interfaces that avoid generic AI aesthetics. Use when designing UI/UX, planning visual direction, or building pages and layouts.

9 1
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results