К основному содержанию
скилл CX Codex

tdd-london-chicago — скилл для Claude Code: TDD и установка

Скилл tdd-london-chicago помогает вести TDD по лондонской или чикагской школе: выбирать моки либо реальные объекты и проходить цикл Red–Green–Refactor.

MIT 124 установок ★ 533 обновлён 2026-10-25

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code
Открыть на GitHub

Что делает tdd-london-chicago

Скилл помогает выбрать стиль тестирования по типу кода. Для доменной логики, расчётов и value objects он предлагает чикагский подход с реальными объектами и проверкой состояния. Для контроллеров, сервисов и внешних интеграций подходит лондонский подход с моками и проверкой взаимодействий.

Работа строится через цикл Red–Green–Refactor: сначала создаётся падающий тест, затем пишется минимальная реализация, после чего код улучшается без новых функций. В составе описаны агенты qe-test-generator, qe-test-implementer и qe-test-refactorer, а также смешанный вариант: London для внешних зависимостей и Chicago для доменной логики.

У лондонского подхода рефакторинг сложнее, потому что моки могут ломаться при изменении кода.

Какие задачи решает

  • выбрать между моками и реальными объектами
  • написать падающий тест перед реализацией
  • провести код через цикл Red–Green–Refactor
  • проверить состояние доменной модели
  • изолировать API и другие внешние зависимости

Примеры запросов агенту

  • Выбери между London и Chicago для src/domain/Order.ts и объясни решение.
  • Сгенерируй падающий тест для расчёта заказа, затем предложи минимальную реализацию.
  • Предложи рефакторинг, сохранив все текущие тесты зелёными.

Как установить tdd-london-chicago

1Через Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code

2Вручную: положить файлы

~/.claude/skills/tdd-london-chicago/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/tdd-london-chicago/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о tdd-london-chicago

Как установить tdd-london-chicago в Claude Code?

Выполните npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code, затем проверьте файл ~/.claude/skills/tdd-london-chicago/SKILL.md.

Что делает tdd-london-chicago?

Скилл помогает применять две школы TDD. Chicago проверяет состояние реальных объектов, а London изолирует код моками и проверяет взаимодействия.

Когда выбирать London, а когда Chicago?

Для расчётов, алгоритмов и value objects выбирайте Chicago. Для API, баз данных и других внешних интеграций выбирайте London; эти подходы можно сочетать.

Исходный текст

SKILL.md · MIT
---
name: tdd-london-chicago
description: "Apply London (mock-based) and Chicago (state-based) TDD schools. Use when practicing test-driven development or choosing testing style for your context."
category: development-practices
priority: high
tokenEstimate: 1100
agents: [qe-test-generator, qe-test-implementer, qe-test-refactorer]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-02
dependencies: []
quick_reference_card: true
tags: [tdd, testing, london-school, chicago-school, red-green-refactor, mocks]
trust_tier: 2
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
---

# Test-Driven Development: London & Chicago Schools

<default_to_action>
When implementing TDD or choosing testing style:
1. IDENTIFY code type: domain logic → Chicago, external deps → London
2. WRITE failing test first (Red phase)
3. IMPLEMENT minimal code to pass (Green phase)
4. REFACTOR while keeping tests green (Refactor phase)
5. REPEAT cycle for next functionality

**Quick Style Selection:**
- Pure functions/calculations → Chicago (real objects, state verification)
- Controllers/services with deps → London (mocks, interaction verification)
- Value objects → Chicago (test final state)
- API integrations → London (mock external services)
- Mix both in practice (London for controllers, Chicago for domain)

**Critical Success Factors:**
- Tests drive design, not just verify it
- Make tests fail first to ensure they test something
- Write minimal code - no features beyond what's tested
</default_to_action>

## Quick Reference Card

### When to Use
- Starting new feature with test-first approach
- Refactoring legacy code with test coverage
- Teaching TDD practices to team
- Choosing between mocking vs real objects

### TDD Cycle
| Phase | Action | Discipline |
|-------|--------|------------|
| **Red** | Write failing test | Verify it fails, check message is clear |
| **Green** | Minimal code to pass | No extra features, don't refactor |
| **Refactor** | Improve structure | Keep tests passing, no new functionality |

### School Comparison
| Aspect | Chicago (Classicist) | London (Mockist) |
|--------|---------------------|------------------|
| Collaborators | Real objects | Mocks/stubs |
| Verification | State (assert outcomes) | Interaction (assert calls) |
| Isolation | Lower (integrated) | Higher (unit only) |
| Refactoring | Easier | Harder (mocks break) |
| Design feedback | Emerges from use | Explicit from start |

