test traffic_light with list comprehensions

I want to use for loops in the Traffic Light project. It has for a Traffic Light that changes color based on what RED phase the traffic is in ('cross' or 'parallel') AND if a timer is done or NOT done

The outputs are the next lights for Parallel and Cross Traffic which gave me this truth table

red	current	current		next	next
phase	parallel	cross	timer	parallel	cross
‘cross’	GREEN	RED	NOT done	GREEN	RED
‘cross’	GREEN	RED	done	YELLOW	RED
‘cross’	YELLOW	RED	NOT done	YELLOW	RED
‘cross’	YELLOW	RED	done	safety RED	safety RED
‘cross’	RED	RED	NOT done	safety RED	safety RED
‘cross’	RED	RED	done	RED	GREEN

red	current	current		next	next
phase	parallel	cross	timer	parallel	cross
‘parallel’	RED	GREEN	NOT done	RED	GREEN
‘parallel’	RED	GREEN	done	RED	YELLOW
‘parallel’	RED	YELLOW	NOT done	RED	YELLOW
‘parallel’	RED	YELLOW	done	safety RED	safety RED
‘parallel’	RED	RED	NOT done	safety RED	safety RED
‘parallel’	RED	RED	done	GREEN	RED

It also makes sure that there is never a case where the lights allow cars to move through the intersection at the same time (to try to avoid accidents).

preview

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

traffic_light/tests/test_traffic_light.py

import src.traffic_light
import unittest


GREEN, YELLOW, RED = 'GREEN', 'YELLOW', 'RED'

traffic_light/tests/test_traffic_light.py

