alirezarezvani/claude-code-skill-factory / generated-skills/tdd-guide
tdd-guide
VerifiedComprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation
| File | Kind | Size |
|---|---|---|
| HOW_TO_USE.md | markdown | 7.0 KB |
| README.md | markdown | 18.1 KB |
| SKILL.md | skill md | 10.7 KB |
| coverage_analyzer.py | script | 15.1 KB |
| expected_output.json | config | 2.3 KB |
| fixture_generator.py | script | 14.0 KB |
| format_detector.py | script | 11.9 KB |
| framework_adapter.py | script | 14.5 KB |
| metrics_calculator.py | script | 15.1 KB |
| output_formatter.py | script | 12.4 KB |
| sample_coverage_report.lcov | other | 615 B |
| sample_input_python.json | config | 1.4 KB |
| sample_input_typescript.json | config | 1.4 KB |
| tdd_workflow.py | script | 16.6 KB |
| test_generator.py | script | 14.3 KB |
framework_adapter.py
View on GitHub"""
Framework adapter module.
Provides multi-framework support with adapters for Jest, Pytest, JUnit, Vitest, and more.
Handles framework-specific patterns, imports, and test structure.
"""
from typing import Dict, List, Any, Optional
from enum import Enum
class Framework(Enum):
"""Supported testing frameworks."""
JEST = "jest"
VITEST = "vitest"
PYTEST = "pytest"
UNITTEST = "unittest"
JUNIT = "junit"
TESTNG = "testng"
MOCHA = "mocha"
JASMINE = "jasmine"
class Language(Enum):
"""Supported programming languages."""
TYPESCRIPT = "typescript"
JAVASCRIPT = "javascript"
PYTHON = "python"
JAVA = "java"
class FrameworkAdapter:
"""Adapter for multiple testing frameworks."""
def __init__(self, framework: Framework, language: Language):
"""
Initialize framework adapter.
Args:
framework: Testing framework
language: Programming language
"""
self.framework = framework
self.language = language
def generate_imports(self) -> str:
"""Generate framework-specific imports."""
if self.framework == Framework.JEST:
return self._jest_imports()
elif self.framework == Framework.VITEST:
return self._vitest_imports()
elif self.framework == Framework.PYTEST:
return self._pytest_imports()
elif self.framework == Framework.UNITTEST:
return self._unittest_imports()
elif self.framework == Framework.JUNIT:
return self._junit_imports()
elif self.framework == Framework.TESTNG:
return self._testng_imports()
elif self.framework == Framework.MOCHA:
return self._mocha_imports()
else:
return ""
def _jest_imports(self) -> str:
"""Generate Jest imports."""
return """import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';"""
def _vitest_imports(self) -> str:
"""Generate Vitest imports."""
return """import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';"""
def _pytest_imports(self) -> str:
"""Generate Pytest imports."""
return """import pytest"""
def _unittest_imports(self) -> str:
"""Generate unittest imports."""
return """import unittest"""
def _junit_imports(self) -> str:
"""Generate JUnit imports."""
return """import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import static org.junit.jupiter.api.Assertions.*;"""
def _testng_imports(self) -> str:
"""Generate TestNG imports."""
return """import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;
import static org.testng.Assert.*;"""
def _mocha_imports(self) -> str:
"""Generate Mocha imports."""
return """import { describe, it, beforeEach, afterEach } from 'mocha';
import { expect } from 'chai';"""
def generate_test_suite_wrapper(
self,
suite_name: str,
test_content: str
) -> str:
"""
Wrap test content in framework-specific suite structure.
Args:
suite_name: Name of test suite
test_content: Test functions/methods
Returns:
Complete test suite code
"""
if self.framework in [Framework.JEST, Framework.VITEST, Framework.MOCHA]:
return f"""describe('{suite_name}', () => {{
{self._indent(test_content, 2)}
}});"""
elif self.framework == Framework.PYTEST:
return f"""class Test{self._to_class_name(suite_name)}:
\"\"\"Test suite for {suite_name}.\"\"\"
{self._indent(test_content, 4)}"""
elif self.framework == Framework.UNITTEST:
return f"""class Test{self._to_class_name(suite_name)}(unittest.TestCase):
\"\"\"Test suite for {suite_name}.\"\"\"
{self._indent(test_content, 4)}"""
elif self.framework in [Framework.JUNIT, Framework.TESTNG]:
return f"""public class {self._to_class_name(suite_name)}Test {{
{self._indent(test_content, 4)}
}}"""
return test_content
def generate_test_function(
self,
test_name: str,
test_body: str,
description: str = ""
) -> str:
"""
Generate framework-specific test function.
Args:
test_name: Name of test
test_body: Test body code
description: Test description
Returns:
Complete test function
"""
if self.framework == Framework.JEST:
return self._jest_test(test_name, test_body, description)
elif self.framework == Framework.VITEST:
return self._vitest_test(test_name, test_body, description)
elif self.framework == Framework.PYTEST:
return self._pytest_test(test_name, test_body, description)
elif self.framework == Framework.UNITTEST:
return self._unittest_test(test_name, test_body, description)
elif self.framework == Framework.JUNIT:
return self._junit_test(test_name, test_body, description)
elif self.framework == Framework.TESTNG:
return self._testng_test(test_name, test_body, description)
elif self.framework == Framework.MOCHA:
return self._mocha_test(test_name, test_body, description)
else:
return ""
def _jest_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate Jest test."""
return f"""it('{test_name}', () => {{
// {description}
{self._indent(test_body, 2)}
}});"""
def _vitest_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate Vitest test."""
return f"""it('{test_name}', () => {{
// {description}
{self._indent(test_body, 2)}
}});"""
def _pytest_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate Pytest test."""
func_name = test_name.replace(' ', '_').replace('-', '_')
return f"""def test_{func_name}(self):
\"\"\"
{description or test_name}
\"\"\"
{self._indent(test_body, 4)}"""
def _unittest_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate unittest test."""
func_name = self._to_camel_case(test_name)
return f"""def test_{func_name}(self):
\"\"\"
{description or test_name}
\"\"\"
{self._indent(test_body, 4)}"""
def _junit_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate JUnit test."""
method_name = self._to_camel_case(test_name)
return f"""@Test
public void test{method_name}() {{
// {description}
{self._indent(test_body, 4)}
}}"""
def _testng_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate TestNG test."""
method_name = self._to_camel_case(test_name)
return f"""@Test
public void test{method_name}() {{
// {description}
{self._indent(test_body, 4)}
}}"""
def _mocha_test(self, test_name: str, test_body: str, description: str) -> str:
"""Generate Mocha test."""
return f"""it('{test_name}', () => {{
// {description}
{self._indent(test_body, 2)}
}});"""
def generate_assertion(
self,
actual: str,
expected: str,
assertion_type: str = "equals"
) -> str:
"""
Generate framework-specific assertion.
Args:
actual: Actual value expression
expected: Expected value expression
assertion_type: Type of assertion (equals, not_equals, true, false, throws)
Returns:
Assertion statement
"""
if self.framework in [Framework.JEST, Framework.VITEST]:
return self._jest_assertion(actual, expected, assertion_type)
elif self.framework in [Framework.PYTEST, Framework.UNITTEST]:
return self._python_assertion(actual, expected, assertion_type)
elif self.framework in [Framework.JUNIT, Framework.TESTNG]:
return self._java_assertion(actual, expected, assertion_type)
elif self.framework == Framework.MOCHA:
return self._chai_assertion(actual, expected, assertion_type)
else:
return f"assert {actual} == {expected}"
def _jest_assertion(self, actual: str, expected: str, assertion_type: str) -> str:
"""Generate Jest assertion."""
if assertion_type == "equals":
return f"expect({actual}).toBe({expected});"
elif assertion_type == "not_equals":
return f"expect({actual}).not.toBe({expected});"
elif assertion_type == "true":
return f"expect({actual}).toBe(true);"
elif assertion_type == "false":
return f"expect({actual}).toBe(false);"
elif assertion_type == "throws":
return f"expect(() => {actual}).toThrow();"
else:
return f"expect({actual}).toBe({expected});"
def _python_assertion(self, actual: str, expected: str, assertion_type: str) -> str:
"""Generate Python assertion."""
if assertion_type == "equals":
return f"assert {actual} == {expected}"
elif assertion_type == "not_equals":
return f"assert {actual} != {expected}"
elif assertion_type == "true":
return f"assert {actual} is True"
elif assertion_type == "false":
return f"assert {actual} is False"
elif assertion_type == "throws":
return f"with pytest.raises(Exception):\n {actual}"
else:
return f"assert {actual} == {expected}"
def _java_assertion(self, actual: str, expected: str, assertion_type: str) -> str:
"""Generate Java assertion."""
if assertion_type == "equals":
return f"assertEquals({expected}, {actual});"
elif assertion_type == "not_equals":
return f"assertNotEquals({expected}, {actual});"
elif assertion_type == "true":
return f"assertTrue({actual});"
elif assertion_type == "false":
return f"assertFalse({actual});"
elif assertion_type == "throws":
return f"assertThrows(Exception.class, () -> {actual});"
else:
return f"assertEquals({expected}, {actual});"
def _chai_assertion(self, actual: str, expected: str, assertion_type: str) -> str:
"""Generate Chai assertion."""
if assertion_type == "equals":
return f"expect({actual}).to.equal({expected});"
elif assertion_type == "not_equals":
return f"expect({actual}).to.not.equal({expected});"
elif assertion_type == "true":
return f"expect({actual}).to.be.true;"
elif assertion_type == "false":
return f"expect({actual}).to.be.false;"
elif assertion_type == "throws":
return f"expect(() => {actual}).to.throw();"
else:
return f"expect({actual}).to.equal({expected});"
def generate_setup_teardown(
self,
setup_code: str = "",
teardown_code: str = ""
) -> str:
"""Generate setup and teardown hooks."""
result = []
if self.framework in [Framework.JEST, Framework.VITEST, Framework.MOCHA]:
if setup_code:
result.append(f"""beforeEach(() => {{
{self._indent(setup_code, 2)}
}});""")
if teardown_code:
result.append(f"""afterEach(() => {{
{self._indent(teardown_code, 2)}
}});""")
elif self.framework == Framework.PYTEST:
if setup_code:
result.append(f"""@pytest.fixture(autouse=True)
def setup_method(self):
{self._indent(setup_code, 4)}
yield""")
if teardown_code:
result.append(f"""
{self._indent(teardown_code, 4)}""")
elif self.framework == Framework.UNITTEST:
if setup_code:
result.append(f"""def setUp(self):
{self._indent(setup_code, 4)}""")
if teardown_code:
result.append(f"""def tearDown(self):
{self._indent(teardown_code, 4)}""")
elif self.framework in [Framework.JUNIT, Framework.TESTNG]:
annotation = "@BeforeEach" if self.framework == Framework.JUNIT else "@BeforeMethod"
if setup_code:
result.append(f"""{annotation}
public void setUp() {{
{self._indent(setup_code, 4)}
}}""")
annotation = "@AfterEach" if self.framework == Framework.JUNIT else "@AfterMethod"
if teardown_code:
result.append(f"""{annotation}
public void tearDown() {{
{self._indent(teardown_code, 4)}
}}""")
return "\n\n".join(result)
def _indent(self, text: str, spaces: int) -> str:
"""Indent text by number of spaces."""
indent = " " * spaces
lines = text.split('\n')
return '\n'.join(indent + line if line.strip() else line for line in lines)
def _to_camel_case(self, text: str) -> str:
"""Convert text to camelCase."""
words = text.replace('-', ' ').replace('_', ' ').split()
if not words:
return text
return words[0].lower() + ''.join(word.capitalize() for word in words[1:])
def _to_class_name(self, text: str) -> str:
"""Convert text to ClassName."""
words = text.replace('-', ' ').replace('_', ' ').split()
return ''.join(word.capitalize() for word in words)
def detect_framework(self, code: str) -> Optional[Framework]:
"""
Auto-detect testing framework from code.
Args:
code: Test code
Returns:
Detected framework or None
"""
# Jest patterns
if 'from \'@jest/globals\'' in code or '@jest/' in code:
return Framework.JEST
# Vitest patterns
if 'from \'vitest\'' in code or 'import { vi }' in code:
return Framework.VITEST
# Pytest patterns
if 'import pytest' in code or 'def test_' in code and 'pytest.fixture' in code:
return Framework.PYTEST
# Unittest patterns
if 'import unittest' in code and 'unittest.TestCase' in code:
return Framework.UNITTEST
# JUnit patterns
if '@Test' in code and 'import org.junit' in code:
return Framework.JUNIT
# TestNG patterns
if '@Test' in code and 'import org.testng' in code:
return Framework.TESTNG
# Mocha patterns
if 'from \'mocha\'' in code or ('describe(' in code and 'from \'chai\'' in code):
return Framework.MOCHA
return None
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |