SuperClaude/.claude/commands/test.md

/test - Create and run comprehensive tests

Legend

Symbol	Meaning		Abbrev	Meaning
→	leads to		cfg	configuration
&	and/with		impl	implementation
w/	with		perf	performance
@	at/located		ops	operations
>	greater than		val	validation
∀	for all/every		req	requirements
∃	exists/there is		deps	dependencies
∴	therefore		env	environment
∵	because		db	database
≡	equivalent		api	interface
≈	approximately		docs	documentation
📁	directory/path		std	standard
🔢	number/count		def	default
📝	text/string		ctx	context
⚙	setting/config		err	error
🎛	control/flags		exec	execution
🔧	configuration		qual	quality
📋	group/category		rec	recovery
🚨	critical/urgent		sev	severity
⚠	warning/caution		resp	response
🔄	retry/recovery		esc	escalation
✅	success/fixed		tok	token
❌	failure/error		opt	optimization
ℹ	information		UX	user experience
⚡	fast/quick		UI	user interface
🐌	slow/delayed		C	critical
✨	complete/done		H	high
📖	read operation		M	medium
✏	edit operation		L	low
🗑	delete operation

Purpose

Create or run comprehensive test suites for code specified in $ARGUMENTS using modern testing frameworks and methodologies.

Syntax

/test [flags] [target]

Universal Flags

--plan: "Show execution plan before running" --uc: "UltraCompressed mode (~70% token reduction)" --ultracompressed: "Alias for --uc" --think: "Multi-file analysis w/ context (4K tokens)" --think-hard: "Deep architectural analysis (10K tokens)" --ultrathink: "Critical system redesign (32K tokens)" --c7: "Enable Context7→library documentation lookup" --seq: "Enable Sequential→complex analysis & thinking" --magic: "Enable Magic→UI component generation" --pup: "Enable Puppeteer→browser automation & testing" --all-mcp: "Enable all MCP servers" --no-mcp: "Disable all MCP servers (native tools only)" --no-c7: "Disable Context7 specifically" --no-seq: "Disable Sequential thinking specifically" --no-magic: "Disable Magic UI builder specifically" --no-pup: "Disable Puppeteer specifically"

Command-Specific Flags

Test Types:

• --unit: Unit tests for individual functions and components
• --integration: Integration tests for APIs, services, and database interactions
• --e2e: End-to-end tests for complete user workflows
• --performance: Performance and load testing
• --security: Security testing and vulnerability assessment

Test Execution:

• --coverage: Generate comprehensive code coverage reports
• --watch: Continuous test execution on file changes
• --interactive: Interactive test runner with real-time feedback
• --parallel: Run tests in parallel for faster execution
• --isolated: Run tests in isolated environments

Testing Tools:

• --pup: Browser-based E2E testing with Puppeteer automation
• --c7: Testing framework documentation and best practices
• --seq: Complex test scenario planning and analysis

Quality Control:

• --strict: Strict testing mode with enhanced validation
• --threshold [percent]: Set minimum coverage threshold (default 80%)
• --fail-fast: Stop on first test failure
• --retry [count]: Retry failed tests specified number of times

Examples

• /test --unit --coverage --watch → Unit tests with coverage and live updates
• /test --e2e --pup --think → E2E tests with Puppeteer and analysis
• /test --integration --c7 --parallel → Integration tests with docs and parallel execution
• /test --performance --threshold 90 --seq → Performance testing with high coverage threshold
• /test --security --strict --interactive → Security testing with strict validation

Test Types and Implementation

Unit Tests:

• Test individual functions, methods, and components in isolation
• Mock external dependencies and services
• Focus on business logic and edge cases
• Ensure fast execution and high reliability
• Cover both happy paths and error conditions

Integration Tests:

• Test interactions between components and services
• Verify API contracts and data flow
• Test database operations and transactions
• Validate external service integrations
• Check error handling and recovery mechanisms

End-to-End Tests:

• Test complete user workflows and journeys
• Verify critical business paths through application
• Include both success and failure scenarios
• Test across different browsers and devices
• Validate user interface interactions and responses

Performance Tests:

• Load testing with realistic user scenarios
• Stress testing to identify breaking points
• Spike testing for traffic surge handling
• Volume testing with large datasets
• Endurance testing for long-running operations

Security Tests:

• Vulnerability scanning and penetration testing
• Authentication and authorization testing
• Input validation and injection attack prevention
• Data encryption and privacy protection
• Session management and access control verification

Pre-Test Setup and Cleanup

Environment Preparation:

• Clean test output directories (coverage/, test-results/)
• Remove artifacts from previous test runs
• Reset test databases to clean baseline state
• Clear test cache and temporary files
• Initialize test data and fixtures

Dependency Management:

• Install and update testing dependencies
• Configure test environments and settings
• Set up mock services and test doubles
• Prepare test databases and seed data
• Configure network and security settings

Coverage Analysis (--coverage)

Coverage Metrics:

• Line coverage: Percentage of executed code lines
• Branch coverage: Percentage of executed conditional branches
• Function coverage: Percentage of called functions
• Statement coverage: Percentage of executed statements
• Path coverage: Percentage of executed code paths

