Update reqs, provide starter tests

Author: marcgibbons

.pylintrc

@@ -1,3 +1,3 @@
 [pylintrc]
 # R0903: too few many public methods
-disable=R0903
+disable=R0903,missing-docstring

README.md

@@ -1,6 +1,6 @@
 # Vending machine – Take 2: Using OOP
 
-This tutorial revists a previous example and uses object-oriented programming
+This tutorial revisits a previous example and uses object-oriented programming
 paradigms to represent the concepts related to a vending machine. We will see
 how classes and objects will help us better represent the "real world" and help
 us track state:
@@ -11,21 +11,18 @@ Let's begin by designing our vending machine by modelling different objects.
 First, we have:
 - Coins
 - Products
-- DollarAmount
+- Vending Machine
 
 We can consider these as abstract classes / concepts. In practise, we have
 specific coins like quarters, loonies & toonies. For products, we have chips,
 candy and drinks – these could be broken down further into specific products
-like "355ml Coca-Cola can". These are considered concrete classes which all share
-common properties to the abstracts coins and products.
-
-Money in this case is a subclass of the python Decimal class and is used to
-represent a dollar amount. It is already provided as part of the boilerplate.
+like "355ml Coca-Cola can". These are considered concrete classes which all
+share common properties to the abstracts coins and products.
 
 We must also model our vending machine and define actions on it:
 - `+ insert_coin(coin: Coin)`
 - `+ buy_product(product: str) -> Product`
-- `+ get_balance() -> Money`
+- `+ get_balance() -> int`
 - `+ get_change() -> List[Coin]`
 
 
@@ -35,38 +32,42 @@ We must also model our vending machine and define actions on it:
 
 | **Coin**                  |
 | -                         |
-| `value: DollarAmount`     |
+| `value: int`     |
 | `label: str`              |
 | `str() -> str`            |
 
 
-| **FiveCent(Coin)**    |                        |
+The following classes inherit from the parent `Coin` class. Inheritance is
+achieved by providing parentheses around the class definition and providing the
+parent class(es) as arguments.
+
+| **Nickel(Coin)**    |                        |
 | -                     | -                      |
-| value                 | `DollarAmount('0.05')` |
+| value                 | `5` |
 | `str()` | `'5¢'`|
 
 
-| **TenCent(Coin)**     |                        |
+| **Dime(Coin)**     |                        |
 | -                     | -                      |
-| value                 | `DollarAmount('0.10')` |
+| value                 | `10` |
 | `str()`               | `'10¢'`                |
 
 
 | **Quarter(Coin)**     |                       |
 | -                     | -                     |
-| value                 | `DollarAmount('0.25')`|
+| value                 | `25`|
 | `str()`               | `'25¢'`               |
 
 
 | **Loonie(Coin)**      |                       |
 | -                     | -                     |
-| value                 | `DollarAmount('1.00')`|
+| value                 | `100`|
 | `str()`               | `'$1'`                |
 
 
 | **Toonie(Coin)**      |                       |
 | -                     | -                     |
-| value                 | `DollarAmount('2.00')`|
+| value                 | `200`|
 | `str()`               | `'$2'`                |
 
 
@@ -75,34 +76,41 @@ We must also model our vending machine and define actions on it:
 | **Product**           |
 | ---                   |
 | `name: str`           |
-| `price: DollarAmount` |
+| `price: int` |
+| `str() -> str`        |
 
 
 | **Chips(Product)**    |                       |
 | -                     | -                     |
 | `name`                | `'Chips'`             |
-| `price`               | `DollarAmount('2.25')`|
+| `price`               | `225`                 |
+| `str() -> str`        | `Chips: $2.25`        |
 
 
 | **Drink(Product)**    |                       |
 | -                     | -                     |
 | `name`                | `'Drink'`             |
-| `price`               | `DollarAmount('2.75')`|
+| `price`               | `275`                 |
+| `str() -> str`        | `Drink: $2.75`        |
 
 
 | **Candy(Product)**    |                        |
 | -                     | -                      |
 | `name`                | `'Candy'`              |
+| `price`               | `315`                  |
+| `str()`               | `Candy: $3.15`         |
 
 
 
 #### Vending Machine
-| **VendingMachine**                        |
-| -                                         |
-| - `+ insert_coin(coin: Coin)`             |
-| - `+ buy_product(product: str) -> Product`|
-| - `+ get_balance() -> Money`              |
-| - `+ get_change() -> List[Coin]`          |
+| **VendingMachine**                            |
+| -
+| `coins: List[Coin]`                           |
+| `purchases: List[Product]`                    |
+| `insert_coin(coin: Coin)`                     |
+| `buy_product(product: str) -> Product`        |
+| `get_balance() -> int`                        |
+| `get_change() -> List[Coin]`                  |
 
 
 
@@ -125,7 +133,7 @@ We must also model our vending machine and define actions on it:
   the purchase should be added to a list of purchases on the object.
 
 
-### .get_balance() -> Money
+### .get_balance() -> int
 
 - The get_balance function should return the sum of inserted coins minus the
   sum of the price of purchased products.

models/__init__.py

@@ -1,2 +1,2 @@
-pytest==4.3.0
-pylint==2.3.1
+pytest
+pylint

models/money.py

@@ -0,0 +1,85 @@
+from dataclasses import FrozenInstanceError
+import pytest
+
+import coins
+
+
+def test_nickel_value():
+    coin = coins.Nickel()
+    assert coin.value == 5
+
+
+def test_nickel_str():
+    coin = coins.Nickel()
+    assert str(coin) == '5¢'
+
+
+def test_dime_value():
+    coin = coins.Dime()
+    assert coin.value == 10
+
+
+def test_dime_str():
+    coin = coins.Dime()
+    assert str(coin) == '10¢'
+
+
+def test_quarter_value():
+    coin = coins.Quarter()
+    assert coin.value == 25
+
+
+def test_quarter_str():
+    coin = coins.Quarter()
+    assert str(coin) == '25¢'
+
+
+def test_loonie_value():
+    coin = coins.Loonie()
+    assert coin.value == 100
+
+
+def test_loonie_str():
+    coin = coins.Loonie()
+    assert str(coin) == '$1'
+
+
+def test_toonie_value():
+    coin = coins.Toonie()
+    assert coin.value == 200
+
+
+def test_toonie_str():
+    coin = coins.Toonie()
+    assert str(coin) == '$2'
+
+
+def test_the_coin_constructor_takes_no_arguments():
+    """
+    Ensure that a developer does not accidentally overwrite the
+    coin `value` by providing an argument.
+
+    In other words, we must ensure that __init__ accepts no
+    arguments.
+    """
+    with pytest.raises(TypeError):
+        coins.Coin(100)  # Ensure that this isn't possible
+
+
+def test_the_instance_value_property_is_immutable():
+    """
+    Ensure that the `value` property of the object cannot be
+    modified on an instance of a coin class.
+
+    This is a special feature of Python 3.7 dataclasses which
+    allow instance immutability by setting `frozen=True` in the
+    dataclass decorator.
+
+    E.g.
+        >>> @dataclass(frozen=True)
+        >>> class MyClass:
+        >>>     ...
+    """
+    coin = coins.Quarter()
+    with pytest.raises(FrozenInstanceError):
+        coin.value = 100  # Ensure that this isn't possible