refactored Chain Of Responsibilities and Factory Method

Author: DmitryTsyvtsyn

src/main/kotlin/design_patterns/Factory Method.kt

@@ -10,33 +10,63 @@ package design_patterns
  *
  */
 
-abstract class Pony
+abstract class House(private val address: String, private val price: Int) {
 
-class EarthPony4 : Pony()
-class Pegasus4 : Pony()
-class Unicorn4 : Pony()
+    override fun toString() = """
+        address = $address
+        price = $price
+    """.trimIndent()
 
-abstract class Place {
-    private var numberOfPonies = 0
+}
+
+// the factory method makes sense if we have a hierarchy of objects
+class WoodenCheapHouse(address: String) : House(address, 50_000)
+class WoodenAverageHouse(address: String) : House(address, 250_000)
+class WoodenExpensiveHouse(address: String) : House(address, 1_000_000)
+
+class StoneCheapHouse(address: String) : House(address, 45_000)
+class StoneAverageHouse(address: String) : House(address, 230_000)
+class StoneExpensiveHouse(address: String) : House(address, 900_000)
+
+// we have a common logic for every HouseCompany
+abstract class HouseCompany {
 
-    abstract fun pony() : Pony
+    private val alreadyBuiltHouses = mutableListOf<House>()
 
-    fun newPony() : Pony {
-        numberOfPonies++
-        return pony()
+    val examplesAlreadyBuiltHouses: String
+        get() = alreadyBuiltHouses.joinToString("\n\n")
+
+    fun orderHouse(address: String, cost: HouseCompanyCost): House {
+        val house = buildHouse(address, cost)
+        alreadyBuiltHouses.add(house)
+        return house
     }
 
-    fun count() = numberOfPonies
-}
+    // the subclasses define a specific implementation
+    protected abstract fun buildHouse(address: String, cost: HouseCompanyCost): House
+
+    enum class HouseCompanyCost { CHEAP, AVERAGE, EXPENSIVE }
 
-class Cloudsdale : Place() {
-    override fun pony() = Pegasus4()
 }
 
-class Canterlot : Place() {
-    override fun pony() = Unicorn4()
+// WoodenHouseCompany only builds wooden houses
+class WoodenHouseCompany : HouseCompany() {
+
+    override fun buildHouse(address: String, cost: HouseCompanyCost) = when(cost) {
+        HouseCompanyCost.CHEAP -> WoodenCheapHouse(address)
+        HouseCompanyCost.AVERAGE -> WoodenAverageHouse(address)
+        HouseCompanyCost.EXPENSIVE -> WoodenExpensiveHouse(address)
+    }
+
 }
 
-class Ponyville : Place() {
-    override fun pony() = EarthPony4()
+// StoneHouseCompany only builds stone houses
+class StoneHouseCompany : HouseCompany() {
+
+    override fun buildHouse(address: String, cost: HouseCompanyCost) = when(cost) {
+        HouseCompanyCost.CHEAP -> StoneCheapHouse(address)
+        HouseCompanyCost.AVERAGE -> StoneAverageHouse(address)
+        HouseCompanyCost.EXPENSIVE -> StoneExpensiveHouse(address)
+    }
+
 }

src/main/kotlin/design_patterns/Сhain Of Responsibilities.kt

@@ -2,58 +2,44 @@ package design_patterns
 
 /**
  *
- * pattern: Chain of responsibility
+ * Chain of responsibility is a behavioral design pattern that allows requests to be sent sequentially
  *
- * description: a design pattern consisting of “a source of command objects and a series of processing objects”.
- * Each processing object in the chain is responsible for a certain type of command, and the processing is done,
- * it forwards the command to the next processor in the chain.
+ * through a chain of handlers
  *
  */
 
-enum class BlockFactor {
-    ONE, TWO, THREE
-}
+enum class BlockFactor { ONE, TWO, THREE }
 
-/**
- * I decided to give an analogy from the Minecraft game.
- * In this game there are blocks that can be broken with a stone pickaxe, iron and diamond.
- * For example: diamond may mine by iron and diamond pickaxes unlike cobblestone, which is mined by any
- */
+// I decided to give an analogy from the Minecraft game.
+// In this game there are blocks that can be broken with a stone pickaxe, iron and diamond.
+// For example: diamond may mine by iron and diamond pickaxes unlike cobblestone, which is mined by any pickaxe
 abstract class Block(private val factor: BlockFactor) {
     fun mayMine(factor: BlockFactor) = this.factor.ordinal <= factor.ordinal
 }
 
-/**
- * blocks from the game
- */
+// the blocks are from the game
 class StoneBlock: Block(BlockFactor.ONE)
 class DiamondBlock: Block(BlockFactor.TWO)
 class ObsidianBlock: Block(BlockFactor.THREE)
 
 abstract class Pickaxe(private val factor: BlockFactor) {
 
     private var nextPickaxe: Pickaxe? = null
+
     fun changeNextPickaxe(pickaxe: Pickaxe) {
-        this.nextPickaxe = pickaxe
+        nextPickaxe = pickaxe
     }
 
-    /**
-     * we mine the block, if it doesn't work, we take another pickaxe, if there is one
-     *
-     * @return return true if a pickaxe can mine
-     */
-    fun mine(block: Block): Boolean =
-        if (block.mayMine(factor)) {
-            true
-        } else {
-            nextPickaxe?.mine(block) ?: false
-        }
+    // we mine the block, if it doesn't work, we take another pickaxe, if there is one, returns true if a pickaxe can mine
+    fun mine(block: Block): Boolean {
+        if (block.mayMine(factor)) return true
+
+        return nextPickaxe?.mine(block) ?: false
+    }
 
 }
 
-/**
- * pickaxes from the game
- */
+// the pickaxes are from the game
 class StonePickaxe: Pickaxe(BlockFactor.ONE)
 
 class IronPickaxe: Pickaxe(BlockFactor.TWO)

src/test/kotlin/design_patterns/ChainOfResponsibilitiesTest.kt

@@ -26,15 +26,15 @@ class ChainOfResponsibilitiesTest {
 
     @Test
     fun test_when_we_have_all_three_pickaxes() {
-        val pickaxe = StonePickaxe()
-        val ironPickaxe = IronPickaxe().apply {
-            changeNextPickaxe(DiamondPickaxe())
-        }
-        pickaxe.changeNextPickaxe(ironPickaxe)
+        val ironPickaxe = IronPickaxe()
+        ironPickaxe.changeNextPickaxe(DiamondPickaxe())
 
-        assertEquals(true, pickaxe.mine(StoneBlock()))
-        assertEquals(true, pickaxe.mine(DiamondBlock()))
-        assertEquals(true, pickaxe.mine(ObsidianBlock()))
+        val stonePickaxe = StonePickaxe()
+        stonePickaxe.changeNextPickaxe(ironPickaxe)
+
+        assertEquals(true, stonePickaxe.mine(StoneBlock()))
+        assertEquals(true, stonePickaxe.mine(DiamondBlock()))
+        assertEquals(true, stonePickaxe.mine(ObsidianBlock()))
     }
 
 }

src/test/kotlin/design_patterns/FactoryMethodTest.kt

@@ -2,33 +2,61 @@ package design_patterns
 
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.core.IsInstanceOf.instanceOf
-import org.junit.Test
 import org.junit.Assert.assertEquals
+import org.junit.Test
 
 class FactoryMethodTest {
 
     @Test
-    fun test_match_objects() {
-        val ponyville = Ponyville()
-        val earthPony = ponyville.newPony()
-
-        assertThat(earthPony, instanceOf(EarthPony4::class.java))
-
-        val canterlot = Canterlot()
-        val unicorn = canterlot.newPony()
-
-        assertThat(unicorn, instanceOf(Unicorn4::class.java))
+    fun `test WoodenHouseCompany`() {
+        val woodenHouseCompany = WoodenHouseCompany()
+
+        val house1 = woodenHouseCompany.orderHouse("77, Brook Ave", HouseCompany.HouseCompanyCost.CHEAP)
+        assertThat(house1, instanceOf(WoodenCheapHouse::class.java))
+
+        val house2 = woodenHouseCompany.orderHouse("77, Brook Ave", HouseCompany.HouseCompanyCost.AVERAGE)
+        assertThat(house2, instanceOf(WoodenAverageHouse::class.java))
+
+        val house3 = woodenHouseCompany.orderHouse("77, Brook Ave", HouseCompany.HouseCompanyCost.EXPENSIVE)
+        assertThat(house3, instanceOf(WoodenExpensiveHouse::class.java))
+
+        val expected = """
+            address = 77, Brook Ave
+            price = 50000
+            
+            address = 77, Brook Ave
+            price = 250000
+            
+            address = 77, Brook Ave
+            price = 1000000
+        """.trimIndent()
+        assertEquals(expected, woodenHouseCompany.examplesAlreadyBuiltHouses)
     }
 
     @Test
-    fun test_count() {
-        val cloudsDale = Cloudsdale()
-
-        cloudsDale.newPony()
-        cloudsDale.newPony()
-        cloudsDale.newPony()
-
-        assertEquals(3, cloudsDale.count())
+    fun `test StoneHouseCompany`() {
+        val stoneHouseCompany = StoneHouseCompany()
+
+        val house1 = stoneHouseCompany.orderHouse("55, Brook Ave", HouseCompany.HouseCompanyCost.CHEAP)
+        assertThat(house1, instanceOf(StoneCheapHouse::class.java))
+
+        val house2 = stoneHouseCompany.orderHouse("55, Brook Ave", HouseCompany.HouseCompanyCost.AVERAGE)
+        assertThat(house2, instanceOf(StoneAverageHouse::class.java))
+
+        val house3 = stoneHouseCompany.orderHouse("55, Brook Ave", HouseCompany.HouseCompanyCost.EXPENSIVE)
+        assertThat(house3, instanceOf(StoneExpensiveHouse::class.java))
+
+        val expected = """
+            address = 55, Brook Ave
+            price = 45000
+            
+            address = 55, Brook Ave
+            price = 230000
+            
+            address = 55, Brook Ave
+            price = 900000
+        """.trimIndent()
+        assertEquals(expected, stoneHouseCompany.examplesAlreadyBuiltHouses)
     }
 
 }