how to make a person with generators

I have a problem in person/tests/test_person.py

test_joe, test_jane, test_john and test_mary have the same assertions.
test_when_year_of_birth_is_not_an_integer also has assertions that are basically the same, the only thing that changes are the values for the year_of_birth parameter.

This means that if I add more people or more cases where year_of_birth is not an integer I would have to add more tests.

I want to use one test for each of the three tests for each person, and one test for every case where year_of_birth is not an integer. I can do this with for loops.

A for loop is a way to repeat the same command over an iterable (a collection of items), it is written like this

for item in collection:
    do something

preview

I have these tests by the end of the chapter

person/tests/test_person.py

import datetime
import src.person
import unittest


class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year
    younger_than_18 = this_year - 17
    not_younger_than_18 = this_year - 18

    first_name = 'first_name'
    last_name = 'last_name'
    sex = 'M'

person/tests/test_person.py

    people = (
        (
            # is_citizen, passed_test
            not_younger_than_18, True, True,
            True, True,
        ),
        (
            # is_citizen, not passed_test
            not_younger_than_18, True, False,
            True, False,
        ),
        (
            # not is_citizen, passed_test
            not_younger_than_18, False, True,
            False, True,
        ),

person/tests/test_person.py

        (
            # not is_citizen, not passed_test
            not_younger_than_18, False, False,
            False, False,
        ),
        (
            # underage, is_citizen, passed_test
            younger_than_18, True, True,
            False, False,
        ),
        (
            # underage, not is_citizen, passed_test
            younger_than_18, False, True,
            False, False,
        ),

person/tests/test_person.py

        (
            # underage, is_citizen, not passed_test
            younger_than_18, True, False,
            False, False,
        ),
        (
            # underage, not is_citizen, not passed_test
            younger_than_18, False, False,
            False, False,
        ),
        # year_of_birth is not an integer
        (None, False, False,),
        (2026.0, False, False,),
        ('2026', False, False,),
        ((2026,), False, False,),
    )

    def calculate_age(self, year_of_birth):
        return self.this_year - year_of_birth

person/tests/test_person.py

    def test_person_object(self):
        for a_person in self.people:
            year_of_birth = a_person[0]

            with self.subTest(a_person):
                try:
                    an_instance = src.person.Person(
                        first_name=self.first_name,
                        last_name=self.last_name,
                        sex=self.sex,
                        year_of_birth=year_of_birth,
                        is_citizen=a_person[1],
                        passed_test=a_person[2],
                    )
                except TypeError as error:
                    self.assertEqual(
                        error.args[0],
                        f"'{year_of_birth}' is not an integer"
                    )
                else:
                    self.assertEqual(
                        an_instance.say_hello(),
                        (
                            f'Hello, my name is {self.first_name}'
                            f' {self.last_name} and I am'
                            f' {self.calculate_age(year_of_birth)}.'
                        )
                    )
                    self.assertEqual(an_instance.can_vote(), a_person[3])
                    self.assertEqual(
                        an_instance.can_get_license(), a_person[4]
                    )

person/tests/test_person.py

    def test_say_hello_function(self):
        for a_person in self.people:
            year_of_birth = a_person[0]

            with self.subTest(a_person):
                try:
                    reality = src.person.say_hello(
                        first_name=self.first_name,
                        last_name=self.last_name,
                        year_of_birth=year_of_birth,
                    )
                except TypeError as error:
                    self.assertEqual(
                        error.args[0],
                        f"'{year_of_birth}' is not an integer"
                    )
                else:
                    self.assertEqual(
                        reality,
                        (
                            f'Hello, my name is {self.first_name}'
                            f' {self.last_name} and I am'
                            f' {self.calculate_age(year_of_birth)}.'
                        )
                    )

person/tests/test_person.py

    def test_person_factory(self):
        for a_person in self.people:
            year_of_birth = a_person[0]

            with self.subTest(a_person):
                self.assertEqual(
                    src.person.person(
                        first_name=self.first_name,
                        last_name=self.last_name,
                        sex=self.sex,
                        year_of_birth=year_of_birth,
                    ),
                    (
                        f'{self.first_name}, {self.last_name},'
                        f' {self.sex}, {year_of_birth}'
                    )
                )

person/tests/test_person.py

    def test_if_person_is_not_alive(self):
        for year_of_birth in (
            self.this_year+1,
            self.this_year-121,
        ):
            age = self.calculate_age(year_of_birth)

            with (
                self.subTest(year_of_birth),
                self.assertRaisesRegex(
                    ValueError,
                    f'a {age} year old person is not alive.'
                ),
            ):
                src.person.Person(
                    first_name=self.first_name,
                    last_name=self.last_name,
                    sex=self.sex,
                    year_of_birth=year_of_birth,
                )

person/tests/test_person.py

    def test_dir_person_object(self):
        self.assertEqual(
            dir(src.person.Person),
            [
                '__class__', '__delattr__', '__dict__',
                '__dir__', '__doc__', '__eq__',
                '__firstlineno__', '__format__', '__ge__',
                '__getattribute__', '__getstate__', '__gt__',
                '__hash__', '__init__', '__init_subclass__',
                '__le__', '__lt__', '__module__', '__ne__',
                '__new__', '__reduce__', '__reduce_ex__',
                '__repr__', '__setattr__', '__sizeof__',
                '__static_attributes__', '__str__',
                '__subclasshook__', '__weakref__',
                'can_get_license', 'can_vote', 'check_age',
                'say_hello',
            ]
        )

person/tests/test_person.py

    def test_dir_person_instance(self):
        self.assertEqual(
            dir(
                src.person.Person(
                    first_name='first_name',
                    last_name='last_name',
                    sex='M',
                    year_of_birth=2026,
                )
            ),
            [
                '__class__', '__delattr__', '__dict__',
                '__dir__', '__doc__', '__eq__',
                '__firstlineno__', '__format__', '__ge__',
                '__getattribute__', '__getstate__', '__gt__',
                '__hash__', '__init__', '__init_subclass__',
                '__le__', '__lt__', '__module__', '__ne__',
                '__new__', '__reduce__', '__reduce_ex__',
                '__repr__', '__setattr__', '__sizeof__',
                '__static_attributes__', '__str__',
                '__subclasshook__', '__weakref__',
                'age', 'can_get_license', 'can_vote',
                'check_age', 'first_name', 'is_citizen',
                'last_name', 'passed_test', 'say_hello',
                'sex', 'year_of_birth',
            ]
        )

person/tests/test_person.py

# Exceptions seen
# AssertionError
# NameError
# TypeError
# AttributeError
# SyntaxError

open the project

I open a terminal
I change directory to the project
terminal
```
cd person
```
I open test_person.py from the tests folder

I use pytest-watcher to run the tests automatically

terminal

uv run pytest-watcher . --now --patterns "**/*.py"

extract test_person_factory

The tests for the person function in test_joe, test_jane, test_john and test_mary make a call to the person function then compare the result with a string.

self.assertEqual(
    src.person.person(
        first_name=first_name,
        last_name=last_name,
        sex=sex,
        year_of_birth=year_of_birth,
    ),
    (
        f'{first_name}, {last_name},'
        f' {sex}, {year_of_birth}'
    )
)

I can make one function with a for loop to remove the repetition.

I add a test for the person function to tests/test_person.py

the test is still green.

I made a tuple named people that contains a tuple for joe

people = (
    ('joe', 'blow', 'M', 1996),
)

I use a for loop to repeat the same commands for each item in the people tuple, in this case there is only one item - the tuple for joe
```
for a_person in (
    ('joe', 'blow', 'M', 1996),
):
```

I use the index of each item in joe for the parameters when the test calls the person function

