ParkingGarage

I want to make a ParkingGarage that heats up food or stays off, if the inputs are

  • is the door open?

  • was the start button pushed?

this is the truth table I get

door

start button

output

open

pushed

OFF

open

NOT pushed

OFF

closed

pushed

HEATING

closed

NOT pushed

OFF

preview

These are the tests I have at the end of the chapter

requirements

start the project

  • I name this project parking garage

  • I open a terminal

  • I use uv to make a directory for the project

    uv init parking garage

    the terminal shows

    Initialized project `parking garage` at `.../pumping_python/parking garage`

    then goes back to the command line

  • I change directory to the project

    cd parking garage

    the terminal shows I am in the parking garage folder

    .../pumping_python/parking garage

  • I remove main.py from the project because I do not use it

    rm main.py

    the terminal goes back to the command line

  • I make a directory for the source code

    mkdir src

    the terminal goes back to the command line

  • I make a Python file to hold the source code in the src directory

    touch src/parking garage.py

    New-Item src/parking garage.py

    the terminal goes back to the command line

  • I make a directory for the tests

    mkdir tests

    the terminal goes back to the command line

  • I make the tests directory a Python package

    Danger

    use 2 underscores (__) before and after init for __init__.py not _init_.py

    touch tests/__init__.py

    New-Item tests/__init__.py

    the terminal goes back to the command line

  • I make a Python file for the tests in the tests directory

    touch tests/test_parking garage.py

    New-Item tests/test_parking garage.py

    the terminal goes back to the command line

  • I open test_parking garage.py in the editor of the Integrated Development Environment (IDE)

    Tip

    I can open a file from the terminal in the Integrated Development Environment (IDE) with the name of the program and the name of the file. That means if I type this in the terminal

    code tests/test_parking garage.py

    Visual Studio Code opens test_parking garage.py in the editor

  • I add the first failing test to test_parking garage.py

    1import unittest
2
3
4class TestParkingGarage(unittest.TestCase):
5
6    def test_failure(self):
7        self.assertFalse(True)

  • I go back to the terminal to make a requirements file for the Python packages I need

    echo "pytest" > requirements.txt

    the terminal goes back to the command line

  • I add pytest-watcher to the requirements file

    echo "pytest-watcher" >> requirements.txt

    the terminal goes back to the command line

  • I install the Python packages that I wrote in the requirements file

    uv add --requirement requirements.txt

    the terminal shows that it installed the Python packages

  • I use tree to look at the structure of the project

    tree

    the terminal shows

    .
├── README.md
├── pyproject.toml
├── requirements.txt
├── src
│   └── parking garage.py
├── tests
│   ├── __init__.py
│   └── test_parking garage.py
└── uv.lock

  • I use pytest-watcher to run the tests automatically

    uv run pytest-watcher . --now

    the terminal is my friend, and shows AssertionError

    ================================ FAILURES ================================
______________________ TestParkingGarage.test_failure ________________________

self = <tests.test_parking garage.TestParkingGarage testMethod=test_failure>

    def test_failure(self):
>       self.assertFalse(True)
E       AssertionError: True is not false

tests/test_parking garage.py:7: AssertionError
======================== short test summary info =========================
FAILED tests/test_parking garage.py::TestParkingGarage::test_failure - AssertionError: True is not false
=========================== 1 failed in X.YZs ============================

    because True is not False

    if the terminal does not show the same error, then check

    • if your tests/__init__.py have 2 underscores (__) before and after init for __init__.py not _init_.py

    • if you ran echo "pytest-watcher" >> requirements.txt, to add pytest-watcher to the requirements file

    fix those errors then try to run uv run pytest-watcher . --now again

  • I add AssertionError to the list of Exceptions seen in test_parking garage.py

     4class TestParkingGarage(unittest.TestCase):
 5
 6    def test_failure(self):
 7        self.assertFalse(True)
 8
 9
10# Exceptions seen
11# AssertionError

  • then I change True to False in the assertion

    7        self.assertFalse(False)

    the test passes

test_open_door

The truth table for if the door is open is

door

start button

output

open

pushed

OFF

open

NOT pushed

OFF

RED: make it fail

I change test_failure to test_open_door, then add an assertion for when the door is open and the start button is pushed

door

start button

output

open

start

OFF

 
 4class TestParkingGarage(unittest.TestCase):
 5
 6    def test_open_door(self):
 7        my_expectation = 'OFF'
 8
 9        reality = src.parking garage.parking garage(
10            door_is_open=True,
11            start_is_pushed=True,
12        )
13        self.assertEqual(reality, my_expectation)
14
15
16# Exceptions seen
17# AssertionError

the terminal is my friend, and shows NameError

NameError: name 'src' is not defined

because I do not have a definition for src in this file

GREEN: make it pass

  • I add NameError to the list of Exceptions seen

    15# Exceptions seen
16# AssertionError
17# NameError

  • I add an import statement at the top of the file

    1import src.parking garage
2import unittest
3
4
5class TestParkingGarage(unittest.TestCase):

    the terminal is my friend, and shows AttributeError

    AttributeError: module 'src.parking garage' has no attribute 'parking garage'

    because parking garage.py in the src folder does not have anything named parking garage in it

    If you get ModuleNotFoundError

    ModuleNotFoundError: No module named 'src'

    check if you have __init__.py in the tests folder with underscores (__) before and after init for __init__.py not _init_.py

  • I add AttributeError to the list of Exceptions seen

    16# Exceptions seen
17# AssertionError
18# NameError
19# AttributeError

  • I open parking garage.py from the src folder in the editor

  • I add a function named parking garage to parking garage.py

    1def parking garage():
2    return None

    the terminal is my friend, and shows TypeError

    TypeError: parking garage() got an unexpected keyword argument 'door_is_open'

    because the test called the parking garage function with 2 keyword arguments and this definition only allows calls with 0 arguments

  • I add TypeError to the list of Exceptions seen in test_parking garage.py

    17# Exceptions seen
18# AssertionError
19# NameError
20# AttributeError
21# TypeError

  • I add the keyword argument to the function in parking garage.py

    1def parking garage(door_is_open):
2    return None

    the terminal is my friend, and shows TypeError

    TypeError: parking garage() got an unexpected keyword argument 'start_is_pushed'

    because the test called the parking garage function with 2 keyword arguments and this definition only allows calls with 1 input

  • I add start_is_pushed to the function signature

    1def parking garage(door_is_open, start_is_pushed):
2    return None

    the terminal is my friend, and shows AssertionError

    AssertionError: None != 'OFF'

    the parking garage function returned None and the test expects ‘OFF’

  • I change the return statement to give the test what it wants

    1def parking garage(door_is_open, start_is_pushed):
2    return 'OFF'

    the test passes. The parking garage function always returns OFF, it does not care about the inputs. Is this Contradiction?

REFACTOR: make it better

  • I add an assertion for when the door is open and the start button is NOT pushed, in test_parking garage.py

    door

    start button

    output

    open

    pushed

    OFF

    open

    NOT pushed

    OFF

    		 
     7    def test_open_door(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            start_is_pushed=True,
13        )
14        self.assertEqual(reality, my_expectation)
15
16        reality = src.parking garage.parking garage(
17            door_is_open=True,
18            start_is_pushed=False,
19        )
20        self.assertEqual(reality, my_expectation)
21
22
23# Exceptions seen

    the test is still green

test_closed_door

The truth table for if the door is closed is

door

start button

output

closed

pushed

HEATING

closed

NOT pushed

OFF

RED: make it fail

I add a test with an assertion for when the door is closed and the start button is pushed

door

start button

output

closed

pushed

HEATING

 
16          reality = src.parking garage.parking garage(
17              door_is_open=True,
18              start_is_pushed=False,
19          )
20          self.assertEqual(reality, my_expectation)
21
22      def test_closed_door(self):
23          my_expectation = 'HEATING'
24          reality = src.parking garage.parking garage(
25              door_is_open=False,
26              start_is_pushed=True,
27          )
28          self.assertEqual(reality, my_expectation)
29
30
31  # Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: 'OFF' != 'HEATING'

because the parking garage function returns ‘OFF’ and the test expects ‘HEATING’

GREEN: make it pass

I add an if statement to parking garage.py

1def parking garage(door_is_open, start_is_pushed):
2    if door_is_open == False:
3        if start_is_pushed == True:
4            return 'HEATING'
5    return 'OFF'

the test passes

REFACTOR: make it better

  • I add the bool built-in function

    1def parking garage(door_is_open, start_is_pushed):
2    # if door_is_open == False:
3    if bool(door_is_open) == False:
4        # if start_is_pushed == True:
5        if bool(start_is_pushed) == True:
6            return 'HEATING'
7    return 'OFF'

    the test is still green

  • I use Logical Negation (NOT) to write the first if statement in terms of True

    1def parking garage(door_is_open, start_is_pushed):
2    # if door_is_open == False:
3    # if bool(door_is_open) == False:
4    if not bool(door_is_open) == True:
5        # if start_is_pushed == True:
6        if bool(start_is_pushed) == True:
7            return 'HEATING'
8    return 'OFF'

    still green

  • I remove == True

     1def parking garage(door_is_open, start_is_pushed):
 2    # if door_is_open == False:
 3    # if bool(door_is_open) == False:
 4    # if not bool(door_is_open) == True:
 5    if not bool(door_is_open):
 6        # if start_is_pushed == True:
 7        # if bool(start_is_pushed) == True:
 8        if bool(start_is_pushed):
 9            return 'HEATING'
10    return 'OFF'

    green

  • I remove bool

     1def parking garage(door_is_open, start_is_pushed):
 2    # if door_is_open == False:
 3    # if bool(door_is_open) == False:
 4    # if not bool(door_is_open) == True:
 5    # if not bool(door_is_open):
 6    if not door_is_open:
 7        # if start_is_pushed == True:
 8        # if bool(start_is_pushed) == True:
 9        # if bool(start_is_pushed):
10        if start_is_pushed:
11            return 'HEATING'
12    return 'OFF'

    still green, because

    • if bool(something) == False is the same as if not bool(something) == True is the same as if not something

    • if bool(something) == True is the same as if something

  • I use Logical Conjunction (AND) to put the two if statements together

     1def parking garage(door_is_open, start_is_pushed):
 2    # if door_is_open == False:
 3    # if bool(door_is_open) == False:
 4    # if not bool(door_is_open) == True:
 5    # if not bool(door_is_open):
 6    # if not door_is_open:
 7        # if start_is_pushed == True:
 8        # if bool(start_is_pushed) == True:
 9        # if bool(start_is_pushed):
10        # if start_is_pushed:
11    if not door_is_open and start_is_pushed:
12        return 'HEATING'
13    return 'OFF'

    the test is still green

  • I remove the commented lines

    1def parking garage(door_is_open, start_is_pushed):
2    if not door_is_open and start_is_pushed:
3        return 'HEATING'
4    return 'OFF'

    This is what happens when the parking garage function is called

    • it returns ‘HEATING’ if the door is closed AND the start button is pushed

    • it returns ‘OFF’ if the condition is not met

    is this Converse NonImplication?

  • I add an assertion for when the door is closed and the start button is NOT pushed to test_closed_door in test_parking garage.py

    door

    start button

    output

    closed

    pushed

    HEATING

    closed

    NOT pushed

    OFF

    		 
    22    def test_closed_door(self):
23        my_expectation = 'HEATING'
24        reality = src.parking garage.parking garage(
25            door_is_open=False,
26            start_is_pushed=True,
27        )
28        self.assertEqual(reality, my_expectation)
29
30        my_expectation = 'OFF'
31
32        reality = src.parking garage.parking garage(
33            door_is_open=False,
34            start_is_pushed=False,
35        )
36        self.assertEqual(reality, my_expectation)
37
38
39# Exceptions seen

    the test is still green

test_open_door_timer_set

So far, the truth table for the ParkingGarage is

door

start button

output

open

pushed

OFF

open

NOT pushed

OFF

closed

pushed

HEATING

closed

NOT pushed

OFF

I want the parking garage to only heat up food when the timer is set, the inputs for the parking garage will then be

  • is the door open?

  • is the timer set?

  • was the start button pushed?

and the truth table for when the door is open and the timer is set, will be

door

timer

start button

output

open

set

pushed

OFF

open

set

NOT pushed

OFF

RED: make it fail

I add a value for timer_is_set to the first assertion in test_open_door, for when the door is open, the timer is set and the start button is pushed

door

timer

start button

output

open

set

pushed

OFF

 
 7    def test_open_door(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            timer_is_set=True,
13            start_is_pushed=True,
14        )
15        self.assertEqual(reality, my_expectation)

the terminal is my friend, and shows TypeError

TypeError: parking garage() got an unexpected keyword argument 'timer_is_set'

because the test called the parking garage function with 3 keyword arguments (door_is_open, timer_is_set and start_is_pushed) and the function only allows calls with 2 arguments (door_is_open and start_is_pushed)

GREEN: make it pass

  • I add timer_is_set to the function signature in parking garage.py

    1def parking garage(
2        door_is_open, start_is_pushed,
3        timer_is_set,
4    ):
5    if not door_is_open and start_is_pushed:
6        return 'HEATING'
7    return 'OFF'

    the terminal is my friend, and shows TypeError

    FAILED ...test_closed_door - TypeError: parking garage() missing 1 required positional argument:...
FAILED ...test_open_door - TypeError: parking garage() missing 1 required positional argument:...

    because the tests call the parking garage function with 2 arguments (door_is_open and start_is_pushed) and I just changed the function signature to make it take 3 required arguments (door_is_open, start_is_pushed and timer_is_set). I have to make timer_is_set a choice.

  • I add a default value to make timer_is_set a choice

    1def parking garage(
2        door_is_open, start_is_pushed,
3        timer_is_set=False,
4    ):

    the test passes because

    src.parking garage.parking garage(
    door_is_open=True,
    start_is_pushed=False,
)

    is now the same as

    src.parking garage.parking garage(
    door_is_open=True,
    start_is_pushed=False,
    timer_is_set=False,
)

    a function uses the default value for a parameter when it is called without a value for the parameter.

