Unit Test Generator
Generate production-ready unit tests across Jest, Vitest, Pytest, and Go
What You Can Do
This skill analyzes your functions and classes to generate exhaustive unit tests that maximize coverage and catch regressions. It systematically identifies logical branches, input variations, and failure modes—then produces framework-specific test code with proper setup/teardown and mocks. Your tests are immediately runnable with clear assertions and meaningful error messages.
Features
Generates tests for Jest, Vitest, Pytest, and Go testing with correct syntax and idioms
Identifies and tests all logical paths, conditionals, and error handling routes
Automatically covers boundary values, null/undefined inputs, type mismatches, and unusual states
Creates appropriate fixtures, mocks, and setup/teardown code for each test
Generates tests for exception handling, timeout scenarios, and failure states
Output serves as executable specifications showing expected function behavior
Analyzes code regardless of language; produces framework-specific output
Example Output
Input function:
function calculateDiscount(price, customerType, quantity) {
if (price <= 0) throw new Error('Invalid price');
let discount = 0;
if (customerType === 'premium') discount = 0.2;
else if (customerType === 'member') discount = 0.1;
if (quantity >= 10) discount += 0.05;
return price * (1 - discount);
}
Generated Jest tests:
describe('calculateDiscount', () => {
it('returns full price for regular customer with small quantity', () => {
expect(calculateDiscount(100, 'regular', 1)).toBe(100);
});
it('applies premium discount of 20%', () => {
expect(calculateDiscount(100, 'premium', 1)).toBe(80);
});
it('applies member discount plus bulk bonus', () => {
expect(calculateDiscount(100, 'member', 10)).toBe(85);
});
it('throws error for negative price', () => {
expect(() => calculateDiscount(-50, 'regular', 1)).toThrow('Invalid price');
});
it('throws error for zero price', () => {
expect(() => calculateDiscount(0, 'premium', 5)).toThrow('Invalid price');
});
});
What's Included
- SKILL.md: Complete instruction file with overview, usage guidelines, and framework-specific prompts
- Test template library: Pre-formatted test stubs for Jest, Vitest, Pytest, and Go testing
- Branch analysis checklist: Systematic guide for identifying edge cases and boundary conditions
- Mock/fixture patterns: Common setup patterns for different frameworks and dependency types
- Framework quick-reference: Syntax examples and assertion methods for each supported framework
Who It's For
- QA Engineers — Generate comprehensive test suites to verify code quality and catch regressions
- Full-stack developers — Create unit tests for new features before or after implementation
- Backend/API developers — Test functions, controllers, and service methods across Python, Go, and Node.js
- Frontend developers — Generate tests for utility functions, hooks, and component logic using Jest/Vitest
- Tech leads and code reviewers — Use generated tests as baselines for coverage analysis and test design review
Best For
- New function/class testing — Immediately generate tests when writing new code
- Refactoring coverage — Create comprehensive tests before modifying existing functions
- Edge case discovery — Systematically identify and test boundary conditions and error paths
- Test coverage gaps — Fill uncovered branches with targeted edge case tests
- Code documentation — Use generated tests as executable specifications of expected behavior
You might also like
You can systematically diagnose database performance bottlenecks by sharing your schema, slow query logs, and execution plans with Claude. It identifies root causes—missing indexes, inefficient joins, lock contention—and provides prioritized recommendations with ready-to-implement SQL. Skip the manual log analysis and get tuning strategies tailored to your workload.
Use Claude to systematically analyze your database queries, execution plans, and schema to identify performance bottlenecks. The skill generates actionable optimization recommendations with SQL rewrites, index strategies, and configuration tuning. You'll receive detailed before-and-after performance analysis to validate improvements and prioritize work by impact.
You can systematically design test cases for any feature or system by analyzing requirements or code to extract test parameters, values, and business constraints. The skill generates a PICT model, executes pairwise testing logic to minimize test case count while maximizing coverage, and delivers a formatted test matrix with expected results—reducing manual test design effort while ensuring comprehensive scenario coverage.
by az9713
Rapidly analyze firmware logs and diagnose hardware issues that cause device failures, connectivity problems, and performance degradation. You'll identify root causes from stack traces, crash dumps, and sensor data, then generate specific optimization recommendations. This skill transforms raw device logs into actionable debugging plans that reduce time-to-resolution from hours to minutes.
You'll develop systematic approaches to injectable formulation design, from API selection through sterilization strategy. Claude helps you troubleshoot failed batches by analyzing root causes, recommends regulatory pathways (505(b)(2), ANDA, NDA), and provides science-backed solutions for stability, compatibility, and manufacturability challenges.
You'll design and implement mobile features with architectural rigor, cross-platform considerations, and edge-case handling built-in. This skill generates complete system designs, platform-specific implementation strategies, performance optimization approaches, and testing frameworks. The output is production-ready guidance spanning iOS and Android with security, offline resilience, and deployment strategies included.
Claude analyzes your code diffs and generates standardized commit messages that follow the Conventional Commits specification. The skill automatically determines the correct commit type, scope, and description based on the changes you've made, ensuring your messages are parseable by automation tools while remaining human-readable for code reviewers.
You can architect multi-node ROS control systems from scratch, including node design patterns, communication flows, and real-time constraints. You'll debug complex node interactions using publisher/subscriber analysis, service call tracing, and action server diagnostics. You can optimize motion controllers through PID tuning, trajectory planning validation, and performance profiling to achieve precise, responsive robotic behavior.