code-ai-installer 3.0.0 → 4.0.1-a

package/domains/development/locales/en/.agents/skills/testing-strategy-js/SKILL.md

@@ -1,11 +1,46 @@
 ---
 name: testing-strategy-js
-description: Testing strategy for JS/TS projects — unit (Vitest), integration (API/DB), e2e (Playwright). AAA pattern, Vitest config, React Testing Library, mocks of external services, coverage thresholds, naming conventions, CI pipeline. Activate when writing new tests, refactoring existing ones, or for questions "how to properly test X".
+description: "Testing strategy for JS/TS projects — unit (Vitest), integration (API/DB), e2e (Playwright). AAA pattern, Vitest config, React Testing Library, mocks of external services, coverage thresholds, naming conventions, CI pipeline. Activate when writing new tests, refactoring existing ones, or for questions 'how to properly test X'."
+type: discretionary
+domain: development
+owners:
+  - senior_full_stack
+gates:
+  - DEV
+tech: []
+topic:
+  - general
+  - testing
+triggers:
+  - test strategy
+  - JS unit tests
+  - integration tests
+  - Vitest config
+  - coverage threshold
+  - AAA pattern
+  - service mocks
+related:
+  - testing-strategy-js-reference
+  - tdd-workflow
+  - tdd-workflow-reference
+  - qa-e2e-playwright
+  - tests-quality-review
+  - qa-test-integrity-audit
+  - qa-mutation-testing
+  - qa-browser-testing
+  - node-express-beast-practices
+  - mongodb-mongoose-best-practices
+  - es2025-beast-practices
+  - es2025-beast-practices-reference
+  - dev-reference-snippets
+budget_lines: 320
+schema_version: 1
 ---
 
+
 # Skill: Testing Strategy (JS/TS)
 