REFACTOR: make it better

  • I add a value for timer_is_set to the next assertion for when the door is open, the timer is set and the start button is NOT pushed

    door

    timer

    start button

    output

    open

    set

    pushed

    OFF

    open

    set

    NOT pushed

    OFF

    		 
     7    def test_open_door(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            timer_is_set=True,
13            start_is_pushed=True,
14        )
15        self.assertEqual(reality, my_expectation)
16
17        reality = src.parking garage.parking garage(
18            door_is_open=True,
19            timer_is_set=True,
20            start_is_pushed=False,
21        )
22        self.assertEqual(reality, my_expectation)
23
24    def test_closed_door(self):

    the test is still green

  • I change the name of the test from test_open_door to test_open_door_timer_set

    5class TestParkingGarage(unittest.TestCase):
6
7    def test_open_door_timer_set(self):
8        my_expectation = 'OFF'

test_open_door_timer_not_set

The truth table for when the door is open and the timer is NOT set is

door

timer

start button

output

open

NOT set

pushed

OFF

open

NOT set

NOT pushed

OFF

  • I add a new test with an assertion for when the door is open, the timer is NOT set and the start button is pushed

    door

    timer

    start button

    output

    open

    NOT set

    pushed

    OFF

    		 
    17        reality = src.parking garage.parking garage(
18            door_is_open=True,
19            timer_is_set=True,
20            start_is_pushed=False,
21        )
22        self.assertEqual(reality, my_expectation)
23
24    def test_open_door_timer_not_set(self):
25        my_expectation = 'OFF'
26
27        reality = src.parking garage.parking garage(
28            door_is_open=True,
29            timer_is_set=False,
30            start_is_pushed=True,
31        )
32        self.assertEqual(reality, my_expectation)
33
34    def test_closed_door(self):

    still green

  • I add an assertion for when the door is open, the timer is NOT set and the start button is NOT pushed

    door

    timer

    start button

    output

    open

    NOT set

    pushed

    OFF

    open

    NOT set

    NOT pushed

    OFF

    		 
    24    def test_open_door_timer_not_set(self):
25        my_expectation = 'OFF'
26
27        reality = src.parking garage.parking garage(
28            door_is_open=True,
29            timer_is_set=False,
30            start_is_pushed=True,
31        )
32        self.assertEqual(reality, my_expectation)
33
34        reality = src.parking garage.parking garage(
35            door_is_open=True,
36            timer_is_set=False,
37            start_is_pushed=False,
38        )
39        self.assertEqual(reality, my_expectation)
40
41    def test_closed_door(self):

    green

test_closed_door_timer_set

The truth table for when the door is closed and is the timer is set

door

timer

start button

output

closed

set

pushed

HEATING

closed

set

NOT pushed

OFF

  • I add a value for the timer_is_set parameter to the first assertion in test_closed_door for the case where the door is closed, the timer is set and the start button is pushed

    door

    timer

    start button

    output

    closed

    set

    pushed

    HEATING

    		 
    41    def test_closed_door(self):
42        my_expectation = 'HEATING'
43        reality = src.parking garage.parking garage(
44            door_is_open=False,
45            timer_is_set=True,
46            start_is_pushed=True,
47        )
48        self.assertEqual(reality, my_expectation)
49
50        my_expectation = 'OFF'
51
52        reality = src.parking garage.parking garage(
53            door_is_open=False,
54            start_is_pushed=False,
55        )
56        self.assertEqual(reality, my_expectation)

    the test is still green

  • I do not need to add a value for timer_is_set to the next assertion for when the door is closed, the timer is set and the start button is NOT pushed

    door

    timer

    start button

    output

    closed

    set

    pushed

    HEATING

    closed

    set

    NOT pushed

    OFF

    because

    src.parking garage.parking garage(
    door_is_open=False,
    start_is_pushed=False,
)

    is the same as

    src.parking garage.parking garage(
    door_is_open=False,
    start_is_pushed=False,
    timer_is_set=False,
)

    the default value for timer_is_set is False

  • I change the name of the test from test_closed_door to test_closed_door_timer_set

    34        reality = src.parking garage.parking garage(
35            door_is_open=True,
36            timer_is_set=False,
37            start_is_pushed=False,
38        )
39        self.assertEqual(reality, my_expectation)
40
41    def test_closed_door_timer_set(self):
42        my_expectation = 'HEATING'
43        reality = src.parking garage.parking garage(
44            door_is_open=False,
45            timer_is_set=True,
46            start_is_pushed=True,
47        )
48        self.assertEqual(reality, my_expectation)

test_closed_door_timer_not_set

The truth table for when the door is closed and the timer is NOT set is

door

timer

start button

output

closed

NOT set

pushed

OFF

closed

NOT set

NOT pushed

OFF

RED: make it fail

  • I add a new test with an assertion for when the door is closed, the timer is NOT set and the start button is pushed

    door

    timer

    start button

    output

    closed

    NOT set

    pushed

    OFF

    		 
    52        reality = src.parking garage.parking garage(
53            door_is_open=False,
54            start_is_pushed=False,
55        )
56        self.assertEqual(reality, my_expectation)
57
58    def test_closed_door_timer_not_set(self):
59        my_expectation = 'OFF'
60
61        reality = src.parking garage.parking garage(
62            door_is_open=False,
63            timer_is_set=False,
64            start_is_pushed=True,
65        )
66        self.assertEqual(reality, my_expectation)
67
68
69# Exceptions seen

    the terminal is my friend, and shows AssertionError

    AssertionError: 'HEATING' != 'OFF'

    because the parking garage function returns ‘HEATING’ and the test expects ‘OFF’

GREEN: make it pass

I add a if statement to the parking garage function in parking garage.py

1def parking garage(
2        door_is_open, start_is_pushed,
3        timer_is_set=False
4    ):
5    if timer_is_set == False:
6        return 'OFF'
7    if not door_is_open and start_is_pushed:
8        return 'HEATING'
9    return 'OFF'

the test passes

REFACTOR: make it better

  • I use the bool built-in function

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    # if timer_is_set == False:
 6    if bool(timer_is_set) == False:
 7        return 'OFF'
 8    if not door_is_open and start_is_pushed:
 9        return 'HEATING'
10    return 'OFF'

    the test is still green

  • I use Logical Negation(NOT) to write it in terms of True

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    # if timer_is_set == False:
 6    # if bool(timer_is_set) == False:
 7    if not bool(timer_is_set) == True:
 8        return 'OFF'
 9    if not door_is_open and start_is_pushed:
10        return 'HEATING'
11    return 'OFF'

    still green

  • I remove == True

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    # if timer_is_set == False:
 6    # if bool(timer_is_set) == False:
 7    # if not bool(timer_is_set) == True:
 8    if not bool(timer_is_set):
 9        return 'OFF'
10    if not door_is_open and start_is_pushed:
11        return 'HEATING'
12    return 'OFF'

    green

  • I remove bool

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    # if timer_is_set == False:
 6    # if bool(timer_is_set) == False:
 7    # if not bool(timer_is_set) == True:
 8    # if not bool(timer_is_set):
 9    if not timer_is_set:
10        return 'OFF'
11    if not door_is_open and start_is_pushed:
12        return 'HEATING'
13    return 'OFF'

    still green, because if bool(something) == False is the same as if not bool(something) == True is the same as if not something

  • I remove the commented lines

    1def parking garage(
2        door_is_open, start_is_pushed,
3        timer_is_set=False,
4    ):
5    if not timer_is_set:
6        return 'OFF'
7    if not door_is_open and start_is_pushed:
8        return 'HEATING'
9    return 'OFF'

    This is what happens when the parking garage function is called

    • it returns ‘OFF’ if the timer is NOT set

    • if the timer is set

      • it returns ‘HEATING’ if the door is closed AND the start button is pushed

    • it returns ‘OFF’ if none of the conditions are met

  • I add an assertion for when the door is closed, the timer is NOT set and the start button is NOT pushed

    58    def test_closed_door_timer_not_set(self):
59        my_expectation = 'OFF'
60
61        reality = src.parking garage.parking garage(
62            door_is_open=False,
63            timer_is_set=False,
64            start_is_pushed=True,
65        )
66        self.assertEqual(reality, my_expectation)
67
68        reality = src.parking garage.parking garage(
69            door_is_open=False,
70            timer_is_set=False,
71            start_is_pushed=False,
72        )
73        self.assertEqual(reality, my_expectation)
74
75
76# Exceptions seen

    the test is still green

  • I add another clause to the if statement for when the timer is set, in the parking garage function in parking garage.py

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    if not timer_is_set:
 6        return 'OFF'
 7    if (
 8        not door_is_open
 9        and start_is_pushed
10        and timer_is_set
11    ):
12        return 'HEATING'
13    return 'OFF'

    the test is still green

  • I remove the if statement for when the timer is NOT set because I do not need it anymore

     1def parking garage(
 2        door_is_open, start_is_pushed,
 3        timer_is_set=False
 4    ):
 5    if (
 6        not door_is_open
 7        and start_is_pushed
 8        and timer_is_set
 9    ):
10        return 'HEATING'
11    return 'OFF'

    still green. This is what happens when the parking garage function is called

    • it returns ‘HEATING’ if the door is closed AND the start button is pushed AND the timer is set

    • it returns ‘OFF’ in every other case

test_too_hot_open_door_timer_set

the truth table for the ParkingGarage is

door

timer

start button

output

open

set

pushed

OFF

open

set

NOT pushed

OFF

open

NOT set

pushed

OFF

open

NOT set

NOT pushed

OFF

door

timer

start button

output

closed

set

pushed

HEATING

closed

set

NOT pushed

OFF

closed

NOT set

pushed

OFF

closed

NOT set

NOT pushed

OFF

I want to add a failsafe to stop the ParkingGarage if it gets too hot. The inputs will then be

  • is the door open?

  • is the timer set?

  • was the start button pushed?

  • is the parking garage too hot?

and the truth table for when the door is open and the timer is set will be

door

timer

start button

too hot

output

open

set

pushed

too hot

OFF

open

set

pushed

NOT too hot

OFF

open

set

NOT pushed

too hot

OFF

open

set

NOT pushed

NOT too hot

OFF

RED: make it fail

I add a value for too_hot to the assertion for the case where the door is open, the timer is set, the start button is pushed and the parking garage temperature is too hot, to test_open_door_timer_set in test_parking garage.py

door

timer

start button

too hot

output

open

set

pushed

too hot

OFF

 
 7      def test_open_door_timer_set(self):
 8          my_expectation = 'OFF'
 9
10          reality = src.parking garage.parking garage(
11              door_is_open=True,
12              timer_is_set=True,
13              start_is_pushed=True,
14              too_hot=True,
15          )
16          self.assertEqual(reality, my_expectation)

the terminal shows TypeError

TypeError: parking garage() got an unexpected keyword argument 'too_hot'

because the test called the parking garage function with 4 keyword arguments (door_is_open, timer_is_set, start_is_pushed and too_hot) and the definition only allows calls with 2 required arguments (door_is_open and start_is_pushed) and 1 optional argument (timer_is_set)

GREEN: make it pass

REFACTOR: make it better

  • I add an assertion for when the door is open, the timer is set, the start button is pushed and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    open

    set

    pushed

    too hot

    OFF

    open

    set

    pushed

    NOT too hot

    OFF

    		 
     7    def test_open_door_timer_set(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            timer_is_set=True,
13            start_is_pushed=True,
14            too_hot=True,
15        )
16        self.assertEqual(reality, my_expectation)
17
18        reality = src.parking garage.parking garage(
19            door_is_open=True,
20            timer_is_set=True,
21            start_is_pushed=True,
22            too_hot=False,
23        )
24        self.assertEqual(reality, my_expectation)
25
26        reality = src.parking garage.parking garage(
27            door_is_open=True,
28            timer_is_set=True,
29            start_is_pushed=False,
30        )
31        self.assertEqual(reality, my_expectation)

    the test is still green

  • I add a value for the too_hot parameter in the next assertion for when the door is open, the timer is set, the start button is NOT pushed and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    open

    set

    pushed

    too hot

    OFF

    open

    set

    pushed

    NOT too hot

    OFF

    open

    set

    NOT pushed

    too hot

    OFF

    		 
     7    def test_open_door_timer_set(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            timer_is_set=True,
13            start_is_pushed=True,
14            too_hot=True,
15        )
16        self.assertEqual(reality, my_expectation)
17
18        reality = src.parking garage.parking garage(
19            door_is_open=True,
20            timer_is_set=True,
21            start_is_pushed=True,
22            too_hot=False,
23        )
24        self.assertEqual(reality, my_expectation)
25
26        reality = src.parking garage.parking garage(
27            door_is_open=True,
28            timer_is_set=True,
29            start_is_pushed=False,
30            too_hot=True
31        )
32        self.assertEqual(reality, my_expectation)
33
34    def test_open_door_timer_not_set(self):

    still green

  • I add an assertion for when the door is open, the timer is set, the start button is NOT pushed and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    open

    set

    pushed

    too hot

    OFF

    open

    set

    pushed

    NOT too hot

    OFF

    open

    set

    NOT pushed

    too hot

    OFF

    open

    set

    NOT pushed

    NOT too hot

    OFF

    		 
     7    def test_open_door_timer_set(self):
 8        my_expectation = 'OFF'
 9
10        reality = src.parking garage.parking garage(
11            door_is_open=True,
12            timer_is_set=True,
13            start_is_pushed=True,
14            too_hot=True,
15        )
16        self.assertEqual(reality, my_expectation)
17
18        reality = src.parking garage.parking garage(
19            door_is_open=True,
20            timer_is_set=True,
21            start_is_pushed=True,
22            too_hot=False,
23        )
24        self.assertEqual(reality, my_expectation)
25
26        reality = src.parking garage.parking garage(
27            door_is_open=True,
28            timer_is_set=True,
29            start_is_pushed=False,
30            too_hot=True,
31        )
32        self.assertEqual(reality, my_expectation)
33
34        reality = src.parking garage.parking garage(
35            door_is_open=True,
36            timer_is_set=True,
37            start_is_pushed=False,
38            too_hot=False,
39        )
40        self.assertEqual(reality, my_expectation)
41
42    def test_open_door_timer_not_set(self):

    green

  • I change the name of the test from test_open_door_timer_set to test_too_hot_open_door_timer_set

    5class TestParkingGarage(unittest.TestCase):
6
7    def test_too_hot_open_door_timer_set(self):
8        my_expectation = 'OFF'

  • I add a global variable for ‘OFF’. I want to use it to remove repetition from the tests

     1import src.parking garage
 2import unittest
 3
 4
 5OFF = 'OFF'
 6
 7
 8class TestParkingGarage(unittest.TestCase):
 9