class TestTrafficLight(unittest.TestCase):

    def test_traffic_light_control(self):
        for row in (
            ('cross', GREEN, RED, False, (GREEN, RED, WALK)),
            ('cross', GREEN, RED, True, (YELLOW, RED, NOT_WALK)),
            ('cross', YELLOW, RED, False, (YELLOW, RED, NOT_WALK)),
            ('cross', YELLOW, RED, True, (RED, RED, NOT_WALK)),
            ('cross', RED, RED, False, (RED, RED, NOT_WALK)),
            ('cross', RED, RED, True, (RED, GREEN, NOT_WALK)),
            ('parallel', RED, GREEN, False, (RED, GREEN, NOT_WALK)),
            ('parallel', RED, GREEN, True, (RED, YELLOW, NOT_WALK)),
            ('parallel', RED, YELLOW, False, (RED, YELLOW, NOT_WALK)),
            ('parallel', RED, YELLOW, True, (RED, RED, NOT_WALK)),
            ('parallel', RED, RED, False, (RED, RED, NOT_WALK)),
            ('parallel', RED, RED, True, (GREEN, RED, WALK)),
        ):
            red_phase = row[0]
            current_parallel = row[1]
            current_cross = row[2]
            timer_done = row[3]

            with self.subTest(
                red_phase=red_phase,
                current_parallel=current_parallel,
                current_cross=current_cross,
                timer_done=timer_done,
            ):
                self.assertEqual(
                    src.traffic_light.control(
                        red_phase=red_phase,
                        current_parallel=current_parallel,
                        current_cross=current_cross,
                        timer_done=timer_done,
                    ),
                    row[4]

traffic_light/tests/test_traffic_light.py

    def test_traffic_light_failsafe(self):
        inputs = (GREEN, YELLOW, 'bad input')
        for red_phase in ('cross', 'parallel', 'bad input'):
            for current_parallel in inputs:
                for current_cross in inputs:
                    for timer_done in (False, True):
                        with self.subTest(
                            red_phase=red_phase,
                            current_parallel=current_parallel,
                            current_cross=current_cross,
                            timer_done=timer_done,
                        ):
                            self.assertEqual(
                                src.traffic_light.control(
                                    red_phase=red_phase,
                                    current_parallel=current_parallel,
                                    current_cross=current_cross,
                                    timer_done=timer_done,
                                ),
                                (RED, RED, NOT_WALK)
                            )


# Exceptions seen
# AssertionError
# NameError
# AttributeError
# TypeError

open the project

I open a terminal
I change directory to the traffic_light folder in the pumping_python folder
terminal
```
cd traffic_light
```
I open test_traffic_light.py from the tests folder
I use pytest-watcher to run the tests automatically
terminal
```
uv run pytest-watcher . --now
```

test_traffic_light_control

RED: make it fail

I add a test with a for loop for all the cases from all the tests except test_traffic_light_failsafe

traffic_light/tests/test_traffic_light.py

class TestTrafficLight(unittest.TestCase):

    def test_traffic_light_control(self):
        for row in (
            ('cross', GREEN, RED, False, (GREEN, RED)),
            ('cross', GREEN, RED, True, (YELLOW, RED)),
            ('cross', YELLOW, RED, False, (YELLOW, RED)),
            ('cross', YELLOW, RED, True, (RED, RED)),
            ('cross', RED, RED, False, (RED, RED)),
            ('cross', RED, RED, True, (RED, GREEN)),
            ('parallel', RED, GREEN, False, (RED, GREEN)),
            ('parallel', RED, GREEN, True, (RED, YELLOW)),
            ('parallel', RED, YELLOW, False, (RED, YELLOW)),
            ('parallel', RED, YELLOW, True, (RED, RED)),
            ('parallel', RED, RED, False, (RED, RED)),
            ('parallel', RED, RED, True, (GREEN, RED)),
        ):
            red_phase = row[0]
            current_parallel = row[1]
            current_cross = row[2]
            timer_done = row[3]

traffic_light/tests/test_traffic_light.py

            with self.subTest(
                red_phase=red_phase,
                current_parallel=current_parallel,
                current_cross=current_cross,
                timer_done=timer_done,
            ):
                self.assertEqual(
                    src.traffic_light.control(
                        red_phase=red_phase,
                        current_parallel=current_parallel,
                        current_cross=current_cross,
                        timer_done=timer_done,
                    ),
                    'BOOM!!!'
                )

    def test_parallel_green_cross_red_timer_not_done(self):

the terminal is my friend, and shows AssertionError

terminal

SUBFAILED(
    red_phase='cross', current_parallel='GREEN',
    current_cross='RED', timer_done=False
) ...AssertionError: ('GREEN', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='cross', current_parallel='GREEN',
    current_cross='RED', timer_done=True
) ...AssertionError: ('YELLOW', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='cross', current_parallel='YELLOW',
    current_cross='RED', timer_done=False
) ...AssertionError: ('YELLOW', 'RED') != 'BOOM!!!'

terminal

SUBFAILED(
    red_phase='cross', current_parallel='YELLOW',
    current_cross='RED', timer_done=True
) ...AssertionError: ('RED', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='cross', current_parallel='RED',
    current_cross='RED', timer_done=False
) ...AssertionError: ('RED', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='cross', current_parallel='RED',
    current_cross='RED', timer_done=True
) ...AssertionError: ('RED', 'GREEN') != 'BOOM!!!'

terminal

SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='GREEN', timer_done=False
) ...AssertionError: ('RED', 'GREEN') != 'BOOM!!!'
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='GREEN', timer_done=True
) ...AssertionError: ('RED', 'YELLOW') != 'BOOM!!!'
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='YELLOW', timer_done=False
) ...AssertionError: ('RED', 'YELLOW') != 'BOOM!!!'

terminal

SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='YELLOW', timer_done=True
) ...AssertionError: ('RED', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='RED', timer_done=False
) ...AssertionError: ('RED', 'RED') != 'BOOM!!!'
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='RED', timer_done=True
) ...AssertionError: ('GREEN', 'RED') != 'BOOM!!!'

GREEN: make it pass

I change the expectation of the assertion in test_traffic_light_control