for a_person in people:
├── a_person = ('joe', 'blow', 'M', 1996)
└── self.assert_person_factory_works(
        first_name=a_person[0],     # 'joe'
        last_name=a_person[1],      # 'blow'
        sex=a_person[2],            # 'M'
        year_of_birth=a_person[3],  # 1996
    )
    └── def assert_person_factory_works(
            self, first_name, last_name,
            sex, year_of_birth
        ):
        ├── first_name    = 'joe'   # a_person[0]
        ├── last_name     = 'blow'  # a_person[1]
        ├── sex           = 'M'     # a_person[2]
        ├── year_of_birth = 1996    # a_person[3]
        └── self.assertEqual(
        ┌────── src.person.person(
        │           first_name=first_name,        # 'joe'
        │           last_name=last_name,          # 'blow'
        │           sex=sex,                      # 'M'
        │           year_of_birth=year_of_birth,  # 1996
        │       ),
        │       (
        │           f'{first_name}, {last_name},'
        │           f' {sex}, {year_of_birth}'
        │       )
        │   )
        └────── src/person/__init__.py
                └── def person(
                        first_name, last_name,
                        sex, year_of_birth,
                    ):
                    ├── first_name    = 'joe'   # a_person[0]
                    ├── last_name     = 'blow'  # a_person[1]
                    ├── sex           = 'M'     # a_person[2]
                    ├── year_of_birth = 1996    # a_person[3]
                    └── return (
                            f'{first_name}, {last_name},'
                            f' {sex}, {year_of_birth}'
                        )
                        return 'joe, blow, M, 1996'

I add jane to the tuple of people

still green, because the result when the person function is called with 'jane', 'doe', 'F' and '1991' is 'jane, doe, F, 1991'.

    for a_person in (
┌───┴── ('jane', 'doe', 'F', 1991),
│       ('joe', 'blow', 'M', 1996),
│   ):
├────── a_person = ('jane', 'doe', 'F', 1991)
└────── self.assert_person_factory_works(
            first_name=a_person[0],     # 'jane'
            last_name=a_person[1],      # 'doe'
            sex=a_person[2],            # 'F'
            year_of_birth=a_person[3],  # 1991
        )
        └── def assert_person_factory_works(
                self, first_name, last_name,
                sex, year_of_birth
            ):
            └── self.assertEqual(
            ┌────── src.person.person(
            │           first_name=first_name,        # 'jane'
            │           last_name=last_name,          # 'doe'
            │           sex=sex,                      # 'F'
            │           year_of_birth=year_of_birth,  # 1991
            │       ),
            │       (
            │           f'{first_name}, {last_name},'
            │           f' {sex}, {year_of_birth}'
            │       )
            │   )
            └────── src/person/__init__.py
                    └── def person(
                            first_name, last_name,
                            sex, year_of_birth,
                        ):
                        ├── first_name    = 'jane'  # a_person[0]
                        ├── last_name     = 'doe'   # a_person[1]
                        ├── sex           = 'F'     # a_person[2]
                        ├── year_of_birth = 1991    # a_person[3]
                        └── return (
                                f'{first_name}, {last_name},'
                                f' {sex}, {year_of_birth}'
                            )
                            return 'jane, doe, M, 1991'

I add a tuple for mary

still green.

    for a_person in (
    │   ('joe', 'blow', 'M', 1996),
    │   ('jane', 'doe', 'F', 1991),
┌───┴── ('mary', 'public', 'F', 2000),
│   ):
├────── a_person = ('mary', 'public', 'F', 2000)
└────── self.assert_person_factory_works(
            first_name=a_person[0],     # 'mary'
            last_name=a_person[1],      # 'public'
            sex=a_person[2],            # 'F'
            year_of_birth=a_person[3],  # 2000
        )
        └── def assert_person_factory_works(
                self, first_name, last_name,
                sex, year_of_birth
            ):
            └── self.assertEqual(
            ┌────── src.person.person(
            │           first_name=first_name,        # 'mary'
            │           last_name=last_name,          # 'public'
            │           sex=sex,                      # 'F'
            │           year_of_birth=year_of_birth,  # 2000
            │       ),
            │       (
            │           f'{first_name}, {last_name},'
            │           f' {sex}, {year_of_birth}'
            │       )
            │   )
            └────── src/person/__init__.py
                    └── def person(
                            first_name, last_name,
                            sex, year_of_birth,
                        ):
                        ├── first_name    = 'mary'    # a_person[0]
                        ├── last_name     = 'public'  # a_person[1]
                        ├── sex           = 'F'       # a_person[2]
                        ├── year_of_birth = 2000      # a_person[3]
                        └── return (
                                f'{first_name}, {last_name},'
                                f' {sex}, {year_of_birth}'
                            )
                            return 'mary, public, M, 2000'

I add a tuple for john

green, showing that for each tuple in the people tuple, the assertion is True.

    for a_person in (
    │   ('joe', 'blow', 'M', 1996),
    │   ('jane', 'doe', 'F', 1991),
    │   ('mary', 'public', 'F', 2000),
┌───┴── ('john', 'smith', 'M', 1980),
│   ):
├────── a_person = ('john', 'smith', 'M', 1980)
└────── self.assert_person_factory_works(
            first_name=a_person[0],     # 'john'
            last_name=a_person[1],      # 'smith'
            sex=a_person[2],            # 'M'
            year_of_birth=a_person[3],  # 1980
        )
        └── def assert_person_factory_works(
                self, first_name, last_name,
                sex, year_of_birth
            ):
            └── self.assertEqual(
            ┌────── src.person.person(
            │           first_name=first_name,        # 'john'
            │           last_name=last_name,          # 'smith'
            │           sex=sex,                      # 'M'
            │           year_of_birth=year_of_birth,  # 1980
            │       ),
            │       (
            │           f'{first_name}, {last_name},'
            │           f' {sex}, {year_of_birth}'
            │       )
            │   )
            └────── src/person/__init__.py
                    └── def person(
                            first_name, last_name,
                            sex, year_of_birth,
                        ):
                        ├── first_name    = 'john'    # a_person[0]
                        ├── last_name     = 'smith'  # a_person[1]
                        ├── sex           = 'M'       # a_person[2]
                        ├── year_of_birth = 1980      # a_person[3]
                        └── return (
                                f'{first_name}, {last_name},'
                                f' {sex}, {year_of_birth}'
                            )
                            return 'john, smith, M, 1980'

I add a tuple for a person with a string as the year_of_birth

the test is still green, because the person function returns a string with the inputs it gets.
I remove the call to the assert_person_factory_works method from test_joe since it is now a repetition
I remove the call to the assert_person_factory_works method from test_jane since it is now a repetition
I remove the call to the assert_person_factory_works method from test_john since it is now a repetition
I remove the call to the assert_person_factory_works method from test_mary since it is now a repetition
I no longer need the assert_person_factory_works method because it is only used by test_person_factory

the terminal is my friend, and shows AssertionError
```
AssertionError: 'jane, doe, F, 1991' != None
```
I change the expectation of the assertion to 'jane, doe, F, 1991'

the terminal shows AssertionError
```
AssertionError: 'joe, blow, M, 1996' != 'jane, doe, F, 1991'
```
because the for loop moved to the next item in the people tuple ('joe')
I change the expectation to the f-string from the assert_person_factory_works method

the test passes.
I remove the call to the assert_person_factory_works method from test_person_factory

the tests are still green.
I remove the assert_person_factory_works method from the TestPerson object

I add a git commit message

terminal

git commit -am 'extract test_person_factory'

The for loop allows me to test any number of people with the same test. I no longer have to write one test for each person.

extract test_say_hello_function

The tests for the say_hello function in test_joe, test_jane, test_john and test_mary make a call to the say_hello function then compare the result with a string.

self.assertEqual(
    src.person.say_hello(
        first_name=first_name,
        last_name=last_name,
        year_of_birth=year_of_birth,
    ),
    (
        f'Hello, my name is {first_name}'
        f' {last_name} and I am'
        f' {self.calculate_age(year_of_birth)}.'
    )
)

I can make one function with a for loop to remove the repetition.

RED: make it fail

