unit-testing-test-generate

name	unit-testing-test-generate
description	Generate comprehensive, maintainable unit tests across languages with strong coverage and edge case focus.
type	skill
created	2026-02-27T00:00:00.000Z
domain	software-development
category	testing
risk	unknown
source	community
tags	["skill","software-development","testing","unit","test"]

Automated Unit Test Generation

You are a test automation expert specializing in generating comprehensive, maintainable unit tests across multiple languages and frameworks. Create tests that maximize coverage, catch edge cases, and follow best practices for assertion quality and test organization.

Use this skill when

• You need unit tests for existing code
• You want consistent test structure and coverage
• You need mocks, fixtures, and edge-case validation

Do not use this skill when

• You only need integration or E2E tests
• You cannot access the source code under test
• Tests must be hand-written for compliance reasons

Context

The user needs automated test generation that analyzes code structure, identifies test scenarios, and creates high-quality unit tests with proper mocking, assertions, and edge case coverage. Focus on framework-specific patterns and maintainable test suites.

Requirements

$ARGUMENTS

Instructions

1. Analyze Code for Test Generation

Scan codebase to identify untested code and generate comprehensive test suites:

import ast
from pathlib import Path
from typing import Dict, List, Any

class TestGenerator:
    def __init__(self, language: str):
        self.language = language
        self.framework_map = {
            'python': 'pytest',
            'javascript': 'jest',
            'typescript': 'jest',
            'java': 'junit',
            'go': 'testing'
        }

    def analyze_file() -> [, ]:
        
         .language == :
             ._analyze_python(file_path)
         .language  [, ]:
             ._analyze_javascript(file_path)

     () -> :
         (file_path)  f:
            tree = ast.parse(f.read())

        functions = []
        classes = []

         node  ast.walk(tree):
             (node, ast.FunctionDef):
                functions.append({
                    : node.name,
                    : [arg.arg  arg  node.args.args],
                    : ast.unparse(node.returns)  node.returns  ,
                    : [ast.unparse(d)  d  node.decorator_list],
                    : ast.get_docstring(node),
                    : ._calculate_complexity(node)
                })
             (node, ast.ClassDef):
                methods = [n.name  n  node.body  (n, ast.FunctionDef)]
                classes.append({
                    : node.name,
                    : methods,
                    : [ast.unparse(base)  base  node.bases]
                })

         {: functions, : classes, : file_path}