traffic_light/tests/test_traffic_light.py

                self.assertEqual(
                    src.traffic_light.control(
                        red_phase=red_phase,
                        current_parallel=current_parallel,
                        current_cross=current_cross,
                        timer_done=timer_done,
                    ),
                    row[4]
                )

    def test_parallel_green_cross_red_timer_not_done(self):

the test passes.

REFACTOR: make it better

I leave test_traffic_light_failsafe and remove the other tests because they are now covered by test_traffic_light_control

traffic_light/tests/test_traffic_light.py

                self.assertEqual(
                    src.traffic_light.control(
                        red_phase=red_phase,
                        current_parallel=current_parallel,
                        current_cross=current_cross,
                        timer_done=timer_done,
                    ),
                    row[4]
                )

    def test_traffic_ligfailsafe(self):

I add a git commit message

terminal

git commit -am \
'extract test_traffic_light_control'

test_traffic_light_failsafe with for loops

RED: make it fail

I add for loops to test_traffic_light_failsafe

traffic_light/tests/test_traffic_light.py

    def test_traffic_light_failsafe(self):
        inputs = (GREEN, YELLOW, 'bad input')
        for red_phase in ('cross', 'parallel', 'bad input'):
            for current_parallel in inputs:
                for current_cross in inputs:
                    for timer_done in (False, True):
                        with self.subTest(
                            red_phase=red_phase,
                            current_parallel=current_parallel,
                            current_cross=current_cross,
                            timer_done=timer_done,
                        ):

traffic_light/tests/test_traffic_light.py

                            self.assertEqual(
                                src.traffic_light.control(
                                    red_phase=red_phase,
                                    current_parallel=current_parallel,
                                    current_cross=current_cross,
                                    timer_done=timer_done,
                                ),
                                'BOOM!!!'
                            )

        self.assertEqual(
            src.traffic_light.control(
                red_phase='cross',
                current_parallel='BAP',
                current_cross=RED,
                timer_done=False,
            ),
            (RED, RED)
        )

the terminal is my friend, and shows AssertionError for fifty four sub tests.

GREEN: make it pass

I change the expectation of the new assertion in test_traffic_light_failsafe

traffic_light/tests/test_traffic_light.py

                            self.assertEqual(
                                src.traffic_light.control(
                                    red_phase=red_phase,
                                    current_parallel=current_parallel,
                                    current_cross=current_cross,
                                    timer_done=timer_done,
                                ),
                                (RED, RED)
                            )

        self.assertEqual(
            src.traffic_light.control(
                red_phase='cross',
                current_parallel='BAP',
                current_cross=RED,
                timer_done=False,
            ),
            (RED, RED)
        )

the test passes.

REFACTOR: make it better

I remove the other assertions from test_traffic_light_failsafe because they are now covered by the for loops

traffic_light/tests/test_traffic_light.py

                            self.assertEqual(
                                src.traffic_light.control(
                                    red_phase=red_phase,
                                    current_parallel=current_parallel,
                                    current_cross=current_cross,
                                    timer_done=timer_done,
                                ),
                                (RED, RED)
                            )


# Exceptions seen
# AssertionError
# NameError
# AttributeError
# TypeError

I add a git commit message

git commit -am \
'test_traffic_light_failsafe with for loops'

test traffic light with walk signal

What if the Traffic Light has a walk signal to let people know that it is safe to cross the street, the truth table would then be

red	current	current		next	next	walk
phase	parallel	cross	timer	parallel	cross
‘cross’	GREEN	RED	NOT done	GREEN	RED	WALK
‘cross’	GREEN	RED	done	YELLOW	RED	DO NOT WALK
‘cross’	YELLOW	RED	NOT done	YELLOW	RED	DO NOT WALK
‘cross’	YELLOW	RED	done	safety RED	safety RED	DO NOT WALK
‘cross’	RED	RED	NOT done	safety RED	safety RED	DO NOT WALK
‘cross’	RED	RED	done	RED	GREEN	DO NOT WALK