I add a test for the say_hello function

      def assert_person_can_say_hello(
              self,first_name, last_name,
              sex, year_of_birth,
          ):
          self.assertEqual(
              src.person.Person(
                  first_name=first_name,
                  last_name=last_name,
                  sex=sex,
                  year_of_birth=year_of_birth,
              ).say_hello(),
              (
                  f'Hello, my name is {first_name}'
                  f' {last_name} and I am'
                  f' {self.calculate_age(year_of_birth)}.'
              )
          )

      def test_say_hello_function(self):
          people = (
              ('jane', 'doe', 'F', 1991),
              ('joe', 'blow', 'M', 1996),
              ('mary', 'public', 'F', 2000),
              ('john', 'smith', 'M', 1980),
              ('first_name', 'last_name', 'F', 'a_string')
          )
          for a_person in people:
              first_name = a_person[0]
              last_name = a_person[1]
              year_of_birth = a_person[3]

              self.assert_say_hello_works(
                  first_name=first_name,
                  last_name=last_name,
                  year_of_birth=year_of_birth,
              )

      def test_person_factory(self):

the terminal is my friend, and shows TypeError

E           TypeError

because

the the say_hello function calls the calculate_age function

the calculate_age function raises TypeError when year_of_birth is not an integer. year_of_birth is a string in the last tuple in the people tuple (('first_name', 'last_name', 'F', 'a_string'))

    for person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
    │   ('john', 'smith', 'M', 1980),