Coverage Goals:

• Aim for >80% overall code coverage
• Focus on critical business logic coverage
• Identify untested code paths and edge cases
• Track coverage trends and improvements
• Generate actionable coverage reports

Coverage Reports:

• HTML reports with detailed line-by-line analysis
• JSON reports for programmatic consumption
• XML reports for CI/CD integration
• Summary reports with key metrics
• Trend analysis and historical comparison

Watch Mode (--watch)

Continuous Testing:

• Automatic test execution on file changes
• Smart test selection based on changed files
• Fast feedback loop during development
• Real-time coverage updates
• Efficient resource utilization

Change Detection:

• Monitor source code files for modifications
• Track test file changes and updates
• Detect configuration and dependency changes
• Handle file system events efficiently
• Provide clear change notifications

Interactive Mode (--interactive)

Interactive Features:

• Test selection and filtering capabilities
• Real-time test execution and results
• Step-through debugging for failing tests
• Live code coverage visualization
• Dynamic test configuration and options

User Experience:

• Clear and intuitive command interface
• Rich output formatting and highlighting
• Progress indicators and status updates
• Error highlighting and debugging aids
• Keyboard shortcuts and navigation

Testing Best Practices

Test Structure and Organization:

• Use descriptive test names explaining what is being tested
• Follow AAA pattern: Arrange, Act, Assert
• Group related tests in logical test suites
• Maintain consistent test file organization
• Use clear and readable test code

Test Independence:

• Ensure tests can run in any order
• Avoid dependencies between tests
• Clean up test state after each test
• Use fresh test data for each test
• Mock external dependencies appropriately

Test Data Management:

• Create reusable test fixtures and factories
• Use meaningful test data that reflects real scenarios
• Maintain test data separately from production data
• Implement data seeding and cleanup procedures
• Version control test data and schemas

Mocking and Test Doubles:

• Mock external services and APIs
• Use test doubles for database interactions
• Stub complex dependencies and integrations
• Verify mock interactions and expectations
• Balance mocking with integration testing

Test Framework Integration

Supported Frameworks:

• Jest: Modern JavaScript testing framework
• Mocha/Chai: Flexible Node.js testing suite
• Pytest: Python testing framework
• JUnit: Java testing framework
• RSpec: Ruby testing framework

CI/CD Integration:

• Automated test execution in pipelines
• Test result reporting and notifications
• Coverage threshold enforcement
• Parallel test execution for speed
• Test artifact collection and storage

Deliverables

• Test Suites: Comprehensive test coverage for all specified areas
• Coverage Reports: Detailed code coverage analysis and metrics
• Test Documentation: Test plans, strategies, and maintenance guides
• CI/CD Integration: Automated testing pipeline configuration
• Performance Baselines: Performance test results and benchmarks

Output Locations

• Coverage Reports: coverage/ directory with HTML, JSON, and XML reports
• Test Results: test-results/ directory with detailed test outcomes
• Performance Reports: .claudedocs/metrics/performance-test-{timestamp}.md
• Test Documentation: .claudedocs/reports/test-strategy-{timestamp}.md

Research Requirements

External_Library_Research:

• Identify library/framework mentioned
• Context7 lookup for official documentation
• Verify API patterns and examples
• Check version compatibility
• Document findings in implementation Pattern_Research:
• Search existing codebase for similar patterns
• Magic component search if UI-related
• WebSearch for official documentation
• Validate approach with Sequential thinking
• Document pattern choice rationale API_Integration_Research:
• Official documentation lookup
• Authentication requirements
• Rate limiting and error handling
• SDK availability and examples
• Integration testing approach

Report Notifications

📄 Analysis report saved to: {path} 📊 Metrics updated: {path} 📋 Summary saved to: {path} 💾 Checkpoint created: {path} 📚 Documentation created: {path} 📁 Created directory: {path} ✅ {operation} completed successfully ❌ {operation} failed: {reason} ⚠ {operation} completed w/ warnings

Quality Assurance Standards

Test Quality:

• Tests should be reliable and deterministic
• Avoid flaky tests that pass/fail inconsistently
• Maintain high test code quality standards
• Regular test review and refactoring
• Continuous improvement of test effectiveness

Coverage Standards:

• Minimum 80% code coverage for new code
• 100% coverage for critical business logic
• Track and improve coverage over time
• Focus on meaningful coverage, not just metrics
• Regular coverage analysis and reporting

Performance Standards:

• Unit tests should execute in milliseconds
• Integration tests should complete within seconds
• E2E tests should finish within reasonable timeframes
• Parallel execution for improved speed
• Regular performance optimization and monitoring

Troubleshooting

• Slow Tests: Use --parallel and optimize test performance
• Flaky E2E Tests: Apply --retry and improve test stability
• Low Coverage: Use --coverage --interactive for targeted improvement
• Complex Scenarios: Combine --seq --think-hard for comprehensive planning

Success Messages

✅ {operation} completed successfully 📝 Created: {file_path} ✏ Updated: {file_path} ✨ Task completed: {task_title}