red	current	current		next	next	walk
phase	parallel	cross	timer	parallel	cross
‘parallel’	RED	GREEN	NOT done	RED	GREEN	DO NOT WALK
‘parallel’	RED	GREEN	done	RED	YELLOW	DO NOT WALK
‘parallel’	RED	YELLOW	NOT done	RED	YELLOW	DO NOT WALK
‘parallel’	RED	YELLOW	done	safety RED	safety RED	DO NOT WALK
‘parallel’	RED	RED	NOT done	safety RED	safety RED	DO NOT WALK
‘parallel’	RED	RED	done	GREEN	RED	WALK

The Traffic Light only shows WALK if the RED phase is 'parallel' AND the current cross is RED AND the timer is done AND the next cross will stay RED OR if the RED phase is 'cross' AND the current parallel is GREEN AND the timer is NOT done AND the next cross will stay RED which means there will be no car moving across the road the person is crossing.

RED: make it fail

I add global variables for 'WALK' and 'DO NOT WALK'

traffic_light/tests/test_traffic_light.py

import src.traffic_light
import unittest

GREEN, YELLOW, RED = 'GREEN', 'YELLOW', 'RED'
WALK, NOT_WALK = 'WALK', 'DO NOT WALK'

class TestTrafficLight(unittest.TestCase):

I add WALK and NOT_WALK to the expectations of test_traffic_light_control

traffic_light/tests/test_traffic_light.py

    def test_traffic_light_control(self):
        for row in (
            ('cross', GREEN, RED, False, (GREEN, RED, WALK)),
            ('cross', GREEN, RED, True, (YELLOW, RED, NOT_WALK)),
            ('cross', YELLOW, RED, False, (YELLOW, RED, NOT_WALK)),
            ('cross', YELLOW, RED, True, (RED, RED, NOT_WALK)),
            ('cross', RED, RED, False, (RED, RED, NOT_WALK)),
            ('cross', RED, RED, True, (RED, GREEN, NOT_WALK)),
            ('parallel', RED, GREEN, False, (RED, GREEN, NOT_WALK)),
            ('parallel', RED, GREEN, True, (RED, YELLOW, NOT_WALK)),
            ('parallel', RED, YELLOW, False, (RED, YELLOW, NOT_WALK)),
            ('parallel', RED, YELLOW, True, (RED, RED, NOT_WALK)),
            ('parallel', RED, RED, False, (RED, RED, NOT_WALK)),
            ('parallel', RED, RED, True, (GREEN, RED, WALK)),
        ):

the terminal is my friend, and shows AssertionError

terminal

SUBFAILED(
    red_phase='cross', current_parallel='GREEN',
    current_cross='RED', timer_done=False
) ...AssertionError: Tuples differ: ('GREEN', 'RED')
                                 != ('GREEN', 'RED', 'WALK')
SUBFAILED(
    red_phase='cross', current_parallel='GREEN',
    current_cross='RED', timer_done=True
) ...AssertionError: Tuples differ: ('YELLOW', 'RED')
                                 != ('YELLOW', 'RED', 'DO NOT WALK')
SUBFAILED(
    red_phase='cross', current_parallel='YELLOW',
    current_cross='RED', timer_done=False
) ...AssertionError: Tuples differ: ('YELLOW', 'RED')
                                 != ('YELLOW', 'RED', 'DO NOT WALK')

terminal

SUBFAILED(
    red_phase='cross', current_parallel='YELLOW',
    current_cross='RED', timer_done=True
) ...AssertionError: Tuples differ: ('RED', 'RED')
                                 != ('RED', 'RED', 'DO NOT WALK')
SUBFAILED(
    red_phase='cross', current_parallel='RED',
    current_cross='RED', timer_done=False
) ...AssertionError: Tuples differ: ('RED', 'RED')
                                 != ('RED', 'RED', 'DO NOT WALK')
SUBFAILED(
    red_phase='cross', current_parallel='RED',
    current_cross='RED', timer_done=True
) ...AssertionError: Tuples differ: ('RED', 'GREEN')
                                 != ('RED', 'GREEN', 'DO NOT WALK')

