code and requirements for pytest

Author: bbelderbos

days/10-12-pytest/fizzbuzz/fizzbuzz.py

@@ -0,0 +1,8 @@
+def fizzbuzz(n):
+    if n % 3 == 0 and n % 5 == 0:
+        return 'Fizz Buzz'
+    if n % 3 == 0:
+        return 'Fizz'
+    if n % 5 == 0:
+        return 'Buzz'
+    return n

days/10-12-pytest/fizzbuzz/test_fizzbuzz.py

@@ -0,0 +1,24 @@
+import pytest
+
+from fizzbuzz import fizzbuzz
+
+@pytest.mark.parametrize("arg, ret",[
+    (1, 1),
+    (2, 2),
+    (3, 'Fizz'),
+    (4, 4),
+    (5, 'Buzz'),
+    (6, 'Fizz'),
+    (7, 7),
+    (8, 8),
+    (9, 'Fizz'),
+    (10, 'Buzz'),
+    (11, 11),
+    (12, 'Fizz'),
+    (13, 13),
+    (14, 14),
+    (15, 'Fizz Buzz'),
+    (16, 16),
+])
+def test_fizzbuzz(arg, ret):
+    assert fizzbuzz(arg) == ret

days/10-12-pytest/guess/guess.py

@@ -0,0 +1,88 @@
+import random
+
+MAX_GUESSES = 5
+START, END = 1, 20
+
+
+def get_random_number():
+    """Get a random number between START and END, returns int"""
+    return random.randint(START, END)
+
+
+class Game:
+    """Number guess class, make it callable to initiate game"""
+
+    def __init__(self):
+        """Init _guesses, _answer, _win to set(), get_random_number(), False"""
+        self._guesses = set()
+        self._answer = get_random_number()
+        self._win = False
+
+    def guess(self):
+        """Ask user for input, convert to int, raise ValueError outputting
+           the following errors when applicable:
+           'Please enter a number'
+           'Should be a number'
+           'Number not in range'
+           'Already guessed'
+           If all good, return the int"""
+        guess = input(f'Guess a number between {START} and {END}: ')
+        if not guess:
+            raise ValueError('Please enter a number')
+
+        try:
+            guess = int(guess)
+        except ValueError:
+            raise ValueError('Should be a number')
+
+        if guess not in range(START, END+1):
+            raise ValueError('Number not in range')
+
+        if guess in self._guesses:
+            raise ValueError('Already guessed')
+
+        self._guesses.add(guess)
+        return guess
+
+    def _validate_guess(self, guess):
+        """Verify if guess is correct, print the following when applicable:
+           {guess} is correct!
+           {guess} is too high
+           {guess} is too low
+           Return a boolean"""
+        if guess == self._answer:
+            print(f'{guess} is correct!')
+            return True
+        else:
+            high_or_low = 'low' if guess < self._answer else 'high'
+            print(f'{guess} is too {high_or_low}')
+            return False
+
+    @property
+    def num_guesses(self):
+        return len(self._guesses)
+
+    def __call__(self):
+        """Entry point / game loop, use a loop break/continue,
+           see the tests for the exact win/lose messaging"""
+        while len(self._guesses) < MAX_GUESSES:
+            try:
+                guess = self.guess()
+            except ValueError as ve:
+                print(ve)
+                continue
+
+            win = self._validate_guess(guess)
+            if win:
+                guess_str = self.num_guesses == 1 and "guess" or "guesses"
+                print(f'It took you {self.num_guesses} {guess_str}')
+                self._win = True
+                break
+        else:
+            # else on while/for = anti-pattern? do find it useful in this case!
+            print(f'Guessed {MAX_GUESSES} times, answer was {self._answer}')
+
+
+if __name__ == '__main__':
+    game = Game()
+    game()

days/10-12-pytest/guess/test_guess.py

@@ -0,0 +1,84 @@
+from unittest.mock import patch
+import random
+
+import pytest
+
+from guess import get_random_number, Game
+
+
+@patch.object(random, 'randint')
+def test_get_random_number(m):
+    m.return_value = 17
+    assert get_random_number() == 17
+
+
+@patch("builtins.input", side_effect=[11, '12', 'Bob', 12, 5,
+                                      -1, 21, 7, None])
+def test_guess(inp):
+    game = Game()
+    # good
+    assert game.guess() == 11
+    assert game.guess() == 12
+    # not a number
+    with pytest.raises(ValueError):
+        game.guess()
+    # already guessed 12
+    with pytest.raises(ValueError):
+        game.guess()
+    # good
+    assert game.guess() == 5
+    # out of range values
+    with pytest.raises(ValueError):
+        game.guess()
+    with pytest.raises(ValueError):
+        game.guess()
+    # good
+    assert game.guess() == 7
+    # user hit enter
+    with pytest.raises(ValueError):
+        game.guess()
+
+
+def test_validate_guess(capfd):
+    game = Game()
+    game._answer = 2
+
+    assert not game._validate_guess(1)
+    out, _ = capfd.readouterr()
+    assert out.rstrip() == '1 is too low'
+
+    assert not game._validate_guess(3)
+    out, _ = capfd.readouterr()
+    assert out.rstrip() == '3 is too high'
+
+    assert game._validate_guess(2)
+    out, _ = capfd.readouterr()
+    assert out.rstrip() == '2 is correct!'
+
+
+@patch("builtins.input", side_effect=[4, 22, 9, 4, 6])
+def test_game_win(inp, capfd):
+    game = Game()
+    game._answer = 6
+
+    game()
+    assert game._win is True
+
+    out = capfd.readouterr()[0]
+    expected = ['4 is too low', 'Number not in range',
+                '9 is too high', 'Already guessed',
+                '6 is correct!', 'It took you 3 guesses']
+
+    output = [line.strip() for line
+              in out.split('\n') if line.strip()]
+    for line, exp in zip(output, expected):
+        assert line == exp
+
+
+@patch("builtins.input", side_effect=[None, 5, 9, 14, 11, 12])
+def test_game_lose(inp, capfd):
+    game = Game()
+    game._answer = 13
+
+    game()
+    assert game._win is False

days/10-12-pytest/requirements.txt

@@ -0,0 +1,2 @@
+pytest
+pytest-cov