┌───┴── ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── a_person = ('first_name', 'last_name', 'F', 'a string')
├────── first_name = a_person[0]    # 'first_name'
├────── last_name = a_person[1]     # 'last_name'
├────── year_of_birth = a_person[3] # 'a string'
└────── self.assert_say_hello_works(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        └── def assert_person_factory_works(
                self, first_name, last_name,
                sex, year_of_birth
            ):
            └── self.assertEqual(
            ┌────── src.person.say_hello(
            │           first_name=first_name,
            │           last_name=last_name,
            │           year_of_birth=year_of_birth,
            │       ),
            │       (
            │           f'Hello, my name is {first_name}'
            │           f' {last_name} and I am'
            │           f' {self.calculate_age(year_of_birth)}.'
            │       )
            │   )
            └────── src/person/__init__.py
                    └── def say_hello(
                                first_name, last_name, year_of_birth
                            ):
                            ├── first_name    = 'first_name'  # a_person[0]
                            ├── last_name     = 'last_name'   # a_person[1]
                            ├── year_of_birth = 'a string'    # a_person[3]
                            └── return (
                                    f'Hello, my name is {first_name}'
                                    f' {last_name} and I am'
                                    f' {calculate_age(year_of_birth)}.'
                                )   │
                                    └── def calculate_age(year_of_birth):
                                        ├── year_of_birth = 'a string'
                                        └── if not isinstance(
                                                year_of_birth, int
                                            ):
                                            └── raise TypeError
                                            ...

GREEN: make it pass

I open __init__.py from the person folder in the src folder
I add a message to the calculate_age function for when TypeError is raised, in src/person/__init__.py

the terminal is my friend, and shows TypeError
```
TypeError: 'a string' is not an integer
```
better.
I change the statements in the assert_say_hello_works method to a try statement with an else clause in tests/test_person.py

the test passes.

REFACTOR: make it better

I want to test the error message to make sure the assert_say_hello_works method only catches TypeError with this specific message. I can use the Exception in the except block as an object to do this

the test is still green.
I add assertEqual to the except block with the dir built-in function to see the attributes and methods of the Exception object in the except block

the terminal is my friend, and shows AssertionError with the list of attributes and methods. Three of the names stand out because they do not have double underscores (__) before and after - add_note, args and with_traceback.

I change the assertion to see what add_note is

the terminal is my friend, and shows AssertionError

AssertionError:
    <built-in method add_note
      of TypeError object at 0xffff7ed65c43>
 != None

because add_note is a method.

I call the add_note method

the terminal is my friend, and shows TypeError
```
TypeError: BaseException.add_note() takes
           exactly one argument (0 given)
```
this is not what I want, on to the next one.
I change the assertion to see what args is

the terminal is my friend, and shows AssertionError
```
AssertionError: ("'a string' is not an integer",) != None
```
fantastic! args is a tuple that has the error message as its first and only item.
I use the index of the error message with an f-string

the test passes.

I change the message for TypeError in the calculate_age function in src/person/__init__.py to test my change

the terminal is my friend, and shows AssertionError

AssertionError: 'BOOM!!!' != "'a string' is not an integer"

because the error message is not correct

    for a_person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
    │   ('john', 'smith', 'M', 1980),
┌───┴── ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'first_name'
├────── last_name = a_person[1]     # 'last_name'
├────── year_of_birth = a_person[3] # 'a string'
└────── self.assert_say_hello_works(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        └── def assert_say_hello_works(
                self, first_name, last_name,
                year_of_birth,
            ):
            └── try:
                    reality = src.person.say_hello(
                        first_name=first_name,
                        last_name=last_name,
                        year_of_birth=year_of_birth,
                    )
                    └── src/person/__init__.py
                          └── def say_hello(
                                  first_name, last_name, year_of_birth,
                              ):
                              └── return (
                                  ├── f'Hello, my name is {first_name}'
                                  ├── f' {last_name} and I am'
                                  └── f' {calculate_age(year_of_birth)}.'
                                  )   │
                                      └── def calculate_age(year_of_birth):
                                          ├── year_of_birth = 'a string'
                                          └── if not isinstance(
                                                  year_of_birth, int
                                              ):
              ┌───────────────────────────────┴── raise TypeError('BOOM!!!')
              └── except TypeError as error:
                  └── self.assertEqual(
                          error.args[0],
                          f"'{year_of_birth}' is not an integer"
                      )
                      └── raise AssertionError
                  else:
                      ...

I undo the change

the test is green again.
I remove the call to the assert_say_hello_works method from test_joe since it is now a repetition
I remove the call to the assert_say_hello_works method from test_jane since it is now a repetition
I remove the call to the assert_say_hello_works method from test_john since it is now a repetition
I remove the call to the assert_say_hello_works method from test_mary since it is now a repetition
I no longer need the assert_say_hello_works method because it is only used by test_say_hello_function

the terminal is my friend, and shows AssertionError
```
AssertionError: 'Hello, my name is jane doe and I am YY.' != None
```
I change the expectation to 'Hello, my name is jane doe and I am YY.'

the terminal shows AssertionError
```
AssertionError: 'Hello, my name is joe blow and I am XX.'
             != 'Hello, my name is jane doe and I am YY.'
```
because the for loop moved to the next item in the people tuple ('joe')
I change the expectation to the f-string from the assert_say_hello_works method

the test passes.
I remove the call to the assert_say_hello_works method from test_say_hello_function
I remove the assert_say_hello_works method from the TestPerson object

I add a git commit message

terminal

git commit -am 'extract test_say_hello_function'

For each person in the people tuple, this test calls the say_hello function

If the call raises TypeError, it asserts that the error message is correct

If the error message is not correct it raises AssertionError

If the error message is correct the test passes

    for a_person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
    │   ('john', 'smith', 'M', 1980),
┌───┴── ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'first_name'
├────── last_name = a_person[1]     # 'last_name'
├────── year_of_birth = a_person[3] # 'a string'
└────── try:
            reality = src.person.say_hello(
                first_name=first_name,
                last_name=last_name,
                year_of_birth=year_of_birth,
            )
            └── src/person/__init__.py
                  └── def say_hello(
                          first_name, last_name, year_of_birth,
                      ):
                      ├── first_name    = 'first_name'  # a_person[0]
                      ├── last_name     = 'last_name'   # a_person[1]
                      ├── year_of_birth = 'a string'    # a_person[3]
                      └── return (
                          ├── f'Hello, my name is {first_name}'
                          ├── f' {last_name} and I am'
                          └── f' {calculate_age(year_of_birth)}.'
                          )   │
                              └── def calculate_age(year_of_birth):
                                  ├── year_of_birth = 'a string'
                                  └── if not isinstance(
                                          year_of_birth, int
                                      ):
    ┌─────────────────────────────────┴── raise TypeError(
    │                                       f"'{year_of_birth}'"
    │                                       " is not an integer"
    │                                   )
    └── except TypeError as error:
        └── self.assertEqual(
                error.args[0],
                f"'{year_of_birth}' is not an integer"
            )
        else:
            ...

If the call to the calculate_age function from the say_hello function does not raise TypeError, it asserts that the result of the call matches the expectation

    for person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
┌───┴── ('john', 'smith', 'M', 1980),
│       ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'john'
├────── last_name = a_person[1]     # 'smith'
├────── year_of_birth = a_person[3] # 1980
└───┬── try:
    │       reality = src.person.say_hello(
    │           first_name=first_name,
    │           last_name=last_name,
    │           year_of_birth=year_of_birth,
    │       )
    │       └── src/person/__init__.py
    │             └── def say_hello(
    │                     first_name, last_name, year_of_birth,
    │                 ):
    │                 ├── first_name    = 'john'  # a_person[0]
    │                 ├── last_name     = 'smith' # a_person[1]
    │                 ├── year_of_birth = 1980    # a_person[3]
    │                 └── return (
    │                     ├── f'Hello, my name is {first_name}'
    │                     ├── f' {last_name} and I am'
    │                     └── f' {calculate_age(year_of_birth)}.'
    │                     )   │
    │                         └── def calculate_age(year_of_birth):
    │                             ├── year_of_birth = 1980 # a_person[3]
    │                             ├── ...
    │                             └── return age
    │   except TypeError as error:
    │       ...
    └── else:
        └── self.assertEqual(
                reality,
                (
                    f'Hello, my name is {first_name}'
                    f' {last_name} and I am'
                    f' {self.calculate_age(year_of_birth)}.'
                )   │
            )       └── def calculate_age(self, year_of_birth):
                        ├── year_of_birth = 1980  # a_person[3]
                        └── return self.this_year - year_of_birth

extract test_say_hello_method

The tests in test_joe, test_jane, test_john and test_mary make an instance of the Person object, then call its say_hello method comparing the results in assertions

self.assertEqual(
    src.person.Person(
        first_name=first_name,
        last_name=last_name,
        sex=sex,
        year_of_birth=year_of_birth,
    ).say_hello(),
    (
        f'Hello, my name is {first_name}'
        f' {last_name} and I am'
        f' {self.calculate_age(year_of_birth)}.'
    )
)

I can make one function with a for loop to remove the repetition.

RED: make it fail

I add a test for the say_hello method of the Person object

      def assert_person_can_say_hello(
              self,first_name, last_name,
              sex, year_of_birth,
          ):
          self.assertEqual(
              src.person.Person(
                  first_name=first_name,
                  last_name=last_name,
                  sex=sex,
                  year_of_birth=year_of_birth,
              ).say_hello(),
              (
                  f'Hello, my name is {first_name}'
                  f' {last_name} and I am'
                  f' {self.calculate_age(year_of_birth)}.'
              )
          )

      def test_say_hello_method(self):
          people = (
              ('jane', 'doe', 'F', 1991),
              ('joe', 'blow', 'M', 1996),
              ('mary', 'public', 'F', 2000),
              ('john', 'smith', 'M', 1980),
              ('first_name', 'last_name', 'F', 'a_string')
          )
          for a_person in people:
              first_name = a_person[0]
              last_name = a_person[1]
              sex = a_person[2]
              year_of_birth = a_person[3]

              self.assert_person_can_say_hello(
                  first_name=first_name,
                  last_name=last_name,
                  sex=sex,
                  year_of_birth=year_of_birth
              )

      def test_say_hello_function(self):

the terminal is my friend, and shows TypeError

E           TypeError: 'a_string' is not an integer

this is the correct Exception for when the year_of_birth is not an integer. I need a better way to know which item in the people tuple raised the Exception.

the subTest method

unittest.TestCase has a method that I can use to show what items in a loop cause a failure in a test. It gives me a way to name each sub test in each loop.

I add a call to the unittest.TestCase.subTest method in test_say_hello_method

the terminal is my friend, and shows TypeError
```
SUBFAILED(first_name='first_name') ...test_say_hello_method -
    TypeError: 'a string' is not an integer
```
better. SUBFAILED(first_name='first_name') shows the value I gave in with self.subTest(first_name=first_name) as the label for the sub test. I can use any name and values I want.

I add year_of_birth to the call to the subTest method

the terminal still shows AssertionError with the extra name and value.

SUBFAILED(first_name='first_name', year_of_birth='a string') ...
    test_say_hello_method - TypeError: 'a string' is not an integer

this is clearer.

GREEN: make it pass

I move the statements in the assert_person_can_say_hello method to a try…except…else clause like I did for test_say_hello_function

the test passes.

REFACTOR: make it better

I change the error message for if the value of the year_of_birth parameter is not an integer in the calculate_age function, in src/person/__init__.py

the terminal is my friend, and shows ASsertionError

SUBFAILED(first_name='first_name', year_of_birth='a string') ...
    test_say_hello_method - AssertionError:
        'BAP!!!' != "'a string' is not an integer"
FAILED tests/test_person.py...
    test_say_hello_function - AssertionError:
        'BAP!!!' != "'a string' is not an integer"

because the error messages do not match

    for a_person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
    │   ('john', 'smith', 'M', 1980),
┌───┴── ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'first_name'
├────── last_name = a_person[1]     # 'last_name'
├────── sex = a_person[2]           # 'F'
├────── year_of_birth = a_person[3] # 'a string'
└────── with self.subTest(
            first_name=first_name,
            year_of_birth=year_of_birth,
        ):
        └── self.assert_person_can_say_hello(
                first_name=first_name,
                last_name=last_name,
                sex=sex,
                year_of_birth=year_of_birth
            )
            └── def assert_person_can_say_hello(
                    self,first_name, last_name,
                    sex, year_of_birth,
                ):
                └── try:
                        reality = src.person.Person(
                            first_name=first_name,
                            last_name=last_name,
                            sex=sex,
                            year_of_birth=year_of_birth,
                        ).say_hello()
                        └── src/person/__init__.py
                              └── class Person:
                                  └── def __init__(
                                          self, first_name, last_name,
                                          sex, year_of_birth=None,
                                          is_citizen=True, passed_test=False,
                                      ):
                                      ├── self.first_name = first_name
                                      ├── self.last_name = last_name
                                      ├── self.year_of_birth = year_of_birth
                                      ├── self.sex = sex
                                      ├── self.is_citizen = is_citizen
                                      ├── self.passed_test = passed_test
                                      └── self.age = calculate_age(
                                              year_of_birth
                                          )
                                          └── def calculate_age(year_of_birth):
                                              ├── year_of_birth = 'a string'
                                              └── if not isinstance(
                                                      year_of_birth, int
                                                  ):
                ┌─────────────────────────────────┴── raise TypeError('BAP!!!')
                └── except TypeError as error:
                    └── self.assertEqual(
                            error.args[0],
                            f"'{year_of_birth}' is not an integer"
                        )
                        └── raise AssertionError
                    else:
                        ...

I want test_say_hello_function to also show which person raises an Exception. I add a call to the subTest method from test_say_hello_function in tests/test_person.py

the terminal shows AssertionError with the first name and year_of_birth of the person that raised the Exception

SUBFAILED(first_name='first_name', year_of_birth='a string') ...
    test_say_hello_method - AssertionError:
        'BAP!!!' != "'a string' is not an integer"
SUBFAILED(first_name='first_name', year_of_birth='a string') ...
    test_say_hello_function - AssertionError:
        'BAP!!!' != "'a string' is not an integer"

I change the error message in the calculate_age function for if the value of the year_of_birth parameter is not an integer back to the correct message, in src/person/__init__.py

the tests are green again.
I remove the call to the assert_person_can_say_hello from test_joe
I remove the call to the assert_person_can_say_hello from test_jane
I remove the call to the assert_person_can_say_hello from test_john
I remove the call to the assert_person_can_say_hello from test_mary

I no longer need the assert_person_can_say_hello method because it is only used by test_say_hello_method

the terminal is my friend, and shows AssertionError for each one of the people with an integer for year_of_birth

SUBFAILED(first_name='jane', year_of_birth=1991) ... -
    AssertionError: 'Hello, my name is jane doe and I am YY.' != None
SUBFAILED(first_name='joe', year_of_birth=1996) ... -
    AssertionError: 'Hello, my name is joe blow and I am XX.' != None
SUBFAILED(first_name='mary', year_of_birth=2000) ... -
    AssertionError: 'Hello, my name is mary public and I am ZZ.' != None
SUBFAILED(first_name='john', year_of_birth=1980) ... -
    AssertionError: 'Hello, my name is john smith and I am AA.' != None

I change the expectation of the assertion to 'Hello, my name is jane doe and I am YY.'

the terminal shows AssertionError

SUBFAILED(first_name='joe', year_of_birth=1996) ...test_say_hello_method -
    AssertionError: 'Hello, my name is joe blow and I am XX.'
                 != 'Hello, my name is jane doe and I am YY.'
SUBFAILED(first_name='mary', year_of_birth=2000) ...test_say_hello_method -
    AssertionError: 'Hello, my name is mary public and I am ZZ.'
                 != 'Hello, my name is jane doe and I am YY.'
SUBFAILED(first_name='john', year_of_birth=1980) ...test_say_hello_method -
    AssertionError: 'Hello, my name is john smith and I am AA.'
                 != 'Hello, my name is jane doe and I am YY.'.

the assertion now fails for the other people in the people tuple.

I change the expectation to the f-string from the assert_person_can_say_hello method

the test passes.
I remove the call to the assert_person_factory_works method from test_say_hello_method
I remove the assert_person_can_say_hello method from the TestPerson object

I add a git commit message

terminal

git commit -am 'extract test_say_hello_method'

For each person in the people tuple, this test makes an instance of the Person object which makes an age attribute by calling the calculate_age function with the given year_of_birth parameter.

If the call raises TypeError, it asserts that the error message is correct

If the error message is not correct, it raises AssertionError

If the error message is correct, the test passes

    for a_person in (
    │   ('jane', 'doe', 'F', 1991),
    │   ('joe', 'blow', 'M', 1996),
    │   ('mary', 'public', 'F', 2000),
    │   ('john', 'smith', 'M', 1980),
┌───┴── ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'first_name'
├────── last_name = a_person[1]     # 'last_name'
├────── sex = a_person[2]           # 'F'
├────── year_of_birth = a_person[3] # 'a string'
└────── with self.subTest(
            first_name=first_name,
            year_of_birth=year_of_birth,
        ):
        └── try:
                reality = src.person.Person(
                    first_name=first_name,
                    last_name=last_name,
                    sex=sex,
                    year_of_birth=year_of_birth,
                ).say_hello()
                └── src/person/__init__.py
                      └── class Person:
                          └── def __init__(
                                  self, first_name, last_name,
                                  sex, year_of_birth=None,
                                  is_citizen=True, passed_test=False,
                              ):
                              ├── self.first_name = first_name
                              ├── self.last_name = last_name
                              ├── self.year_of_birth = year_of_birth
                              ├── self.sex = sex
                              ├── self.is_citizen = is_citizen
                              ├── self.passed_test = passed_test
                              └── self.age = calculate_age(
                                      year_of_birth
                                  )
                                  └── def calculate_age(year_of_birth):
                                      ├── year_of_birth = 'a string'
                                      └── if not isinstance(
                                              year_of_birth, int
                                          ):
        ┌─────────────────────────────────┴── raise TypeError(
        │                                        f"'{year_of_birth}'"
        │                                        " is not an integer"
        │                                     )
        └── except TypeError as error:
            └── self.assertEqual(
                    error.args[0],
                    f"'{year_of_birth}' is not an integer"
                )
            else:
                ...

If the call to the calculate_age function from the __init__ method of the Person object does not raise TypeError, it asserts that the result of the call to the say_hello method matches the expectation

    for person in (
    │   ('jane', 'doe', 'F', 1991),
┌───┴── ('joe', 'blow', 'M', 1996),
│       ('mary', 'public', 'F', 2000),
│       ('john', 'smith', 'M', 1980),
│       ('first_name', 'last_name', 'F', 'a string'),
│   ):
├────── first_name = a_person[0]    # 'joe'
├────── last_name = a_person[1]     # 'blow'
├────── sex = a_person[2]           # 'M'
├────── year_of_birth = a_person[3] # 1996
└────── with self.subTest(
            first_name=first_name,
            year_of_birth=year_of_birth,
        ):
        ├── try:
        │       reality = src.person.Person(
        │           first_name=first_name,
        │           last_name=last_name,
        │           sex=sex,
        │           year_of_birth=year_of_birth,
        │       ).say_hello()
        │       ├── src/person/__init__.py
        │       │    └── class Person:
        │       │        └── def __init__(
        │       │               self, first_name, last_name,
        │       │               sex, year_of_birth=None,
        │       │               is_citizen=True, passed_test=False,
        │       │            ):
        │       │            ├── self.first_name = first_name
        │       │            ├── self.last_name = last_name
        │       │            ├── self.year_of_birth = year_of_birth
        │       │            ├── self.sex = sex
        │       │            ├── self.is_citizen = is_citizen
        │       │            ├── self.passed_test = passed_test
        │       │            └── self.age = calculate_age(
        │       │                   year_of_birth
        │       │                )
        │       │                └── def calculate_age(year_of_birth):
        │       │                    ├── year_of_birth = 'a string'
        │       │                    └── if not isinstance(
        │       │                           year_of_birth, int
        │       │                        ):
        │       │                        └── def calculate_age(year_of_birth):
        │       │                            ├── year_of_birth = 1996
        │       │                            ├── ...
        │       │                            └── return age
        │       └── def say_hello(self):
        │           └── return (
        │                   f'Hello, my name is {self.first_name}'
        │                   f' {self.last_name} and I am {self.age}.'
        │               )
        ├── except TypeError as error:
        │       ...
        └── else:
            └── self.assertEqual(
                    reality,
                    (
                        f'Hello, my name is {first_name}'
                        f' {last_name} and I am'
                        f' {self.calculate_age(year_of_birth)}.'
                    )
                )   │
                    └── def calculate_age(self, year_of_birth):
                        ├── year_of_birth = 1996
                        └── return self.this_year - year_of_birth

extract people object attribute

test_person_factory, test_say_hello_function and test_say_hello_method all use the same tuple of persons.

I add an object attribute for the people tuple to the TestPerson object
I use the object attribute for people in the for loop in test_say_hello_method

the test is still green.
I remove the commented lines from test_say_hello_method
I use the object attribute for people in the for loop in test_say_hello_function

still green.
I remove the commented lines from test_say_hello_function
I use the object attribute for people in the for loop in test_person_factory

the test is still green.
I remove the commented lines from test_person_factory

I add a git commit message

terminal

git commit -am 'extract people object attribute'

extract test_if_person_can_vote

The tests in test_joe, test_jane, test_john, test_mary and test_underage_citizen make an instance of the Person object, then call its can_vote method comparing the results in assertions.

an_instance = src.person.Person(
    first_name=first_name,
    last_name=last_name,
    sex=sex,
    year_of_birth=year_of_birth,
    is_citizen=False | True,
    passed_test=False | True,
)
self.assertEqual(an_instance.can_vote(), False | True)

I can make one function with a for loop to remove the repetition.

The can_vote method of the Person object sends two parameters (age and response) when it calls the check_age method to return False or True for if a person cannot vote or can vote based on the following inputs

is the person younger than 18?
is the person a citizen?

The truth table for the can_vote method is

age < 18	is citizen	can vote
True	True	False
True	False	False
False	True	True
False	False	False

RED: make it fail

I add a test with an assertion for if a person is younger than 18 AND is a citizen

age < 18	is citizen	can vote
True	True	False

      def test_person_factory(self):
          for a_person in self.people:
              first_name = a_person[0]
              last_name = a_person[1]
              sex = a_person[2]
              year_of_birth = a_person[3]

              self.assertEqual(
                  src.person.person(
                      first_name=first_name,
                      last_name=last_name,
                      sex=sex,
                      year_of_birth=year_of_birth,
                  ),
                  (
                      f'{first_name}, {last_name},'
                      f' {sex}, {year_of_birth}'
                  )
              )

      def test_if_person_can_vote(self):
          truth_table = (
              (datetime.date.today().year-17, True),
          )
          for row in truth_table:
              with self.subTest(row=row):
                  an_instance = src.person.Person(
                      first_name='first_name',
                      last_name='last_name',
                      sex='F',
                      year_of_birth=row[0],
                      is_citizen=row[1],
                  )
                  self.assertEqual(an_instance.can_vote(), True)

      def test_joe(self):

the terminal is my friend, and shows AssertionError

SUBFAILED(row=(2009, True)) ...AssertionError: False != True

GREEN: make it pass

I change True to False in the assertion for if a person is younger than 18 AND is a citizen

    def test_if_person_can_vote(self):
        truth_table = (
            (datetime.date.today().year-17, True),
        )
        for row in truth_table:
            with self.subTest(row=row):
                an_instance = src.person.Person(
                    first_name='first_name',
                    last_name='last_name',
                    sex='F',
                    year_of_birth=row[0],
                    is_citizen=row[1],
                )
                self.assertEqual(an_instance.can_vote(), False)

    def test_joe(self):

the test passes.

REFACTOR: make it better

I add a tuple to the truth_table tuple for if a person is younger than 18 AND is NOT a citizen

age < 18

is citizen

can vote

True

False

False

the test is still green.
I add a tuple to the truth_table tuple for if a person is NOT younger than 18 AND is a citizen

age < 18

is citizen

can vote

False

True

True

the terminal is my friend, and shows AssertionError
```
SUBFAILED(row=(2008, True)) ...test_if_person_can_vote -
    AssertionError: True != False
```
I add the expectation to the tuples for the rows in the truth_table tuple

I use the index of the new values as the expectation of the assertion

the terminal is my friend, and shows IndexError

SUBFAILED(row=(2009, True, False)) ...test_if_person_can_vote -
    IndexError: tuple index out of range
SUBFAILED(row=(2009, False, False)) ...test_if_person_can_vote -
    IndexError: tuple index out of range
SUBFAILED(row=(2008, True, True)) ...test_if_person_can_vote -
    IndexError: tuple index out of range

I change the index to the right number

the test passes.
I add a tuple to the truth_table tuple for if a person is NOT younger than 18 AND is NOT a citizen

age < 18

is citizen

can vote

False

False

False

still green.
I remove the assertion for the can_vote method from test_joe
I remove the assertion for the can_vote method from test_jane
I remove the assertion for the can_vote method from test_john
I remove the assertion for the can_vote method from test_mary
I remove the assertion for the can_vote method from test_underage_citizen

I add a git commit message

terminal

git commit -am 'extract test_if_person_can_vote'

extract test_if_person_can_get_license

The tests in test_joe, test_jane, test_john, test_mary and test_underage_citizen make an instance of the Person object, then call its can_get_license method comparing the results in assertions.

an_instance = src.person.Person(
    first_name=first_name,
    last_name=last_name,
    sex=sex,
    year_of_birth=year_of_birth,
    is_citizen=False | True,
    passed_test=False | True,
)
self.assertEqual(
    an_instance.can_get_license(), False | True
)

I can make one function with a for loop to remove the repetition.

The can_get_license method of the Person object also sends two parameters when it calls the check_age method to return False or True for if a person cannot get a license or can get a license based on the following inputs

is the person younger than 18?
did the person pass the test?

The truth table for the can_get_license is

age < 18	passed test	can get license
True	True	False
True	False	False
False	True	True
False	False	False

RED: make it fail

I add a test with an assertion for if a person is NOT younger than 18 AND has NOT passed the test

age < 18	passed test	can get license
False	False	False

                  self.assertEqual(an_instance.can_vote(), row[2])

      def test_if_person_can_get_license(self):
          truth_table = (
              (datetime.date.today().year-18, False, False),
          )
          for row in truth_table:
              with self.subTest(row=row):
                  an_instance = src.person.Person(
                      first_name='first_name',
                      last_name='last_name',
                      sex='M',
                      year_of_birth=row[0],
                      passed_test=row[1],
                  )
                  self.assertEqual(
                      an_instance.can_get_license(), True
                  )

      def test_joe(self):

the terminal is my friend, and shows AssertionError

SUBFAILED(row=(2008, False, False)) ...test_if_person_can_get_license
    - AssertionError: False != True

GREEN: make it pass

I change the expectation of the assertion

                self.assertEqual(
                    an_instance.can_get_license(), False
                )

the test passes.

REFACTOR: make it better

I add a tuple to the truth_table tuple for if a person is NOT younger than 18 AND has passed the test

age < 18

passed test

can get license

False

True

True

the terminal is my friend, and shows AssertionError
```
SUBFAILED(row=(2008, True, True)) ...
    test_if_person_can_get_license - AssertionError:
        True != False
```
I use the index to change the expectation to the last item of the row tuple

the test passes.
I add a tuple to the truth_table tuple for if a person is younger than 18 AND has NOT passed the test

age < 18

passed test

can get license

True

False

False

the test is still green.
I add a tuple to the truth_table tuple for if a person is younger than 18 AND has passed the test

age < 18

passed test

can get license

True

True

False

still green.
I remove test_joe, test_jane, test_john, test_mary and test_underage_citizen since they are now repetitions of test_if_person_can_get_license

I add a git commit message

terminal

git commit -am \
'extract test_if_person_can_get_license'

extract truth_table object attribute

The truth_table tuple is used in both test_if_person_can_vote and test_if_person_can_get_license. I can make an object attribute to remove the repetition.

I add an object attribute for the truth_table tuple to the TestPerson object
I use the object attribute for truth_table in the for loop in test_if_person_can_vote

the test is still green.
I remove the commented lines from test_if_person_can_vote
I use the object attribute for truth_table in the for loop in test_if_person_can_get_license

still green.
I remove the commented lines from test_if_person_can_vote

I add a git commit message

terminal

git commit -am \
'extract truth_table object attribute'

extract test_person_object

test_say_hello_method, test_if_person_can_vote and test_if_person_can_get_license make an instance of the Person object, then call methods and compare the results in assertions

reality = src.person.Person(
    first_name=first_name,
    last_name=last_name,
    sex=sex,
    year_of_birth=year_of_birth,
).say_hello()

self.assertEqual(
    reality,
    (
        f'Hello, my name is {first_name}'
        f' {last_name} and I am'
        f' {self.calculate_age(year_of_birth)}.'
    )
)

an_instance = src.person.Person(
    first_name='first_name',
    last_name='last_name',
    sex='M',
    year_of_birth=row[0],
    passed_test=row[1],
)
self.assertEqual(an_instance.can_vote(), row[2])
self.assertEqual(an_instance.can_get_license(), row[-1])

I can make one function with a for loop to remove the repetition.

RED: make it fail

I add a test with the code from test_say_hello_method for the Person object

  def calculate_age(self, year_of_birth):
      return self.this_year - year_of_birth

  def test_person_object(self):
      for a_person in self.people:
          first_name = a_person[0]
          last_name = a_person[1]
          sex = a_person[2]
          year_of_birth = a_person[3]

          with self.subTest(
              first_name=first_name,
              year_of_birth=year_of_birth,
          ):
              try:
                  an_instance = src.person.Person(
                      first_name=first_name,
                      last_name=last_name,
                      sex=sex,
                      year_of_birth=year_of_birth,
                  )
              except TypeError as error:
                  self.assertEqual(
                      error.args[0],
                      f"'{year_of_birth}' is not an integer"
                  )
              else:
                  self.assertEqual(
                      an_instance.boom(),
                      (
                          f'Hello, my name is {first_name}'
                          f' {last_name} and I am'
                          f' {self.calculate_age(year_of_birth)}.'
                      )
                  )

  def test_say_hello_method(self):

the terminal is my friend, and shows AttributeError

SUBFAILED(first_name='jane', year_of_birth=1991)
    AttributeError: 'Person' object has no attribute 'boom'
SUBFAILED(first_name='joe', year_of_birth=1996)
    AttributeError: 'Person' object has no attribute 'boom'
SUBFAILED(first_name='mary', year_of_birth=2000)
    AttributeError: 'Person' object has no attribute 'boom'
SUBFAILED(first_name='john', year_of_birth=1980)
    AttributeError: 'Person' object has no attribute 'boom'

GREEN: make it pass

I change boom to say_hello in the assertion

                else:
                    self.assertEqual(
                        an_instance.say_hello(),
                        (
                            f'Hello, my name is {first_name}'
                            f' {last_name} and I am'
                            f' {self.calculate_age(year_of_birth)}.'
                        )
                    )

    def test_say_hello_method(self):

the test passes.

REFACTOR: make it better

I remove test_say_hello_method because it is now a repetition

I add an assertion for the can_vote method to test_person_object

the terminal is my friend, and shows AssertionError

SUBFAILED(first_name='jane', year_of_birth=1991)
    AssertionError: True != False
SUBFAILED(first_name='joe', year_of_birth=1996)
    AssertionError: True != False
SUBFAILED(first_name='mary', year_of_birth=2000)
    AssertionError: True != False
SUBFAILED(first_name='john', year_of_birth=1980)
    AssertionError: True != False

I add values for is_citizen to the people object attribute of the TestPerson object
I use the values for the is_citizen parameter when making an instance of the Person object in test_person_object

the terminal still shows AssertionError
I change the expectation of the assertion for the can_vote method to use the value of the is_citizen variable

the test passes.

I add an assertion for the can_get_license method to test_person_object

the terminal is my friend, and shows AssertionError

SUBFAILED(first_name='jane', year_of_birth=1991)
    AssertionError: False != True
SUBFAILED(first_name='joe', year_of_birth=1996)
    AssertionError: False != True
SUBFAILED(first_name='mary', year_of_birth=2000)
    AssertionError: False != True
SUBFAILED(first_name='john', year_of_birth=1980)
    AssertionError: False != True

I add values for passed_test to the people object attribute of the TestPerson object
I use the values for the passed_test parameter when making an instance of the Person object in test_person_object

the terminal still shows AssertionError
I change the expectation of the assertion for the can_get_license method to use the value of the passed_test variable

the test passes.
test_person_object is missing the cases for if a person younger than 18

age < 18

is citizen

can vote

True

True

False

True

False

False

age < 18

passed test

can get license

True

True

False

True

False

False

which gives this truth table when put together

age < 18

is citizen

passed_test

can vote

can_get_license

True

True

True

False

False

True

False

True

False

False

True

True

False

False

False

True

False

False

False

False

I add tuples for these cases to the people object attribute

the terminal is my friend, and shows AssertionError
```
SUBFAILED(first_name='first_name', year_of_birth=YYYY) ...
    AssertionError: False != True
SUBFAILED(first_name='first_name', year_of_birth=YYYY) ...
    AssertionError: False != True
SUBFAILED(first_name='first_name', year_of_birth=YYYY) ...
    AssertionError: False != True
```
I need a better error message, so I know which tuples caused the failures.

I change the names in the subTest method to show the entire tuple in test_person_object

the terminal shows

SUBFAILED[('first_name', 'last_name', 'M', YYYY, True, True)] ...
    AssertionError: False != True
SUBFAILED[('first_name', 'last_name', 'M', YYYY, False, True)] ...
    AssertionError: False != True
SUBFAILED[('first_name', 'last_name', 'M', YYYY, True, False)] ...
    AssertionError: False != True

because I used the value for the is_citizen variable as the expectation of the assertion for the can_vote method which is wrong when the person is younger than 18, the expectation should always be False.

I add the expectation for all the cases of the can_vote method to the people object attribute
I remove the is_citizen variable then change the expectation of the assertion for the can_vote method in test_person_object to the new item I added to the tuples in the people object attribute

the terminal is my friend, and shows AssertionError
```
SUBFAILED[('first_name', 'last_name', 'M', YYYY, True, True, False)] ...
    AssertionError: False != True
SUBFAILED[('first_name', 'last_name', 'M', YYYY, False, True, False)] ...
    AssertionError: False != True
```
because I used the value for the passed_test variable as the expectation of the assertion for the can_get_license method which is wrong when the person is younger than 18, the expectation should always be False.
I add the expectation for all the cases of the can_get_license method to the people object attribute
I remove the passed_test variable then change the expectation of the assertion for the can_get_license method in test_person_object to the new item I added to the tuples in the people object attribute

the test passes.
I remove the commented lines from test_person_object
I remove test_if_person_can_vote because it is now a repetition
I remove test_if_person_can_get_license because it is now a repetition
I remove the truth_table object_attribute because it is no longer used

I add a git commit message

terminal

git commit -am 'extract test_person_object'

extract object attributes

The people object attribute can be described with the following truth table

If a person is younger than 18

age < 18

is citizen

passed_test

can vote

can_get_license

True

True

True

False

False

True

False

True

False

False

True

True

False

False

False

True

False

False

False

False

If a person is NOT younger than 18

age < 18	is citizen	passed_test	can vote	can_get_license	person
False	True	True	True	True	jane
False	False	True	False	True	mary
False	True	False	True	False	joe
False	False	False	False	False	john

I make an object attribute for datetime.date.today().year-17
I change the comments then use the new object attribute for datetime.date.today().year-17 from the people object attribute

the tests are still green.
I add a new object attribute for if a person is NOT younger than 18
I add comments then use the new object attribute for the year_of_birth values of jane, joe, mary and john in the people object attribute

still green.
I change the values for first_name, last_name and sex to 'first_name', 'last_name', 'M', for all the tuples in the people object attribute

green.
I add object attributes for first_name, last_name and sex
I use the new object attributes for first_name, last_name and sex, move them out of the for loop in test_person_object

still green.
I use the new object attributes for first_name and last_name, then move them out of the for loop in test_say_hello_function

the test is still green.
I use the new object attributes for first_name, last_name and sex, then move them out of the for loop in test_person_factory

still green.
I use the object attributes directly in test_person_factory (I do not need the variables)

green.
I use the object attributes directly in test_say_hello_function
I use the object attributes directly in test_person_object
I remove the values of first_name, last_name amd sex from the tuples in the people object attribute

the terminal is my friend, and shows IndexError and ValueError
```
SUBFAILED[(2008, True, True, True, True)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2008, True, True, True, True)] ...test_say_hello_function -
    ValueError
```
because the positions changed when I changed the tuple. I would have to change all the indexes if I change the tuple, there has to be a better way
I undo the change

the tests are green again.
I change the values for the first three items of the tuples in the people object attribute to the year_of_birth value and the boolean for is_citizen and passed_test

the tests are still green.
I change the indexes for year_of_birth, is_citizen and passed_test in test_person_object

still green.
I change the index for year_of_birth in test_say_hello_function

green.
I change the index for year_of_birth in test_person_factory

still green.

I remove the repeated values from the tuples in the people object attribute

the terminal is my friend, and shows IndexError

SUBFAILED[(2008, True, True, True, True)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2008, True, False, True, False)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2008, False, True, False, True)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2008, False, False, False, False)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2009, True, True, False, False)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2009, False, True, False, False)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2009, True, False, False, False)] ...test_person_object -
    IndexError: tuple index out of range