terminal

SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='GREEN', timer_done=False
) ...AssertionError: Tuples differ: ('RED', 'GREEN')
                                 != ('RED', 'GREEN', 'DO NOT WALK')
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='GREEN', timer_done=True
) ...AssertionError: Tuples differ: ('RED', 'YELLOW')
                                 != ('RED', 'YELLOW', 'DO NOT WALK')
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='YELLOW', timer_done=False
) ...AssertionError: Tuples differ: ('RED', 'YELLOW')
                                 != ('RED', 'YELLOW', 'DO NOT WALK')

terminal

SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='YELLOW', timer_done=True
) ...AssertionError: Tuples differ: ('RED', 'RED')
                                 != ('RED', 'RED', 'DO NOT WALK')
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='RED', timer_done=False
) ...AssertionError: Tuples differ: ('RED', 'RED')
                                 != ('RED', 'RED', 'DO NOT WALK')
SUBFAILED(
    red_phase='parallel', current_parallel='RED',
    current_cross='RED', timer_done=True
) ...AssertionError: Tuples differ: ('GREEN', 'RED')
                                 != ('GREEN', 'RED', 'WALK')

GREEN: make it pass

I open __init__.py from the traffic_light folder in the src folder

I add global variables for 'WALK' and 'DO NOT WALK' in src/traffic_light/__init__.py

traffic_light/src/traffic_light/__init__.py

GREEN, YELLOW, RED = 'GREEN', 'YELLOW', 'RED'
WALK, NOT_WALK = 'WALK', 'DO NOT WALK'


def is_not_safe(parallel, cross):

I add WALK and NOT_WALK to the next_light function

traffic_light/src/traffic_light/__init__.py

def next_light(red_phase, parallel, cross):
    if red_phase == 'cross':
        if parallel == GREEN:
            return YELLOW, RED, NOT_WALK
        if parallel == RED:
            return RED, GREEN, NOT_WALK
    if red_phase == 'parallel':
        if cross == GREEN:
            return RED, YELLOW, NOT_WALK
        if cross == RED:
            return GREEN, RED, WALK
    return RED, RED, NOT_WALK


def control(
        timer_done, red_phase='parallel',
        current_parallel=RED, current_cross=RED,
    ):

the terminal shows AssertionError for six sub tests.

I add NOT_WALK to the if statement for if the timer is NOT done, in the control function

traffic_light/src/traffic_light/__init__.py

def control(
        timer_done, red_phase='parallel',
        current_parallel=RED, current_cross=RED,
    ):
    if triggers_failsafe(current_parallel, current_cross):
        return RED, RED

    if not timer_done:
        return current_parallel, current_cross, NOT_WALK

    if timer_done:

the terminal shows AssertionError

SUBFAILED(
    red_phase='cross', current_parallel='GREEN',
    current_cross='RED', timer_done=False
) ... AssertionError: Tuples differ: ('GREEN', 'RED', 'DO NOT WALK')
                                  != ('GREEN', 'RED', 'WALK')

I add an if statement for if the RED phase is 'cross' AND current_parallel is GREEN to if not timer_done:

traffic_light/src/traffic_light/__init__.py

    if not timer_done:
        if red_phase == 'cross' and current_parallel == GREEN:
            return current_parallel, current_cross, WALK
        return current_parallel, current_cross, NOT_WALK

    if timer_done:

the test passes.

REFACTOR: make it better

I add NOT_WALK to test_traffic_light_failsafe in tests/test_traffic_light.py because I cannot predict what light will be next when such events happen, for example a power failure

traffic_light/tests/test_traffic_light.py

                            self.assertEqual(
                                src.traffic_light.control(
                                    red_phase=red_phase,
                                    current_parallel=current_parallel,
                                    current_cross=current_cross,
                                    timer_done=timer_done,
                                ),
                                (RED, RED, NOT_WALK)
                            )


# Exceptions seen

the terminal shows AssertionError for fifty four sub tests.