### Agent Coordination
- `qe-test-generator`: Generate tests in both schools
- `qe-test-implementer`: Implement minimal code (Green)
- `qe-test-refactorer`: Safe refactoring (Refactor)

---

## Chicago School (State-Based)

**Philosophy:** Test observable behavior through public API. Keep tests close to consumer usage.

```javascript
// State verification - test final outcome
describe('Order', () => {
  it('calculates total with tax', () => {
    const order = new Order();
    order.addItem(new Product('Widget', 10.00), 2);
    order.addItem(new Product('Gadget', 15.00), 1);

    expect(order.totalWithTax(0.10)).toBe(38.50);
  });
});
```

**When Chicago Shines:**
- Domain logic with clear state
- Algorithms and calculations
- Value objects (`Money`, `Email`)
- Simple collaborations
- Learning new domain

---

## London School (Mock-Based)

**Philosophy:** Test each unit in isolation. Focus on how objects collaborate.

```javascript
// Interaction verification - test method calls
describe('Order', () => {
  it('delegates tax calculation', () => {
    const taxCalculator = {
      calculateTax: jest.fn().mockReturnValue(3.50)
    };
    const order = new Order(taxCalculator);
    order.addItem({ price: 10 }, 2);

    order.totalWithTax();

    expect(taxCalculator.calculateTax).toHaveBeenCalledWith(20.00);
  });
});
```

**When London Shines:**
- External integrations (DB, APIs)
- Command patterns with side effects
- Complex workflows
- Slow operations (network, I/O)

---

## Mixed Approach (Recommended)

```javascript
// London for controller (external deps)
describe('OrderController', () => {
  it('creates order and sends confirmation', async () => {
    const orderService = { create: jest.fn().mockResolvedValue({ id: 123 }) };
    const emailService = { send: jest.fn() };

    const controller = new OrderController(orderService, emailService);
    await controller.placeOrder(orderData);

    expect(orderService.create).toHaveBeenCalledWith(orderData);
    expect(emailService.send).toHaveBeenCalled();
  });
});

// Chicago for domain logic
describe('OrderService', () => {
  it('applies discount when threshold met', () => {
    const service = new OrderService();
    const order = service.create({ items: [...], total: 150 });

    expect(order.discount).toBe(15); // 10% off > $100
  });
});
```

---

## Common Pitfalls

### ❌ Over-Mocking (London)
```javascript
// BAD - mocking everything
const product = { getName: jest.fn(), getPrice: jest.fn() };
```
**Better:** Only mock external dependencies.

### ❌ Mocking Internals
```javascript
// BAD - testing private methods
expect(order._calculateSubtotal).toHaveBeenCalled();
```
**Better:** Test public behavior only.

### ❌ Test Pain = Design Pain
- Need many mocks? → Too many dependencies
- Hard to set up? → Constructor does too much
- Can't test without database? → Coupling issue

---

## Agent-Assisted TDD

```typescript
// Agent generates tests in both schools
await Task("Generate Tests", {
  style: 'chicago',      // or 'london'
  target: 'src/domain/Order.ts',
  focus: 'state-verification'  // or 'collaboration-patterns'
}, "qe-test-generator");

// Agent-human ping-pong TDD
// Human writes test concept
const testIdea = "Order applies 10% discount when total > $100";

// Agent generates formal failing test (Red)
await Task("Create Failing Test", testIdea, "qe-test-generator");

// Human writes minimal code (Green)

// Agent suggests refactorings
await Task("Suggest Refactorings", { preserveTests: true }, "qe-test-refactorer");
```

---

## Agent Coordination Hints

### Memory Namespace
```
aqe/tdd/
├── test-plan/*        - TDD session plans
├── red-phase/*        - Failing tests generated
├── green-phase/*      - Implementation code
└── refactor-phase/*   - Refactoring suggestions
```

### Fleet Coordination
```typescript
const tddFleet = await FleetManager.coordinate({
  workflow: 'red-green-refactor',
  agents: {
    testGenerator: 'qe-test-generator',
    testExecutor: 'qe-test-executor',
    qualityAnalyzer: 'qe-quality-analyzer'
  },
  mode: 'sequential'
});
```

---

## Related Skills
- [agentic-quality-engineering](../agentic-quality-engineering/) - TDD with agent coordination
- [refactoring-patterns](../refactoring-patterns/) - Refactor phase techniques
- [api-testing-patterns](../api-testing-patterns/) - London school for API testing