SUBFAILED[(2009, False, False, False, False)] ...test_person_object -
    IndexError: tuple index out of range

I change the indexes for the expectations of the results to calls of the can_vote and can_get_license methods in test_person_object

the test is green again.

I add a git commit message

terminal

git commit -am 'extract object attributes'

use assertRaises with test_when_person_is_older_than_120

RED: make it fail

I use the assertRaises method to replace the try statement in test_when_person_is_older_than_120

    def test_when_person_is_older_than_120(self):
        # try:
        with self.assertRaises(TypeError):
            src.person.Person(
                first_name='first_name',
                last_name='last_name',
                sex='M',
                year_of_birth=self.this_year-121
            )
        # except ValueError:
        #     pass

    def test_when_year_of_birth_is_the_future(self):

the terminal is my friend, and shows ValueError

E           ValueError

GREEN: make it pass

I change the Exception to match

    def test_when_person_is_older_than_120(self):
        # try:
        with self.assertRaises(ValueError):

the test passes.

REFACTOR: make it better

I change assertRaises to assertRaisesRegex to test the message of the Exception

the terminal is my friend, and shows AssertionError
```
AssertionError:
    "a 121 year old person is too old to be alive."
    does not match ""
```
I add a message to the Exception in the calculate_age function in src/person/__init__.py

