Add Conjured logic

python/constants.py

@@ -1,3 +1,8 @@
+"""
+Constants file
+"""
+
 BACKSTAGE = "Backstage passes to a TAFKAL80ETC concert"
 AGED_BRIE = "Aged Brie"
 SULFURAS = "Sulfuras, Hand of Ragnaros"
+CONJURED = "Conjured"

python/gilded_rose.py

@@ -1,45 +1,134 @@
 # -*- coding: utf-8 -*-
 
+"""
+Use and apply the logic from Gilded Rose
+"""
 
 import constants
 
 
-class GildedRose(object):
+def decrease_sell_in(item, amount=1):
+    """
+    Decrease sell in value by the specified amount
+    :param item:
+    :param amount:
+    :return:
+    """
+    item.sell_in -= amount
+
+
+def decrease_quality(item, amount=1):
+    """
+    Decrease quality value by the specified amount
+    :param item:
+    :param amount:
+    :return:
+    """
+    item.quality -= amount
+
+
+def increase_quality(item, amount=1):
+    """
+    Increase quality value by the specified amount
+    :param item:
+    :param amount:
+    :return:
+    """
+    item.quality += amount
+
+
+def common_item(item):
+    """Generate common item logic"""
+    if item.quality > 0:
+        decrease_quality(item)
+    decrease_sell_in(item)
+    if item.sell_in < 0 < item.quality:
+        decrease_quality(item)
+
+
+def aged_brie(item):
+    """
+    Generate Aged Brie logic
+    :param item:
+    :return:
+    """
+    if item.quality < 50:
+        increase_quality(item)
+    decrease_sell_in(item)
+    if item.sell_in < 0 and item.quality < 50:
+        increase_quality(item)
+
+
+def backstage(item):
+    """
+    Generate Backstage Passes logic
+    :param item:
+    :return:
+    """
+    if item.quality < 50:
+        item.quality = item.quality + 1
+        if item.sell_in < 11 and item.quality < 50:
+            increase_quality(item)
+        if item.sell_in < 6 and item.quality < 50:
+            increase_quality(item)
+    decrease_sell_in(item, 1)
+    if item.sell_in < 0:
+        item.quality = 0
+
+
+def sulfuras(item):
+    """
+    Generate Sulfuras logic
+    :param item:
+    :return:
+    """
+    return item
+
+
+def conjured(item):
+    """
+    Generate Conjured logic
+    :param item:
+    :return:
+    """
+    if item.quality > 0:
+        decrease_quality(item, 2)
+    decrease_sell_in(item)
+    if item.sell_in < 0 < item.quality:
+        decrease_quality(item, 2)
+
+
+class GildedRose:
+    """
+    A class to represent the shop
+    """
+
     def __init__(self, items):
         self.items = items
 
     def update_quality(self):
+        """
+        Update the quality of the given item
+        :return:
+        """
         for item in self.items:
-            if item.name != constants.AGED_BRIE and item.name != constants.BACKSTAGE:
+            if item.name == constants.AGED_BRIE:
-                if item.quality > 0:
+                aged_brie(item)
-                    if item.name != constants.SULFURAS:
+            elif item.name == constants.BACKSTAGE:
-                        item.quality = item.quality - 1
+                backstage(item)
+            elif item.name == constants.SULFURAS:
+                sulfuras(item)
+            elif item.name == constants.CONJURED:
+                conjured(item)
             else:
-                if item.quality < 50:
+                common_item(item)
-                    item.quality = item.quality + 1
-                    if item.name == constants.BACKSTAGE:
-                        if item.sell_in < 11:
-                            if item.quality < 50:
-                                item.quality = item.quality + 1
-                        if item.sell_in < 6:
-                            if item.quality < 50:
-                                item.quality = item.quality + 1
-            if item.name != constants.SULFURAS:
-                item.sell_in = item.sell_in - 1
-            if item.sell_in < 0:
-                if item.name != constants.AGED_BRIE:
-                    if item.name != constants.BACKSTAGE:
-                        if item.quality > 0:
-                            if item.name != constants.SULFURAS:
-                                item.quality = item.quality - 1
-                    else:
-                        item.quality = item.quality - item.quality
-                else:
-                    if item.quality < 50:
-                        item.quality = item.quality + 1
 
 
 class Item:
