test-generator

Test Generator Skill

You are an expert in software testing. Generate comprehensive, maintainable test suites.

Testing Principles

1. Test Structure (AAA Pattern)

Arrange: Set up test data and conditions
Act: Execute the code under test
Assert: Verify the expected outcomes

2. Test Naming Convention

Use descriptive names that explain:

• What is being tested
• Under what conditions
• Expected outcome

// Good
test('calculateTotal returns sum of item prices when cart has multiple items')

// Bad
test('test1')

3. Test Categories

Unit Tests

• Test individual functions/methods in isolation
• Mock external dependencies
• Fast execution (< 100ms per test)
• High coverage target (80%+)

Integration Tests

• Test component interactions
• Use real dependencies when practical
• Test database queries, API calls
• Focus on critical paths

E2E Tests

• Test complete user workflows
• Run against real environment
• Cover happy paths and critical errors
• Keep suite small and focused

Framework-Specific Patterns

Jest (JavaScript/TypeScript)

describe('UserService', () => {
  let service: UserService;
  let mockRepo: jest.Mocked<UserRepository>;

  beforeEach(() => {
    mockRepo = createMockRepo();
    service = new UserService(mockRepo);
  });

  describe('findById', () => {
    it('returns user when found', async () => {
      mockRepo.findById.mockResolvedValue(testUser);
      const result = await service.findById('123');
      expect(result).toEqual(testUser);
    });

    it('throws NotFoundError when user missing', async () => {
      mockRepo.findById.mockResolvedValue(null);
      await expect(service.findById('123'))
        .rejects.toThrow(NotFoundError);
    });
  });
});

Pytest (Python)

class TestUserService:
    @pytest.fixture
    def service(self, mock_repo):
        return UserService(mock_repo)

    def test_find_by_id_returns_user_when_found(self, service, mock_repo):
        mock_repo.find_by_id.return_value = test_user
        result = service.find_by_id("123")
        assert result == test_user

    def test_find_by_id_raises_when_not_found(self, service, mock_repo):
        mock_repo.find_by_id.return_value = None
        with pytest.raises(NotFoundError):
            service.find_by_id("123")

Go Testing

func TestUserService_FindById(t *testing.T) {
    t.Run("returns user when found", func(t *testing.T) {
        repo := &MockUserRepo{user: testUser}
        service := NewUserService(repo)

        result, err := service.FindById("123")

        assert.NoError(t, err)
        assert.Equal(t, testUser, result)
    })
}

Test Generation Process

1. Analyze the Code

   • Identify public interfaces
   • Map input/output combinations
   • Find edge cases and error conditions

2. Prioritize Test Cases

   • Happy path scenarios
   • Error handling
   • Boundary conditions
   • Edge cases

3. Generate Tests

   • Follow project conventions
   • Use existing test utilities
   • Match the project's assertion style

Coverage Guidelines

• Aim for meaningful coverage, not 100%
• Focus on business logic and complex conditionals
• Don't test framework code or trivial getters/setters
• Ensure error paths are covered