Feature/our awesome work

src/Good.php

@@ -8,8 +8,19 @@ public static function milk(): self
         return new Milk;
     }
 
+    public static function wool(): self
+    {
+        return new Wool;
+    }
+
     public function isMilk(): bool
     {
         return false;
     }
+
+
+    public function isWool(): bool
+    {
+        return false;
+    }
 }

src/Market.php

@@ -3,16 +3,25 @@
 
 final class Market
 {
+    /** @var PriceList[] */
+    private $priceLists = [];
+
+    public function __construct()
+    {
+        $this->priceLists[Milk::class] = PriceListBuilder::milkPrices();
+        $this->priceLists[Wool::class] = PriceListBuilder::woolPrices();
+    }
+
+
     public function priceFor(Good $good): Pound
     {
-        return new Pound(5);
+        return $this->priceLists[get_class($good)]->current();
     }
 
     public function sellTo(Offer $offer): Pound
     {
-        return new Pound(
-            $offer->amount()->amount() *
-            $this->priceFor($offer->good())->amount()
-        );
+        $profit = $this->priceLists[get_class($offer->good())]->current()->multiply($offer->amount());
+        $this->priceLists[get_class($offer->good())]->increaseStock($offer->amount());
+        return $profit;
     }
 }

src/Milk.php

@@ -1,4 +1,5 @@
 <?php declare(strict_types=1);
+
 namespace ClansOfCaledonia;
 
 final class Milk extends Good

src/Offer.php

@@ -13,9 +13,9 @@ final class Offer
      */
     private $good;
 
-    public function __construct(Quantity $unit, Good $good)
+    public function __construct(Quantity $quantity, Good $good)
     {
-        $this->amount = $unit;
+        $this->amount = $quantity;
         $this->good   = $good;
     }
 

src/Pound.php

@@ -17,4 +17,9 @@ public function amount(): int
     {
         return $this->amount;
     }
+
+    public function multiply(Quantity $quantity): Pound
+    {
+        return new Pound($this->amount * $quantity->amount());
+    }
 }

src/PriceList.php

@@ -30,4 +30,16 @@ public function current(): Pound
     {
         return $this->prices[$this->position];
     }
+
+
+    public function increaseStock(Quantity $quantity): void
+    {
+        $this->position = max($this->position - $quantity->amount(), 0);
+    }
+
+
+    public function decreaseStock(Quantity $quantity): void
+    {
+        $this->position = min($this->position + $quantity->amount(), count($this->prices)-1);
+    }
 }

src/PriceListBuilder.php

@@ -3,7 +3,7 @@
 
 final class PriceListBuilder
 {
-    public function milkPrices(): PriceList
+    public static function milkPrices(): PriceList
     {
         return PriceList::fromList(
             new Pound(3),
@@ -18,4 +18,20 @@ public function milkPrices(): PriceList
             new Pound(8)
         );
     }
+
+    public static function woolPrices(): PriceList
+    {
+        return PriceList::fromList(
+            new Pound(3),
+            new Pound(3),
+            new Pound(4),
+            new Pound(4),
+            new Pound(5),
+            new Pound(5),
+            new Pound(6),
+            new Pound(6),
+            new Pound(7),
+            new Pound(8 )
+        );
+    }
 }

src/Wool.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace ClansOfCaledonia;
+
+class Wool extends Good
+{
+
+    public function isWool(): bool
+    {
+        return true;
+    }
+}

src/autoload.php

@@ -16,7 +16,8 @@ function($class) {
                 'clansofcaledonia\\pound' => '/Pound.php',
                 'clansofcaledonia\\pricelist' => '/PriceList.php',
                 'clansofcaledonia\\pricelistbuilder' => '/PriceListBuilder.php',
-                'clansofcaledonia\\quantity' => '/Quantity.php'
+                'clansofcaledonia\\quantity' => '/Quantity.php',
+                'clansofcaledonia\\wool' => '/Wool.php'
             );
         }
         $cn = strtolower($class);

tests/GoodTest.php

@@ -6,6 +6,7 @@
 /**
  * @covers \ClansOfCaledonia\Good
  * @covers \ClansOfCaledonia\Milk
+ * @covers \ClansOfCaledonia\Wool
  */
 final class GoodTest extends TestCase
 {
@@ -14,5 +15,15 @@ public function testCanBeMilk(): void
         $milk = Good::milk();
 
         $this->assertTrue($milk->isMilk());
+        $this->assertFalse($milk->isWool());
+    }
+
+
+    public function testCanBeWool(): void
+    {
+        $wool = Good::wool();
+
+        $this->assertTrue($wool->isWool());
+        $this->assertFalse($wool->isMilk());
     }
 }

tests/MarketTest.php

