git:20260818.6723100 to git:20260819.170df67

- # Unit Testing Skill

- Write effective, maintainable unit tests informed by the project's actual framework,

- production error data, and current best practices.

- ---

- ## Step 0: Auto-Detect Test Environment

- Before writing any tests, discover the project's testing setup.

- Read the dependency manifest (`package.json`, `requirements.txt`, `pyproject.toml`, `go.mod`,

- `Cargo.toml`, `build.gradle`, `Gemfile`) and look for:

- | **Jest** | `jest` in devDependencies, `jest.config.*`, `"jest"` key in `package.json` |

- | **Playwright** | `@playwright/test` in devDependencies, `playwright.config.ts` |

- | **Cypress** | `cypress` in devDependencies, `cypress.config.*` |

- | **pytest** | `pytest` in requirements, `conftest.py` files |

- | **Go test** | `_test.go` files, `go test` in Makefile |

- | **RSpec** | `rspec` in Gemfile, `spec/` directory |

- | **JUnit** | `junit` in build.gradle, `src/test/` directory |

- Glob: **/test_*.py → Python test files

- Glob: **/*_test.go → Go test files

- Glob: **/spec/**/*_spec.rb → Ruby spec files

- Read 2-3 existing test files to understand:

- - Import patterns and test utilities used

- - Naming conventions (`describe`/`it` vs `test`)

- - Mock/stub patterns (`vi.mock`, `jest.mock`, `unittest.mock`)

- - Setup/teardown patterns (`beforeEach`, `afterEach`, fixtures)

- - Assertion library (`expect`, `assert`, `chai`)

- ```

- Glob: **/vitest.config.*

- Glob: **/jest.config.*

- Glob: **/pytest.ini

- Glob: **/conftest.py

- Glob: **/setup.cfg

- Glob: **/.nycrc*

- Glob: **/c8.config.*

- ```

-

- Extract: coverage thresholds, test directories, global setup files, module aliases.

- If there's a coverage tool configured (c8, istanbul/nyc, coverage.py):

-

- ```bash

- # Check if coverage script exists

- Grep: "coverage" in package.json scripts section

- Grep: "c8" or "nyc" or "istanbul" in package.json

- ```

- ## Step 1: Research Testing Best Practices

-

- Before writing tests, research current best practices for the detected framework.

-

- ### 1a. Context7 — Official Testing Library Docs

- Fetch docs for the detected test framework:

- {

- "libraryName": "<DETECTED_FRAMEWORK>",

- "query": "unit testing best practices"

- }

- ```

-

- Then fetch specific guidance:

-

- ```json

- context7:query-docs

- {

- "libraryId": "<RESOLVED_ID>",

- "query": "testing patterns mocking setup teardown"

- }

- Do this for each major testing dependency (e.g., `vitest`, `@testing-library/react`, `msw`).

- ### 1b. Firecrawl — Current Testing Patterns

- "limit": 5,

- "sources": [{ "type": "web" }]

- Run 2-3 searches targeting different aspects:

-

- | Search | Query |

- |--------|-------|

- | Best practices | `<framework> testing best practices [current year]` |

- | Mocking patterns | `<framework> mocking API calls best practices` |

- | Component testing | `React Testing Library component testing patterns [current year]` |

- | Coverage strategy | `unit test coverage strategy meaningful tests vs coverage percentage` |

-

- Scrape the 1-2 most authoritative results for implementation details:

-

- ```json

- firecrawl:firecrawl_scrape

- {

- "url": "<AUTHORITATIVE_URL>",

- "formats": ["markdown"],

- "onlyMainContent": true

- }

- ```

- ## Step 2: Analyze Coverage Gaps (Sentry Integration)

-

- Use Sentry MCP to find production errors that should have been caught by tests.

-

- ### 2a. Find Unresolved Production Errors

- ### 2b. Cross-Reference with Test Coverage

-

- For each Sentry error:

- 1. Identify the source file from the stack trace

- 2. Check if a corresponding test file exists (`Glob: **/<filename>.test.*`)

- 3. If tests exist, check whether they cover the failing code path

