qa-test-planner

What this skill does

# QA Test Planner

A comprehensive skill for QA engineers to create test plans, generate manual test cases, build regression test suites, validate designs against Figma, and document bugs effectively.

## What This Skill Does

Helps QA engineers with:
- **Test Plan Creation** - Comprehensive test strategy and planning
- **Manual Test Case Generation** - Detailed step-by-step test cases
- **Regression Test Suites** - Critical path and smoke test suites
- **Figma Design Validation** - Compare implementation against designs (requires Figma MCP)
- **Bug Report Templates** - Clear, reproducible bug documentation
- **Test Coverage Analysis** - Identify gaps in testing
- **Test Execution Tracking** - Monitor testing progress

## Why You Need This Skill

**Without structured testing:**
- Inconsistent test coverage
- Missed edge cases
- Poor bug documentation
- No regression safety net
- Design implementation gaps
- Unclear test strategy

**With this skill:**
- Comprehensive test coverage
- Repeatable test cases
- Systematic regression testing
- Design-implementation validation
- Professional bug reports
- Clear testing roadmap

## Core Components

### 1. Test Plan Generator
- Test scope and objectives
- Testing approach and strategy
- Test environment requirements
- Entry/exit criteria
- Risk assessment
- Resource allocation
- Timeline and milestones

### 2. Manual Test Case Generator
- Step-by-step instructions
- Expected vs actual results
- Preconditions and setup
- Test data requirements
- Priority and severity
- Edge case identification

### 3. Regression Test Suite Builder
- Smoke test cases
- Critical path testing
- Integration test scenarios
- Backward compatibility checks
- Performance regression tests

### 4. Figma Design Validation (with MCP)
- Compare UI implementation to designs
- Identify visual discrepancies
- Validate spacing, colors, typography
- Check component consistency
- Flag design-dev mismatches

### 5. Bug Report Generator
- Clear reproduction steps
- Environment details
- Expected vs actual behavior
- Screenshots and evidence
- Severity and priority
- Related test cases

## Test Case Structure

### Standard Test Case Format

```markdown
## TC-001: [Test Case Title]

**Priority:** High | Medium | Low
**Type:** Functional | UI | Integration | Regression
**Status:** Not Run | Pass | Fail | Blocked

### Objective
[What are we testing and why]

### Preconditions
- [Setup requirement 1]
- [Setup requirement 2]
- [Test data needed]

### Test Steps
1. [Action to perform]
   **Expected:** [What should happen]

2. [Action to perform]
   **Expected:** [What should happen]

3. [Action to perform]
   **Expected:** [What should happen]

### Test Data
- Input: [Test data values]
- User: [Test account details]
- Configuration: [Environment settings]

### Post-conditions
- [System state after test]
- [Cleanup required]

### Notes
- [Edge cases to consider]
- [Related test cases]
- [Known issues]
```

## Test Plan Template

### Executive Summary
- Feature/product being tested
- Testing objectives
- Key risks
- Timeline overview

### Test Scope

**In Scope:**
- Features to be tested
- Test types (functional, UI, performance, etc.)
- Platforms and environments
- User flows and scenarios

**Out of Scope:**
- Features not being tested (deferred)
- Known limitations
- Third-party integrations (if applicable)

### Test Strategy

**Test Types:**
- Manual testing
- Exploratory testing
- Regression testing
- Integration testing
- User acceptance testing
- Performance testing (if applicable)

**Test Approach:**
- Black box testing
- Positive and negative testing
- Boundary value analysis
- Equivalence partitioning

### Test Environment
- Operating systems
- Browsers and versions
- Devices (mobile, tablet, desktop)
- Test data requirements
- Backend/API environments

### Entry Criteria
- [ ] Requirements documented
- [ ] Designs finalized
- [ ] Test environment ready
- [ ] Test data prepared
- [ ] Build deployed to test environment

### Exit Criteria
- [ ] All high-priority test cases executed
- [ ] 90%+ test case pass rate
- [ ] All critical bugs fixed
- [ ] No open high-severity bugs
- [ ] Regression suite passed
- [ ] Stakeholder sign-off