-Specific patterns, templates and DO/DON'T for writing reliable tests.
+Decision rules + canonical tables for writing reliable tests. Full DO/DON'T code examples — in `$testing-strategy-js-reference`.
 
 **Sections:**
 1. [Test Pyramid and Boundaries](#1-test-pyramid)
@@ -45,472 +80,129 @@ Specific patterns, templates and DO/DON'T for writing reliable tests.
 
 ## 2. Unit Tests
 
-### ✅ DO: AAA pattern (Arrange → Act → Assert)
-
-```js
-import { describe, it, expect } from 'vitest';
-import { calculateDiscount } from './pricing.js';
-
-describe('calculateDiscount', () => {
-  it('should apply percentage discount to base price', () => {
-    // Arrange
-    const basePrice = 100;
-    const discountPercent = 20;
-
-    // Act
-    const result = calculateDiscount(basePrice, discountPercent);
+**Rules:**
+- **AAA pattern** (Arrange → Act → Assert) with comments in code or blank-line separators
+- **Edge cases explicitly** — happy path + boundaries (min/max) + error paths + null/undefined
+- **Custom hooks via `renderHook` + `act`** from `@testing-library/react`
+- **One `it` — one concept** — do not group unrelated assertions
+- **Pure functions = pure tests** — no I/O, mocks, fakeTimers (unless the function uses Date.now)
 
-    // Assert
-    expect(result).toBe(80);
-  });
-
-  it('should clamp discount at 0 (never negative price)', () => {
-    const result = calculateDiscount(50, 120);
-    expect(result).toBe(0);
-  });
-
-  it('should return original price when discount is 0', () => {
-    expect(calculateDiscount(100, 0)).toBe(100);
-  });
-
-  it('should throw on negative base price', () => {
-    expect(() => calculateDiscount(-10, 5)).toThrow('Price must be non-negative');
-  });
-});
-```
-
-### ✅ DO: test edge cases explicitly
-
-```js
-describe('parseTimerValue', () => {
-  // Happy path
-  it('should parse "05:30" into { minutes: 5, seconds: 30 }', () => {
-    expect(parseTimerValue('05:30')).toEqual({ minutes: 5, seconds: 30 });
-  });
-
-  // Boundaries
-  it('should handle "00:00" as zero timer', () => {
-    expect(parseTimerValue('00:00')).toEqual({ minutes: 0, seconds: 0 });
-  });
-
-  it('should handle "99:59" as max timer', () => {
-    expect(parseTimerValue('99:59')).toEqual({ minutes: 99, seconds: 59 });
-  });
-
-  // Error paths
-  it('should throw on invalid format "abc"', () => {
-    expect(() => parseTimerValue('abc')).toThrow();
-  });
-
-  it('should throw on seconds > 59', () => {
-    expect(() => parseTimerValue('01:60')).toThrow();
-  });
-
-  // Null / undefined
-  it('should throw on null input', () => {
-    expect(() => parseTimerValue(null)).toThrow();
-  });
-});
-```
-
-### ✅ DO: test custom hooks via renderHook
-
-```js
-import { renderHook, act } from '@testing-library/react';
-import { useCounter } from './useCounter.js';
-
-describe('useCounter', () => {
-  it('should initialize with default value 0', () => {
-    const { result } = renderHook(() => useCounter());
-    expect(result.current.count).toBe(0);
-  });
-
-  it('should initialize with custom value', () => {
-    const { result } = renderHook(() => useCounter(10));
-    expect(result.current.count).toBe(10);
-  });
-
-  it('should increment count', () => {
-    const { result } = renderHook(() => useCounter());
-    act(() => result.current.increment());
-    expect(result.current.count).toBe(1);
-  });
-
-  it('should not go below 0', () => {
-    const { result } = renderHook(() => useCounter(0));
-    act(() => result.current.decrement());
-    expect(result.current.count).toBe(0);
-  });
-});
-```
+> Full AAA + edge cases + hooks code → `$testing-strategy-js-reference` §2.
 
 ---
 
 ## 3. React Components (RTL)
 
-### ✅ DO: test behavior, not implementation
-
-```js
-import { render, screen, fireEvent } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { SearchInput } from './SearchInput.jsx';
-
-describe('SearchInput', () => {
-  it('should call onSearch with query when button clicked', async () => {
-    const user = userEvent.setup();
-    const onSearch = vi.fn();
-
-    render(<SearchInput onSearch={onSearch} />);
+**Rules:**
+- **Test behavior, not implementation** — via DOM, not via internal state
+- **`userEvent.setup()`** in every test (not shared) — isolated user input
+- **`screen.getByRole`** — priority №1
+- **`screen.findBy*`** for async DOM (auto-retry with timeout)
+- ❌ **Do not use `container.querySelector`** — that is an implementation detail
+- ❌ **Do not check `result.current` for UI** — that is a hook test, not a component test
 
-    await user.type(screen.getByRole('textbox', { name: /search/i }), 'laptop');
-    await user.click(screen.getByRole('button', { name: /search/i }));
+### RTL Query priority (best to worst)
 
-    expect(onSearch).toHaveBeenCalledWith('laptop');
-    expect(onSearch).toHaveBeenCalledTimes(1);
-  });
+| Priority | Method | When to use |
+|---|---|---|
+| 1 | `getByRole` | Semantic elements (button, textbox, heading) |
+| 2 | `getByLabelText` | Forms |
+| 3 | `getByPlaceholderText` | Fields without label (rare) |
+| 4 | `getByText` | Static text |
+| 5 | `getByDisplayValue` | Filled form |
+| 6 | `getByAltText` / `getByTitle` | Images / hover hints |
+| 7 | `getByTestId` | Last resort (no semantics) |
 
-  it('should show error message for empty query', async () => {
-    const user = userEvent.setup();
-    render(<SearchInput onSearch={vi.fn()} />);
-
-    await user.click(screen.getByRole('button', { name: /search/i }));
-
-    expect(screen.getByRole('alert')).toHaveTextContent(/enter a query/i);
-  });
-
-  it('should disable button while loading', () => {
-    render(<SearchInput onSearch={vi.fn()} isLoading />);
-
-    expect(screen.getByRole('button', { name: /search/i })).toBeDisabled();
-  });
-});
-```
-
-### ❌ DON'T: test implementation details
-
-```js
-// ❌ Bad: dependence on internal state
-it('should set state to true', () => {
-  const { result } = renderHook(() => useToggle());
-  act(() => result.current[1]());
-  // Checking internal state — fragile
-  expect(result.current[0]).toBe(true);
-});
-
-// ✅ Good: verifying behavior via DOM
-it('should show content after toggle click', async () => {
-  const user = userEvent.setup();
-  render(<Accordion title="Details">Content</Accordion>);
-
-  expect(screen.queryByText('Content')).not.toBeInTheDocument();
-  await user.click(screen.getByRole('button', { name: /details/i }));
-  expect(screen.getByText('Content')).toBeVisible();
-});
-```
-
-### ✅ DO: RTL queries by priority
-
-```js
-// Query priority (from best to worst):
-// 1. getByRole     — semantic roles (best of all)
-// 2. getByLabelText — forms
-// 3. getByText     — static text
-// 4. getByTestId   — last resort
-
-// ✅ By role — resilient to layout changes
-screen.getByRole('button', { name: /save/i });
-screen.getByRole('textbox', { name: /email/i });
-screen.getByRole('heading', { level: 2 });
-
-// ✅ By label — forms
-screen.getByLabelText(/password/i);
-
-// ⚠️ By text — less resilient to i18n
-screen.getByText(/no templates found/i);
-
-// 🔧 By testid — when there is no semantics
-screen.getByTestId('popup-container');
-```
+> Full RTL + behavior testing + queries code → `$testing-strategy-js-reference` §3.
 
 ---
 
 ## 4. Integration Tests
 
-### ✅ DO: API handler tests with supertest
-
-```js
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import request from 'supertest';
-import { createApp } from '../app.js';
-
-describe('POST /api/products', () => {
-  let app;
-
-  beforeAll(() => {
-    app = createApp({ db: testDb });
-  });
-
-  afterAll(async () => {
-    await testDb.cleanup();
-  });
-
-  it('should create product and return 201', async () => {
-    const res = await request(app)
-      .post('/api/products')
-      .send({ name: 'Summer Hat', price: 25, category: 'accessories' })
-      .expect(201);
-
-    expect(res.body).toMatchObject({
-      name: 'Summer Hat',
-      price: 25,
-      category: 'accessories',
-    });
-    expect(res.body).toHaveProperty('id');
-    expect(res.body).toHaveProperty('createdAt');
-  });
-
-  it('should reject duplicate product name with 409', async () => {
-    await request(app)
-      .post('/api/products')
-      .send({ name: 'Unique Widget', price: 10, category: 'tools' });
-
-    await request(app)
-      .post('/api/products')
-      .send({ name: 'Unique Widget', price: 20, category: 'tools' })
-      .expect(409);
-  });
-
-  it('should reject invalid price with 400 and error details', async () => {
-    const res = await request(app)
-      .post('/api/products')
-      .send({ name: 'Bad Item', price: -5, category: 'tools' })
-      .expect(400);
-
-    expect(res.body.error).toMatch(/price/i);
-  });
-});
-```
+**Rules:**
+- **`supertest`** for API handler tests — real Express via `request(app)`
+- **`beforeAll` for setup**, **`afterAll` for cleanup** (DB, fixtures)
+- **Contract tests** — `expect.objectContaining({ ... })` + `expect.any(String)` for shape without business logic
+- **Isolate DB** — testDb separate from dev/prod; truncate/cleanup between runs
+- **Statuses in assertions** — `.expect(201)` / `.expect(409)` / `.expect(400)`
 
-### ✅ DO: tests for contracts (verify response shape, not business logic)
-
-```js
-describe('GET /api/templates', () => {
-  it('should match API contract shape', async () => {
-    const res = await request(app)
-      .get('/api/templates')
-      .expect(200);
-
-    expect(res.body).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: expect.any(String),
-          name: expect.any(String),
-          category: expect.any(String),
-          thumbnail: expect.stringMatching(/^https?:\/\//),
-        }),
-      ])
-    );
-  });
-});
-```
+> Full supertest + contract testing code → `$testing-strategy-js-reference` §4.
 
 ---
 
 ## 5. Mocks and Test Doubles
 
-### ✅ DO: mock external boundaries, not internal logic
-
-```js
-// ✅ Mocking external HTTP API
-vi.mock('../services/openai.js', () => ({
-  generateText: vi.fn().mockResolvedValue('Mocked AI response'),
-}));
+### Boundary Mocking Rule (main principle)
 
-// ✅ Mocking timers
-import { vi, beforeEach, afterEach } from 'vitest';
+**Mock ONLY at the boundary of your system.** Boundary is anything that:
+- **Not managed by your code** — external APIs, third-party SDKs, OS services
+- **Non-deterministic** — time, randomness, network, concurrency
+- **Has unwanted side effects in the test** — FS, prod DB, payment, email
 
-beforeEach(() => vi.useFakeTimers());
-afterEach(() => vi.useRealTimers());
+**Inside the boundary — real code, no mocks.** A test should catch regressions in your logic, not confirm that mocks are configured correctly.
 
-it('should expire item after timeout', () => {
-  const onExpire = vi.fn();
-  startTimer(onExpire, 5000);
+### Decision tree: mock or real?
 
-  vi.advanceTimersByTime(5000);
-
-  expect(onExpire).toHaveBeenCalledOnce();
-});
 ```
-
-### ✅ DO: test data factories instead of hardcode
-
-```js
-// test-utils/factories.js
-
-/**
- * Creates a test product object with override capability.
- * @param {Partial<Product>} overrides - fields to override.
- * @returns {Product} test product.
- */
-function createProduct(overrides = {}) {
-  return {
-    id: crypto.randomUUID(),
-    name: 'Test Product',
-    price: 29.99,
-    category: 'widgets',
-    active: true,
-    createdAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-// Usage in tests:
-it('should deactivate expired product', () => {
-  const product = createProduct({ active: true, expiresAt: '2024-01-01' });
-  const result = deactivateExpired(product);
-  expect(result.active).toBe(false);
-});
+Dependency on what?
+│
+├─ External HTTP API / SDK / cloud service ───► MOCK (boundary)
+├─ Time / randomness / crypto.randomUUID ─────► MOCK (determinism)
+├─ File system / process / env ───────────────► MOCK (isolation)
+├─ Production DB / Stripe / Email service ────► MOCK (side effects)
+├─ Your own module / utility ─────────────────► REAL (your logic)
+├─ Pure data transformation ──────────────────► REAL (no dependencies)
+├─ Router / navigation / state in integration ► REAL (system behavior)
+└─ testDb (isolated) in integration ──────────► REAL (DB-layer contract)
 ```
 
-### ❌ DON'T: excessive mocks
+**Priority rules:**
+- If you can test with a real dependency without side effects — **DO NOT mock**
+- If you mock but you're not sure why — **drop the mock and try the real thing**
+- Mock count in a single test >5 — **reconsider boundaries** (test is at the wrong abstraction)
 
-```js
-// ❌ Mocked everything — the test verifies nothing
-vi.mock('../db.js');
-vi.mock('../validator.js');
-vi.mock('../logger.js');
-vi.mock('../event-bus.js');
+### Integration patterns at system boundaries
 
-it('should save product', async () => {
-  db.save.mockResolvedValue({ id: 1 });
-  validator.validate.mockReturnValue(true);
+| Boundary | Mock (transport) | Keep real (transformation) |
+|---|---|---|
+| HTTP fetch to external API | `fetch` global / axios instance | Response parsing, error mapping, retry logic |
+| DB via ORM (Mongoose/Prisma) | Connection / driver | Schema validation, query builders, transformers |
+| LLM/AI service (OpenAI, Anthropic) | API client `.chat.completions.create` | Prompt assembly, response parsing, fallback |
+| Email/SMS provider (Stripe, Twilio) | Provider SDK | Template rendering, recipient validation, dry-run output |
 
-  await saveProduct({ name: 'Widget' });
+**Principle:** mock the **transport** (what goes out to network/third-party service), keep the **transformation** real (your logic for preparing data and processing the response).
 
-  expect(db.save).toHaveBeenCalled(); // we are testing mocks, not logic
-});
+### Base rules
 
-// ✅ Integration test verifies the real flow
-it('should save valid product to DB', async () => {
-  const result = await saveProduct({ name: 'Premium Widget', price: 29.99, category: 'digital' });
-  expect(result.id).toBeDefined();
+- **Test data factories** (`createProduct({ ...overrides })`) instead of hardcode
+- **`vi.useFakeTimers()` / `vi.useRealTimers()`** in `beforeEach` / `afterEach`
+- **`vi.mocked(fn).mockResolvedValue(...)`** for type-safe mocks
 
-  const stored = await db.findById(result.id);
-  expect(stored.name).toBe('Premium Widget');
-});
-```
-
-### What to mock, and what not to
-
-| Mock ✅ | DO NOT mock ❌ |
-|----------|-------------|
-| HTTP API (fetch, axios) | Own utilities |
-| External services (OpenAI, Stripe, Redis) | Simple data transformations |
-| Timers (setTimeout, setInterval) | Router / navigation (if not E2E) |
-| File system (fs) | Internal modules (meaning of integration is lost) |
-| crypto.randomUUID (determinism) | — |
+> Full mocks + factories + decision tree examples code → `$testing-strategy-js-reference` §5.
+> Detection of gaming patterns in tests (mocks masked as behavior) → `$qa-test-integrity-audit`.
 
 ---
 
 ## 6. Naming and Structure
 
-### File organization
+**Rules:**
+- **Test files next to code** — `pricing.js` + `pricing.test.js`
+- **`describe('[Unit/Module]') → it('should [ACTION] when [CONDITION]')`**
+- **Integration tests** — `*.integration.test.js` (for CI filtering)
+- **E2E** — separate folder `src/e2e/specs/`
+- **Checklist per module**: happy path + edge cases + boundaries + error paths + async (if applicable)
 
-```
-src/
-├── utils/
-│   ├── pricing.js
-│   └── pricing.test.js          # Unit — next to code
-├── hooks/
-│   ├── useTimer.js
-│   └── useTimer.test.js         # Unit — next to code
-├── components/
-│   ├── SearchInput.jsx
-│   └── SearchInput.test.jsx     # RTL — next to component
-├── api/
-│   ├── products.handler.js
-│   └── products.integration.test.js  # Integration — next to route
-└── e2e/                          # E2E — separate folder
-    └── specs/
-```
-
-### ✅ DO: describe/it naming convention
-
-```js
-// Format: describe('[Unit/Module]') → it('should [ACTION] when [CONDITION]')
-describe('InputValidator', () => {
-  describe('validate', () => {
-    it('should return valid for correct input value', () => { /* ... */ });
-    it('should return invalid when value is empty', () => { /* ... */ });
-    it('should return invalid when value exceeds max length', () => { /* ... */ });
-  });
-
-  describe('isExpired', () => {
-    it('should return true when expiresAt is in the past', () => { /* ... */ });
-    it('should return false when expiresAt is in the future', () => { /* ... */ });
-    it('should return false when expiresAt is null (never expires)', () => { /* ... */ });
-  });
-});
-```
-
-### Checklist for each tested module
-
-- [ ] Happy path (main scenario)
-- [ ] Edge cases (0, null, undefined, empty string, empty array)
-- [ ] Boundaries (min/max values)
-- [ ] Error paths (invalid input, network errors)
-- [ ] Async (timeouts, race conditions — if applicable)
+> Full file tree + describe convention example → `$testing-strategy-js-reference` §6.
 
 ---
 
 ## 7. Coverage and CI
 
-### Vitest config
-
-```js
-// vitest.config.js
-import { defineConfig } from 'vitest/config';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  plugins: [react()],
-  test: {
-    globals: true,
-    environment: 'jsdom',
-    setupFiles: ['./src/test-setup.js'],
-    include: ['src/**/*.test.{js,jsx,ts,tsx}'],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov'],
-      include: ['src/**/*.{js,jsx,ts,tsx}'],
-      exclude: [
-        'src/**/*.test.*',
-        'src/**/*.spec.*',
-        'src/**/index.{js,ts}',     // barrel files
-        'src/test-utils/**',
-        'src/**/*.d.ts',
-      ],
-      thresholds: {
-        statements: 80,
-        branches: 75,
-        functions: 80,
-        lines: 80,
-      },
-    },
-  },
-});
-```
-
-### Setup file
-
-```js
-// src/test-setup.js
-import '@testing-library/jest-dom/vitest';
-
-// Global cleanup (RTL >= v14 does this automatically)
-// import { cleanup } from '@testing-library/react';
-// afterEach(cleanup);
-```
+**Rules:**
+- **Vitest config** — globals, jsdom, setupFiles, coverage provider v8
+- **Coverage exclude** — `*.test.*`, `*.spec.*`, `index.{js,ts}` (barrel), `test-utils/**`, `*.d.ts`
+- **CI runs `vitest run --coverage`** — fail when thresholds break
+- **`@testing-library/jest-dom/vitest`** in setup for matchers (`toBeVisible`, `toHaveTextContent`)
 
 ### Coverage thresholds
 
@@ -521,97 +213,40 @@ import '@testing-library/jest-dom/vitest';
 | Functions | 70% | 80% | 90%+ |
 | Lines | 70% | 80% | 90%+ |
 
-### Scripts in package.json
-
-```json
-{
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui"
-  }
-}
-```
-
----
+### Mutation testing and tier-based thresholds
 
-## 8. Anti-patterns
+Coverage shows that lines executed — but not that the test actually catches a bug. **Mutation testing** changes the code (mutations) and verifies that at least one test fails — the real indicator of test quality.
 
-### ❌ DON'T: tests depend on execution order
+Tier-based model (Test Integrity Defense):
 
-```js
-// ❌ Bad: second test depends on the first one
-let sharedState;
+| Tier | What it is | Mutation score | Coverage fallback |
+|---|---|---|---|
+| **Tier 1** | Critical paths — auth, billing, payments, security, crypto | ≥ 80% | n/a |
+| **Tier 2** | Default — business logic | ≥ 60% | n/a |
+| **Tier 3** | Low-risk — UI shell, fixtures, scaffolding | optional | ≥ 70% |
 
-it('should create item', () => {
-  sharedState = createItem({ name: 'test' });
-  expect(sharedState.id).toBeDefined();
-});
+Heuristic auto-tier-1 for paths: `src/auth/**`, `src/billing/**`, `src/security/**`, `src/payments/**`, `src/crypto/**`. Override via JSDoc `@tier N` comment in the module.
 
-it('should update item', () => {
-  updateItem(sharedState.id, { name: 'updated' }); // sharedState from previous test
-});
+> Setup Stryker (JS/TS) / mutmut (Python) + tier thresholds + CI integration → `$qa-mutation-testing`.
 
-// ✅ Good: each test creates its own data
-it('should update item', () => {
-  const item = createItem({ name: 'test' });
-  const updated = updateItem(item.id, { name: 'updated' });
-  expect(updated.name).toBe('updated');
-});
-```
+> Full `vitest.config.js` + setup + scripts → `$testing-strategy-js-reference` §7.
 
-### ❌ DON'T: snapshot tests without thinking
-
-```js
-// ❌ Meaningless snapshot — any change breaks the test
-it('renders correctly', () => {
-  const { container } = render(<ComplexForm />);
-  expect(container).toMatchSnapshot(); // 500 lines snapshot, nobody reviews
-});
-
-// ✅ Snapshot only for stable output
-it('should render error boundary fallback', () => {
-  const { container } = render(<ErrorFallback error={new Error('Oops')} />);
-  expect(container).toMatchInlineSnapshot(`
-    <div class="error-fallback">
-      <p>Something went wrong: Oops</p>
-    </div>
-  `);
-});
-```
-
-### ❌ DON'T: "magic" values without explanations
-
-```js
-// ❌ What is 42? Why 3?
-expect(result).toBe(42);
-expect(items).toHaveLength(3);
+---
 
-// ✅ Values are clear from context
-const BASE_PRICE = 100;
-const DISCOUNT = 58;  // 58% discount
-const EXPECTED_PRICE = 42; // 100 - 58
+## 8. Anti-patterns
 
-expect(calculatePrice(BASE_PRICE, DISCOUNT)).toBe(EXPECTED_PRICE);
-```
+**Rules (DON'T):**
+- ❌ **Tests depend on order** — `let sharedState` between `it` blocks. Each test creates its own data.
+- ❌ **Snapshot without thinking** — `toMatchSnapshot()` of 500 lines. Use `toMatchInlineSnapshot` for short stable outputs.
+- ❌ **Magic values** — `expect(result).toBe(42)`. Explain via named constants.
+- ❌ **Async without await** — `it('...', () => { fetchData().then(...) })`. Always `async` + `await`.
+- ❌ **Excessive mocks** — mock everything → the test verifies mocks, not code.
+- ❌ **Tests for private methods** — test the public API; private code is covered through it.
+- ❌ **`any` / `// @ts-ignore` in tests** — breaks type safety of the test code.
+- ❌ **Mock-driven testing** — test sets `mock.returns(X)`, then asserts `result === X`. That checks the mock works, not that the code works. See `$qa-test-integrity-audit` for detection.
+- ❌ **Test follows code without rationale** — changed the code → tweaked the test until green, without explicit justification why the new behavior is correct. Self-confirming test, AI-gaming pattern.
 
-### ❌ DON'T: async without await
-
-```js
-// ❌ Test always passes — assertion does not execute
-it('should fetch data', () => {
-  fetchData().then(data => {
-    expect(data).toBeDefined(); // will never execute as an assertion
-  });
-});
-
-// ✅ Correct: await + async
-it('should fetch data', async () => {
-  const data = await fetchData();
-  expect(data).toBeDefined();
-});
-```
+> Full bad-example blocks + corrections → `$testing-strategy-js-reference` §8.
 
 ---
 
@@ -625,12 +260,19 @@ it('should fetch data', async () => {
 - [ ] Factories for test data (if repeated)
 - [ ] Coverage ≥ 80% statements
 - [ ] No `any`, no `// @ts-ignore` in tests
+- [ ] Mocks only at system boundaries (Boundary Mocking Rule §5)
 
 ---
 
 ## See also
-- `$tests-quality-review` — review of tests quality
+- `$testing-strategy-js-reference` — full DO/DON'T testing code reference
+- `$tdd-workflow` — RED→GREEN→REFACTOR (writing tests before code)
 - `$qa-e2e-playwright` — E2E via Playwright
+- `$tests-quality-review` — test quality review
+- `$qa-test-integrity-audit` — gaming pattern detection and mock-to-real ratio
+- `$qa-mutation-testing` — Stryker (JS/TS) / mutmut (Python) + tier-based thresholds + CI integration
 - `$qa-browser-testing` — visual testing in Antigravity
-- `$es2025-beast-practices` — modern JS for writing clean code
+- `$node-express-beast-practices` — testable backend structure
+- `$mongodb-mongoose-best-practices` — DB layer testing
+- `$es2025-beast-practices` — modern JS for clean test code
 - `$dev-reference-snippets` — TDD, React, API examples