the test passes.
I remove the commented lines from test_when_person_is_older_than_120 in tests/test_person.py

I add a git commit message

terminal

git commit -am \
'use assertRaises with test_when_person_is_older_than_120'

use assertRaises with test_when_year_of_birth_is_the_future

RED: make it fail

I use the assertRaisesRegex method to replace the try statement in test_when_year_of_birth_is_the_future

    def test_when_year_of_birth_is_the_future(self):
        # try:
        with self.assertRaisesRegex(
            ValueError, 'BOOM!!!'
        ):
            src.person.Person(
                first_name='first_name',
                last_name='last_name',
                sex='F',
                year_of_birth=self.this_year+1,
            )
        # except ValueError:
        #     pass

    def test_when_year_of_birth_is_not_an_integer(self):

the terminal is my friend, and shows AssertionError

AssertionError:
    "BOOM!!!" does not match
    "a -1 year old person is too old to be alive."

GREEN: make it pass

I change the Exception to match

    def test_when_year_of_birth_is_the_future(self):
        # try:
        with self.assertRaises(ValueError):

the test passes.

REFACTOR: make it better

I change assertRaises to assertRaisesRegex to test the message of the Exception

the terminal is my friend, and shows AssertionError
```
AssertionError:
    "BOOM!!!" does not match
    "a -1 year old person is too old to be alive."
```
I need a better message for if a person is too old to be alive or too young to be alive.

