code-testing

name

code-testing

description

Generate and run unit and integration tests using pytest (Python) or Jest (JavaScript) with fixtures, mocks, and async support. Use for test-driven development, code review validation, coverage verification, and regression testing. Target 80%+ code coverage. Supports pytest markers, Jest snapshots, and CI/CD integration. Triggers on "test", "TDD", "unit test", "integration test", "test coverage", "pytest", "jest".

Code Testing

Purpose

Generate and run comprehensive unit and integration tests following TDD principles with proper fixtures, mocking, and coverage measurement.

When to Use

• Test-driven development (TDD)
• Code review validation
• Coverage verification
• Regression testing
• CI/CD pipeline integration
• Ensuring code quality

Core Instructions

Python Unit Test (pytest)

import pytest
from my_module import calculate_total

@pytest.fixture
def sample_data():
    """Fixture providing test data"""
    return {
        "items": [
            {"price": 10.0, "quantity": 2},
            {"price": 5.0, "quantity": 3}
        ]
    }

def test_calculate_total(sample_data):
    """Test total calculation"""
    result = calculate_total(sample_data["items"])
    assert result == 35.0

def test_calculate_total_empty():
    """Test with empty list"""
    result = calculate_total([])
    assert result == 0.0

@pytest.mark.asyncio
async def test_async_function():
    """Test async operations"""
    result = await fetch_data()
    assert result is not None
    assert "id" in result

JavaScript Test (Jest)

import { render, screen } from '@testing-library/react';
import { calculateTotal } from './utils';
import Component from './Component';

describe('calculateTotal', () => {
  test('calculates total correctly', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5, quantity: 3 }
    ];
    expect(calculateTotal(items)).toBe(35);
  });

  test('handles empty array', () => {
    expect(calculateTotal([])).toBe(0);
  });
});

describe('Component', () => {
  test('renders correctly', () => {
    render(<Component />);
    expect(screen.getByText('Hello')).toBeInTheDocument();
  });

  test(,  () => {
    ();
     data =  screen.();
    (data).();
  });
});

Mocking External Dependencies

Python (unittest.mock):

from unittest.mock import Mock, patch

@patch('my_module.external_api_call')
def test_with_mock(mock_api):
    """Mock external API"""
    mock_api.return_value = {"status": "success"}

    result = my_function()

    assert result["status"] == "success"
    mock_api.assert_called_once()

JavaScript (Jest):

jest.mock('./api', () => ({
  fetchData: jest.fn()
}));

import { fetchData } from './api';

test('mocks API call', async () => {
  fetchData.mockResolvedValue({ status: 'success' });

  const result = await myFunction();

  expect(result.status).toBe('success');
  expect(fetchData).toHaveBeenCalledTimes(1);
});

TDD Workflow (Red-Green-Refactor)

1. RED: Write Failing Test

def test_new_feature():
    """Test for feature that doesn't exist yet"""
    result = new_feature(input_data)
    assert result == expected_output

Run test: pytest → ❌ FAILS (feature not implemented)

2. GREEN: Implement Minimum Code

def new_feature(input_data):
    """Minimal implementation to pass test"""
    return expected_output

Run test: pytest → ✅ PASSES

3. REFACTOR: Improve Code

def new_feature(input_data):
    """Refactored implementation"""
    # Clean, efficient implementation
    return process(input_data)

Run test: pytest → ✅ STILL PASSES

Coverage Measurement

Python (pytest-cov)

# Run tests with coverage
pytest tests/ --cov=src --cov-report=html --cov-report=term

# Generate HTML report
pytest --cov=src --cov-report=html
open htmlcov/index.html

# Fail if coverage below threshold
pytest --cov=src --cov-fail-under=80

JavaScript (Jest)

# Run tests with coverage
npm test -- --coverage

# Coverage thresholds in jest.config.js
module.exports = {
  coverageThreshold: {
    global: {
      branches: 80,
      functions: 80,
      lines: 80,
      statements: 80
    }
  }
};

Best Practices

Structure Tests (AAA Pattern)

def test_user_creation():
    # ARRANGE: Setup test data
    user_data = {"name": "John", "email": "[e-mail]"}

    # ACT: Execute the function
    user = create_user(user_data)

    # ASSERT: Verify results
    assert user.name == "John"
    assert user.email == "[e-mail]"
    assert user.id is not None

Use Descriptive Names

# Good
def test_calculate_total_with_discount_applied():
    pass

# Bad
def test_calc():
    pass

Test Edge Cases

def test_division_by_zero():
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

def test_empty_input():
    result = process([])
    assert result == []

def test_null_input():
    result = process(None)
    assert result is None

Use Fixtures for Setup

@pytest.fixture
def database():
    """Setup test database"""
    db = create_test_db()
    yield db
    db.cleanup()

def test_with_db(database):
    user = database.create_user("test")
    assert user.name == "test"

CI/CD Integration

GitHub Actions

- name: Run tests
  run: |
    pytest tests/ --cov=src --cov-report=xml

- name: Upload coverage
  uses: codecov/codecov-action@v3
  with:
    files: ./coverage.xml

Output Formats

JUnit XML (for CI):

pytest --junitxml=test-results.xml

JSON (for parsing):

pytest --json-report --json-report-file=report.json

Performance Testing

import pytest
import time

@pytest.mark.benchmark
def test_performance(benchmark):
    """Benchmark function performance"""
    result = benchmark(expensive_function, large_input)
    assert result is not None

@pytest.mark.timeout(5)
def test_timeout():
    """Test must complete within 5 seconds"""
    result = slow_function()
    assert result is not None

Dependencies

Python:

• pytest - Test framework
• pytest-cov - Coverage plugin
• pytest-asyncio - Async test support
• pytest-mock - Mocking utilities

JavaScript:

• jest - Test framework
• @testing-library/react - React testing
• @testing-library/jest-dom - Custom matchers

Version

v1.0.0 (2025-10-23)