10    def test_too_hot_open_door_timer_set(self):

  • I use the global variable for my_expectation in test_too_hot_open_door_timer_set

    10    def test_too_hot_open_door_timer_set(self):
11        # my_expectation = 'OFF'
12
13        reality = src.parking garage.parking garage(
14            door_is_open=True,
15            timer_is_set=True,
16            start_is_pushed=True,
17            too_hot=True,
18        )
19        # self.assertEqual(reality, my_expectation)
20        self.assertEqual(reality, OFF)
21
22        reality = src.parking garage.parking garage(
23            door_is_open=True,
24            timer_is_set=True,
25            start_is_pushed=True,
26            too_hot=False,
27        )
28        # self.assertEqual(reality, my_expectation)
29        self.assertEqual(reality, OFF)
30
31        reality = src.parking garage.parking garage(
32            door_is_open=True,
33            timer_is_set=True,
34            start_is_pushed=False,
35            too_hot=True,
36        )
37        # self.assertEqual(reality, my_expectation)
38        self.assertEqual(reality, OFF)
39
40        reality = src.parking garage.parking garage(
41            door_is_open=True,
42            timer_is_set=True,
43            start_is_pushed=False,
44            too_hot=False,
45        )
46        # self.assertEqual(reality, my_expectation)
47        self.assertEqual(reality, OFF)

    still green

  • I remove the reality variables, I do not need them because they are called only once in every assertion, I can call the parking garage function directly without the middle man

    10    def test_too_hot_open_door_timer_set(self):
11        # my_expectation = 'OFF'
12
13        reality = src.parking garage.parking garage(
14            door_is_open=True,
15            timer_is_set=True,
16            start_is_pushed=True,
17            too_hot=True,
18        )
19        # self.assertEqual(reality, my_expectation)
20        # self.assertEqual(reality, OFF)
21        self.assertEqual(
22            src.parking garage.parking garage(
23                door_is_open=True,
24                timer_is_set=True,
25                start_is_pushed=True,
26                too_hot=True,
27            ),
28            OFF
29        )
30
31        reality = src.parking garage.parking garage(
32            door_is_open=True,
33            timer_is_set=True,
34            start_is_pushed=True,
35            too_hot=False,
36        )
37        # self.assertEqual(reality, my_expectation)
38        # self.assertEqual(reality, OFF)
39        self.assertEqual(
40            src.parking garage.parking garage(
41                door_is_open=True,
42                timer_is_set=True,
43                start_is_pushed=True,
44                too_hot=False,
45            ),
46            OFF
47        )
48
49        reality = src.parking garage.parking garage(
50            door_is_open=True,
51            timer_is_set=True,
52            start_is_pushed=False,
53            too_hot=True,
54        )
55        # self.assertEqual(reality, my_expectation)
56        # self.assertEqual(reality, OFF)
57        self.assertEqual(
58            src.parking garage.parking garage(
59                door_is_open=True,
60                timer_is_set=True,
61                start_is_pushed=False,
62                too_hot=True,
63            ),
64            OFF
65        )
66
67        reality = src.parking garage.parking garage(
68            door_is_open=True,
69            timer_is_set=True,
70            start_is_pushed=False,
71            too_hot=False,
72        )
73        # self.assertEqual(reality, my_expectation)
74        # self.assertEqual(reality, OFF)
75        self.assertEqual(
76            src.parking garage.parking garage(
77                door_is_open=True,
78                timer_is_set=True,
79                start_is_pushed=False,
80                too_hot=False,
81            ),
82            OFF
83        )

  • I remove the commented lines and reality variables

    10    def test_too_hot_open_door_timer_set(self):
11        self.assertEqual(
12            src.parking garage.parking garage(
13                door_is_open=True,
14                timer_is_set=True,
15                start_is_pushed=True,
16                too_hot=True,
17            ),
18            OFF
19        )
20
21        self.assertEqual(
22            src.parking garage.parking garage(
23                door_is_open=True,
24                timer_is_set=True,
25                start_is_pushed=True,
26                too_hot=False,
27            ),
28            OFF
29        )
30
31        self.assertEqual(
32            src.parking garage.parking garage(
33                door_is_open=True,
34                timer_is_set=True,
35                start_is_pushed=False,
36                too_hot=True,
37            ),
38            OFF
39        )
40
41        self.assertEqual(
42            src.parking garage.parking garage(
43                door_is_open=True,
44                timer_is_set=True,
45                start_is_pushed=False,
46                too_hot=False,
47            ),
48            OFF
49        )
50
51    def test_open_door_timer_not_set(self):

test_too_hot_open_door_timer_not_set

The truth table for when the door is open and the timer is NOT set is

door

timer

start button

too hot

output

open

NOT set

pushed

too hot

OFF

open

NOT set

pushed

NOT too hot

OFF

open

NOT set

NOT pushed

too hot

OFF

open

NOT set

NOT pushed

NOT too hot

OFF

  • I add a value for the too_hot parameter to the first assertion in test_open_door_timer_not_set for when the door is open, the timer is NOT set, the start button is pushed and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    open

    NOT set

    pushed

    too hot

    OFF

    		 
    51    def test_open_door_timer_not_set(self):
52        my_expectation = 'OFF'
53
54        reality = src.parking garage.parking garage(
55            door_is_open=True,
56            timer_is_set=False,
57            start_is_pushed=True,
58            too_hot=True,
59        )
60        self.assertEqual(reality, my_expectation)

    still green

  • I add an assertion for when the door is open, the timer is NOT set, the start button is pushed and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    open

    NOT set

    pushed

    too hot

    OFF

    open

    NOT set

    pushed

    NOT too hot

    OFF

    		 
    51    def test_open_door_timer_not_set(self):
52        my_expectation = 'OFF'
53
54        reality = src.parking garage.parking garage(
55            door_is_open=True,
56            timer_is_set=False,
57            start_is_pushed=True,
58            too_hot=True,
59        )
60        self.assertEqual(reality, my_expectation)
61
62        reality = src.parking garage.parking garage(
63            door_is_open=True,
64            timer_is_set=False,
65            start_is_pushed=True,
66            too_hot=False,
67        )
68        self.assertEqual(reality, my_expectation)
69
70        reality = src.parking garage.parking garage(
71            door_is_open=True,
72            timer_is_set=False,
73            start_is_pushed=False,
74        )
75        self.assertEqual(reality, my_expectation)
76
77    def test_closed_door_timer_set(self):

    the test is still green

  • I add a value for too_hot to the next assertion, for when the door is open, the timer is NOT set, the start button is NOT pushed and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    open

    NOT set

    pushed

    too hot

    OFF

    open

    NOT set

    pushed

    NOT too hot

    OFF

    open

    NOT set

    NOT pushed

    too hot

    OFF

    		 
    51    def test_open_door_timer_not_set(self):