- 4. If no tests exist, prioritize writing tests for this file

-

- ### 2c. Generate Priority List

- ## Step 3: Write Tests

- // Arrange — set up test data and dependencies

-

- // Act — execute the behavior under test

-

- // Assert — verify the outcome

- **Test file names** — co-locate with source or mirror directory structure:

- **Test descriptions** — use `should [behavior] when [condition]`:

-

- ```typescript

- describe('validateEmail', () => {

- it('should return true for valid email', () => { /* ... */ });

- it('should return false when @ is missing', () => { /* ... */ });

- it('should return false for empty string', () => { /* ... */ });

- it('should handle unicode characters in local part', () => { /* ... */ });

- });

- ```

- **DO test:**

- - Public API / exported functions

- - Business logic and domain rules

- - Edge cases and boundary values

- - Error handling and failure modes

- - User interactions (clicks, inputs, submissions)

- - State transitions

- - Data transformations

- **DON'T test:**

- - Implementation details (private methods, internal state)

- - Third-party library internals

- - Trivial code (simple getters/setters)

- - Framework behavior

- - CSS classes or DOM structure (test behavior, not markup)

- For every function, consider:

-

- | Unicode | Emoji, CJK characters, RTL text, zero-width spaces |

- | Concurrency | Rapid successive calls, race conditions |

- | Network | Timeout, 404, 500, empty response, malformed JSON |

- | Dates | Midnight, DST transitions, leap years, timezone boundaries |

- ## Step 4: Testing Patterns by Category

- it('should format positive amounts', () => {

- expect(formatCurrency(1234.5)).toBe('$1,234.50');

- });

-

- it('should handle zero', () => {

- expect(formatCurrency(0)).toBe('$0.00');

- });

-

- it('should handle negative amounts', () => {

- expect(formatCurrency(-100)).toBe('-$100.00');

- });

-

- it('should handle very large numbers', () => {

- expect(formatCurrency(999999999.99)).toBe('$999,999,999.99');

- });

- it('should return user data for valid id', async () => {

- const user = await fetchUser('123');

- expect(user).toEqual({ id: '123', name: 'John Doe' });

- });

-

- it('should throw for non-existent user', async () => {

- await expect(fetchUser('invalid')).rejects.toThrow('User not found');

- });

-

- it('should handle network timeout', async () => {

- vi.useFakeTimers(); // or jest.useFakeTimers()

- const promise = fetchUser('123');

- vi.advanceTimersByTime(30000);

- await expect(promise).rejects.toThrow('timeout');

- vi.useRealTimers();

- });

- import { render, screen, fireEvent, waitFor } from '@testing-library/react';

-

-

-

- email: 'test@example.com',

- password: 'password123',

-

-

- expect(screen.getByRole('button', { name: /sign in/i })).toBeDisabled();

- });

- import { renderHook, act, waitFor } from '@testing-library/react';

- it('should start with initial value', () => {

- const { result } = renderHook(() => useCounter(10));

- expect(result.current.count).toBe(10);

- });

-

- it('should increment', () => {

- const { result } = renderHook(() => useCounter(0));

- act(() => result.current.increment());

- expect(result.current.count).toBe(1);

- });

-

- it('should not go below zero', () => {

- const { result } = renderHook(() => useCounter(0));

- act(() => result.current.decrement());

- expect(result.current.count).toBe(0);

- });

- it('should create user with valid data', async () => {

- const req = new Request('http://localhost/api/users', {

- method: 'POST',

- body: JSON.stringify({ name: 'Test', email: 'test@example.com' }),

- });

-

- const response = await POST(req);

- const data = await response.json();

-

- expect(response.status).toBe(201);

- expect(data).toMatchObject({ name: 'Test', email: 'test@example.com' });

- });

-

- it('should return 422 for invalid email', async () => {

- const req = new Request('http://localhost/api/users', {

- method: 'POST',

- body: JSON.stringify({ name: 'Test', email: 'invalid' }),

- });

-

- const response = await POST(req);

- expect(response.status).toBe(422);

- });

- ## Step 5: Test Data Management

- // Usage

-