I add NOT_WALK to if triggers_failsafe(current_parallel, current_cross): in the control function in src/traffic_light/__init__.py

traffic_light/src/traffic_light/__init__.py

def control(
        timer_done, red_phase='parallel',
        current_parallel=RED, current_cross=RED,
    ):
    if triggers_failsafe(current_parallel, current_cross):
        return RED, RED, NOT_WALK

    if not timer_done:

the test passes.

I add a global variable for RED, RED, NOT_WALK

traffic_light/src/traffic_light/__init__.py

GREEN, YELLOW, RED = 'GREEN', 'YELLOW', 'RED'
WALK, NOT_WALK = 'WALK', 'DO NOT WALK'
FAILSAFE = RED, RED, NOT_WALK


def is_not_safe(parallel, cross):

I use the variable in the default return statement of the next_light function

traffic_light/src/traffic_light/__init__.py

def next_light(red_phase, parallel, cross):
    if red_phase == 'cross':
        if parallel == GREEN:
            return YELLOW, RED, NOT_WALK
        if parallel == RED:
            return RED, GREEN, NOT_WALK
    if red_phase == 'parallel':
        if cross == GREEN:
            return RED, YELLOW, NOT_WALK
        if cross == RED:
            return GREEN, RED, WALK
    return FAILSAFE


def control(
        timer_done, red_phase='parallel',
        current_parallel=RED, current_cross=RED,
    ):

the tests are still green.

I use the variable in the control function

traffic_light/src/traffic_light/__init__.py

def control(
        timer_done, red_phase='parallel',
        current_parallel=RED, current_cross=RED,
    ):
    if triggers_failsafe(current_parallel, current_cross):
        return FAILSAFE

    if not timer_done:
        if red_phase == 'cross' and current_parallel == GREEN:
            return current_parallel, current_cross, WALK
        return current_parallel, current_cross, NOT_WALK

    if timer_done:
        return next_light(
            red_phase, current_parallel, current_cross
        )

    return FAILSAFE

still green.

I add a git commit message

git commit -am \
'test traffic_light with walk signal'

close the project

I close tests/test_traffic_light.py and src/traffic_light/__init__.py
I click in the terminal where the tests are running
I use q on the keyboard to leave the tests. The terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory.

review

I used for loops to make less tests which is simpler and at the same time more complex
I used a tuple to represent all the states of the Traffic Light and its outputs, which is not as easy to read, there has to be a better way

I ran tests for a Traffic Light that changes lights based on what RED phase the traffic is in ('cross' or 'parallel') AND if a timer is done or NOT done

The outputs are the next lights for Parallel and Cross Traffic which gave me this truth table

red	current	current		next	next
phase	parallel	cross	timer	parallel	cross
‘cross’	GREEN	RED	NOT done	GREEN	RED
‘cross’	GREEN	RED	done	YELLOW	RED
‘cross’	YELLOW	RED	NOT done	YELLOW	RED
‘cross’	YELLOW	RED	done	safety RED	safety RED
‘cross’	RED	RED	NOT done	safety RED	safety RED
‘cross’	RED	RED	done	RED	GREEN

red	current	current		next	next
phase	parallel	cross	timer	parallel	cross
‘parallel’	RED	GREEN	NOT done	RED	GREEN
‘parallel’	RED	GREEN	done	RED	YELLOW
‘parallel’	RED	YELLOW	NOT done	RED	YELLOW
‘parallel’	RED	YELLOW	done	safety RED	safety RED
‘parallel’	RED	RED	NOT done	safety RED	safety RED
‘parallel’	RED	RED	done	GREEN	RED

It also makes sure that there is never a case where the lights allow cars to move through the intersection at the same time (to try to avoid accidents).

What if the Traffic Light has a walk button and I push it? What if the Traffic Light changes based on if there is an emergency vehicle? What would the inputs be and what truth table do I get?

code from the chapter

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

what is next?

Would you like to test binary operations from the truth_table project with loops?

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.