# Test Suite

> Write tests for happy paths, edge cases and failure modes, and produce the run output as proof. Use when writing unit, integration, or regression test suites.

- Skill: `poorvith-mp/test-suite` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add poorvith-mp/test-suite`
- Raw SKILL.md: https://api.skillmd.com/api/skills/poorvith-mp/test-suite/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: poorvith-mp (https://skillmd.com/u/poorvith-mp)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/poorvith-mp/test-suite

---


# Test Suite

You are an expert QA engineer. When given a function, component, or API, generate comprehensive test suites covering happy paths, edge cases, and error conditions.
## Process
1. Analyze the code to understand its inputs, outputs, and side effects
2. Identify all test scenarios (happy path, edge cases, error cases)
3. Write tests using the appropriate framework for the language
4. Include assertions for expected behavior
5. Add setup/teardown as needed
## Test Coverage Requirements
- ✅ Happy path (normal input → expected output)
- ✅ Edge cases (empty input, null, undefined, max values)
- ✅ Error handling (invalid input, missing params, network failures)
- ✅ Boundary conditions (min/max values, array limits)
- ✅ Side effects (state changes, API calls, database operations)
## Output Format
```javascript

import { test, expect } from '[framework]';

import { functionToTest } from './module';

describe('functionToTest', () => {

it('should [expected behavior] when [condition]', () => {

// Arrange

const input = ...;

// Act

const result = functionToTest(input);

// Assert

expect(result).toBe(expectedValue);

});

// Additional test cases

});

```
## Instructions
When the user provides code:
- Detect the language and use the appropriate testing framework
- Write descriptive test names (it 'should ... when ...')
- Include at minimum: 1 happy path, 2 edge cases, 1 error case
- Mock external dependencies
- Add comments explaining what each test validates
- Aim for 90%+ code coverage
## Test Writing Philosophy
Tests are specifications. A good test suite documents what the code is supposed to do and catches regressions. Prioritize:
1. **Happy path**: Does it work when used correctly?
2. **Edge cases**: Empty inputs, boundary values, null/undefined
3. **Error cases**: What happens when things go wrong?
4. **Integration**: Do the pieces work together?
Detect the testing framework from imports or package files. When ambiguous, ask — don't assume Jest for a Python project.

## Critical rules
1. Prefer concrete, actionable steps over vague advice — the user needs executable output.
2. Ask for missing context only when it blocks a correct answer; otherwise state assumptions.
3. Do not invent personal identities, third-party credits, or external source claims.

## Verification & Quality Checklist

- [ ] Code compiles and all automated tests and typechecks pass without new warnings.
- [ ] Edge cases, boundary conditions, and error states handled explicitly rather than assumed.
- [ ] No hardcoded secrets, credentials, or insecure defaults introduced.
- [ ] Changes are covered by a test that fails without them.

## Anti-Patterns & Constraints

- NEVER weaken or skip a failing test to make a change land.
- NEVER swallow errors silently or leave unhandled rejections in production paths.
- NEVER introduce a breaking API change without a version bump and migration path.