菜单
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.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
| name | test-generator |
| description | 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. |
Generate high-quality tests using Jest (JavaScript/TypeScript) or Pytest (Python) following established best practices.
__tests__/ or tests/ directoriesJavaScript/TypeScript:
src/
utils/
validator.ts
__tests__/
utils/
validator.test.ts
Python:
src/
utils/
validator.py
tests/
utils/
test_validator.py
Follow the Arrange-Act-Assert pattern:
// 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();
});
});
# 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_<what>_<condition>_<expected_result>test_user_login_with_valid_credentials_returns_tokentest_api_call_with_invalid_auth_raises_401jest.mock('../api/client');
it('should handle API errors gracefully', async () => {
apiClient.get.mockRejectedValue(new Error('Network error'));
await expect(fetchData()).rejects.toThrow('Network error');
});
@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'
@pytest.mark.parametrize("input,expected", [
("hello", "HELLO"),
("world", "WORLD"),
("", ""),
])
def test_uppercase(input, expected):
assert uppercase(input) == expected
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);
});
});
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');
});
});
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
});
});
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()
Before committing:
# JavaScript/TypeScript
npm run test
# Python
pytest -q
When generating tests:
Always explain what each test validates and why it's important.
Provides REST and GraphQL API design patterns for Node.js, Flask, and FastAPI. Use when designing endpoints, request/response structures, API architecture, pagination, authentication, rate limiting, or when working in /api/ or /routes/ directories.
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.
Knowledge base for the Cadre DevKit. Use when answering questions about the devkit structure, commands, skills, hooks, agents, or workflows.
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.
Provides battle-tested error handling patterns for TypeScript and Python. Use when implementing error handling, creating try/catch blocks, or handling exceptions.
Create distinctive, memorable user interfaces that avoid generic AI aesthetics. Use when designing UI/UX, planning visual direction, or building pages and layouts.