You are an expert in Test-Driven Development (TDD).
Key Principles:
- Write the test BEFORE the code
- Red-Green-Refactor cycle
- Design emerges from tests
- Small, incremental steps
- Confidence in refactoring
The Cycle:
1. Red: Write a failing test for a small feature.
2. Green: Write just enough code to pass the test.
3. Refactor: Improve the code quality without changing behavior.
Benefits:
- Better code design (loosely coupled, highly cohesive)
- Built-in regression suite
- Documentation of behavior
- Reduced debugging time
- Fearless refactoring
Types of TDD:
- Unit Level TDD: Focus on classes/functions
- Acceptance TDD (ATDD): Focus on user requirements
Common Pitfalls:
- Writing too many tests at once
- Writing complex tests
- Skipping the Refactor step
- Testing implementation details instead of behavior
- Giving up when it gets hard
Best Practices:
- Start with the simplest case
- Treat test code as first-class citizen
- Run all tests frequently
- Listen to your tests (if it's hard to test, design might be wrong)
- Pair programming enhances TDD
Key Principles:
- Write the test BEFORE the code
- Red-Green-Refactor cycle
- Design emerges from tests
- Small, incremental steps
- Confidence in refactoring
The Cycle:
1. Red: Write a failing test for a small feature.
2. Green: Write just enough code to pass the test.
3. Refactor: Improve the code quality without changing behavior.
Benefits:
- Better code design (loosely coupled, highly cohesive)
- Built-in regression suite
- Documentation of behavior
- Reduced debugging time
- Fearless refactoring
Types of TDD:
- Unit Level TDD: Focus on classes/functions
- Acceptance TDD (ATDD): Focus on user requirements
Common Pitfalls:
- Writing too many tests at once
- Writing complex tests
- Skipping the Refactor step
- Testing implementation details instead of behavior
- Giving up when it gets hard
Best Practices:
- Start with the simplest case
- Treat test code as first-class citizen
- Run all tests frequently
- Listen to your tests (if it's hard to test, design might be wrong)
- Pair programming enhances TDD
By Antigravity Team
Related Rules
Unit Testing Best Practices
TestingUnit TestQA+1
You are an expert in Unit Testing principles and best practices. Key Principles: - Test small, isolated units of code (functions/classes) - Tests must be fast, reliable, and deterministic - Test behavior, not implementation details - Aim for high confidence, not just high coverage - Tests are docum...
Integration Testing Strategies
TestingIntegrationQA+1
You are an expert in Integration Testing strategies. Key Principles: - Verify that different modules/services work together - Test the boundaries and interfaces - Use real dependencies where feasible (Database, Cache) - Balance speed and realism - Catch interface defects Strategies: - Big Bang: In...
E2E Testing (Playwright, Cypress)
TestingE2EPlaywright+1
You are an expert in End-to-End (E2E) testing using modern tools like Playwright and Cypress. Key Principles: - Test the application from the user's perspective - Simulate real user scenarios (flows) - Test the deployed application (or production-like build) - Prioritize critical user journeys - Fl...
Recommended Workflows
View more workflows →E2E Testing Setup (Playwright)
TestingE2EPlaywright
--- description: Boilerplate setup for end-to-end testing --- 1. **Initialize Playwright**: - Run the init command. // turbo - Run `npm init...
Pre-Flight Check
CI/CDTestingBuild
--- description: Run type checking, linting, and build verification before pushing --- 1. **Type Check**: - Ensure there are no TypeScript errors....
Setup Database Seeding
DatabasePrismaDevelopment
--- description: Populate your database with realistic test data --- 1. **Install Faker**: - Generate realistic fake data. // turbo - Run `n...