+    """
+    A class to represent the item itself
+    """
+
     def __init__(self, name, sell_in, quality):
         self.name = name
         self.sell_in = sell_in

python/test_gilded_rose.py

@@ -6,65 +6,56 @@ from gilded_rose import Item, GildedRose
 
 
 class GildedRoseTest(unittest.TestCase):
-    def test_foo(self):
+    def test_degrades_twice_as_fast_after_sell_in_date_has_passed(self):
-        items = [Item("foo", 0, 0)]
-        gilded_rose = GildedRose(items)
-        gilded_rose.update_quality()
-        self.assertEqual("foo", items[0].name)
-
-    def degradesTwiceAsFastAfterSellInDateHasPassed(self):
         items = [Item("foo", 0, 2)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(0, items[0].quality)
-        self.assertEquals(0, items[0].quality)
 
-    def neverMustHaveNegativeQuality(self):
+    def test_never_must_have_negative_quality(self):
         items = [Item("foo", 0, 0)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(0, items[0].quality)
-        self.assertEquals(0, items[0].quality)
 
-    def increaseAgedBrieQualityWhenItGetsOlder(self):
+    def test_increase_aged_brie_quality_when_it_gets_older(self):
         items = [Item(constants.AGED_BRIE, 0, 2)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(4, items[0].quality)
-        self.assertEquals(4, items[0].quality)
 
-    def neverMustHaveAnItemWithMoreThan50OfQuality(self):
+    def test_never_must_have_an_item_with_more_than_50_of_quality(self):
         items = [Item(constants.AGED_BRIE, 0, 50)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(50, items[0].quality)
-        self.assertEquals(50, items[0].quality)
 
-    def neverModifySulfurasQuality(self):
+    def test_never_modify_sulfuras_quality(self):
         items = [Item(constants.SULFURAS, 0, 50)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(50, items[0].quality)
-        self.assertEquals(50, items[0].quality)
 
-    def neverModifySulfurasQualityEvenISGreaterThan50(self):
+    def test_never_modify_sulfuras_quality_even_is_greater_than_50(self):
         items = [Item(constants.SULFURAS, 0, 80)]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(80, items[0].quality)
-        self.assertEquals(80, items[0].quality)
 
-    def mustIncreaseBackstagePassesQualityWhenItsSellInApproaches(self):
+    def test_must_increase_backstage_passes_quality_when_its_sell_in_approaches(self):
         items = [
             Item(constants.BACKSTAGE, 15, 20),
             Item(constants.BACKSTAGE, 10, 20),
             Item(constants.BACKSTAGE, 5, 20),
         ]
-        gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-        gilded_rose.update_quality()
+        self.assertEqual(21, items[0].quality)
-        self.assertEquals(21, items[0].quality)
+        self.assertEqual(22, items[1].quality)
-        self.assertEquals(22, items[1].quality)
+        self.assertEqual(23, items[2].quality)
-        self.assertEquals(23, items[2].quality)
 
-    # def mustDecreaseQualityTwiceAsFastIfItemIsConjured(self):
+    def test_backstage_quality_must_be_zero_after_concert(self):
-    #     items = [Item(constants.CONJURED, 0, 20)]
+        items = [Item(constants.BACKSTAGE, 0, 80)]
-    #     gilded_rose = GildedRose(items)
+        GildedRose(items).update_quality()
-    #     gilded_rose.update_quality()
+        self.assertEqual(0, items[0].quality)
-    #     self.assertEquals(16, items[0].quality)
+
+    def test_must_decrease_quality_twice_as_fast_if_item_is_conjured(self):
+        items = [Item(constants.CONJURED, 0, 20)]
+        GildedRose(items).update_quality()
+        self.assertEqual(16, items[0].quality)
 
 
 if __name__ == "__main__":