I change the message of the Exception in the calculate_age function in src/person/__init__.py

the terminal is my friend, and shows AssertionError

FAILED ...test_when_person_is_older_than_120 -
    AssertionError: "a 121 year old person is too old to be alive."
     does not match "a 121 year old person is not alive."
FAILED ...test_when_year_of_birth_is_the_future -
    AssertionError: "BOOM!!!" does not match
                    "a -1 year old person is not alive."

I change the error message in test_when_person_is_older_than_120 in tests/test_person.py

the terminal still shows AssertionError
I change the error message in test_when_year_of_birth_is_the_future

the test passes.
I remove the commented lines from test_when_year_of_birth_is_the_future

I add a git commit message

terminal

git commit -am \
'use assertRaises with test_when_year_of_birth_is_the_future'

extract test_if_person_is_not_alive

test_when_person_is_older_than_120 and test_when_year_of_birth_is_the_future both check if ValueError is raised if year_of_birth makes the person older than 120 or younger than 0

age = self.calculate_age(year_of_birth)

with self.assertRaisesRegex(
    ValueError,
    f'a {age} year old person is not alive.'
):
    src.person.Person(
        first_name='first_name',
        last_name='last_name',
        sex='M',
        year_of_birth=year_of_birth,
    )

I can make one function with a for loop to remove the repetition.

