testing-unit

What this skill does

## Purpose

This skill equips the AI to assist with unit testing using frameworks like Jest/Vitest for JavaScript, pytest for Python, Go's testify, RSpec for Ruby, XCTest for Swift, and JUnit5 for Java. It focuses on mocking dependencies, creating stubs, and ensuring test isolation to verify code behavior in controlled environments.

## When to Use

Use this skill when writing new unit tests, debugging existing ones, or refactoring code that requires isolated testing. Apply it for TDD workflows, mocking external APIs or databases, or ensuring functions work independently. For example, use it when a function depends on a network call—mock it to test locally without real dependencies.

## Key Capabilities

- **Mocking**: Create mocks for functions or modules, e.g., in Jest with `jest.mock('module')` to replace real implementations.
- **Stubbing**: Define stub responses, like in pytest using `monkeypatch.setattr()` to fake object methods.
- **Isolation**: Run tests in isolation, such as using Go's testify to assert without side effects, or JUnit5's `@TempDir` for isolated file operations.
- **Framework-Specific**: Support for Jest/Vitest assertions (e.g., `expect().toBe()`), pytest fixtures for setup/teardown, RSpec's `double` for mocks, XCTest's `setUp()` for isolation, and JUnit5's `@Mock` annotations.
- **Config Formats**: Use Jest's `jest.config.js` with `{ testEnvironment: 'node', setupFilesAfterEnv: ['<rootDir>/setupTests.js'] }` for custom mocks; pytest's `pytest.ini` with `[pytest] addopts = -v` for verbose output.

## Usage Patterns

To accomplish unit testing tasks, follow these steps: 1) Identify dependencies to mock (e.g., HTTP calls). 2) Set up mocks or stubs in your test file. 3) Write assertions to verify outputs. 4) Run tests with appropriate flags. For TDD, write a failing test first, then implement code. In Jest, structure tests with `describe()` blocks; in pytest, use fixtures for shared setup. Always isolate tests by avoiding global state—use `beforeEach()` in Jest or `@pytest.fixture(scope='function')` in pytest.

## Common Commands/API

- **Jest/Vitest**: Run tests with `npx jest --watchAll` for interactive mode; mock modules via `jest.mock('axios', () => ({ get: jest.fn().mockResolvedValue({ data: {} }) }));`. API: Use `expect(value).toEqual(expected)` for assertions.
- **pytest**: Execute with `pytest tests/ -v --cov` for coverage; stub functions with `def test_function(monkeypatch): monkeypatch.setattr('module.func', lambda: 'stubbed')`. API: Leverage `@pytest.fixture` for isolation, e.g., `def mock_db(): return {'query': lambda: []}`.
- **Go (testify)**: Build with `go test -v ./...` and use `mock.Mock` from testify; e.g., `mockCtrl := gomock.NewController(t); mockObj := NewMockInterface(mockCtrl); mockObj.EXPECT().Method().Return(value)`.
- **RSpec**: Run via `rspec spec/`; create doubles with `double('Object', method: -> 'stubbed')`. API: Use `expect { code }.to change { something }`.
- **XCTest**: Compile and run with `xcodebuild test`; mock in Swift using `protocol` stubs, e.g., `class MockService: ServiceProtocol { func fetchData() -> Data { return Data() } }`.
- **JUnit5**: Execute via `./gradlew test`; use Mockito with `@ExtendWith(MockitoExtension.class) public class TestClass { @Mock private Dependency dep; @InjectMocks private ClassUnderTest cut; }`. If integrating external services, set env vars like `$API_KEY` for authentication in tests.

## Integration Notes

Integrate this skill by embedding unit tests into CI/CD pipelines, e.g., add Jest to a GitHub Actions workflow with `run: npm test`. For multi-language projects, use a monorepo setup with tools like Nx for Jest and pytest. Configure environment variables for secrets, e.g., export `$DATABASE_URL` in your test runner. Link with code coverage tools like Istanbul for Jest or Coverage.py for pytest; ensure mocks respect these by using `--no-cov` flags when debugging. For API-dependent tests, inject env vars like `$SERVICE_API_KEY` into your test command, e.g., `pytest --api-key=$SERVICE_API_KEY`.

## Error Handling

Handle common errors prescriptively: For assertion failures in Jest, check stack traces and use `jest.fn().mockImplementation()` to debug mocks; if a mock isn't called, add `.toHaveBeenCalled()` assertions. In pytest, catch fixture errors by wrapping in try/except, e.g., `def test_with_fixture(fix): try: fix.setup() except Exception as e: pytest.fail(str(e))`. For Go, use testify's `assert.NoError(t, err)` to fail tests on errors. In RSpec, handle doubles with `allow(double).to receive(:method).and_raise(Error)`. For JUnit5, use `@Test(expected = Exception.class)` for expected failures. Always isolate error-prone code with stubs to prevent cascading failures; rerun with verbose flags like `jest --debug` or `pytest -s` for detailed output.

## Concrete Usage Examples

1. **Jest Mock Example**: To test a function that fetches data, mock the fetch API:  
   `jest.mock('node-fetch'); const fetch = require('node-fetch'); fetch.mockResolvedValue({ json: () => Promise.resolve({ data: 'mocked' }) }); test('fetches data', async () => { expect(await fetchData()).toEqual('mocked'); });`

2. **pytest Fixture Example**: To isolate a database-dependent test, use a fixture:  
   `import pytest @pytest.fixture def mock_db(): return {'query': lambda: [{'id': 1}]} def test_query(mock_db): assert mock_db['query']()[0]['id'] == 1`

## Graph Relationships

- Related to: testing-integration (for broader testing workflows), code-debugging (for fixing test failures)
- Clusters with: testing (as part of the testing cluster), code-execution (for running tests in isolated environments)
- Depends on: environment-setup (for managing test dependencies like mocks)