@@ -5,19 +5,25 @@
 
 /**
  * @covers \ClansOfCaledonia\Market
+ * @covers \ClansOfCaledonia\PriceListBuilder
  *
  * @uses \ClansOfCaledonia\Pound
  * @uses \ClansOfCaledonia\Good
  * @uses \ClansOfCaledonia\Offer
  * @uses \ClansOfCaledonia\Quantity
+ * @uses \ClansOfCaledonia\PriceList
  */
 final class MarketTest extends TestCase
 {
-    public function testMilkCosts5PoundsInitially(): void
+
+    /**
+     * @dataProvider initialGoodProvider
+     */
+    public function testInitiallyGoodCost(Good $good, int $amount): void
     {
         $market = new Market;
 
-        $this->assertEquals(new Pound(5), $market->priceFor(Good::milk()));
+        $this->assertEquals(new Pound($amount), $market->priceFor($good));
     }
 
     public function testMilkCanBeSoldToTheMarket(): Market
@@ -43,4 +49,37 @@ public function testSellingMilkToTheMarketReducesMilkPrice(Market $market): void
     {
         $this->assertEquals(new Pound(4), $market->priceFor(Good::milk()));
     }
+
+    public function testWoolCanBeSoldToTheMarket(): Market
+    {
+        $market = new Market;
+
+        $payment = $market->sellTo(
+            new Offer(
+                new Quantity(1),
+                Good::wool()
+            )
+        );
+
+        $this->assertEquals(new Pound(4), $payment);
+
+        return $market;
+    }
+
+    /**
+     * @depends testWoolCanBeSoldToTheMarket
+     */
+    public function testSellingWoolToTheMarketReducesWoolPrice(Market $market): void
+    {
+        $this->assertEquals(new Pound(4), $market->priceFor(Good::wool()));
+    }
+
+
+    public function initialGoodProvider()
+    {
+        return [
+            'initialMilkCosts5Pound' => [Good::milk(), 5],
+            'initialWoolCosts4Pound' => [Good::wool(), 4],
+        ];
+    }
 }

tests/PoundTest.php

@@ -5,6 +5,8 @@
 
 /**
  * @covers \ClansOfCaledonia\Pound
+ *
+ * @uses \ClansOfCaledonia\Quantity
  */
 final class PoundTest extends TestCase
 {
@@ -16,4 +18,25 @@ public function testHasAmount(): void
 
         $this->assertSame($amount, $p->amount());
     }
+
+
+    /**
+     * @dataProvider multiplyDataProvider
+     */
+    public function testPoundCanMultiply(int $amount, Quantity $factor, int $expected)
+    {
+        $p = new Pound($amount);
+
+        $this->assertSame($expected, $p->multiply($factor)->amount());
+    }
+
+
+    public function multiplyDataProvider()
+    {
+        return [
+            [ 5, new Quantity(2), 10],
+            [ 1, new Quantity(100), 100],
+            [ -3, new Quantity(4), -12],
+        ];
+    }
 }

tests/PriceListTest.php

@@ -1,4 +1,5 @@
 <?php declare(strict_types=1);
+
 namespace ClansOfCaledonia;
 
 use PHPUnit\Framework\TestCase;
@@ -7,6 +8,7 @@
  * @covers \ClansOfCaledonia\PriceList
  *
  * @uses \ClansOfCaledonia\Pound
+ * @uses \ClansOfCaledonia\Quantity
  */
 final class PriceListTest extends TestCase
 {
@@ -27,4 +29,48 @@ public function testHasInitialPrice(): void
 
         $this->assertEquals(new Pound(4), $prices->current());
     }
+
+    public function testInreaseStock()
+    {
+        $prices = $this->priceList();
+        $this->assertEquals(new Pound(4), $prices->current());
+        $prices->increaseStock(new Quantity(1));
+        $this->assertEquals(new Pound(3), $prices->current());
+        $prices->increaseStock(new Quantity(2));
+        $this->assertEquals(new Pound(1), $prices->current());
+        $prices->increaseStock(new Quantity(1));
+        $this->assertEquals(new Pound(1), $prices->current());
+    }
+
+    public function testDecreaseStock(): void
+    {
+        $prices = $this->priceList();
+        $this->assertEquals(new Pound(4), $prices->current());
+        $prices->decreaseStock(new Quantity(1));
+        $this->assertEquals(new Pound(5), $prices->current());
+        $prices->decreaseStock(new Quantity(2));
+        $this->assertEquals(new Pound(7), $prices->current());
+        $prices->decreaseStock(new Quantity(1));
+        $this->assertEquals(new Pound(8), $prices->current());
+        $prices->decreaseStock(new Quantity(2));
+        $this->assertEquals(new Pound(10), $prices->current());
+        $prices->decreaseStock(new Quantity(1));
+        $this->assertEquals(new Pound(10), $prices->current());
+    }
+
+    public function priceList(): PriceList
+    {
+        return PriceList::fromList(
+            new Pound(1),
+            new Pound(2),
+            new Pound(3),
+            new Pound(4),
+            new Pound(5),
+            new Pound(6),
+            new Pound(7),
+            new Pound(8),
+            new Pound(9),
+            new Pound(10)
+        );
+    }
 }

tests/QuantityTest.php

@@ -10,9 +10,9 @@ final class QuantityTest extends TestCase
 {
     public function testHasAmount(): void
     {
-        $unit = new Quantity(1);
+        $quantity = new Quantity(1);
 
-        $this->assertSame(1, $unit->amount());
+        $this->assertSame(1, $quantity->amount());
     }
 
     /**