unit-test-generator

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