vitest-testing

AI-friendly testing guidance for Vitest with focus on practical patterns, testability, and behavior-driven development.

📋 Note: This skill is currently in development (40% complete). See IMPLEMENTATION_STATUS.md for complete context on progress and how to resume development.

🎯 Quick Start

I need to...

• Write a test for a new feature → Start with Decision Tree
• Make code more testable → See Testability Patterns
• Understand testing principles → Read F.I.R.S.T Principles
• Find quick syntax → Check Cheatsheet
• See a complete example → Explore Authentication Example

📚 Skill Organization

Core Principles

Testing fundamentals that guide all decisions:

• F.I.R.S.T Principles - Fast, Isolated, Repeatable, Self-Checking, Timely
• AAA Pattern - Arrange-Act-Assert structure
• BDD Integration - Given/When/Then with AAA
• Testing Pyramid - Unit/Integration/E2E strategy

Testing Strategies

Approaches for different testing scenarios:

• Black Box Testing - Testing behavior via public APIs
• White Box Testing - When to test implementation details
• Implementation Details - Guidelines for testing internals
• Coverage Strategies - Meaningful coverage patterns

Practical Patterns

Ready-to-use patterns for common scenarios:

• Test Doubles - Mocks, stubs, spies, fakes
• Async Testing - Testing promises and async/await
• Error Testing - Exception and error scenarios
• Component Testing - React/Vue component patterns
• API Testing - HTTP/API client testing

Refactoring for Testability

Transform hard-to-test code into testable code:

• Testability Patterns - Making code testable
• Dependency Injection - DI patterns for testing
• Pure Functions - Extracting pure logic
• Side Effect Isolation - Isolating side effects

Complete Examples

Full implementations with tests:

• Authentication - Login, logout, token refresh
• CRUD Operations - Create, read, update, delete
• State Management - Redux/Zustand testing
• API Integration - API client with error handling

Quick Reference

Fast lookups and decision aids:

• Decision Tree - Visual decision flow
• Cheatsheet - Matchers, setup, mocking
• Matchers Reference - Complete matcher guide
• Setup Patterns - beforeEach, afterEach, fixtures

Agent Integration

How this skill integrates with Claude Code agents:

• TypeScript Coder Hooks - TS coder integration
• Architecture Alignment - DDD/Clean Architecture
• Workflow Patterns - Development workflows

🚀 Common Workflows

New Feature Development

1. Check Decision Tree → What type of test?
2. Apply F.I.R.S.T Principles → Fast, isolated tests
3. Use AAA Pattern → Arrange, Act, Assert
4. Follow Black Box Strategy → Test public APIs
5. Reference Complete Example → Template for implementation

Fixing Bugs

1. Write Failing Test → Reproduce the bug
2. Fix Implementation → Make test pass
3. Add Edge Cases → Prevent regression
4. Verify with Coverage → Ensure adequate coverage

Refactoring

1. Ensure Tests Pass → Green before refactor
2. Extract Testable Units → Use refactoring patterns
3. Add Granular Tests → Test extracted units
4. Verify Behavior → All tests still pass

Code Review

1. Check Test Coverage → Adequate coverage?
2. Review Test Quality → F.I.R.S.T principles?
3. Verify Black Box → Testing behavior not implementation?
4. Assess Maintainability → Clear, readable tests?

🎓 Learning Path

Beginner

1. F.I.R.S.T Principles
2. AAA Pattern
3. Cheatsheet
4. Authentication Example

Intermediate

1. Black Box Testing
2. Test Doubles
3. Async Testing
4. Testability Patterns

Advanced

1. Implementation Details
2. BDD Integration
3. Side Effect Isolation
4. Architecture Alignment

🔗 Related Skills

• @skills/architecture-patterns/ - DDD, Clean Architecture, Hexagonal patterns
  • Tests should align with architectural boundaries
  • Domain models → Test business rules (black box)
  • Use cases → Test orchestration with mocks
  • Repositories → Test with in-memory implementations

💡 Philosophy

This skill follows these core beliefs:

Behavior over Implementation

• Tests should verify WHAT the code does, not HOW it does it
• Focus on observable outcomes and public contracts
• Implementation details should be testable indirectly

Example-Driven Learning

• Every principle includes practical examples
• Before/after refactoring shows the impact
• Complete examples provide working templates

Integration with Workflow

• Seamless integration with typescript-coder agent
• Decision trees reduce cognitive load
• Quick references support flow state

Testability by Design

• Code that's hard to test is poorly designed
• Refactoring patterns transform untestable code
• Testability improves overall code quality

---

Start here: Decision Tree - Find the right testing approach for your scenario