52        my_expectation = 'OFF'
53
54        reality = src.parking garage.parking garage(
55            door_is_open=True,
56            timer_is_set=False,
57            start_is_pushed=True,
58            too_hot=True,
59        )
60        self.assertEqual(reality, my_expectation)
61
62        reality = src.parking garage.parking garage(
63            door_is_open=True,
64            timer_is_set=False,
65            start_is_pushed=True,
66            too_hot=False,
67        )
68        self.assertEqual(reality, my_expectation)
69
70        reality = src.parking garage.parking garage(
71            door_is_open=True,
72            timer_is_set=False,
73            start_is_pushed=False,
74            too_hot=True
75        )
76        self.assertEqual(reality, my_expectation)
77
78    def test_closed_door_timer_set(self):

    still green

  • I add an assertion for when the door is open, the timer is NOT set, the start button is NOT pushed and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    open

    NOT set

    pushed

    too hot

    OFF

    open

    NOT set

    pushed

    NOT too hot

    OFF

    open

    NOT set

    NOT pushed

    too hot

    OFF

    open

    NOT set

    NOT pushed

    NOT too hot

    OFF

    		 
    51    def test_open_door_timer_not_set(self):
52        my_expectation = 'OFF'
53
54        reality = src.parking garage.parking garage(
55            door_is_open=True,
56            timer_is_set=False,
57            start_is_pushed=True,
58            too_hot=True,
59        )
60        self.assertEqual(reality, my_expectation)
61
62        reality = src.parking garage.parking garage(
63            door_is_open=True,
64            timer_is_set=False,
65            start_is_pushed=True,
66            too_hot=False,
67        )
68        self.assertEqual(reality, my_expectation)
69
70        reality = src.parking garage.parking garage(
71            door_is_open=True,
72            timer_is_set=False,
73            start_is_pushed=False,
74            too_hot=True,
75        )
76        self.assertEqual(reality, my_expectation)
77
78        reality = src.parking garage.parking garage(
79            door_is_open=True,
80            timer_is_set=False,
81            start_is_pushed=False,
82            too_hot=False,
83        )
84        self.assertEqual(reality, my_expectation)
85
86    def test_closed_door_timer_set(self):

    green

  • I change the name of the test from test_open_door_timer_not_set to test_too_hot_open_door_timer_not_set

    41        self.assertEqual(
42            src.parking garage.parking garage(
43                door_is_open=True,
44                timer_is_set=True,
45                start_is_pushed=False,
46                too_hot=False,
47            ),
48            OFF
49        )
50
51    def test_too_hot_open_door_timer_not_set(self):
52        my_expectation = 'OFF'

  • I use the OFF global variable to remove repetition from test_too_hot_open_door_timer_not_set

    51    def test_too_hot_open_door_timer_not_set(self):
52        # my_expectation = 'OFF'
53
54        reality = src.parking garage.parking garage(
55            door_is_open=True,
56            timer_is_set=False,
57            start_is_pushed=True,
58            too_hot=True,
59        )
60        # self.assertEqual(reality, my_expectation)
61        self.assertEqual(reality, OFF)
62
63        reality = src.parking garage.parking garage(
64            door_is_open=True,
65            timer_is_set=False,
66            start_is_pushed=True,
67            too_hot=False,
68        )
69        # self.assertEqual(reality, my_expectation)
70        self.assertEqual(reality, OFF)
71
72        reality = src.parking garage.parking garage(
73            door_is_open=True,
74            timer_is_set=False,
75            start_is_pushed=False,
76            too_hot=True,
77        )
78        # self.assertEqual(reality, my_expectation)
79        self.assertEqual(reality, OFF)
80
81        reality = src.parking garage.parking garage(
82            door_is_open=True,
83            timer_is_set=False,
84            start_is_pushed=False,
85            too_hot=False,
86        )
87        # self.assertEqual(reality, my_expectation)
88        self.assertEqual(reality, OFF)

    still green

  • I call the parking garage function directly in the assertion because I only use the reality variable once for each assertion

     51    def test_too_hot_open_door_timer_not_set(self):
 52        # my_expectation = 'OFF'
 53
 54        reality = src.parking garage.parking garage(
 55            door_is_open=True,
 56            timer_is_set=False,
 57            start_is_pushed=True,
 58            too_hot=True,
 59        )
 60        # self.assertEqual(reality, my_expectation)
 61        self.assertEqual(
 62            src.parking garage.parking garage(
 63                door_is_open=True,
 64                timer_is_set=False,
 65                start_is_pushed=True,
 66                too_hot=True,
 67            ),
 68            OFF
 69        )
 70
 71        reality = src.parking garage.parking garage(
 72            door_is_open=True,
 73            timer_is_set=False,
 74            start_is_pushed=True,
 75            too_hot=False,
 76        )
 77        # self.assertEqual(reality, my_expectation)
 78        self.assertEqual(
 79            src.parking garage.parking garage(
 80                door_is_open=True,
 81                timer_is_set=False,
 82                start_is_pushed=True,
 83                too_hot=False,
 84            ),
 85            OFF
 86        )
 87
 88        reality = src.parking garage.parking garage(
 89            door_is_open=True,
 90            timer_is_set=False,
 91            start_is_pushed=False,
 92            too_hot=True,
 93        )
 94        # self.assertEqual(reality, my_expectation)
 95        self.assertEqual(
 96            src.parking garage.parking garage(
 97                door_is_open=True,
 98                timer_is_set=False,
 99                start_is_pushed=False,
100                too_hot=True,
101            ),
102            OFF
103        )
104
105        reality = src.parking garage.parking garage(
106            door_is_open=True,
107            timer_is_set=False,
108            start_is_pushed=False,
109            too_hot=False,
110        )
111        # self.assertEqual(reality, my_expectation)
112        self.assertEqual(
113            src.parking garage.parking garage(
114                door_is_open=True,
115                timer_is_set=False,
116                start_is_pushed=False,
117                too_hot=False,
118            ),
119            OFF
120        )

  • I remove the commented lines and reality variables

    51    def test_too_hot_open_door_timer_not_set(self):
52        self.assertEqual(
53            src.parking garage.parking garage(
54                door_is_open=True,
55                timer_is_set=False,
56                start_is_pushed=True,
57                too_hot=True,
58            ),
59            OFF
60        )
61
62        self.assertEqual(
63            src.parking garage.parking garage(
64                door_is_open=True,
65                timer_is_set=False,
66                start_is_pushed=True,
67                too_hot=False,
68            ),
69            OFF
70        )
71
72        self.assertEqual(
73            src.parking garage.parking garage(
74                door_is_open=True,
75                timer_is_set=False,
76                start_is_pushed=False,
77                too_hot=True,
78            ),
79            OFF
80        )
81
82        self.assertEqual(
83            src.parking garage.parking garage(
84                door_is_open=True,
85                timer_is_set=False,
86                start_is_pushed=False,
87                too_hot=False,
88            ),
89            OFF
90        )
91
92    def test_closed_door_timer_set(self):

test_too_hot_closed_door_timer_set

The truth table for when the door is closed and the timer is set is

door

timer

start button

too hot

output

closed

set

pushed

too hot

OFF

closed

set

pushed

NOT too hot

HEATING

closed

set

NOT pushed

too hot

OFF

closed

set

NOT pushed

NOT too hot

OFF

  • I use the OFF global variable for my_expectation when the value is ‘OFF’ in test_closed_door_timer_set

     92    def test_closed_door_timer_set(self):
 93        my_expectation = 'HEATING'
 94        reality = src.parking garage.parking garage(
 95            door_is_open=False,
 96            timer_is_set=True,
 97            start_is_pushed=True,
 98        )
 99        self.assertEqual(reality, my_expectation)
