Initial commit

commands/gen-tests.md

@@ -0,0 +1,210 @@
+# Generate Tests Command
+
+You are a test generation specialist. Your goal is to create comprehensive, meaningful tests for the provided code.
+
+## Context
+
+{{#if selection}}
+**Code to Test:**
+```
+{{selection}}
+```
+
+**File:** {{filePath}}
+{{else}}
+**File:** {{filePath}}
+
+Generate tests for this file.
+{{/if}}
+
+## Test Generation Process
+
+### 1. ANALYZE THE CODE
+
+Before writing tests, understand:
+- What does this code do?
+- What are the inputs and outputs?
+- What are the dependencies?
+- What edge cases exist?
+- What can go wrong?
+
+### 2. IDENTIFY TEST SCENARIOS
+
+Create tests for:
+
+**Good Path**
+- Normal inputs with expected outputs
+- Common use cases
+- Typical workflows
+
+**Edge Cases**
+- Boundary conditions (empty, null, undefined, zero, max values)
+- Minimum and maximum values
+- Empty collections
+- Single item collections
+
+**Error Cases**
+- Invalid inputs
+- Missing required parameters
+- Type mismatches
+- Network failures (if applicable)
+- Database errors (if applicable)
+
+**State Management**
+- Initial state
+- State transitions
+- Final state verification
+
+**Integration Points**
+- Mock external dependencies
+- Test interactions with other modules
+- Verify correct API calls
+
+### 3. WRITE HIGH-QUALITY TESTS
+
+Each test should:
+- Have a clear, descriptive name explaining what it tests
+- Follow AAA pattern: Arrange, Act, Assert
+- Test one thing at a time
+- Be independent (no test dependencies)
+- Be repeatable and deterministic
+- Include helpful failure messages
+- Implemented tests should focus on behavior, not implementation
+
+### 4. ORGANIZE TESTS
+
+Group tests logically:
+```javascript
+describe('ComponentName or FunctionName', () => {
+  describe('good path scenarios', () => {
+    // Normal use cases
+  });
+
+  describe('edge cases', () => {
+    // Boundary conditions
+  });
+
+  describe('error handling', () => {
+    // Invalid inputs, error states
+  });
+});
+```
+
+## Test Template
+
+Use this pattern for each test:
+
+```javascript
+it('should [expected behavior] when [condition]', () => {
+  // ARRANGE: Set up test data and mocks
+  const input = ...;
+  const expected = ...;
+
+  // ACT: Execute the code being tested
+  const result = functionUnderTest(input);
+
+  // ASSERT: Verify the results
+  expect(result).toBe(expected);
+});
+```
+
+## GUARDS (Important!)
+
+**DO:**
+- Write tests that would actually catch bugs
+- Use realistic test data
+- Include edge cases and error scenarios
+- Mock external dependencies properly
+- Write clear, descriptive test names
+- Follow the testing framework conventions in the project
+- Verify both return values AND side effects
+- Add helpful assertion messages
+
+**DON'T:**
+- Write tests that just test the framework
+- Test implementation details (test behavior, not internals)
+- Create brittle tests that break with refactoring
+- Use hard-coded magic values without explanation
+- Write tests that depend on each other
+- Ignore async/promise handling
+- Forget to clean up after tests (teardown)
+
+## Framework Detection
+
+Detect which testing framework is used:
+- Jest
+- Jasmine
+- pytest (Python)
+- JUnit (Java)
+- RSpec (Ruby)
+- Others
+
+Match the syntax and patterns of the detected framework.
+
+## Output Format
+
+Provide tests in this structure:
+
+```markdown
+## Generated Test Suite
+
+**Testing Framework:** [Detected or recommended framework]
+
+**Coverage Summary:**
+- Good path tests: [count]
+- Edge case tests: [count]
+- Error handling tests: [count]
+- Total tests: [count]
+
+**Test Code:**
+
+[Full test file code here]
+
+**Setup Instructions:**
+[Any necessary setup, mocking configuration, or dependencies]
+
+**Notes:**
+[Any important context about the tests]
+```
+
+## Example Output
+
+```javascript
+describe('calculateDiscount', () => {
+  describe('good path', () => {
+    it('should apply 10% discount for amounts between $100-$500', () => {
+      const result = calculateDiscount(200);
+      expect(result).toBe(20);
+    });
+
+    it('should apply 20% discount for amounts over $500', () => {
+      const result = calculateDiscount(600);
+      expect(result).toBe(120);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should return 0 discount for $0 amount', () => {
+      const result = calculateDiscount(0);
+      expect(result).toBe(0);
+    });
+
+    it('should handle very large numbers', () => {
+      const result = calculateDiscount(Number.MAX_SAFE_INTEGER);
+      expect(result).toBeGreaterThan(0);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw error for negative amounts', () => {
+      expect(() => calculateDiscount(-10)).toThrow('Amount cannot be negative');
+    });
+
+    it('should throw error for non-numeric input', () => {
+      expect(() => calculateDiscount('abc')).toThrow('Amount must be a number');
+    });
+  });
+});
+```
+
+Now generate comprehensive tests for the provided code.