RED: make it fail

I add a test with an assertion for if a person is born in the future or is older than 120

      def test_person_factory(self):
          for a_person in self.people:
              year_of_birth = a_person[0]

              with self.subTest(a_person):
                  self.assertEqual(
                      src.person.person(
                          first_name=self.first_name,
                          last_name=self.last_name,
                          sex=self.sex,
                          year_of_birth=year_of_birth,
                      ),
                      (
                          f'{self.first_name}, {self.last_name},'
                          f' {self.sex}, {year_of_birth}'
                      )
                  )

      def test_if_person_is_not_alive(self):
          for year_of_birth in (
              self.this_year+1,
              self.this_year-121,
          ):
              age = self.calculate_age(year_of_birth)

              with self.subTest(year_of_birth):
                  with self.assertRaisesRegex(
                      ValueError,
                      'BOOM!!!'
                  ):
                      src.person.Person(
                          first_name=self.first_name,
                          last_name=self.last_name,
                          sex=self.sex,
                          year_of_birth=year_of_birth,
                      )

      def test_when_person_is_older_than_120(self):

the terminal is my friend, and shows AssertionError

SUBFAILED(year_of_birth=XXXX) ...AssertionError:
    "BOOM!!!" does not match "a -1 year old person is not alive."
SUBFAILED(year_of_birth=YYYY) ...AssertionError:
    "BOOM!!!" does not match "a 121 year old person is not alive."

GREEN: make it pass

I change the error message in extract test_if_person_is_not_alive to match

      def test_if_person_is_not_alive(self):
          for year_of_birth in (
              self.this_year+1,
              self.this_year-121,
          ):
              age = self.calculate_age(year_of_birth)

              with self.subTest(year_of_birth):
                  with self.assertRaisesRegex(
                      ValueError,
                      f'a {age} year old person is not alive.'
                  ):
                      src.person.Person(
                          first_name=self.first_name,
                          last_name=self.last_name,
                          sex=self.sex,
                          year_of_birth=year_of_birth,
                      )

the test passes.

REFACTOR: make it better

I put the two with statements together

the test is still green.
I remove test_when_person_is_older_than_120 because it is now covered by test_if_person_is_not_alive
I remove test_when_year_of_birth_is_the_future because it is now covered by test_if_person_is_not_alive

I add a git commit message

terminal

git commit -am \
'extract test_if_person_is_not_alive'

move test_when_year_of_birth_is_not_an_integer to test_person_object

test_when_year_of_birth_is_not_an_integer has multiple try statements for if year_of_birth is not an integer. It is also the last tuple in the people object attribute - its year_of_birth values are not integers. I can use the object attributes to remove the repetition

I add tuples for the cases in test_when_year_of_birth_is_not_an_integer to the people object attribute

the tests are still green.

I change the expected Exception in test_person_object to test my change

the terminal is my friend, and shows TypeError

SUBFAILED[(None, False, False)] ...test_person_object -
    TypeError: 'None' is not an integer
SUBFAILED[(2026.0, False, False)] ...test_person_object -
    TypeError: '2026.0' is not an integer
SUBFAILED[('2026', False, False)] ...test_person_object -
    TypeError: '2026' is not an integer
SUBFAILED[((2026,), False, False)] ...test_person_object -
    TypeError: '(2026,)' is not an integer
SUBFAILED[('a_string', False, False, False, False)] ...test_person_object -
    TypeError: 'a_string' is not an integer

good, the test works.

I undo the change

the test is green again.
I remove the last tuple from the people object attribute because it is a repetition of when year_of_birth is a string (('2026', False, False,),)
I remove test_when_year_of_birth_is_not_an_integer because it is now covered by test_person_object

I add a git commit message

terminal

git commit -am \
'move test_when_year_of_birth_is_not_an_integer to test_person_object'

close the project

I close test_person.py and src/person/__init__.py
I use q on the keyboard to leave the tests. The terminal goes back to the command line.
I change directory to the parent of person
terminal
```
cd ..
```

review

I can use for loops for things that repeat.

My tests still have problems:

The attribute tests - test_dir_person_object and test_dir_person_instance catch changes to the attributes and methods of the Person object and they are a problem to maintain. There has to be a better way.
The people object attribute is confusing, anyone who reads it without going through the process of making it would not know what the booleans stands for and the last few tuples I added are a different length than the others. There has to be a better way.

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 AssertionError 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.