backend-test-writer
Use when generating tests for backend code (Express routes, MongoDB models, Node services) - analyzes file type, detects test framework from package.json, generates comprehensive tests with setup/teardown and edge case coverage
When & Why to Use This Skill
The Backend Test Writer is a specialized Claude skill designed to automate the creation of comprehensive test suites for Node.js, Express, and MongoDB (MERN stack) applications. It intelligently analyzes project structures, detects existing frameworks like Jest or Vitest, and generates high-quality unit and integration tests. By covering success paths, validation errors, and complex edge cases, it ensures robust backend reliability with zero-config setup.
Use Cases
- Automating integration tests for Express routes using Supertest and in-memory MongoDB to verify API endpoints.
- Generating unit tests for complex business logic within services and utility functions using mocked dependencies.
- Setting up test infrastructure from scratch, including package.json configuration and installing necessary libraries like mongodb-memory-server.
- Improving code coverage by automatically identifying and testing edge cases such as authentication failures (401/403) and resource-not-found scenarios (404).
- Standardizing test patterns across a development team by following consistent setup/teardown and naming conventions.
| name | backend-test-writer |
|---|---|
| description | Use when generating tests for backend code (Express routes, MongoDB models, Node services) - analyzes file type, detects test framework from package.json, generates comprehensive tests with setup/teardown and edge case coverage |
Backend Test Writer
Generate comprehensive backend tests for MERN stack code. Analyzes file type, detects project conventions, produces tests that actually run.
Philosophy: Smart defaults, zero config. Detect everything from project.
Workflow
Copy and track progress:
- Phase 0: Infrastructure check
- Phase 1: Analyze target files
- Phase 2: Generate tests
- Phase 3: Report summary
Phase 0: Infrastructure Check
Before generating tests, verify setup:
- Check
package.jsonfor test framework (Jest/Vitest/Mocha) - If none → prompt: "Set up Jest + Supertest?"
- Check for
mongodb-memory-server(needed for integration tests) - Detect test file convention (colocated vs
__tests__/vstests/)
Stop if: No test framework and user declines setup.
Phase 1: Analyze Target Files
| Pattern | Type | Test Approach |
|---|---|---|
routes/, *.routes.js |
Route | Integration (Supertest + real DB) |
controllers/ |
Controller | Integration |
services/ |
Service | Unit (mocked deps) |
models/, *.model.js |
Model | Unit (validation tests) |
middleware/ |
Middleware | Unit (mock req/res/next) |
utils/, helpers/ |
Utility | Unit (pure functions) |
Override: User can specify --unit or --integration.
Phase 2: Generate Tests
Process files sequentially with progress. User can stop anytime.
Each test includes:
- Proper imports for detected framework
- Setup/teardown (DB connection, cleanup)
- Comprehensive coverage:
- Success cases (happy path)
- Validation errors (400)
- Not found (404)
- Auth failures (401/403) if protected
- Edge cases (duplicates, empty, null)
Reference: See test-patterns.md for complete code examples.
Phase 3: Report
Generated: X test files
Coverage: Y test cases total
Next: Run `npm test` to verify
Quick Reference
| File Type | Imports | DB Setup |
|---|---|---|
| Route | supertest, mongodb-memory-server |
Real (in-memory) |
| Service | jest |
Mocked |
| Model | mongoose |
Mocked |
| Middleware | jest |
None |
Test Structure Pattern
describe('[Resource] [Method]', () => {
describe('success cases', () => {
it('should [expected behavior]', async () => {});
});
describe('validation errors', () => {
it('should return 400 for [invalid case]', async () => {});
});
describe('edge cases', () => {
it('should handle [edge case]', async () => {});
});
});
Checklists
Infrastructure (Check First)
- Test framework in
package.json - Test script defined (
"test": "jest") - Supertest installed (integration tests)
- mongodb-memory-server installed (DB tests)
Per-File Generation
- Check for existing tests first (gap analysis if found)
- Correct imports for file type
- Setup/teardown included
- Happy path tested
- Error cases tested (400, 404, 401)
- Edge cases tested (domain-specific: date→DST/timezone, money→precision, etc.)
- No secrets in assertions
- Async/await handled properly
- Priority assigned to each test (P0=critical, P1=important, P2=nice-to-have)
- Test helper factories suggested for complex inputs
Common Mistakes
| Mistake | Fix |
|---|---|
| Starting server in tests | Import app, let Supertest handle it |
| No DB cleanup | Add afterEach with deleteMany({}) |
| Testing implementation | Test behavior through HTTP interface |
| Missing async/await | Await async operations |
| Mocking in integration tests | Use real DB for integration |
Guidelines
- Don't generate tests for unread code
- Don't skip infrastructure check
- Don't generate only happy paths
- Don't forget cleanup between tests
Reference Files
Load when implementing specific patterns:
| When | Reference |
|---|---|
| Writing any test | test-patterns.md |
| Setting up test infrastructure | test-setup.md |