Restore fox goose corn

Author: WillGibson

fox_goose_corn/README.md

@@ -0,0 +1,8 @@
+# Fox Goose Corn
+
+Requirements:
+
+- You must get the fox, goose, and bag of corn safely across the other side of the river
+- You can only carry 1 item on the boat across with you.
+- The fox cannot be left alone with the goose, (or it will be eaten).
+- The goose cannot be left alone with the corn, (or it will be eaten).

fox_goose_corn/__init__.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from fox_goose_corn.src.model.boat import Boat
+from fox_goose_corn.src.model.cargo_item import (
+    AbstractCargoItem,
+    Fox,
+    Goose,
+    Corn,
+    CargoEatingCargoException,
+)
+
+
+class CrossingManager:
+    def __init__(self, boat: Boat, fox: Fox, goose: Goose, corn: Corn):
+        self._corn = corn
+        self._goose = goose
+        self._fox = fox
+        self._boat = boat
+
+    def cross_with(self, cargo_item: AbstractCargoItem) -> None:
+        self._boat.add_cargo(cargo_item)
+        self._boat.cross_river()
+        self._check_the_cargo_is_safe()
+
+    def cross_empty(self) -> None:
+        self._boat.cross_river()
+
+    def _check_the_cargo_is_safe(self) -> None:
+        if self._fox.is_on_same_side_as(self._goose) or self._goose.is_on_same_side_as(self._corn):
+            raise CargoEatingCargoException

fox_goose_corn/src/__init__.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+from fox_goose_corn.src.model.cargo_item import AbstractCargoItem, Fox
+from fox_goose_corn.src.model.river import RiverSide
+
+
+class Boat:
+    _current_side: RiverSide = RiverSide.FARM_SIDE
+    _cargo_item: Optional[AbstractCargoItem] = None
+
+    def cross_river(self):
+        self._current_side = (
+            RiverSide.MARKET_SIDE
+            if self._current_side is RiverSide.FARM_SIDE
+            else RiverSide.FARM_SIDE
+        )
+
+        if self._cargo_item is not None:
+            self._unload_cargo_item()
+
+    def is_at(self, expected_side: RiverSide):
+        return self._current_side is expected_side
+
+    def add_cargo(self, cargo_item: AbstractCargoItem):
+        if not isinstance(cargo_item, AbstractCargoItem):
+            raise InvalidCargoItemException
+
+        if self._cargo_item is not None:
+            raise TooManyCargoItemsException
+
+        self._cargo_item = cargo_item
+
+    def _unload_cargo_item(self):
+        self._cargo_item.unload_cargo_item_at(self._current_side)
+        self._cargo_item = None
+
+
+class InvalidCargoItemException(Exception):
+    pass
+
+
+class TooManyCargoItemsException(Exception):
+    pass

fox_goose_corn/src/crossing_manager.py

@@ -0,0 +1,33 @@
+from abc import abstractmethod, ABC
+from typing import Type
+
+from fox_goose_corn.src.model.river import RiverSide
+
+
+class AbstractCargoItem(ABC):
+    _current_side: RiverSide = RiverSide.FARM_SIDE
+
+    def is_at(self, expected_side: RiverSide) -> None:
+        return self._current_side is expected_side
+
+    def unload_cargo_item_at(self, side: RiverSide) -> None:
+        self._current_side = side
+
+    def is_on_same_side_as(self, other_cargo_item: "AbstractCargoItem") -> bool:
+        return self._current_side == other_cargo_item._current_side
+
+
+class Fox(AbstractCargoItem):
+    pass
+
+
+class Goose(AbstractCargoItem):
+    pass
+
+
+class Corn(AbstractCargoItem):
+    pass
+
+
+class CargoEatingCargoException(Exception):
+    pass

fox_goose_corn/src/model/boat.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class RiverSide(Enum):
+    FARM_SIDE: str = "farm-side"
+    MARKET_SIDE: str = "market-side"

fox_goose_corn/src/model/cargo_item.py

@@ -0,0 +1,74 @@
+import pytest
+
+from fox_goose_corn.src.model.boat import (
+    Boat,
+    TooManyCargoItemsException,
+    InvalidCargoItemException,
+)
+from fox_goose_corn.src.model.cargo_item import Fox, Goose, Corn
+from fox_goose_corn.src.model.river import RiverSide
+
+
+class TestBoat:
+    def test_boat_always_starts_the_day_farm_side(self):
+        boat = Boat()
+
+        assert boat.is_at(RiverSide.FARM_SIDE)
+        assert not boat.is_at(RiverSide.MARKET_SIDE)
+
+    def test_boat_can_cross_river_from_farm_to_market(self):
+        boat = Boat()
+
+        boat.cross_river()
+
+        assert boat.is_at(RiverSide.MARKET_SIDE)
+
+    def test_boat_can_cross_river_from_market_to_farm(self):
+        boat = Boat()
+        boat.cross_river()
+        assert boat.is_at(RiverSide.MARKET_SIDE)
+
+        boat.cross_river()
+
+        assert boat.is_at(RiverSide.FARM_SIDE)
+
+    @pytest.mark.parametrize("cargo_item_type", [Fox, Goose, Corn])
+    def test_boat_can_take_cargo(self, cargo_item_type):
+        boat = Boat()
+        cargo_item = cargo_item_type()
+
+        boat.add_cargo(cargo_item)
+
+    def test_boat_can_only_take_expected_cargo_types(self):
+        boat = Boat()
+        cargo_item = Boat()
+
+        with pytest.raises(InvalidCargoItemException):
+            boat.add_cargo(cargo_item)
+
+    def test_boat_cannot_take_more_than_one_cargo_item(self):
+        boat = Boat()
+        cargo_item_1 = Fox()
+        cargo_item_2 = Goose()
+        boat.add_cargo(cargo_item_1)
+
+        with pytest.raises(TooManyCargoItemsException):
+            boat.add_cargo(cargo_item_2)
+
+    def test_boat_can_take_cargo_across_river_from_farm_to_market(self):
+        boat = Boat()
+        cargo_item = Fox()
+
+        boat.add_cargo(cargo_item)
+        boat.cross_river()
+
+        assert cargo_item.is_at(RiverSide.MARKET_SIDE)
+
+    def test_boat_is_empty_after_crossing_with_a_cargo_item(self):
+        boat = Boat()
+        cargo_item_1 = Fox()
+        cargo_item_2 = Goose()
+        boat.add_cargo(cargo_item_1)
+        boat.cross_river()
+
+        boat.add_cargo(cargo_item_2)