Unit Test Generator

Automatically generates comprehensive unit tests for your code, supporting multiple programming languages and testing frameworks.

What This Skill Does

This skill creates high-quality unit tests by:

• •Analyzing function/method signatures and logic
• •Generating test cases for happy paths
• •Creating edge case tests
• •Adding error condition tests
• •Following language-specific best practices
• •Using appropriate testing frameworks
• •Including setup/teardown when needed

Instructions

1. Code Analysis

When asked to generate tests:

1. •

   Identify target code:

   • •Use Read to examine the source file
   • •Parse function/class signatures
   • •Understand parameters, return types, and dependencies
2. •

   Detect language and framework:

   • •Python: pytest, unittest
   • •JavaScript/TypeScript: Jest, Mocha, Vitest
   • •Go: testing package
   • •Rust: built-in test framework
   • •Java: JUnit
3. •

   Analyze logic:

   • •Identify all code paths
   • •Find conditionals and branches
   • •Locate error handling
   • •Determine edge cases

2. Test Generation Strategy

Create tests covering:

Happy Path Tests:

• •Normal input → expected output
• •Valid use cases
• •Common scenarios

Edge Cases:

• •Empty inputs
• •Boundary values (min, max)
• •Special characters
• •Large datasets
• •Zero/null values

Error Conditions:

• •Invalid inputs
• •Type mismatches
• •Missing required parameters
• •Exception scenarios

Integration Points:

• •Mock external dependencies
• •Stub API calls
• •Fake database interactions

3. Test Structure

Follow framework-specific conventions:

Python (pytest):

import pytest
from module import function_to_test

class TestFunctionName:
    def test_happy_path(self):
        # Arrange
        input_data = "valid input"

        # Act
        result = function_to_test(input_data)

        # Assert
        assert result == expected_value

    def test_edge_case_empty_input(self):
        with pytest.raises(ValueError):
            function_to_test("")

JavaScript (Jest):

describe('functionName', () => {
  test('should handle valid input', () => {
    // Arrange
    const input = 'test';

    // Act
    const result = functionName(input);

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

  test('should throw error on invalid input', () => {
    expect(() => functionName(null)).toThrow();
  });
});

4. Test Quality

Ensure generated tests:

• •Have descriptive names (test_should_do_x_when_y)
• •Follow AAA pattern (Arrange, Act, Assert)
• •Are independent and isolated
• •Run deterministically
• •Have clear assertions
• •Include comments explaining complex scenarios

5. Output

Present the generated tests and:

• •Explain coverage achieved
• •Note any uncovered scenarios
• •Suggest where to place test file
• •Offer to write tests to appropriate test directory

Examples

Example 1: Python Function

User Request: "Generate tests for the calculate_discount function"

Source Code:

def calculate_discount(price: float, discount_percent: int) -> float:
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Discount must be between 0 and 100")
    return price * (1 - discount_percent / 100)

Generated Tests:

import pytest
from shopping import calculate_discount

class TestCalculateDiscount:
    def test_valid_discount(self):
        """Test normal discount calculation"""
        result = calculate_discount(100.0, 20)
        assert result == 80.0

    def test_zero_discount(self):
        """Test with no discount"""
        result = calculate_discount(100.0, 0)
        assert result == 100.0

    def test_full_discount(self):
        """Test with 100% discount"""
        result = calculate_discount(100.0, 100)
        assert result == 0.0

    def test_negative_discount_raises_error(self):
        """Test that negative discount raises ValueError"""
        with pytest.raises(ValueError, match="between 0 and 100"):
            calculate_discount(100.0, -10)

    def test_discount_over_100_raises_error(self):
        """Test that discount > 100 raises ValueError"""
        with pytest.raises(ValueError, match="between 0 and 100"):
            calculate_discount(100.0, 150)

    def test_zero_price(self):
        """Test with price of 0"""
        result = calculate_discount(0.0, 50)
        assert result == 0.0

Example 2: JavaScript Class

User Request: "Create unit tests for the UserValidator class"

Generated Approach:

1. •Read the class definition
2. •Identify all methods
3. •Generate tests for each method
4. •Mock dependencies (if any)
5. •Create comprehensive test suite

Tool Requirements

• •Read: Examine source code files
• •Grep: Find existing tests, check coverage
• •Write: Create test files
• •Bash: Run tests to verify they work (optional)

Limitations

• •Cannot test private implementation details (by design)
• •May not cover all business logic edge cases without context
• •Generated tests should be reviewed and customized
• •Cannot generate integration/E2E tests (use specific skills for those)
• •Works best with pure functions and well-structured code

Best Practices

When using this skill:

1. •Start with one function: Don't try to test entire file at once
2. •Review generated tests: Ensure they make sense for your use case
3. •Add domain knowledge: Include business-specific edge cases
4. •Run the tests: Verify they pass before committing
5. •Maintain test quality: Keep tests updated as code changes

Error Handling

• •Complex code: Break down into smaller testable units first
• •Heavy dependencies: Suggest refactoring for testability
• •No clear test path: Ask user for expected behavior
• •Existing tests found: Offer to extend rather than replace

Configuration

Adapts to detected setup:

Related Skills

• •tdd-workflow - Test-driven development process
• •coverage-analyzer - Analyze test coverage
• •test-refactorer - Improve existing tests

Changelog

Version 1.0.0 (2025-01-13)

• •Initial release
• •Support for Python, JavaScript, TypeScript
• •pytest and Jest framework support
• •AAA pattern enforcement
• •Edge case generation

Contributing

Want to add support for a new language or framework?

1. •Open an issue with the language/framework name
2. •Submit a PR with examples
3. •Follow Contributing Guidelines

License

Apache License 2.0 - See LICENSE

Author

GLINCKER Team

• •GitHub: @GLINCKER
• •Repository: claude-code-marketplace