From cc53ad07e0e3107339dc5246635b40762c440085 Mon Sep 17 00:00:00 2001 From: brianblessou Date: Sun, 12 May 2019 21:54:08 +0200 Subject: [PATCH] Add test for all items --- .../java/com/gildedrose/GildedRoseItem.java | 11 +- .../main/java/com/gildedrose/ItemFactory.java | 7 +- .../java/com/gildedrose/ItemInterface.java | 2 + .../com/gildedrose/{ => items}/AgedBrie.java | 10 +- .../gildedrose/{ => items}/BackStageItem.java | 10 +- .../gildedrose/{ => items}/ConjuredItem.java | 9 +- .../gildedrose/{ => items}/NormalItem.java | 10 +- .../com/gildedrose/items/SulfuraItem.java | 15 ++ .../GildedRoseAgedBrieItemTest.java | 134 ++++++++++++++++ ...mTest.java => GildedRoseAllItemsTest.java} | 2 +- .../GildedRoseBackStageItemTest.java | 134 ++++++++++++++++ .../GildedRoseConjuredItemTest.java | 134 ++++++++++++++++ .../gildedrose/GildedRoseNormalItemTest.java | 146 ++++++++++++++++++ .../gildedrose/GildedRoseSulfuraItemTest.java | 133 ++++++++++++++++ 14 files changed, 740 insertions(+), 17 deletions(-) rename Java/src/main/java/com/gildedrose/{ => items}/AgedBrie.java (62%) rename Java/src/main/java/com/gildedrose/{ => items}/BackStageItem.java (75%) rename Java/src/main/java/com/gildedrose/{ => items}/ConjuredItem.java (65%) rename Java/src/main/java/com/gildedrose/{ => items}/NormalItem.java (72%) create mode 100644 Java/src/main/java/com/gildedrose/items/SulfuraItem.java create mode 100644 Java/src/test/java/com/gildedrose/GildedRoseAgedBrieItemTest.java rename Java/src/test/java/com/gildedrose/{GildedRoseItemTest.java => GildedRoseAllItemsTest.java} (99%) create mode 100644 Java/src/test/java/com/gildedrose/GildedRoseBackStageItemTest.java create mode 100644 Java/src/test/java/com/gildedrose/GildedRoseConjuredItemTest.java create mode 100644 Java/src/test/java/com/gildedrose/GildedRoseNormalItemTest.java create mode 100644 Java/src/test/java/com/gildedrose/GildedRoseSulfuraItemTest.java diff --git a/Java/src/main/java/com/gildedrose/GildedRoseItem.java b/Java/src/main/java/com/gildedrose/GildedRoseItem.java index 9d82cdec..0afdbc6c 100644 --- a/Java/src/main/java/com/gildedrose/GildedRoseItem.java +++ b/Java/src/main/java/com/gildedrose/GildedRoseItem.java @@ -7,7 +7,6 @@ import com.sun.xml.internal.rngom.parse.host.Base; */ class GildedRoseItem { Item[] items; - public static final String SULFURA = "Sulfuras, Hand of Ragnaros"; private ItemFactory itemFactory; public GildedRoseItem(Item[] items) { @@ -15,18 +14,10 @@ class GildedRoseItem { itemFactory = new ItemFactory(); } - private void updateNumberOfdayToSellRemaining(Item item) { - item.sellIn -= 1; - } - - public void updateQuality() { for (Item item : items) { - if (item.name.equals(SULFURA)) { - continue; - } ItemInterface typeItem = itemFactory.createItemType(item); - updateNumberOfdayToSellRemaining(item); + typeItem.updateNumberOfdayToSellRemaining(); typeItem.updateQuality(); } } diff --git a/Java/src/main/java/com/gildedrose/ItemFactory.java b/Java/src/main/java/com/gildedrose/ItemFactory.java index 20624add..28fdf805 100644 --- a/Java/src/main/java/com/gildedrose/ItemFactory.java +++ b/Java/src/main/java/com/gildedrose/ItemFactory.java @@ -1,8 +1,9 @@ package com.gildedrose; +import com.gildedrose.items.*; + public class ItemFactory { - - + public static final String SULFURA = "Sulfuras, Hand of Ragnaros"; public static final String AGED_BRIE = "Aged Brie"; public static final String BACKSTAGE = "Backstage passes to a TAFKAL80ETC concert"; public static final String CONJURED = "Conjured Mana Cake"; @@ -15,6 +16,8 @@ public class ItemFactory { return new BackStageItem(item); } else if (item.name.equals(CONJURED)) { return new ConjuredItem(item); + } else if (item.name.equals(SULFURA)) { + return new SulfuraItem(item); } else { return new NormalItem(item); } diff --git a/Java/src/main/java/com/gildedrose/ItemInterface.java b/Java/src/main/java/com/gildedrose/ItemInterface.java index cf65de31..e644adf6 100644 --- a/Java/src/main/java/com/gildedrose/ItemInterface.java +++ b/Java/src/main/java/com/gildedrose/ItemInterface.java @@ -2,4 +2,6 @@ package com.gildedrose; public interface ItemInterface { void updateQuality(); + + void updateNumberOfdayToSellRemaining(); } diff --git a/Java/src/main/java/com/gildedrose/AgedBrie.java b/Java/src/main/java/com/gildedrose/items/AgedBrie.java similarity index 62% rename from Java/src/main/java/com/gildedrose/AgedBrie.java rename to Java/src/main/java/com/gildedrose/items/AgedBrie.java index a9ac525e..35b16779 100644 --- a/Java/src/main/java/com/gildedrose/AgedBrie.java +++ b/Java/src/main/java/com/gildedrose/items/AgedBrie.java @@ -1,4 +1,8 @@ -package com.gildedrose; +package com.gildedrose.items; + +import com.gildedrose.BaseItem; +import com.gildedrose.Item; +import com.gildedrose.ItemInterface; /** * Class for Aged Brie item inherited from NormalItem @@ -16,4 +20,8 @@ public class AgedBrie extends BaseItem implements ItemInterface { increaseQualityBy(1); } } + + public void updateNumberOfdayToSellRemaining() { + item.sellIn -= 1; + } } diff --git a/Java/src/main/java/com/gildedrose/BackStageItem.java b/Java/src/main/java/com/gildedrose/items/BackStageItem.java similarity index 75% rename from Java/src/main/java/com/gildedrose/BackStageItem.java rename to Java/src/main/java/com/gildedrose/items/BackStageItem.java index f5cf3d5a..615cffb1 100644 --- a/Java/src/main/java/com/gildedrose/BackStageItem.java +++ b/Java/src/main/java/com/gildedrose/items/BackStageItem.java @@ -1,4 +1,8 @@ -package com.gildedrose; +package com.gildedrose.items; + +import com.gildedrose.BaseItem; +import com.gildedrose.Item; +import com.gildedrose.ItemInterface; /** * Class Back Stage item inherited form NormalItem @@ -23,4 +27,8 @@ public class BackStageItem extends BaseItem implements ItemInterface { item.quality -= item.quality; } } + + public void updateNumberOfdayToSellRemaining() { + item.sellIn -= 1; + } } diff --git a/Java/src/main/java/com/gildedrose/ConjuredItem.java b/Java/src/main/java/com/gildedrose/items/ConjuredItem.java similarity index 65% rename from Java/src/main/java/com/gildedrose/ConjuredItem.java rename to Java/src/main/java/com/gildedrose/items/ConjuredItem.java index 5eaffadb..7c006aaf 100644 --- a/Java/src/main/java/com/gildedrose/ConjuredItem.java +++ b/Java/src/main/java/com/gildedrose/items/ConjuredItem.java @@ -1,5 +1,8 @@ -package com.gildedrose; +package com.gildedrose.items; +import com.gildedrose.BaseItem; +import com.gildedrose.Item; +import com.gildedrose.ItemInterface; import com.sun.xml.internal.rngom.parse.host.Base; /** @@ -16,4 +19,8 @@ public class ConjuredItem extends BaseItem implements ItemInterface { decreaseQualityBy(1); } } + + public void updateNumberOfdayToSellRemaining() { + item.sellIn -= 1; + } } diff --git a/Java/src/main/java/com/gildedrose/NormalItem.java b/Java/src/main/java/com/gildedrose/items/NormalItem.java similarity index 72% rename from Java/src/main/java/com/gildedrose/NormalItem.java rename to Java/src/main/java/com/gildedrose/items/NormalItem.java index 2ddd9b19..63a24c13 100644 --- a/Java/src/main/java/com/gildedrose/NormalItem.java +++ b/Java/src/main/java/com/gildedrose/items/NormalItem.java @@ -1,4 +1,8 @@ -package com.gildedrose; +package com.gildedrose.items; + +import com.gildedrose.BaseItem; +import com.gildedrose.Item; +import com.gildedrose.ItemInterface; /** * Class for a regular item with business rule for normal item: @@ -18,4 +22,8 @@ public class NormalItem extends BaseItem implements ItemInterface { decreaseQualityBy(1); } } + + public void updateNumberOfdayToSellRemaining() { + item.sellIn -= 1; + } } diff --git a/Java/src/main/java/com/gildedrose/items/SulfuraItem.java b/Java/src/main/java/com/gildedrose/items/SulfuraItem.java new file mode 100644 index 00000000..cb3d12f1 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/items/SulfuraItem.java @@ -0,0 +1,15 @@ +package com.gildedrose.items; + +import com.gildedrose.Item; +import com.gildedrose.BaseItem; +import com.gildedrose.ItemInterface; + +public class SulfuraItem extends BaseItem implements ItemInterface { + public SulfuraItem(Item item) { + this.item=item; + } + + public void updateQuality() { } + + public void updateNumberOfdayToSellRemaining() { } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseAgedBrieItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseAgedBrieItemTest.java new file mode 100644 index 00000000..38a3aea3 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/GildedRoseAgedBrieItemTest.java @@ -0,0 +1,134 @@ +package com.gildedrose; + +import org.junit.Test; + +import java.util.HashMap; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test the result of item.sellIn and item.quality after n days + */ +public class GildedRoseAgedBrieItemTest { + private Item[] itemsSample = new Item[]{new Item("Aged Brie", 2, 0)}; + + private GildedRoseItem app = new GildedRoseItem(itemsSample); + + /** + * Test if item.sellIn and item.quality is the same that expected after a number of day. + * + * @param items, contains values calculated by executeUpdateQuality function + * @param map, contains values that we expect + * @param message, to make difference between tests + */ + public void assertItems(Item[] items, HashMap map, String message) { + for (Item item : items) { + switch (item.name) { + case "Aged Brie": + assertArrayEquals(message, map.get("Aged Brie"), new int[]{item.sellIn, item.quality}); + break; + default: + System.out.println("oops"); + } + } + } + + /** + * Execute n times the function update quality + * + * @param numberOfTimes, number of times that you want to execute that function + */ + private void executeUpdateQuality(int numberOfTimes) { + for(int i=0;i mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{1, 1}); + } + }; + executeUpdateQuality(1); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_2_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{0, 2}); + } + }; + executeUpdateQuality(2); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_3_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-1, 4}); + } + }; + executeUpdateQuality(3); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_4_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-2, 6}); + } + }; + executeUpdateQuality(4); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_9_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-7, 16}); + } + }; + executeUpdateQuality(9); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_10_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-8, 18}); + } + }; + executeUpdateQuality(10); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_11_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-9, 20}); + } + }; + executeUpdateQuality(11); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_aged_brie_after_25_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Aged Brie", new int[]{-23, 48}); + } + }; + executeUpdateQuality(25); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseAllItemsTest.java similarity index 99% rename from Java/src/test/java/com/gildedrose/GildedRoseItemTest.java rename to Java/src/test/java/com/gildedrose/GildedRoseAllItemsTest.java index e3b1387f..29510355 100644 --- a/Java/src/test/java/com/gildedrose/GildedRoseItemTest.java +++ b/Java/src/test/java/com/gildedrose/GildedRoseAllItemsTest.java @@ -8,7 +8,7 @@ import org.junit.Test; /** * Test the result of item.sellIn and item.quality after n days */ -public class GildedRoseItemTest { +public class GildedRoseAllItemsTest { private Item[] itemsSample = new Item[]{new Item("+5 Dexterity Vest", 10, 20), // new Item("Aged Brie", 2, 0), // new Item("Elixir of the Mongoose", 5, 7), // diff --git a/Java/src/test/java/com/gildedrose/GildedRoseBackStageItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseBackStageItemTest.java new file mode 100644 index 00000000..5bb1c2f8 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/GildedRoseBackStageItemTest.java @@ -0,0 +1,134 @@ +package com.gildedrose; + +import org.junit.Test; + +import java.util.HashMap; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test the result of item.sellIn and item.quality after n days + */ +public class GildedRoseBackStageItemTest { + private Item[] itemsSample = new Item[]{new Item("Backstage passes to a TAFKAL80ETC concert", 15, 20)}; + + private GildedRoseItem app = new GildedRoseItem(itemsSample); + + /** + * Test if item.sellIn and item.quality is the same that expected after a number of day. + * + * @param items, contains values calculated by executeUpdateQuality function + * @param map, contains values that we expect + * @param message, to make difference between tests + */ + public void assertItems(Item[] items, HashMap map, String message) { + for (Item item : items) { + switch (item.name) { + case "Backstage passes to a TAFKAL80ETC concert": + assertArrayEquals(message, map.get("Backstage passes to a TAFKAL80ETC concert"), new int[]{item.sellIn, item.quality}); + break; + default: + System.out.println("oops"); + } + } + } + + /** + * Execute n times the function update quality + * + * @param numberOfTimes, number of times that you want to execute that function + */ + private void executeUpdateQuality(int numberOfTimes) { + for(int i=0;i mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{14, 21}); + } + }; + executeUpdateQuality(1); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_2_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{13, 22}); + } + }; + executeUpdateQuality(2); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_3_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{12, 23}); + } + }; + executeUpdateQuality(3); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_4_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{11, 24}); + } + }; + executeUpdateQuality(4); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_9_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{6, 33}); + } + }; + executeUpdateQuality(9); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_10_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{5, 35}); + } + }; + executeUpdateQuality(10); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_11_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{4, 38}); + } + }; + executeUpdateQuality(11); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_back_stage_after_25_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Backstage passes to a TAFKAL80ETC concert", new int[]{-10, 0}); + } + }; + executeUpdateQuality(25); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseConjuredItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseConjuredItemTest.java new file mode 100644 index 00000000..6f203241 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/GildedRoseConjuredItemTest.java @@ -0,0 +1,134 @@ +package com.gildedrose; + +import org.junit.Test; + +import java.util.HashMap; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test the result of item.sellIn and item.quality after n days + */ +public class GildedRoseConjuredItemTest { + private Item[] itemsSample = new Item[]{new Item("Conjured Mana Cake", 3, 6) }; + + private GildedRoseItem app = new GildedRoseItem(itemsSample); + + /** + * Test if item.sellIn and item.quality is the same that expected after a number of day. + * + * @param items, contains values calculated by executeUpdateQuality function + * @param map, contains values that we expect + * @param message, to make difference between tests + */ + public void assertItems(Item[] items, HashMap map, String message) { + for (Item item : items) { + switch (item.name) { + case "Conjured Mana Cake": + assertArrayEquals(message, map.get("Conjured Mana Cake"), new int[]{item.sellIn, item.quality}); + break; + default: + System.out.println("oops"); + } + } + } + + /** + * Execute n times the function update quality + * + * @param numberOfTimes, number of times that you want to execute that function + */ + private void executeUpdateQuality(int numberOfTimes) { + for(int i=0;i mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{2, 5}); + } + }; + executeUpdateQuality(1); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_2_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{1, 4}); + } + }; + executeUpdateQuality(2); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_3_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{0, 3}); + } + }; + executeUpdateQuality(3); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_4_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{-1, 1}); + } + }; + executeUpdateQuality(4); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_9_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{-6, 0}); + } + }; + executeUpdateQuality(9); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_10_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{-7, 0}); + } + }; + executeUpdateQuality(10); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_11_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{-8, 0}); + } + }; + executeUpdateQuality(11); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_conjured_after_25_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Conjured Mana Cake", new int[]{-22, 0}); + } + }; + executeUpdateQuality(25); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseNormalItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseNormalItemTest.java new file mode 100644 index 00000000..66d05f1d --- /dev/null +++ b/Java/src/test/java/com/gildedrose/GildedRoseNormalItemTest.java @@ -0,0 +1,146 @@ +package com.gildedrose; + +import org.junit.Test; + +import java.util.HashMap; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test the result of item.sellIn and item.quality after n days + */ +public class GildedRoseNormalItemTest { + private Item[] itemsSample = new Item[]{new Item("+5 Dexterity Vest", 10, 20), // + new Item("Elixir of the Mongoose", 5, 7)}; + + private GildedRoseItem app = new GildedRoseItem(itemsSample); + + /** + * Test if item.sellIn and item.quality is the same that expected after a number of day. + * + * @param items, contains values calculated by executeUpdateQuality function + * @param map, contains values that we expect + * @param message, to make difference between tests + */ + public void assertItems(Item[] items, HashMap map, String message) { + for (Item item : items) { + switch (item.name) { + case "+5 Dexterity Vest": + assertArrayEquals(message, map.get("+5 Dexterity Vest"), new int[]{item.sellIn, item.quality}); + break; + case "Elixir of the Mongoose": + assertArrayEquals(message, map.get("Elixir of the Mongoose"), new int[]{item.sellIn, item.quality}); + break; + default: + System.out.println("oops"); + } + } + } + + /** + * Execute n times the function update quality + * + * @param numberOfTimes, number of times that you want to execute that function + */ + private void executeUpdateQuality(int numberOfTimes) { + for(int i=0;i mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{9, 19}); + put("Elixir of the Mongoose", new int[]{4, 6}); + } + }; + executeUpdateQuality(1); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_2_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{8, 18}); + put("Elixir of the Mongoose", new int[]{3, 5}); + } + }; + executeUpdateQuality(2); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_3_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{7, 17}); + put("Elixir of the Mongoose", new int[]{2, 4}); + } + }; + executeUpdateQuality(3); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_4_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{6, 16}); + put("Elixir of the Mongoose", new int[]{1, 3}); + } + }; + executeUpdateQuality(4); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_9_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{1, 11}); + put("Elixir of the Mongoose", new int[]{-4, 0}); + } + }; + executeUpdateQuality(9); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_10_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{0, 10}); + put("Elixir of the Mongoose", new int[]{-5, 0}); + } + }; + executeUpdateQuality(10); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_11_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{-1, 8}); + put("Elixir of the Mongoose", new int[]{-6, 0}); + } + }; + executeUpdateQuality(11); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void test_normal_after_25_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("+5 Dexterity Vest", new int[]{-15, 0}); + put("Elixir of the Mongoose", new int[]{-20, 0}); + } + }; + executeUpdateQuality(25); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseSulfuraItemTest.java b/Java/src/test/java/com/gildedrose/GildedRoseSulfuraItemTest.java new file mode 100644 index 00000000..8e3fcd59 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/GildedRoseSulfuraItemTest.java @@ -0,0 +1,133 @@ +package com.gildedrose; + +import org.junit.Test; + +import java.util.HashMap; + +import static org.junit.Assert.assertArrayEquals; + +/** + * Test the result of item.sellIn and item.quality after n days + */ +public class GildedRoseSulfuraItemTest { + private Item[] itemsSample = new Item[]{new Item("Sulfuras, Hand of Ragnaros", 0, 80)}; + + private GildedRoseItem app = new GildedRoseItem(itemsSample); + + /** + * Test if item.sellIn and item.quality is the same that expected after a number of day. + * + * @param items, contains values calculated by executeUpdateQuality function + * @param map, contains values that we expect + * @param message, to make difference between tests + */ + public void assertItems(Item[] items, HashMap map, String message) { + for (Item item : items) { + switch (item.name) { + case "Sulfuras, Hand of Ragnaros": + assertArrayEquals(message, map.get("Sulfuras, Hand of Ragnaros"), new int[]{item.sellIn, item.quality}); + break; + default: + System.out.println("oops"); + } + } + } + + /** + * Execute n times the function update quality + * + * @param numberOfTimes, number of times that you want to execute that function + */ + private void executeUpdateQuality(int numberOfTimes) { + for(int i=0;i mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80});} + }; + executeUpdateQuality(1); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_2_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(2); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_3_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(3); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_4_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(4); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_9_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(9); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_10_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(10); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_11_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(11); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } + + @Test + public void sulfura_test_after_25_days() { + HashMap mapExpectedValued = new HashMap(){ + { + put("Sulfuras, Hand of Ragnaros", new int[]{0, 80}); + } + }; + executeUpdateQuality(25); + assertItems(itemsSample, mapExpectedValued, new Throwable().getStackTrace()[0].getMethodName()); + } +}