---

## Remember

**Chicago:** Test state, use real objects, refactor freely
**London:** Test interactions, mock dependencies, design interfaces first
**Both:** Write the test first, make it pass, refactor

Neither is "right." Choose based on context. Mix as needed. Goal: well-designed, tested code.

**With Agents:** Agents excel at generating tests, validating green phase, and suggesting refactorings. Use agents to maintain TDD discipline while humans focus on design decisions.

## Gotchas

- Agent skips Red phase and writes test + implementation together — enforce "test must fail first" by running test before writing code
- London school over-mocking creates brittle tests that break on any refactor — mock at architectural boundaries, not every function
- Chicago school tests become slow as integration scope grows — keep test boundaries tight
- Agent defaults to jest.mock() for everything — prefer dependency injection for testability
- Refactor phase is where agent cuts corners most — verify no behavior changes by checking test output is identical

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Похожие скиллы

Все скиллы по теме «Тесты и QA» →
tdd-workflow travisjneuman Скилл tdd-workflow для Claude Code, Codex, Cursor и других платформ, который включает режим разработки через тесты: сначала пишется падающий тест (RED), потом минимальный код для прохода (GREEN), затем рефакторинг. CX Codex +1 141установок rtk-tdd rtk-ai Скилл rtk-tdd ведёт разработку на Rust по циклу Red-Green-Refactor и сам включается для задач с кодом, тестами, рефакторингом и исправлением ошибок. CX Codex +1 2 300установок tdd parcadei Скилл tdd ведёт агента по строгому циклу red-green-refactor: сначала падающий тест, потом минимальный код, потом проверка. CX Codex +1 474установок backend-development-tdd-orchestrator Seth Hobson Субагент backend-development-tdd-orchestrator для Claude Code ведёт разработку по red-green-refactor: сначала тест, потом код, потом рефакторинг. Держит дисциплину тестов в проекте и следит, чтобы тест появлялся раньше кода. CX Codex ★ 42 780звёзд репо w-tdd blockmatic-icebox Скилл w-tdd для Claude Code ведёт разработку через цикл red-green-refactor. Он включается, когда разработчик просит применить TDD или этого требует репозиторий. CX Codex +1 647установок 054-design-tdd Juan Antonio Breña Moral Скилл 054-design-tdd ведёт разработчика через цикл «красный-зелёный-рефакторинг» при тестировании Java-кода. Пишешь падающий тест, минимум кода для прохода, потом переделываешь — всё время держа тесты зелёными. CX Codex +1 177установок

Из того же набора73

Весь набор →
qe-iterative-loop Скилл qe-iterative-loop для Claude Code запускает автономные циклы red-green-refactor: агент чинит падающие тесты, достигает целевого покрытия и проходит quality gates. Циклы устраняют падения тестов и повышают покрытие. CX Codex +1 126установок xp-practices Скилл xp-practices для парного программирования, непрерывной интеграции, TDD и других практик экстремального программирования в ИИ-кодинге. CX Codex +1 125установок context-driven-testing Скилл context-driven-testing подбирает стратегию тестирования под цели и риски конкретного проекта вместо шаблонных практик. Помогает агенту приоритизировать проверки. CX Codex +1 125установок n8n-integration-testing-patterns Скилл n8n-integration-testing-patterns проверяет контракты API, сценарии ошибок, лимиты запросов и авторизацию внешних сервисов в узлах n8n. Пригодится при отладке интеграций. CX Codex +1 124установок qe-chaos-resilience Скилл qe-chaos-resilience для Claude Code внедряет контролируемые сбои в распределённые системы и проверяет восстановление. Запускается при тестировании circuit breaker'ов, failover и retry-логики. CX Codex +1 123установок consultancy-practices Скилл consultancy-practices для Claude Code, Codex, Cursor и других платформ применяет практики консалтинга качества ПО. Слушает клиента, выявляет боль, приоритизирует по матрице воздействие/усилия, передаёт знания вместо зависимости. CX Codex +1 122установок mutation-testing Скилл mutation-testing запускает мутационное тестирование: меняет код (операторы, границы, логику), прогоняет тесты и считает, сколько мутантов выжило — это слабые места. CX Codex +1 122установок qe-code-intelligence Скилл qe-code-intelligence строит семантический индекс кодовой базы, карты зависимостей и граф знаний. Помогает разобраться в незнакомом коде, отследить цепочки вызовов и найти нужные участки по смыслу запроса. CX Codex +1 122установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой