mirror of
https://github.com/emilybache/GildedRose-Refactoring-Kata.git
synced 2026-05-15 14:21:12 +00:00
826 lines
24 KiB
Markdown
826 lines
24 KiB
Markdown
# GildedRose Strategy Pattern Refactor — Implementation Plan
|
|
|
|
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
|
|
|
**Goal:** Refactor `GildedRose.update_quality` from a nested if/elif chain into a Strategy Pattern with an internal `ItemRecord` dataclass, `days` injection, and full test coverage including the new Conjured item type.
|
|
|
|
**Architecture:** Each item type gets a dedicated `UpdateStrategy` class. `GildedRose.__init__` wraps every `Item` in an internal `ItemRecord(item, strategy)` by looking up the item name in a dict; unknowns get `NormalStrategy`. `update_quality(days=1)` delegates to each record's strategy, simulating `days` days in one call.
|
|
|
|
**Tech Stack:** Python 3.10+, `unittest.TestCase`, `pytest`, `dataclasses`, `typing.Protocol`
|
|
|
|
---
|
|
|
|
## File Map
|
|
|
|
| File | Change |
|
|
|---|---|
|
|
| `gilded_rose.py` | Add `UpdateStrategy` Protocol, five strategy classes, `ItemRecord` dataclass, `_STRATEGY_MAP`, refactor `GildedRose` |
|
|
| `tests/test_gilded_rose.py` | Fix `test_foo`, add one `TestCase` per strategy class + integration `TestGildedRose` |
|
|
|
|
---
|
|
|
|
### Task 1: Fix the broken placeholder test
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py`
|
|
|
|
The existing `test_foo` always fails because it asserts `items[0].name == "fixme"` — `update_quality` never changes names. Fix it to assert the real behaviour: a normal item with `quality=0` stays at `0` after one update.
|
|
|
|
- [ ] **Step 1: Update the assertion and rename the test**
|
|
|
|
Replace the test body in `tests/test_gilded_rose.py`:
|
|
|
|
```python
|
|
class GildedRoseTest(unittest.TestCase):
|
|
def test_normal_item_at_zero_quality_stays_zero(self):
|
|
items = [Item("foo", 0, 0)]
|
|
gilded_rose = GildedRose(items)
|
|
gilded_rose.update_quality()
|
|
self.assertEqual(0, items[0].quality)
|
|
```
|
|
|
|
- [ ] **Step 2: Run the test and confirm it passes**
|
|
|
|
```bash
|
|
cd /Users/rajvora/Documents/interviews/GildedRose-Refactoring-Kata/python
|
|
python3 -m pytest tests/test_gilded_rose.py -v
|
|
```
|
|
|
|
Expected: `PASSED tests/test_gilded_rose.py::GildedRoseTest::test_normal_item_at_zero_quality_stays_zero`
|
|
|
|
- [ ] **Step 3: Commit**
|
|
|
|
```bash
|
|
git add tests/test_gilded_rose.py
|
|
git commit -m "fix: correct placeholder test_foo assertion"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 2: NormalStrategy — TDD
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestNormalStrategy`
|
|
- Modify: `gilded_rose.py` — add `NormalStrategy`
|
|
|
|
Normal items: `-1 quality/day`, `-2/day` once `sell_in < 0`, quality floors at `0`.
|
|
|
|
- [ ] **Step 1: Write failing tests for NormalStrategy**
|
|
|
|
Add this class to `tests/test_gilded_rose.py` (after the existing `GildedRoseTest`):
|
|
|
|
```python
|
|
class TestNormalStrategy(unittest.TestCase):
|
|
"""Tests for NormalStrategy — default degradation behaviour."""
|
|
|
|
def setUp(self):
|
|
self.strategy = NormalStrategy()
|
|
|
|
def test_quality_decrements_by_one_each_day(self):
|
|
item = Item("widget", sell_in=10, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(19, item.quality)
|
|
self.assertEqual(9, item.sell_in)
|
|
|
|
def test_quality_floors_at_zero(self):
|
|
# Quality must never go negative
|
|
item = Item("widget", sell_in=5, quality=0)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.quality)
|
|
|
|
def test_quality_degrades_twice_after_sell_date(self):
|
|
# Once sell_in goes below 0, each day removes 2 quality
|
|
item = Item("widget", sell_in=0, quality=10)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(8, item.quality)
|
|
self.assertEqual(-1, item.sell_in)
|
|
|
|
def test_multi_day_crosses_sell_date(self):
|
|
# Days=5 starting from sell_in=2: 2 normal days then 3 post-sell days
|
|
# Day1: q=9 si=1 | Day2: q=8 si=0 | Day3: q=6 si=-1
|
|
# Day4: q=4 si=-2 | Day5: q=2 si=-3
|
|
item = Item("widget", sell_in=2, quality=10)
|
|
self.strategy.update(item, days=5)
|
|
self.assertEqual(2, item.quality)
|
|
self.assertEqual(-3, item.sell_in)
|
|
|
|
def test_quality_floors_at_zero_when_crossing_sell_date(self):
|
|
item = Item("widget", sell_in=1, quality=1)
|
|
# Day1: q=0 si=0 | Day2: post-sell but already 0
|
|
self.strategy.update(item, days=2)
|
|
self.assertEqual(0, item.quality)
|
|
```
|
|
|
|
Also update the import line at the top of the test file to include `NormalStrategy`:
|
|
|
|
```python
|
|
from gilded_rose import Item, GildedRose, NormalStrategy
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestNormalStrategy -v
|
|
```
|
|
|
|
Expected: `ImportError` or `AttributeError` — `NormalStrategy` does not exist yet.
|
|
|
|
- [ ] **Step 3: Implement NormalStrategy in gilded_rose.py**
|
|
|
|
Add at the top of `gilded_rose.py` (before the `GildedRose` class, after any existing code):
|
|
|
|
```python
|
|
# -*- coding: utf-8 -*-
|
|
from dataclasses import dataclass
|
|
from typing import Protocol
|
|
|
|
|
|
class UpdateStrategy(Protocol):
|
|
"""Interface for per-item-type quality update logic."""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
"""Mutate item.quality and item.sell_in to reflect `days` passing."""
|
|
...
|
|
|
|
|
|
class NormalStrategy:
|
|
"""
|
|
Default degradation strategy.
|
|
|
|
Quality decreases by 1 per day; by 2 per day once the sell date
|
|
has passed (sell_in < 0). Quality never falls below 0.
|
|
"""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
for _ in range(days):
|
|
item.quality = max(0, item.quality - 1)
|
|
item.sell_in -= 1
|
|
if item.sell_in < 0:
|
|
item.quality = max(0, item.quality - 1)
|
|
```
|
|
|
|
- [ ] **Step 4: Run tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestNormalStrategy -v
|
|
```
|
|
|
|
Expected: all 5 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite to confirm no regressions**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
Expected: all tests pass.
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: add NormalStrategy with days injection"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 3: AgedBrieStrategy — TDD
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestAgedBrieStrategy`
|
|
- Modify: `gilded_rose.py` — add `AgedBrieStrategy`
|
|
|
|
Aged Brie: `+1 quality/day`, `+2/day` after sell date, caps at `50`.
|
|
|
|
- [ ] **Step 1: Write failing tests**
|
|
|
|
Add to the import line:
|
|
|
|
```python
|
|
from gilded_rose import Item, GildedRose, NormalStrategy, AgedBrieStrategy
|
|
```
|
|
|
|
Add this class:
|
|
|
|
```python
|
|
class TestAgedBrieStrategy(unittest.TestCase):
|
|
"""Tests for AgedBrieStrategy — quality improves with age."""
|
|
|
|
def setUp(self):
|
|
self.strategy = AgedBrieStrategy()
|
|
|
|
def test_quality_increments_by_one_each_day(self):
|
|
item = Item("Aged Brie", sell_in=10, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(21, item.quality)
|
|
self.assertEqual(9, item.sell_in)
|
|
|
|
def test_quality_caps_at_50(self):
|
|
item = Item("Aged Brie", sell_in=10, quality=50)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(50, item.quality)
|
|
|
|
def test_quality_increments_twice_after_sell_date(self):
|
|
# Past sell date: +2 per day
|
|
item = Item("Aged Brie", sell_in=0, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(22, item.quality)
|
|
self.assertEqual(-1, item.sell_in)
|
|
|
|
def test_multi_day_crosses_sell_date(self):
|
|
# sell_in=1, quality=46, days=3
|
|
# Day1: q=47 si=0 | Day2: q=49 si=-1 | Day3: q=50 (capped) si=-2
|
|
item = Item("Aged Brie", sell_in=1, quality=46)
|
|
self.strategy.update(item, days=3)
|
|
self.assertEqual(50, item.quality)
|
|
self.assertEqual(-2, item.sell_in)
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestAgedBrieStrategy -v
|
|
```
|
|
|
|
Expected: `ImportError` — `AgedBrieStrategy` does not exist yet.
|
|
|
|
- [ ] **Step 3: Implement AgedBrieStrategy in gilded_rose.py**
|
|
|
|
Add after `NormalStrategy`:
|
|
|
|
```python
|
|
class AgedBrieStrategy:
|
|
"""
|
|
Quality improvement strategy for Aged Brie.
|
|
|
|
Quality increases by 1 per day; by 2 per day once the sell date
|
|
has passed. Quality never exceeds 50.
|
|
"""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
for _ in range(days):
|
|
item.quality = min(50, item.quality + 1)
|
|
item.sell_in -= 1
|
|
if item.sell_in < 0:
|
|
item.quality = min(50, item.quality + 1)
|
|
```
|
|
|
|
- [ ] **Step 4: Run tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestAgedBrieStrategy -v
|
|
```
|
|
|
|
Expected: all 4 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: add AgedBrieStrategy"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 4: BackstagePassStrategy — TDD
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestBackstagePassStrategy`
|
|
- Modify: `gilded_rose.py` — add `BackstagePassStrategy`
|
|
|
|
Rules: `+1` quality normally; `+2` when `sell_in ≤ 10`; `+3` when `sell_in ≤ 5`; drops to `0` when `sell_in` reaches `0` at start of day (concert day). Quality caps at `50`.
|
|
|
|
- [ ] **Step 1: Write failing tests**
|
|
|
|
Update import:
|
|
|
|
```python
|
|
from gilded_rose import (
|
|
Item, GildedRose, NormalStrategy, AgedBrieStrategy,
|
|
BackstagePassStrategy,
|
|
)
|
|
```
|
|
|
|
Add:
|
|
|
|
```python
|
|
class TestBackstagePassStrategy(unittest.TestCase):
|
|
"""Tests for BackstagePassStrategy — tiered increase, zeroes after concert."""
|
|
|
|
def setUp(self):
|
|
self.strategy = BackstagePassStrategy()
|
|
|
|
def test_quality_increments_by_1_when_more_than_10_days(self):
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=15, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(21, item.quality)
|
|
self.assertEqual(14, item.sell_in)
|
|
|
|
def test_quality_increments_by_2_when_10_or_fewer_days(self):
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=10, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(22, item.quality)
|
|
self.assertEqual(9, item.sell_in)
|
|
|
|
def test_quality_increments_by_3_when_5_or_fewer_days(self):
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=5, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(23, item.quality)
|
|
self.assertEqual(4, item.sell_in)
|
|
|
|
def test_quality_drops_to_zero_on_concert_day(self):
|
|
# sell_in=0 means the concert is today — quality zeroes out
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=0, quality=30)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.quality)
|
|
self.assertEqual(-1, item.sell_in)
|
|
|
|
def test_quality_stays_zero_after_concert(self):
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=-1, quality=0)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.quality)
|
|
|
|
def test_quality_caps_at_50(self):
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=5, quality=49)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(50, item.quality)
|
|
|
|
def test_multi_day_crosses_all_thresholds(self):
|
|
# sell_in=12, quality=20, days=4
|
|
# Day1(si=12): +1 → q=21, si=11
|
|
# Day2(si=11): +1 → q=22, si=10
|
|
# Day3(si=10): +2 → q=24, si=9
|
|
# Day4(si=9): +2 → q=26, si=8
|
|
item = Item("Backstage passes to a TAFKAL80ETC concert", sell_in=12, quality=20)
|
|
self.strategy.update(item, days=4)
|
|
self.assertEqual(26, item.quality)
|
|
self.assertEqual(8, item.sell_in)
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestBackstagePassStrategy -v
|
|
```
|
|
|
|
Expected: `ImportError` — `BackstagePassStrategy` not defined.
|
|
|
|
- [ ] **Step 3: Implement BackstagePassStrategy**
|
|
|
|
Add after `AgedBrieStrategy`:
|
|
|
|
```python
|
|
class BackstagePassStrategy:
|
|
"""
|
|
Quality strategy for backstage passes.
|
|
|
|
Quality increases as the concert approaches:
|
|
- +1/day when more than 10 days remain
|
|
- +2/day when 10 or fewer days remain
|
|
- +3/day when 5 or fewer days remain
|
|
Quality drops to 0 on concert day (sell_in == 0 at start of day)
|
|
and stays 0 afterwards. Quality never exceeds 50.
|
|
"""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
for _ in range(days):
|
|
if item.sell_in <= 0:
|
|
# Concert day or past — quality is worthless
|
|
item.quality = 0
|
|
item.sell_in -= 1
|
|
continue
|
|
if item.sell_in <= 5:
|
|
item.quality = min(50, item.quality + 3)
|
|
elif item.sell_in <= 10:
|
|
item.quality = min(50, item.quality + 2)
|
|
else:
|
|
item.quality = min(50, item.quality + 1)
|
|
item.sell_in -= 1
|
|
```
|
|
|
|
- [ ] **Step 4: Run tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestBackstagePassStrategy -v
|
|
```
|
|
|
|
Expected: all 7 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: add BackstagePassStrategy"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 5: SulfurasStrategy — TDD
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestSulfurasStrategy`
|
|
- Modify: `gilded_rose.py` — add `SulfurasStrategy`
|
|
|
|
Sulfuras is legendary: `quality` is always `80`, `sell_in` never changes.
|
|
|
|
- [ ] **Step 1: Write failing tests**
|
|
|
|
Update import:
|
|
|
|
```python
|
|
from gilded_rose import (
|
|
Item, GildedRose, NormalStrategy, AgedBrieStrategy,
|
|
BackstagePassStrategy, SulfurasStrategy,
|
|
)
|
|
```
|
|
|
|
Add:
|
|
|
|
```python
|
|
class TestSulfurasStrategy(unittest.TestCase):
|
|
"""Tests for SulfurasStrategy — legendary item, never changes."""
|
|
|
|
def setUp(self):
|
|
self.strategy = SulfurasStrategy()
|
|
|
|
def test_quality_never_changes(self):
|
|
item = Item("Sulfuras, Hand of Ragnaros", sell_in=0, quality=80)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(80, item.quality)
|
|
|
|
def test_sell_in_never_changes(self):
|
|
item = Item("Sulfuras, Hand of Ragnaros", sell_in=0, quality=80)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.sell_in)
|
|
|
|
def test_unchanged_after_many_days(self):
|
|
item = Item("Sulfuras, Hand of Ragnaros", sell_in=0, quality=80)
|
|
self.strategy.update(item, days=100)
|
|
self.assertEqual(80, item.quality)
|
|
self.assertEqual(0, item.sell_in)
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestSulfurasStrategy -v
|
|
```
|
|
|
|
Expected: `ImportError`.
|
|
|
|
- [ ] **Step 3: Implement SulfurasStrategy**
|
|
|
|
Add after `BackstagePassStrategy`:
|
|
|
|
```python
|
|
class SulfurasStrategy:
|
|
"""
|
|
No-op strategy for Sulfuras, Hand of Ragnaros.
|
|
|
|
Legendary items never degrade and never need to be sold.
|
|
Neither quality nor sell_in is ever mutated.
|
|
"""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
pass # legendary items are immutable
|
|
```
|
|
|
|
- [ ] **Step 4: Run tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestSulfurasStrategy -v
|
|
```
|
|
|
|
Expected: all 3 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: add SulfurasStrategy"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 6: ConjuredStrategy — TDD
|
|
|
|
**Files:**
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestConjuredStrategy`
|
|
- Modify: `gilded_rose.py` — add `ConjuredStrategy`
|
|
|
|
Conjured items degrade at twice the normal rate: `-2/day`, `-4/day` after sell date. Quality floors at `0`.
|
|
|
|
- [ ] **Step 1: Write failing tests**
|
|
|
|
Update import:
|
|
|
|
```python
|
|
from gilded_rose import (
|
|
Item, GildedRose, NormalStrategy, AgedBrieStrategy,
|
|
BackstagePassStrategy, SulfurasStrategy, ConjuredStrategy,
|
|
)
|
|
```
|
|
|
|
Add:
|
|
|
|
```python
|
|
class TestConjuredStrategy(unittest.TestCase):
|
|
"""Tests for ConjuredStrategy — degrades twice as fast as normal."""
|
|
|
|
def setUp(self):
|
|
self.strategy = ConjuredStrategy()
|
|
|
|
def test_quality_decrements_by_2_each_day(self):
|
|
item = Item("Conjured Mana Cake", sell_in=10, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(18, item.quality)
|
|
self.assertEqual(9, item.sell_in)
|
|
|
|
def test_quality_floors_at_zero(self):
|
|
item = Item("Conjured Mana Cake", sell_in=5, quality=1)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.quality)
|
|
|
|
def test_quality_degrades_by_4_after_sell_date(self):
|
|
# Past sell date: -4 per day
|
|
item = Item("Conjured Mana Cake", sell_in=0, quality=20)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(16, item.quality)
|
|
self.assertEqual(-1, item.sell_in)
|
|
|
|
def test_multi_day_crosses_sell_date(self):
|
|
# sell_in=1, quality=10, days=3
|
|
# Day1: q=8 si=0 | Day2: q=4 si=-1 | Day3: q=0 si=-2
|
|
item = Item("Conjured Mana Cake", sell_in=1, quality=10)
|
|
self.strategy.update(item, days=3)
|
|
self.assertEqual(0, item.quality)
|
|
self.assertEqual(-2, item.sell_in)
|
|
|
|
def test_quality_floors_at_zero_post_sell_date(self):
|
|
item = Item("Conjured Mana Cake", sell_in=0, quality=2)
|
|
self.strategy.update(item, days=1)
|
|
self.assertEqual(0, item.quality)
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestConjuredStrategy -v
|
|
```
|
|
|
|
Expected: `ImportError`.
|
|
|
|
- [ ] **Step 3: Implement ConjuredStrategy**
|
|
|
|
Add after `SulfurasStrategy`:
|
|
|
|
```python
|
|
class ConjuredStrategy:
|
|
"""
|
|
Double-degradation strategy for Conjured items.
|
|
|
|
Quality decreases by 2 per day; by 4 per day once the sell date
|
|
has passed. Quality never falls below 0.
|
|
"""
|
|
|
|
def update(self, item: "Item", days: int) -> None:
|
|
for _ in range(days):
|
|
item.quality = max(0, item.quality - 2)
|
|
item.sell_in -= 1
|
|
if item.sell_in < 0:
|
|
item.quality = max(0, item.quality - 2)
|
|
```
|
|
|
|
- [ ] **Step 4: Run tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestConjuredStrategy -v
|
|
```
|
|
|
|
Expected: all 5 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: add ConjuredStrategy"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 7: Wire GildedRose to use strategies — TDD
|
|
|
|
**Files:**
|
|
- Modify: `gilded_rose.py` — add `ItemRecord`, `_STRATEGY_MAP`, refactor `GildedRose`
|
|
- Modify: `tests/test_gilded_rose.py` — add `TestGildedRose` integration tests
|
|
|
|
This is the wiring step: `GildedRose` replaces its monolithic `update_quality` body with strategy dispatch via `ItemRecord`.
|
|
|
|
- [ ] **Step 1: Write failing integration tests**
|
|
|
|
Update import to add `ItemRecord`:
|
|
|
|
```python
|
|
from gilded_rose import (
|
|
Item, GildedRose, NormalStrategy, AgedBrieStrategy,
|
|
BackstagePassStrategy, SulfurasStrategy, ConjuredStrategy,
|
|
ItemRecord,
|
|
)
|
|
```
|
|
|
|
Add:
|
|
|
|
```python
|
|
class TestGildedRose(unittest.TestCase):
|
|
"""
|
|
Integration tests for GildedRose.
|
|
|
|
Verifies strategy dispatch by name and that the days parameter
|
|
is forwarded correctly.
|
|
"""
|
|
|
|
def test_dispatches_normal_strategy_for_unknown_item(self):
|
|
items = [Item("unknown widget", sell_in=5, quality=10)]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(9, items[0].quality)
|
|
self.assertEqual(4, items[0].sell_in)
|
|
|
|
def test_dispatches_aged_brie_strategy(self):
|
|
items = [Item("Aged Brie", sell_in=5, quality=20)]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(21, items[0].quality)
|
|
|
|
def test_dispatches_backstage_pass_strategy(self):
|
|
items = [Item("Backstage passes to a TAFKAL80ETC concert", sell_in=5, quality=20)]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(23, items[0].quality)
|
|
|
|
def test_dispatches_sulfuras_strategy(self):
|
|
items = [Item("Sulfuras, Hand of Ragnaros", sell_in=0, quality=80)]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(80, items[0].quality)
|
|
self.assertEqual(0, items[0].sell_in)
|
|
|
|
def test_dispatches_conjured_strategy(self):
|
|
items = [Item("Conjured Mana Cake", sell_in=5, quality=20)]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(18, items[0].quality)
|
|
|
|
def test_multi_day_update_via_days_param(self):
|
|
items = [Item("unknown widget", sell_in=3, quality=10)]
|
|
GildedRose(items).update_quality(days=3)
|
|
# Day1: q=9 si=2 | Day2: q=8 si=1 | Day3: q=7 si=0
|
|
self.assertEqual(7, items[0].quality)
|
|
self.assertEqual(0, items[0].sell_in)
|
|
|
|
def test_multiple_items_updated_independently(self):
|
|
items = [
|
|
Item("Aged Brie", sell_in=5, quality=20),
|
|
Item("unknown widget", sell_in=5, quality=20),
|
|
]
|
|
GildedRose(items).update_quality()
|
|
self.assertEqual(21, items[0].quality) # Aged Brie goes up
|
|
self.assertEqual(19, items[1].quality) # normal goes down
|
|
|
|
def test_item_record_allows_direct_strategy_injection(self):
|
|
# Verify ItemRecord can be used to inject a strategy directly in tests
|
|
item = Item("anything", sell_in=5, quality=20)
|
|
record = ItemRecord(item=item, strategy=ConjuredStrategy())
|
|
record.strategy.update(record.item, days=1)
|
|
self.assertEqual(18, item.quality)
|
|
```
|
|
|
|
- [ ] **Step 2: Run tests to confirm they FAIL**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestGildedRose -v
|
|
```
|
|
|
|
Expected: `ImportError` for `ItemRecord`; or `TypeError` on `update_quality(days=3)` since the current implementation doesn't accept `days`.
|
|
|
|
- [ ] **Step 3: Refactor GildedRose in gilded_rose.py**
|
|
|
|
Replace the entire `GildedRose` class with the following (keep `Item` class unchanged at the bottom of the file):
|
|
|
|
```python
|
|
_STRATEGY_MAP: dict[str, UpdateStrategy] = {
|
|
"Aged Brie": AgedBrieStrategy(),
|
|
"Backstage passes to a TAFKAL80ETC concert": BackstagePassStrategy(),
|
|
"Sulfuras, Hand of Ragnaros": SulfurasStrategy(),
|
|
"Conjured Mana Cake": ConjuredStrategy(),
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class ItemRecord:
|
|
"""
|
|
Internal pairing of an Item with its UpdateStrategy.
|
|
|
|
Built once in GildedRose.__init__ so the name-to-strategy lookup
|
|
happens at construction time, not on every update call.
|
|
Exposed publicly so tests can inject strategies directly without
|
|
going through the name-lookup dict.
|
|
"""
|
|
|
|
item: Item
|
|
strategy: UpdateStrategy
|
|
|
|
|
|
class GildedRose:
|
|
"""
|
|
Inventory manager for the Gilded Rose inn.
|
|
|
|
Accepts a list of Item objects and updates their quality and sell_in
|
|
values according to each item's type-specific strategy. The Item
|
|
class and the items list are left untouched per the goblin's terms.
|
|
|
|
Usage:
|
|
rose = GildedRose(items)
|
|
rose.update_quality() # advance one day
|
|
rose.update_quality(days=7) # advance a full week
|
|
"""
|
|
|
|
def __init__(self, items: list[Item]) -> None:
|
|
self.items = items
|
|
self._records: list[ItemRecord] = [
|
|
ItemRecord(
|
|
item=i,
|
|
strategy=_STRATEGY_MAP.get(i.name, NormalStrategy()),
|
|
)
|
|
for i in items
|
|
]
|
|
|
|
def update_quality(self, days: int = 1) -> None:
|
|
"""Advance quality and sell_in for all items by `days` days."""
|
|
for record in self._records:
|
|
record.strategy.update(record.item, days)
|
|
```
|
|
|
|
- [ ] **Step 4: Run integration tests to confirm they PASS**
|
|
|
|
```bash
|
|
python3 -m pytest tests/test_gilded_rose.py::TestGildedRose -v
|
|
```
|
|
|
|
Expected: all 8 tests `PASSED`.
|
|
|
|
- [ ] **Step 5: Run full suite to confirm all tests pass**
|
|
|
|
```bash
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
Expected: all tests across all `TestCase` classes `PASSED`.
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
git add gilded_rose.py tests/test_gilded_rose.py
|
|
git commit -m "feat: refactor GildedRose with Strategy pattern and ItemRecord"
|
|
```
|
|
|
|
---
|
|
|
|
## Verification
|
|
|
|
Run the full suite from the project root:
|
|
|
|
```bash
|
|
cd /Users/rajvora/Documents/interviews/GildedRose-Refactoring-Kata/python
|
|
python3 -m pytest tests/ -v
|
|
```
|
|
|
|
Expected output: all tests in `GildedRoseTest`, `TestNormalStrategy`, `TestAgedBrieStrategy`, `TestBackstagePassStrategy`, `TestSulfurasStrategy`, `TestConjuredStrategy`, and `TestGildedRose` show `PASSED`.
|
|
|
|
Also verify the texttest fixture still runs:
|
|
|
|
```bash
|
|
python3 texttest_fixture.py 5
|
|
```
|
|
|
|
Expected: 5 days of inventory output with no errors.
|