test-generation

Generate comprehensive tests following project testing patterns. Use after implementing features.

⭐21stars🔀15forks📁View on GitHub🕐Updated Jan 7, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill automates the generation of comprehensive unit, integration, and E2E tests by adhering to predefined project patterns and industry best practices. It streamlines the software development lifecycle by ensuring consistent test structures, high code coverage, and robust error handling, ultimately improving code reliability and maintainability.

Use Cases

  • Automating unit test creation for new features using the Arrange-Act-Assert (AAA) pattern to ensure functional correctness.
  • Generating integration tests to validate seamless communication and data flow between different system components.
  • Developing End-to-End (E2E) test suites for critical user journeys to prevent regressions in production environments.
  • Improving legacy codebase quality by generating missing tests that align with existing naming conventions and coverage targets.
nametest-generation
descriptionGenerate comprehensive tests following project testing patterns.

Test Generation Skill

Purpose

Create consistent, comprehensive tests.

Test Patterns

Unit Test Pattern

Reference: patterns/unit-tests.md

describe('[Unit Under Test]', () => {
  describe('[method/function]', () => {
    it('should [expected behavior] when [condition]', () => {
      // Arrange
      const input = ...;
      const expected = ...;

      // Act
      const result = functionUnderTest(input);

      // Assert
      expect(result).toEqual(expected);
    });

    it('should throw [error] when [invalid condition]', () => {
      // Arrange
      const invalidInput = ...;

      // Act & Assert
      expect(() => functionUnderTest(invalidInput))
        .toThrow(ExpectedError);
    });
  });
});

Integration Test Pattern

Reference: patterns/integration-tests.md

E2E Test Pattern

Reference: patterns/e2e-tests.md

Coverage Targets

Type Lines Functions Branches
Unit 80% 80% 70%
Integration 60% 60% 50%
E2E Critical paths - -

Test Naming Convention

[should/does] [expected behavior] [when/given] [condition]

Examples:

  • should return user when valid ID provided
  • should throw NotFoundError when user does not exist
  • should disable button when form is invalid

What to Test

  • Happy path (normal operation)
  • Edge cases (boundaries)
  • Error cases (exceptions)
  • State transitions

Test Structure

AAA Pattern

// Arrange - set up test data and conditions
const input = createTestInput();
const mockService = createMock();

// Act - execute the code under test
const result = await functionUnderTest(input);

// Assert - verify the outcome
expect(result).toEqual(expectedOutput);
expect(mockService.method).toHaveBeenCalledWith(expectedArgs);

BDD Style

describe('User Service', () => {
  describe('when creating a user', () => {
    it('should save the user to the database', () => { });
    it('should send a welcome email', () => { });
    it('should return the created user', () => { });
  });

  describe('when the email is invalid', () => {
    it('should throw a ValidationError', () => { });
  });
});

Test Template

Use: templates/test-template.ts

Best Practices

Do

  • Test behavior, not implementation
  • Use descriptive test names
  • Keep tests independent
  • Use factories for test data
  • Mock external dependencies

Don't

  • Test private methods directly
  • Share state between tests
  • Use production data in tests
  • Over-mock (test should be meaningful)
  • Write flaky tests

Storage Location

Save test reports to: docs/reviews/test-report-{session}.md