/write-tests

Write Tests Command

Write unit and integration tests

Instructions

Follow this systematic approach to write effective tests: **$ARGUMENTS**

1. **Test Framework Detection**

• Identify the testing framework in use (Jest, Mocha, PyTest, RSpec, etc.)
• Review existing test structure and conventions
• Check test configuration files and setup
• Understand project-specific testing patterns

2. **Code Analysis for Testing**

• Analyze the code that needs testing
• Identify public interfaces and critical business logic
• Map out dependencies and external interactions
• Understand error conditions and edge cases

3. **Test Strategy Planning**

• Determine test levels needed:
• Unit tests for individual functions/methods
• Integration tests for component interactions
• End-to-end tests for user workflows
• Plan test coverage goals and priorities
• Identify mock and stub requirements

4. **Unit Test Implementation**

• Test individual functions and methods in isolation
• Cover happy path scenarios first
• Test edge cases and boundary conditions
• Test error conditions and exception handling
• Use proper assertions and expectations

5. **Test Structure and Organization**

• Follow the AAA pattern (Arrange, Act, Assert)
• Use descriptive test names that explain the scenario
• Group related tests using test suites/describe blocks
• Keep tests focused and atomic

6. **Mocking and Stubbing**

• Mock external dependencies and services
• Stub complex operations for unit tests
• Use proper isolation for reliable tests
• Avoid over-mocking that makes tests brittle

7. **Data Setup and Teardown**

• Create test fixtures and sample data
• Set up and tear down test environments cleanly
• Use factories or builders for complex test data
• Ensure tests don't interfere with each other

8. **Integration Test Writing**

• Test component interactions and data flow
• Test API endpoints with various scenarios
• Test database operations and transactions
• Test external service integrations

9. **Error and Exception Testing**

• Test all error conditions and exception paths
• Verify proper error messages and codes
• Test error recovery and fallback mechanisms
• Test validation and security scenarios

10. **Performance and Load Testing**

• Add performance tests for critical operations
• Test under different load conditions
• Verify memory usage and resource cleanup
• Test timeout and rate limiting scenarios

11. **Security Testing**

• Test authentication and authorization
• Test input validation and sanitization
• Test for common security vulnerabilities
• Test access control and permissions

12. **Accessibility Testing (for UI)**

• Test keyboard navigation and screen readers
• Test color contrast and visual accessibility
• Test ARIA attributes and semantic markup
• Test with assistive technology simulations

13. **Cross-Platform Testing**

• Test on different operating systems
• Test on different browsers (for web apps)
• Test on different device sizes and resolutions
• Test with different versions of dependencies

14. **Test Utilities and Helpers**

• Create reusable test utilities and helpers
• Build test data factories and builders
• Create custom matchers and assertions
• Set up common test setup and teardown functions

15. **Snapshot and Visual Testing**

• Use snapshot testing for UI components
• Implement visual regression testing
• Test rendered output and markup
• Version control snapshots properly

16. **Async Testing**

• Test asynchronous operations properly
• Use appropriate async testing patterns
• Test promise resolution and rejection
• Test callback and event-driven code

17. **Test Documentation**

• Document complex test scenarios and reasoning
• Add comments for non-obvious test logic
• Create test documentation for team reference
• Document test data requirements and setup

18. **Test Maintenance**

• Keep tests up to date with code changes
• Refactor tests when code is refactored
• Remove obsolete tests and update assertions
• Monitor and fix flaky tests

**Framework-Specific Guidelines:**

**Jest/JavaScript:**

describe('ComponentName', () => {
  beforeEach(() => {
    // Setup
  });

  it('should handle valid input correctly', () => {
    // Arrange
    const input = 'test';
    // Act
    const result = functionToTest(input);
    // Assert
    expect(result).toBe(expectedValue);
  });
});

**PyTest/Python:**

class TestClassName:
    def setup_method(self):
        # Setup
        pass

    def test_should_handle_valid_input(self):
        # Arrange
        input_data = "test"
        # Act
        result = function_to_test(input_data)
        # Assert
        assert result == expected_value

**RSpec/Ruby:**

RSpec.describe ClassName do
  describe '#method_name' do
    it 'handles valid input correctly' do
      # Arrange
      input = 'test'
      # Act
      result = subject.method_name(input)
      # Assert
      expect(result).to eq(expected_value)
    end
  end
end

Remember to prioritize testing critical business logic and user-facing functionality first, then expand coverage to supporting code.