Unit Test Generator

Generate comprehensive unit tests with edge cases, mocks, and assertions. Achieve high test coverage and catch bugs before production. Works with any testing framework and language.

or press Ctrl+Shift+C

Prompt:

You are a test-driven development expert who writes comprehensive, maintainable test suites. Create unit tests that catch bugs, document behavior, and ensure code reliability.

I need comprehensive unit tests for the following code:

TEST CONTEXT:
Language: [PROGRAMMING LANGUAGE]
Testing Framework: [JEST / PYTEST / JUNIT / MOCHA / ETC]
Coverage Target: [PERCENTAGE]
Mock Strategy: [MOCK ALL EXTERNAL / MINIMAL MOCKS / ETC]

Code to Test:
```[language]
[PASTE YOUR CODE HERE]
```

Dependencies/Imports:
```[language]
[PASTE RELEVANT DEPENDENCIES IF ANY]
```

Please generate:

1. COMPLETE TEST SUITE
Full test implementation:
```[language]
// ============================================
// UNIT TESTS FOR [MODULE/CLASS NAME]
// ============================================

import { describe, test, expect, beforeEach, afterEach, jest } from '[framework]';
import { [ClassToTest] } from './[module]';
// Import mocks and dependencies

// Mock external dependencies
jest.mock('./externalService', () => ({
    // Mock implementation
}));

describe('[ClassToTest]', () => {
    let instance;
    let mockDependency;
    
    // Setup and teardown
    beforeEach(() => {
        // Reset mocks
        jest.clearAllMocks();
        
        // Create fresh instance
        mockDependency = {
            method: jest.fn()
        };
        instance = new [ClassToTest](mockDependency);
    });
    
    afterEach(() => {
        // Cleanup
    });
    
    // ========== HAPPY PATH TESTS ==========
    describe('Happy Path', () => {
        test('should [expected behavior] when [condition]', () => {
            // Arrange
            const input = /* test data */;
            const expected = /* expected result */;
            
            // Act
            const result = instance.method(input);
            
            // Assert
            expect(result).toEqual(expected);
            expect(mockDependency.method).toHaveBeenCalledWith(/* args */);
            expect(mockDependency.method).toHaveBeenCalledTimes(1);
        });
        
        test('should [another behavior] when [another condition]', () => {
            // Test implementation
        });
    });
    
    // ========== EDGE CASES ==========
    describe('Edge Cases', () => {
        test('should handle empty input', () => {
            // Test empty arrays, strings, objects
        });
        
        test('should handle null/undefined', () => {
            // Test null and undefined inputs
        });
        
        test('should handle maximum values', () => {
            // Test with MAX_SAFE_INTEGER, etc
        });
        
        test('should handle minimum values', () => {
            // Test with negative numbers, zero
        });
        
        test('should handle special characters', () => {
            // Test with unicode, emojis, etc
        });
    });
    
    // ========== ERROR CASES ==========
    describe('Error Handling', () => {
        test('should throw error when [invalid condition]', () => {
            // Arrange
            const invalidInput = /* invalid data */;
            
            // Act & Assert
            expect(() => {
                instance.method(invalidInput);
            }).toThrow('[Expected Error Message]');
        });
        
        test('should handle async errors gracefully', async () => {
            // Mock rejection
            mockDependency.asyncMethod.mockRejectedValue(new Error('Network error'));
            
            // Test error handling
            await expect(instance.asyncMethod()).rejects.toThrow('Network error');
        });
    });
    
    // ========== ASYNC TESTS ==========
    describe('Async Operations', () => {
        test('should handle async operations correctly', async () => {
            // Arrange
            const mockData = { /* data */ };
            mockDependency.fetchData.mockResolvedValue(mockData);
            
            // Act
            const result = await instance.asyncMethod();
            
            // Assert
            expect(result).toEqual(/* expected */);
        });
        
        test('should handle concurrent async calls', async () => {
            // Test race conditions
        });
    });
    
    // ========== INTEGRATION POINTS ==========
    describe('Integration Points', () => {
        test('should interact correctly with [dependency]', () => {
            // Test dependency interactions
        });
        
        test('should emit correct events', () => {
            // Test event emissions
        });
    });
});
```

2. TEST COVERAGE MATRIX
What's being tested:
```
Method: [methodName]
✅ Normal inputs
✅ Edge cases (null, undefined, empty)
✅ Boundary values
✅ Error conditions
✅ Async scenarios
✅ Performance (if applicable)

Method: [anotherMethod]
✅ [Test scenarios]
...

COVERAGE SUMMARY:
- Lines: 95%
- Branches: 90%
- Functions: 100%
- Statements: 92%
```

3. MOCK IMPLEMENTATIONS
Reusable mocks:
```[language]
// __mocks__/externalService.js
export const mockExternalService = {
    fetchData: jest.fn(() => Promise.resolve({ data: 'mock' })),
    sendData: jest.fn(() => Promise.resolve({ success: true })),
    // Add failure scenarios
    fetchDataFailure: jest.fn(() => Promise.reject(new Error('Network error')))
};

// Mock factories for different scenarios
export const createMockUser = (overrides = {}) => ({
    id: 1,
    name: 'Test User',
    email: 'test@example.com',
    ...overrides
});

export const createMockDatabase = () => ({
    query: jest.fn(),
    insert: jest.fn(),
    update: jest.fn(),
    delete: jest.fn()
});
```

4. PARAMETERIZED TESTS
Test multiple scenarios efficiently:
```[language]
describe.each([
    ['empty string', '', 0],
    ['single word', 'hello', 1],
    ['multiple words', 'hello world', 2],
    ['with punctuation', 'hello, world!', 2],
    ['with numbers', 'hello 123 world', 3],
])('wordCount(%s)', (description, input, expected) => {
    test(`returns ${expected} for ${description}`, () => {
        expect(wordCount(input)).toBe(expected);
    });
});
```

5. PERFORMANCE TESTS
Ensure code performs well:
```[language]
test('should complete within performance budget', () => {
    const startTime = performance.now();
    const largeDataSet = Array(10000).fill(0).map((_, i) => i);
    
    // Act
    instance.processData(largeDataSet);
    
    // Assert
    const endTime = performance.now();
    const executionTime = endTime - startTime;
    expect(executionTime).toBeLessThan(100); // ms
});
```

6. SNAPSHOT TESTS
For UI or complex objects:
```[language]
test('should match snapshot', () => {
    const result = instance.generateReport(data);
    expect(result).toMatchSnapshot();
});

test('should match inline snapshot', () => {
    expect(instance.formatData(input)).toMatchInlineSnapshot(`
        Object {
            "formatted": true,
            "data": Array [1, 2, 3]
        }
    `);
});
```

7. TEST UTILITIES
Helper functions for tests:
```[language]
// testUtils.js
export const waitFor = (condition, timeout = 5000) => {
    // Polling utility
};

export const setupTestDatabase = async () => {
    // Database setup for tests
};

export const cleanupTestData = async () => {
    // Cleanup after tests
};

export const assertDeepEquals = (actual, expected) => {
    // Custom deep equality assertion
};
```

8. CI/CD INTEGRATION
Run tests in pipeline:
```yaml
# .github/workflows/test.yml
name: Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test -- --coverage
      - name: Upload coverage
        uses: codecov/codecov-action@v2
```

9. TEST DOCUMENTATION
Explain test approach:
```markdown
## Testing Strategy
- Unit tests for all public methods
- Integration tests for API endpoints
- E2E tests for critical user flows

## Running Tests
npm test           # Run all tests
npm test:watch     # Watch mode
npm test:coverage  # With coverage report

## Writing Tests
- Follow AAA pattern (Arrange, Act, Assert)
- One assertion per test when possible
- Use descriptive test names
```

10. COMMON TESTING PATTERNS
Reusable patterns:
- **Builder Pattern** for test data
- **Object Mother** for complex objects
- **Test Data Factory** for consistency
- **Custom Matchers** for domain logic
- **Test Fixtures** for static data

Please ensure tests are:
- Independent (no shared state)
- Repeatable (same result every time)
- Fast (milliseconds not seconds)
- Descriptive (clear failure messages)
- Maintainable (easy to update)

Pro Tips:

Include the actual implementation code, not just the interface
Specify your mocking preferences (full mocks vs minimal)
Mention any specific edge cases you're concerned about
Include external dependencies that need mocking
Specify if you need integration tests vs pure unit tests

⚡ Code at Peak Performance

Long coding sessions demand sustained mental energy. Neuro Energizer uses scientifically-proven nootropics to enhance focus, memory, and cognitive speed - helping you debug faster, think clearer, and code better for hours without the crash.

Unlock Your Coding Potential →

*Sponsored - We may earn a commission if you purchase. This helps us keep all prompts free.

Unit Test Generator

Pro Tips:

⚡ Code at Peak Performance

🚀 Works 10x Better With

The Genius Wave

Unit Test Generator

Pro Tips:

Related Prompts

Debug Master

Code Review Pro

Legacy Code Refactorer

⚡ Code at Peak Performance

🚀 Works 10x Better With

The Genius Wave