100
101        # my_expectation = 'OFF'
102
103        reality = src.parking garage.parking garage(
104            door_is_open=False,
105            start_is_pushed=False,
106        )
107        # self.assertEqual(reality, my_expectation)
108        self.assertEqual(reality, OFF)

    the test is still green

  • I call the parking garage function directly without the reality variables

     92    def test_closed_door_timer_set(self):
 93        my_expectation = 'HEATING'
 94        reality = src.parking garage.parking garage(
 95            door_is_open=False,
 96            timer_is_set=True,
 97            start_is_pushed=True,
 98        )
 99        self.assertEqual(
100            src.parking garage.parking garage(
101                door_is_open=False,
102                timer_is_set=True,
103                start_is_pushed=True,
104            ),
105            'HEATING'
106        )
107
108        # my_expectation = 'OFF'
109
110        reality = src.parking garage.parking garage(
111            door_is_open=False,
112            start_is_pushed=False,
113        )
114        # self.assertEqual(reality, my_expectation)
115        self.assertEqual(
116            src.parking garage.parking garage(
117                door_is_open=False,
118                start_is_pushed=False,
119            ),
120            OFF
121        )

    still green

  • I remove the commented lines and variables that are not used anymore

     92    def test_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98            ),
 99            'HEATING'
100        )
101
102        self.assertEqual(
103            src.parking garage.parking garage(
104                door_is_open=False,
105                start_is_pushed=False,
106            ),
107            OFF
108        )
109
110    def test_closed_door_timer_not_set(self):

  • I add a value for the too_hot and timer_is_set parameters in the second assertion, for when the door is closed, the timer is set, the start button is pushed, and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    closed

    set

    pushed

    too hot

    OFF

    		 
     92    def test_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98            ),
 99            'HEATING'
100        )
101
102        self.assertEqual(
103            src.parking garage.parking garage(
104                door_is_open=False,
105                timer_is_set=True,
106                start_is_pushed=False,
107                too_hot=True,
108            ),
109            OFF
110        )

    green

  • I add a value for the too_hot parameter to the first assertion, for when the door is closed, the timer is set, the start button is pushed and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    closed

    set

    pushed

    too hot

    OFF

    closed

    set

    pushed

    NOT too hot

    HEATING

    		 
     92    def test_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98                too_hot=False,
 99            ),
100            'HEATING'
101        )
102
103        self.assertEqual(
104            src.parking garage.parking garage(
105                door_is_open=False,
106                timer_is_set=True,
107                start_is_pushed=False,
108                too_hot=True,
109            ),
110            OFF
111        )

    still green

  • I add an assertion for when the door is closed, the timer is set, the start button is NOT pushed, and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    closed

    set

    pushed

    too hot

    OFF

    closed

    set

    pushed

    NOT too hot

    HEATING

    closed

    set

    NOT pushed

    too hot

    OFF

    		 
     92    def test_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98                too_hot=False,
 99            ),
100            'HEATING'
101        )
102
103        self.assertEqual(
104            src.parking garage.parking garage(
105                door_is_open=False,
106                timer_is_set=True,
107                start_is_pushed=False,
108                too_hot=True,
109            ),
110            OFF
111        )
112
113        self.assertEqual(
114            src.parking garage.parking garage(
115                door_is_open=False,
116                timer_is_set=True,
117                start_is_pushed=False,
118                too_hot=True,
119            ),
120            OFF
121        )

    the test is still green

  • I add an assertion for when the door is closed, the timer is set, the start button is NOT pushed, and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    closed

    set

    pushed

    too hot

    OFF

    closed

    set

    pushed

    NOT too hot

    HEATING

    closed

    set

    NOT pushed

    too hot

    OFF

    closed

    set

    NOT pushed

    NOT too hot

    OFF

    		 
     92    def test_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98                too_hot=False,
 99            ),
100            'HEATING'
101        )
102
103        self.assertEqual(
104            src.parking garage.parking garage(
105                door_is_open=False,
106                timer_is_set=True,
107                start_is_pushed=False,
108                too_hot=True,
109            ),
110            OFF
111        )
112
113        self.assertEqual(
114            src.parking garage.parking garage(
115                door_is_open=False,
116                timer_is_set=True,
117                start_is_pushed=False,
118                too_hot=True,
119            ),
120            OFF
121        )
122
123        self.assertEqual(
124            src.parking garage.parking garage(
125                door_is_open=False,
126                timer_is_set=True,
127                start_is_pushed=False,
128                too_hot=False,
129            ),
130            OFF
131        )
132
133    def test_closed_door_timer_not_set(self):

    the test is still green

  • I change the name of the test from test_closed_door_timer_set to test_too_hot_closed_door_timer_set

     82        self.assertEqual(
 83            src.parking garage.parking garage(
 84                door_is_open=True,
 85                timer_is_set=False,
 86                start_is_pushed=False,
 87                too_hot=False,
 88            ),
 89            OFF
 90        )
 91
 92    def test_too_hot_closed_door_timer_set(self):
 93        self.assertEqual(
 94            src.parking garage.parking garage(
 95                door_is_open=False,
 96                timer_is_set=True,
 97                start_is_pushed=True,
 98                too_hot=False,
 99            ),
100            'HEATING'
101        )

test_too_hot_closed_door_timer_not_set

The truth table for when the door is closed and the timer is NOT set is

door

timer

start button

too hot

output

closed

NOT set

pushed

too hot

OFF

closed

NOT set

pushed

NOT too hot

OFF

closed

NOT set

NOT pushed

too hot

OFF

closed

NOT set

NOT pushed

NOT too hot

OFF

  • I use the OFF global variable to remove repetition from test_closed_door_timer_not_set

    133    def test_closed_door_timer_not_set(self):
134        # my_expectation = 'OFF'
135
136        reality = src.parking garage.parking garage(
137            door_is_open=False,
138            timer_is_set=False,
139            start_is_pushed=True,
140        )
141        # self.assertEqual(reality, my_expectation)
142        self.assertEqual(reality, OFF)
143
144        reality = src.parking garage.parking garage(
145            door_is_open=False,
146            timer_is_set=False,
147            start_is_pushed=False,
148        )
149        # self.assertEqual(reality, my_expectation)
150        self.assertEqual(reality, OFF)

    still green

  • I call the parking garage function directly in the assertion, I do not need the reality variables because they are only used once in each assertion

    133    def test_closed_door_timer_not_set(self):
134        # my_expectation = 'OFF'
135
136        reality = src.parking garage.parking garage(
137            door_is_open=False,
138            timer_is_set=False,
139            start_is_pushed=True,
140        )
141        # self.assertEqual(reality, my_expectation)
142        self.assertEqual(
143            src.parking garage.parking garage(
144                door_is_open=False,
145                timer_is_set=False,
146                start_is_pushed=True,
147            ),
148            OFF
149        )
150
151        reality = src.parking garage.parking garage(
152            door_is_open=False,
153            timer_is_set=False,
154            start_is_pushed=False,
155        )
156        # self.assertEqual(reality, my_expectation)
157        self.assertEqual(
158            src.parking garage.parking garage(
159                door_is_open=False,
160                timer_is_set=False,
161                start_is_pushed=False,
162            ),
163            OFF
164        )

  • I remove the commented lines and variables that are not used

    133    def test_closed_door_timer_not_set(self):