### Risk Assessment

| Risk | Probability | Impact | Mitigation |
|------|-------------|--------|------------|
| [Risk 1] | High/Med/Low | High/Med/Low | [How to mitigate] |
| [Risk 2] | High/Med/Low | High/Med/Low | [How to mitigate] |

### Test Deliverables
- Test plan document
- Test cases
- Test execution reports
- Bug reports
- Test summary report

## Test Types and Approaches

### 1. Functional Testing

**What:** Verify features work as specified

**Test Cases:**
- Happy path scenarios
- Error handling
- Input validation
- Business logic
- Data integrity

**Example:**
```
TC: User Login with Valid Credentials
1. Navigate to login page
2. Enter valid email and password
3. Click "Login" button
Expected: User redirected to dashboard, welcome message shown
```

### 2. UI/Visual Testing

**What:** Verify visual appearance and layout

**Test Cases:**
- Layout and alignment
- Responsive design
- Color and typography
- Component states (hover, active, disabled)
- Cross-browser compatibility

**With Figma MCP:**
- Compare implementation to Figma designs
- Verify spacing (padding, margins)
- Check font sizes and weights
- Validate color values
- Ensure icon accuracy

**Example:**
```
TC: Homepage Hero Section Visual Validation
1. Open homepage in browser
2. Compare against Figma design [link]
3. Verify:
   - Heading font: 48px, bold, #1A1A1A
   - CTA button: 16px padding, #0066FF background
   - Image aspect ratio: 16:9
   - Spacing: 64px margin-bottom
Expected: All visual elements match Figma exactly
```

### 3. Regression Testing

**What:** Ensure existing functionality still works

**When to Run:**
- Before each release
- After bug fixes
- After new features
- Weekly smoke tests

**Suite Components:**
- Smoke tests (critical paths)
- Full regression (comprehensive)
- Targeted regression (affected areas)

**Example:**
```
Regression Suite: User Authentication
- Login with valid credentials
- Login with invalid credentials
- Password reset flow
- Session timeout handling
- Multi-device login
- Social login (Google, GitHub)
```

### 4. Integration Testing

**What:** Verify different components work together

**Test Cases:**
- API integration
- Database operations
- Third-party services
- Cross-module interactions
- Data flow between components

**Example:**
```
TC: Checkout Payment Integration
1. Add item to cart
2. Proceed to checkout
3. Enter payment details (Stripe)
4. Submit payment
Expected:
- Payment processed via Stripe API
- Order created in database
- Confirmation email sent
- Inventory updated
```

### 5. Exploratory Testing

**What:** Unscripted, creative testing

**Approach:**
- Charter-based exploration
- User persona simulation
- Edge case discovery
- Usability evaluation

**Session Template:**
```
Exploratory Testing Session
Charter: Explore [feature] as [user type]
Time: 60 minutes
Focus: [Area to explore]

Findings:
- [Bug/issue discovered]
- [UX concern]
- [Improvement suggestion]

Follow-up:
- [Test cases to create]
- [Bugs to file]
```

## Figma MCP Integration

### Design Validation Workflow

**Prerequisites:**
- Figma MCP server configured
- Design file access
- Figma URLs available

**Validation Process:**

1. **Get Design Specs from Figma**
```
"Get the button specifications from Figma file [URL]"
- Component: Primary Button
- Width: 120px
- Height: 40px
- Border-radius: 8px
- Background: #0066FF
- Font: 16px, Medium, #FFFFFF
```

2. **Compare Implementation**
```
TC: Primary Button Visual Validation
1. Inspect primary button in browser dev tools
2. Compare against Figma specs:
   - Dimensions: 120x40px ✓ / ✗
   - Border-radius: 8px ✓ / ✗
   - Background color: #0066FF ✓ / ✗
   - Font: 16px Medium #FFFFFF ✓ / ✗
3. Document discrepancies
```

3. **Create Bug if Mismatch**
```
BUG: Primary button color