def test_update_quality_v2_increases_quality_backstage_tickets(self):
items = [
BackStageTicketItem("foo", 10, 10),
BackStageTicketItem("bar", 4, 10),
BackStageTicketItem("pj", 0, 10)
]
gilded_rose = GildedRose(items)
gilded_rose.update_quality_v2()
self.assertEqual(12, items[0].quality)
self.assertEqual(13, items[1].quality)
self.assertEqual(0, items[2].quality)
def generate_fixture(days=None):
items = [
Item(
name="+5 Dexterity Vest",
sell_in=10,
quality=20,
),
Item(
name="Aged Brie",
sell_in=2,
quality=0,
),
Item(name="Elixir of the Mongoose", sell_in=5, quality=7),
Item(
name="Sulfuras, Hand of Ragnaros",
sell_in=0,
quality=80,
),
Item(
name="Sulfuras, Hand of Ragnaros",
sell_in=-1,
quality=80,
),
Item(
name="Backstage passes to a TAFKAL80ETC concert",
sell_in=15,
quality=20,
),
Item(
name="Backstage passes to a TAFKAL80ETC concert",
sell_in=10,
quality=49,
),
Item(
name="Backstage passes to a TAFKAL80ETC concert",
sell_in=5,
quality=49,
),
Item(
name="Conjured Mana Cake",
sell_in=3,
quality=6,
),
]
if days is None:
days = 2
for day in range(days):
print("-------- day %s --------" % day)
print("name, sellIn, quality")
for item in items:
print(item)
print("")
GildedRose(items).update_quality()
def test_update_quality_increases_quality_backstage_tickets(self):
items = [
Item("Backstage passes to a TAFKAL80ETC concert", 10, 10),
Item("Backstage passes to a TAFKAL80ETC concert", 4, 10),
Item("Backstage passes to a TAFKAL80ETC concert", 0, 10)
]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEqual(12, items[0].quality)
self.assertEqual(13, items[1].quality)
self.assertEqual(0, items[2].quality)
def test_concert_item_when_sell_in_less_than_ten_days_quality_increase_by_two(
self):
set_quantity = 20
ten_days_left = 10
expected_incremental = 2
items = [Item(self.concert_item_name, ten_days_left, set_quantity)]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEquals(items[0].quality,
set_quantity + expected_incremental)
def test_legendary_item_decay(self):
items = [
LegendaryItem("Sulfuras, Hand of Ragnaros", 0, 80),
LegendaryItem("Sulfuras, Hand of Ragnaros", 1, 80),
]
gilded_rose = GildedRose(items)
self.assertEqual(items[0].quality, 80)
self.assertEqual(items[1].quality, 80)
gilded_rose.update_quality()
self.assertEqual(items[0].quality, 80)
self.assertEqual(items[1].quality, 80)
def test_aged_brie_increase_in_quality_when_sellin_is_negative(self):
# Given
quality = 2
expected_quality = quality + 2
items = [Item("Aged Brie", -2, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_quality_cant_be_negative(self):
# Given
quality = 0
expected_quality = quality
items = [Item("foo", 2, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_when_sellin_is_positive_quality_decrease_from_one(self):
# Given
quality = 1
expected_quality = quality - 1
items = [Item("foo", 1, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_increase_pass_overdue(self):
# Quality drops to 0 after the concert
self.items.append(item_creator.create("Backstage passes to a TAFKAL80ETC concert", 0, 35))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': -1, 'quality': 0},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_update_quality_decreases_quality_by_4_if_sell_in_is_below_0_for_conjured_items(self):
self.conjured_item.sell_in = -1
self.conjured_item.quality = 8
gilded_rose = GildedRose([self.conjured_item])
gilded_rose.update_quality()
self.assertEqual(4, self.conjured_item.quality)
gilded_rose.update_quality()
self.assertEqual(0, self.conjured_item.quality)
def test_update_quality_increases_quality_by_3_for_backstage_passes_if_sell_in_is_below_6(self):
self.backstage_passes.sell_in = 5
self.backstage_passes.quality = 2
gilded_rose = GildedRose([self.backstage_passes])
gilded_rose.update_quality()
self.assertEqual(5, self.backstage_passes.quality)
gilded_rose.update_quality()
self.assertEqual(8, self.backstage_passes.quality)
def test_conjured_items_degrade_in_quality_faster(self):
starting_quality = 10
items = [
Item("Conjured Item", 10, starting_quality),
Item("foo", 10, starting_quality)
]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEqual((starting_quality - gilded_rose.items[1].quality),
(starting_quality - gilded_rose.items[0].quality) / 2)
def test_quality_degrades_faster_after_sell__by_date(self):
starting_quality = 10
items = [
Item("foo", 5, starting_quality), # 5 days left to sell
Item("foo", -1, starting_quality) # 1 day over sell by date
]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertGreater((starting_quality - gilded_rose.items[1].quality),
(starting_quality - gilded_rose.items[0].quality))
def test_item_past_expiration_quality_degrades_double(self):
#Define test item
items = [
Item(name="+5 Dexterity Vest", sell_in=1, quality=20),
]
#Save quality value for use in the assert
day0_quality = items[0].quality
#Iterate 2 days, saving quality data for testing
GildedRose(items).update_quality() #Iterate one day
day1_quality = items[0].quality
GildedRose(items).update_quality() #Iterate one day
day2_quality = items[0].quality
#Calculated differences between days
diff_day0_day1 = day0_quality - day1_quality
diff_day1_day2 = day1_quality - day2_quality
#Verify when item has "Expired" it loses value twice as fast
#Diff between day1 and day2 should be double diff between day0 and day1 because sell_in is then less than 1
self.assertEqual(diff_day1_day2, (diff_day0_day1 * 2))
self.assertTrue(self.item_are_valid_tests(items))
def test_foo(self):
items = [Item("foo", 1, 3)]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEqual(0, items[0].sell_in)
self.assertEqual(2, items[0].quality, 'quality decreases with 1 when sell_in is positive')
gilded_rose.update_quality()
self.assertEqual(-1, items[0].sell_in)
self.assertEqual(0, items[0].quality, 'quality decreases with 2 when sell_in becomes negative')
gilded_rose.update_quality()
self.assertEqual(-2, items[0].sell_in)
self.assertEqual(0, items[0].quality, 'quality never becomes negative')
def test_increase_brie(self):
# "Aged Brie" actually increases in Quality the older it gets
self.items.append(item_creator.create("Aged Brie", 20, 30))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': 19, 'quality': 31},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_increase_pass_by_two(self):
# Quality increases by 2 when there are 10 days or less
self.items.append(item_creator.create("Backstage passes to a TAFKAL80ETC concert", 8, 30))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': 7, 'quality': 32},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_update_quality_decreases_quality_by_2_if_sell_in_is_below_0(self):
self.item.sell_in = -1
self.item.quality = 4
gilded_rose = GildedRose([self.item])
gilded_rose.update_quality()
self.assertEqual(2, self.item.quality)
gilded_rose.update_quality()
self.assertEqual(0, self.item.quality)
def test_decrease_double_overdue(self):
# Once the sell by date has passed, Quality degrades twice as fast
self.items.append(item_creator.create("+5 Dexterity Vest", 0, 20))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': -1, 'quality': 18},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_update_quality_increases_quality_by_2_for_aged_brie_if_sell_in_is_below_0(self):
self.aged_brie.sell_in = -1
self.aged_brie.quality = 2
gilded_rose = GildedRose([self.aged_brie])
gilded_rose.update_quality()
self.assertEqual(4, self.aged_brie.quality)
gilded_rose.update_quality()
self.assertEqual(6, self.aged_brie.quality)
def test_when_sellin_is_negative_quality_decrease_twice_as_fast(self):
# Given
quality = 10
expected_quality = quality - 1 * 2
items = [Item("foo", -1, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_sulfuras(gilded_rose):
items = [Item('Sulfuras', sell_in=math.inf, quality=80)]
inventory = GildedRose(items)
item = inventory.items[0]
inventory.update_quality()
assert 80 == item.quality
assert math.inf == item.sell_in
days_after(500, inventory)
assert 80 == item.quality
assert math.inf == item.sell_in
def test_aged_brie_increase_in_quality_the_older_it_gets(self):
# Given
quality = 2
expected_quality = quality + 1
items = [Item("Aged Brie", 2, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_max_quality(self):
# The Quality of an item is never more than 50
self.items.append(item_creator.create("Aged Brie", 10, 50))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': 9, 'quality': 50},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_quality_of_item_cant_exceed_50(self):
# Given
quality = 50
expected_quality = quality
items = [Item("Aged Brie", 2, quality)]
gilded_rose = GildedRose(items)
# When
gilded_rose.update_quality()
# Then
self.assertEquals(expected_quality, items[0].quality)
def test_normal_decrease(self):
# Regular items degrade by one (quality + sell_in)
self.items.append(item_creator.create("5 Dexterity Vest", 10, 20))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': 9, 'quality': 19},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_concert_item_when_sell_in_more_than_ten_days_quality_increase_by_one(
self):
set_quantity = 20
set_sell_in = 15
expected_incremental = 1
items = [Item(self.concert_item_name, set_sell_in, set_quantity)]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEquals(items[0].quality,
set_quantity + expected_incremental)
def test_immutable_sulfuras(self):
# "Sulfuras", being a legendary item, never has to be sold or decreases in Quality
self.items.append(item_creator.create("Sulfuras, Hand of Ragnaros", -1, 80))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': -1, 'quality': 80},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
def test_concert_item_when_sell_in_left_five_days_quality_increase_by_three(
self):
set_quantity = 20
five_days_left = 5
expected_incremental = 3
items = [Item(self.concert_item_name, five_days_left, set_quantity)]
gilded_rose = GildedRose(items)
gilded_rose.update_quality()
self.assertEquals(items[0].quality,
set_quantity + expected_incremental)
def test_conjured_decrease(self):
# "Conjured" items degrade in Quality twice as fast as normal items
self.items.append(item_creator.create("Conjured Health Potion", 10, 10))
self.test_shop = GildedRose(self.items)
self.test_shop.update_quality()
results = [
{'sell_in': 9, 'quality': 8},
]
for num, result in enumerate(results):
item = self.items[num]
self.assertEqual(item.quality, result['quality'])
self.assertEqual(item.sell_in, result['sell_in'])