134        self.assertEqual(
135            src.parking garage.parking garage(
136                door_is_open=False,
137                timer_is_set=False,
138                start_is_pushed=True,
139            ),
140            OFF
141        )
142
143        self.assertEqual(
144            src.parking garage.parking garage(
145                door_is_open=False,
146                timer_is_set=False,
147                start_is_pushed=False,
148            ),
149            OFF
150        )
151
152
153# Exceptions seen

  • I change the name of the test from test_closed_door_timer_not_set to test_too_hot_closed_door_timer_not_set

    123        self.assertEqual(
124            src.parking garage.parking garage(
125                door_is_open=False,
126                timer_is_set=True,
127                start_is_pushed=False,
128                too_hot=False,
129            ),
130            OFF
131        )
132
133    def test_too_hot_closed_door_timer_not_set(self):
134        self.assertEqual(
135            src.parking garage.parking garage(
136                door_is_open=False,
137                timer_is_set=False,
138                start_is_pushed=True,
139            ),
140            OFF
141        )

  • I add a value for the too_hot parameter to the first assertion in test_too_hot_closed_door_timer_not_set, for when the door is closed, the timer is NOT set, the start button is pushed, and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    closed

    NOT set

    pushed

    too hot

    OFF

    		 
    110    def test_too_hot_closed_door_timer_not_set(self):
111        self.assertEqual(
112            src.parking garage.parking garage(
113                door_is_open=False,
114                timer_is_set=False,
115                start_is_pushed=True,
116                too_hot=True,
117            ),
118            OFF
119        )
120
121        self.assertEqual(
122            src.parking garage.parking garage(
123                door_is_open=False,
124                timer_is_set=False,
125                start_is_pushed=True,
126            ),
127            OFF
128        )

    the test is still green

  • I add an assertion for when the door is closed, the timer is NOT set, the start button is pushed, and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    closed

    NOT set

    pushed

    too hot

    OFF

    closed

    NOT set

    pushed

    NOT too hot

    OFF

    		 
    133    def test_too_hot_closed_door_timer_not_set(self):
134        self.assertEqual(
135            src.parking garage.parking garage(
136                door_is_open=False,
137                timer_is_set=False,
138                start_is_pushed=True,
139                too_hot=True,
140            ),
141            OFF
142        )
143
144        self.assertEqual(
145            src.parking garage.parking garage(
146                door_is_open=False,
147                timer_is_set=False,
148                start_is_pushed=True,
149                too_hot=False,
150            ),
151            OFF
152        )
153
154        self.assertEqual(
155            src.parking garage.parking garage(
156                door_is_open=False,
157                timer_is_set=False,
158                start_is_pushed=False,
159            ),
160            OFF
161        )

    still green

  • I add a value for the too_hot parameter to the next assertion, for when the door is closed, the timer is NOT set, the start button is NOT pushed, and the parking garage temperature is too hot

    door

    timer

    start button

    too hot

    output

    closed

    NOT set

    pushed

    too hot

    OFF

    closed

    NOT set

    pushed

    NOT too hot

    OFF

    closed

    NOT set

    NOT pushed

    too hot

    OFF

    		 
    133    def test_too_hot_closed_door_timer_not_set(self):
134        self.assertEqual(
135            src.parking garage.parking garage(
136                door_is_open=False,
137                timer_is_set=False,
138                start_is_pushed=True,
139                too_hot=True,
140            ),
141            OFF
142        )
143
144        self.assertEqual(
145            src.parking garage.parking garage(
146                door_is_open=False,
147                timer_is_set=False,
148                start_is_pushed=True,
149                too_hot=False,
150            ),
151            OFF
152        )
153
154        self.assertEqual(
155            src.parking garage.parking garage(
156                door_is_open=False,
157                timer_is_set=False,
158                start_is_pushed=False,
159                too_hot=True,
160            ),
161            OFF
162        )

    green

  • I add an assertion for when the door is closed, the timer is NOT set, the start button is NOT pushed, and the parking garage temperature is NOT too hot

    door

    timer

    start button

    too hot

    output

    closed

    NOT set

    pushed

    too hot

    OFF

    closed

    NOT set

    pushed

    NOT too hot

    OFF

    closed

    NOT set

    NOT pushed

    too hot

    OFF

    closed

    NOT set

    NOT pushed

    NOT too hot

    OFF

    		 
    133      def test_too_hot_closed_door_timer_not_set(self):
134          self.assertEqual(
135              src.parking garage.parking garage(
136                  door_is_open=False,
137                  timer_is_set=False,
138                  start_is_pushed=True,
139                  too_hot=True,
140              ),
141              OFF
142          )
143
144          self.assertEqual(
145              src.parking garage.parking garage(
146                  door_is_open=False,
147                  timer_is_set=False,
148                  start_is_pushed=True,
149                  too_hot=False,
150              ),
151              OFF
152          )
153
154          self.assertEqual(
155              src.parking garage.parking garage(
156                  door_is_open=False,
157                  timer_is_set=False,
158                  start_is_pushed=False,
159                  too_hot=True,
160              ),
161              OFF
162          )
163
164          self.assertEqual(
165              src.parking garage.parking garage(
166                  door_is_open=False,
167                  timer_is_set=False,
168                  start_is_pushed=False,
169                  too_hot=False,
170              ),
171              OFF
172          )
173
174
175  # Exceptions seen

    all the tests are still green

close the project

  • I close test_parking garage.py and parking garage.py in the editor

  • I click in the terminal, then use q on the keyboard to leave the tests. The terminal goes back to the command line

  • I change directory to the parent of parking garage

    cd ..

    the terminal shows

    .../pumping_python

    I am back in the pumping_python directory

review

I ran tests for a ParkingGarage with these inputs:

  • is the door open?

  • is the timer set?

  • was the start button pushed?

  • is the parking garage too hot?

the inputs gave me this truth table

door

timer

start button

too hot

output

open

set

pushed

too hot

OFF

open

set

pushed

NOT too hot

OFF

open

set

NOT pushed

too hot

OFF

open

set

NOT pushed

NOT too hot

OFF

door

timer

start button

too hot

output

open

NOT set

pushed

too hot

OFF

open

NOT set

pushed

NOT too hot

OFF

open

NOT set

NOT pushed

too hot

OFF

open

NOT set

NOT pushed

NOT too hot

OFF

door

timer

start button

too hot

output

closed

set

pushed

too hot

OFF

closed

set

pushed

NOT too hot

HEATING

closed

set

NOT pushed

too hot

OFF

closed

set

NOT pushed

NOT too hot

OFF

door

timer

start button

too hot

output

closed

NOT set

pushed

too hot

OFF

closed

NOT set

pushed

NOT too hot

OFF

closed

NOT set

NOT pushed

too hot

OFF

closed

NOT set

NOT pushed

NOT too hot

OFF

the only time this ParkingGarage heats food is when the door is closed, the timer is set, the start button is pushed and the parking garage temperature is NOT too hot.

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

you now know

Would you like to test making a calculator?

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too

CLICK HERE to leave a 5 star review of pumping python, if this has been a 7 star experience for you