test person with datetime

The person project has a problem with the calculation of the ages. It only shows the right age if the program is run in 2026, because the year is hardcoded. If I run it in a different year or change the year on my computer, the ages will be wrong and the tests for say_hello will fail.

I want the calculation to always be right, which means the program should always know the correct year.

I can use the datetime module from The Python Standard Library. You can think of it as a toolbox with different tools I can use to do things with dates and times. I can also use assertions to make sure I get the right year of birth for the calculations.

preview

I add the following code 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

    def assert_person_factory_works(
            self, first_name, last_name,
            sex, year_of_birth
        ):

person/tests/test_person.py

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

person/tests/test_person.py

    def assert_say_hello_works(
            self, first_name, last_name,
            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)}.'
            )
        )

person/tests/test_person.py

    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)}.'
            )
        )

person/tests/test_person.py

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        sex = 'M'
        year_of_birth = 1980

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

        self.assert_say_hello_works(
            first_name=first_name,
            last_name=last_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,
        )

person/tests/test_person.py

    def test_when_person_is_older_than_120(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=self.this_year-121
        )
        # ).say_hello() fails
        # because age > 120

person/tests/test_person.py

    def test_when_year_of_birth_is_the_future(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='F',
            year_of_birth=self.this_year+1,
        )
        # ).say_hello() fails
        # because age < 0

person/tests/test_person.py

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,     # fails
            # year_of_birth=2026.0,   # fails
            # year_of_birth='2026',   # fails
            # year_of_birth=(2026,),  # fails
        )
        # ).say_hello() fails
        # because year_of_birth is not an integer

    def test_dir_person_class(self):

open the project

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

I use pytest-watcher to run the tests automatically

uv run pytest-watcher . --now

the terminal shows

tests/test_person.py ......                         [100%]

=================== 6 passed in M.NOs ====================

test_dir_datetime

I want to see what comes with the datetime module.

RED: make it fail

I add test_dir_datetime to 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__',

                'last_name', 'say_hello', 'sex', 'year_of_birth',
            ]
        )

    def test_dir_datetime(self):
        self.assertEqual(
            dir(datetime),
            []
        )


# Exceptions seen

the terminal is my friend, and shows NameError

NameError: name 'datetime' is not defined.
           Did you forget to import 'datetime'?

GREEN: make it pass

I add an import statement for datetime

import datetime
import src.person
import unittest


class TestPerson(unittest.TestCase):

the terminal is my friend, and shows AssertionError

AssertionError:
    Lists differ: [
        'MAXYEAR', 'MINYEAR', 'UTC',
        '__all__', '[179 chars]nfo'
    ] != []

it also shows the entire difference between the lists

I copy (ctrl/command+c) the values from the terminal, paste (ctrl/command+v) them as the expectation of the assertion and remove the extra characters, in test_dir_datetime

Caution

Your list of attributes and methods may be different depending on your Python version

    def test_dir_datetime(self):
        self.assertEqual(
            dir(datetime),
            [
                'MAXYEAR',
                'MINYEAR',
                'UTC',
                '__all__',
                '__builtins__',
                '__cached__',
                '__doc__',
                '__file__',
                '__loader__',
                '__name__',
                '__package__',
                '__spec__',
                'date',
                'datetime',
                'datetime_CAPI',
                'time',
                'timedelta',
                'timezone',
                'tzinfo'
            ]
        )


# Exceptions seen

the test passes because when import datetime runs, Python brings in an object (everything in Python is an object) for the datetime module from The Python Standard Library so I can use it in tests/test_person.py as datetime.

This means that there is a file or folder on the computer named datetime that got added when I installed Python.

test_dir_datetime_date

A few names stand out in the list of attributes and methods of datetime

date - I assume this handles dates
time - I assume this handles time
datetime - I assume a combination of date and time

What I want is something that will give me the current year.

RED: make it fail

I add test_dir_datetime_date to tests/test_person.py

      def test_dir_datetime(self):
          self.assertEqual(
              dir(datetime),
              [
                  'MAXYEAR',

                  'tzinfo'
              ]
          )

      def test_dir_datetime_date(self):
          self.assertEqual(
              dir(datetime.date),
              []
          )


  # Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError:
    Lists differ: [
        '__add__', '__class__', '__delattr__',
        '_[585 chars]ear'
    ] != []

with a message about how to see the entire difference

Diff is 787 characters long.
Set self.maxDiff to None to see it.

GREEN: make it pass

I set self.maxDiff to None
```
232    def test_dir_datetime_date(self):
233        self.maxDiff = None
234        self.assertEqual(
235            dir(datetime.date),
236            []
237        )
238
239
240# Exceptions seen
```
- The terminal shows the entire difference between reality and my_expectation.
- maxDiff is an attribute of the unittest.TestCase class that sets the maximum number of characters to show when comparing two objects in the terminal, when it is set to None it shows the full difference.

I copy (ctrl/command+c) the values from the terminal, paste (ctrl/command+v) them as my_expectation and remove the extra characters

    def test_dir_datetime_date(self):
        self.maxDiff = None
        self.assertEqual(
            dir(datetime.date),
            [
                '__add__', '__class__', '__delattr__',
                '__dir__', '__doc__', '__eq__',
                '__format__', '__ge__', '__getattribute__',
                '__getstate__', '__gt__', '__hash__',
                '__init__', '__init_subclass__', '__le__',
                '__lt__', '__ne__', '__new__', '__radd__',
                '__reduce__', '__reduce_ex__',
                '__replace__', '__repr__', '__rsub__',
                '__setattr__', '__sizeof__', '__str__',
                '__sub__', '__subclasshook__', 'ctime',
                'day', 'fromisocalendar', 'fromisoformat',
                'fromordinal', 'fromtimestamp',
                'isocalendar', 'isoformat', 'isoweekday',
                'max', 'min', 'month', 'replace',
                'resolution', 'strftime', 'strptime',
                'timetuple', 'today', 'toordinal',
                'weekday', 'year'
            ]
        )


# Exceptions seen

the test passes.

test_dir_datetime_date_year

I see year in the list of attributes and methods of datetime.date.

RED: make it fail

I add a test for the year attribute of the date attribute of the datetime module in tests/test_person.py

                'weekday', 'year'
            ]
        )

    def test_dir_datetime_date_year(self):
        self.assertEqual(
            dir(datetime.date.year),
            []
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError with only attributes that start and end with double underscore (__)

GREEN: make it pass

I change the assertion to see what the datetime.date.year object is

    def test_dir_datetime_date_year(self):
        self.assertEqual(
            # dir(datetime.date.year),
            datetime.date.year,
            []
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError:
    <attribute 'year' of 'datetime.date' objects>
 != []

I try making an instance of the datetime.date object

    def test_dir_datetime_date_year(self):
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            datetime.date().year,
            []
        )


# Exceptions seen

the terminal is my friend, and shows TypeError

TypeError: function missing
           required argument 'year' (pos 1)

It is a function that has required input. I want something that automatically knows the date and gives me the year.

test_dir_datetime_date_today

I also saw today in the list of attributes and methods of datetime.date.

RED: make it fail

I change test_dir_datetime_date_year to a test for the today attribute of the date attribute of the datetime module in tests/test_person.py

                'weekday', 'year'
            ]
        )

    # def test_dir_datetime_date_year(self):
    def test_dir_datetime_date_today(self):
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            # datetime.date().year,
            datetime.date.today,
            []
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError:
    <built-in method today
     of type object at 0xffff0fab2345>
 != []

GREEN: make it pass

I call the datetime.date.today method to see what it returns

    # def test_dir_datetime_date_year(self):
    def test_dir_datetime_date_today(self):
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            # datetime.date().year,
            # datetime.date.today,
            datetime.date.today(),
            []
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: datetime.date(YYYY, MM, DD) != []

where YYYY is the current year, MM is the current month and DD is the current date. Progress!

When I called datetime.date() it asked for the year argument, and the result of the call to datetime.date.today() is datetime.date(YYYY, MM, DD) which looks like an instance of the datetime.date object with input. I use the dir built-in function to show its attributes

    # def test_dir_datetime_date_year(self):
    def test_dir_datetime_date_today(self):
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            # datetime.date().year,
            # datetime.date.today,
            # datetime.date.today(),
            dir(datetime.date.today()),
            []
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError with a message about setting self.maxDiff to see the full difference

I set self.maxDiff to None

    # def test_dir_datetime_date_year(self):
    def test_dir_datetime_date_today(self):
        self.maxDiff = None
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            # datetime.date().year,
            # datetime.date.today,
            # datetime.date.today(),
            dir(datetime.date.today()),
            []
        )


# Exceptions seen

the terminal shows the entire difference between reality and my_expectation and there is a year attribute because they are the same as the attributes and methods of datetime.date

I change the expectation of the assertion

    # def test_dir_datetime_date_year(self):
    def test_dir_datetime_date_today(self):
        self.maxDiff = None
        self.assertEqual(
            # dir(datetime.date.year),
            # datetime.date.year,
            # datetime.date().year,
            # datetime.date.today,
            # datetime.date.today(),
            dir(datetime.date.today()),
            # []
            dir(datetime.date)
        )


# Exceptions seen

the test passes.

test_datetime_date_today_year

It looks like I have a way to get the current year.

RED: make it fail

I add test_datetime_date_today_year to test the year attribute of the result of a call to the today method of the date object of the datetime module (datetime.date.today().year) in tests/test_person.py

            dir(datetime.date)
        )

    def test_datetime_date_today_year(self):
        self.assertEqual(
            datetime.date.today().year,
            1900
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: YYYY != 1900

where YYYY is the current year.

GREEN: make it pass

I change my expectation to match reality and the test passes.

I remove all the datetime tests now that I know datetime.date.today().year works

    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__',

                'last_name', 'say_hello', 'sex', 'year_of_birth',
            ]
        )


# Exceptions seen

I have a way to automatically get the current year that will always be correct.

I imagine Python follows this path to get the value of datetime.date.today().year

datetime.date.today().year
└── datetime
    └── class date:
        │   @staticmethod
        └── def today():
            ├── current_year  = YYYY
            ├── current_month = MM
            ├── current_day   = DD
            └── return datetime.date(
                    current_year, current_month, current_day
                )

test age with current year

I change the age calculation in the expectation of the assert_say_hello_works method to datetime.date.today().year

    def assert_say_hello_works(
            self, first_name, last_name,
            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' {2026-year_of_birth}.'
                f' {datetime.date.today().year-year_of_birth}.'
            )
        )

    def assert_person_can_say_hello(
            self,first_name, last_name,
            sex, year_of_birth,
        ):

all the tests are still green.

I change the age calculation in the expectation of the assert_person_can_say_hello method to datetime.date.today().year

    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' {2026-year_of_birth}.'
                f' {datetime.date.today().year-year_of_birth}.'
            )
        )

    def test_joe(self):

still green.

I open a new terminal then make sure I am in the person folder
```
cd person
```

I add a git commit message in the new terminal

git commit -am \
'use datetime to calculate age'

extract this_year attribute

The assert_say_hello_works and assert_person_can_say_hello methods both call datetime.date.today() to get the year attribute. I can use a object attribute to remove the repetition

I go back to the terminal where the tests are running

I add a object attribute to TestPerson for the current year

class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year

    def assert_person_factory_works(
            self, first_name, last_name,
            sex, year_of_birth
        ):

I use the attribute for datetime.date.today().year in the assert_say_hello_works method

    def assert_say_hello_works(
            self, first_name, last_name,
            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' {2026-year_of_birth}.'
                # f' {datetime.date.today().year-year_of_birth}.'
                f' {self.this_year-year_of_birth}.'
            )
        )

    def assert_person_can_say_hello(
            self,first_name, last_name,
            sex, year_of_birth,
        ):

still green.

I use the attribute for datetime.date.today().year in the assert_person_can_say_hello method

    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' {2026-year_of_birth}.'
                # f' {datetime.date.today().year-year_of_birth}.'
                f' {self.this_year-year_of_birth}.'
            )
        )

    def test_joe(self):

the tests are still green.

I add a git commit message in the other terminal

git commit -am \
'extract this_year attribute'

extract calculate_age method

The assert_say_hello_works and assert_person_can_say_hello methods both do a calculation for the age. I can use a method to remove the repetition.

RED: make it fail

I go back to the terminal where the tests are running

I add a method to TestPerson to calculate the age

    def assert_person_factory_works(
            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,
            ),
            (
                f'{first_name}, {last_name},'
                f' {sex}, {year_of_birth}'
            )
        )

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

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

I use the method for self.this_year-year_of_birth in the assert_say_hello_works method

    def assert_say_hello_works(
            self, first_name, last_name,
            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' {2026-year_of_birth}.'
                # f' {datetime.date.today().year-year_of_birth}.'
                # f' {self.this_year-year_of_birth}.'
                f' {self.calculate_age(year_of_birth)}.'
            )
        )

    def assert_person_can_say_hello(
            self,first_name, last_name,
            sex, year_of_birth,
        ):

the terminal is my friend, and shows TypeError

TypeError:
    TestPerson.calculate_age() takes
    1 positional argument but 2 were given

GREEN: make it pass

I add self to the parentheses of calculate_age

    def assert_person_factory_works(
            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,
            ),
            (
                f'{first_name}, {last_name},'
                f' {sex}, {year_of_birth}'
            )
        )

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

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

the test passes.

REFACTOR: make it better

I remove the commented lines from the assert_say_hello_works method

    def assert_say_hello_works(
            self, first_name, last_name,
            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)}.'
            )
        )

    def assert_person_can_say_hello(
            self,first_name, last_name,
            sex, year_of_birth,
        ):

I use the method for self.this_year-year_of_birth in the assert_person_can_say_hello method

    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' {2026-year_of_birth}.'
                # f' {datetime.date.today().year-year_of_birth}.'
                # f' {self.this_year-year_of_birth}.'
                f' {self.calculate_age(year_of_birth)}.'
            )
        )

    def test_joe(self):

the test is still green.

I remove the commented lines from the assert_person_can_say_hello method

    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_joe(self):

The this_year object attribute is now used in only one place - the calculate_age method. I can call what it points to directly, with no need for the object attribute as a middle man

    # def calculate_age(year_of_birth):
    def calculate_age(self, year_of_birth):
        # return self.this_year - year_of_birth
        return (
            datetime.date.today().year
          - year_of_birth
        )

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

I add the staticmethod decorator since calculate_age no longer uses anything that belongs to the TestPerson class

    # def calculate_age(year_of_birth):
    @staticmethod
    def calculate_age(self, year_of_birth):

the terminal is my friend, and shows TypeError

TypeError:
    TestPerson.calculate_age() missing
    1 required positional argument: 'year_of_birth'

I remove self from the parentheses

    @staticmethod
    def calculate_age(year_of_birth):
    # def calculate_age(self, year_of_birth):
        # return self.this_year - year_of_birth
        return (
            datetime.date.today().year
          - year_of_birth
        )

the test is green again.

I remove the commented lines from the calculate_age method

    @staticmethod
    def calculate_age(year_of_birth):
        return (
            datetime.date.today().year
          - year_of_birth
        )

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

I remove the this_year attribute from the TestPerson class since it is no longer used

class TestPerson(unittest.TestCase):

    def assert_person_factory_works(
            self, first_name, last_name,
            sex, year_of_birth
        ):

when self.calculate_age(year_of_birth) runs

self.calculate_age(year_of_birth)
└── class TestPerson(unittest.TestCase)
    │   @staticmethod
    └── def calculate_age(year_of_birth):
        └── return (
        ┌────── datetime.date.today().year
        │     - year_of_birth
        │   )
        │
        └── datetime
            └── class date:
                │   @staticmethod
                └── def today():
                    ├── current_year  = YYYY
                    ├── current_month = MM
                    ├── current_day   = DD
                    └── return datetime.date(
                            current_year, current_month, current_day
                        )

using substitution for the return statement

return (
    datetime.date.today().year
  - year_of_birth
)
return (
    datetime.date(YYYY, MM, DD).year
  - year_of_birth
)
return (YYYY - year_of_birth)

where YYYY is the current year.

I add a git commit message in the other terminal

git commit -am \
'extract calculate_age method'

add calculate_age function

The tests use the right calculation for the age, and the solution still uses a fixed value (2026)

RED: make it fail

I go back to the terminal where the tests are running
I open __init__.py from the person folder in the src folder

I add a function to calculate the age, with the same body as the calculate_age method, in src/person/__init__.py

    def say_hello(self):
        return (
            f'Hello, my name is {self.first_name}'
            f' {self.last_name} and I am'
            f' {2026-self.year_of_birth}.'
        )


def calculate_age(year_of_birth):
    return (
        datetime.date.today().year
      - year_of_birth
    )


def say_hello(
        first_name, last_name, year_of_birth,
    ):

I use the function in the say_hello method of the Person class

    def say_hello(self):
        return (
            f'Hello, my name is {self.first_name}'
            f' {self.last_name} and I am'
            # f' {2026-self.year_of_birth}.'
            f' {calculate_age(self.year_of_birth)}.'
        )


def calculate_age(year_of_birth):

the terminal is my friend, and shows NameError

NameError: name 'datetime' is not defined.
           Did you forget to import 'datetime'?

I did.

GREEN: make it pass

I add an import statement at the top of src/person/__init__.py
```
1import datetime
2
3
4class Person:
```
all tests are green again.

I remove the commented line from the say_hello method

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


def calculate_age(year_of_birth):

I use the function in the say_hello function

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' {2026-year_of_birth}.'
        f' {calculate_age(year_of_birth)}.'
    )


def person(
        first_name, last_name,
        sex, year_of_birth,
    ):

still green.

I remove the commented line from the say_hello function

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 person(
        first_name, last_name,
        sex, year_of_birth,
    ):

I change the calculation in the calculate_age method to make sure the tests work, in tests/test_person.py

    @staticmethod
    def calculate_age(year_of_birth):
        return 1900 - year_of_birth
        return (
            datetime.date.today().year
          - year_of_birth
        )

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

The terminal is my friend, and shows AssertionError for all four people.
The ages of the expectations are all negative numbers, since I used a year that is earlier than the dates of birth except for john. This is a problem.
The results of the call all have the right age. Lovely!

I change the calculation in the calculate_age method back

    @staticmethod
    def calculate_age(year_of_birth):
        return (
            datetime.date.today().year
          - year_of_birth
        )

    def test_joe(self):

green again.

I add a git commit message in the other terminal

git commit -am \
'add calculate_age function'

test_when_person_is_older_than_120

I want the calculate_age function to make sure that the age of the person is not more than 120 because I do not know that there are any people alive older than that, yet. For example john smith has a year_of_birth of 1580 which makes him too old to be alive.

RED: make it fail

I go back to the terminal where the tests are running

I add a variable with an assert statement to the calculate_age function in src/person/__init__.py

def calculate_age(year_of_birth):
    # return (
    age = (
        datetime.date.today().year
      - year_of_birth
    )
    assert age <= 120
    return age


def say_hello(
    first_name, last_name, year_of_birth,
):

the terminal is my friend, and shows AssertionError

E       AssertionError

another problem, the error message does not tell me much. At least the short test summary info shows me what test the error happened in

FAILED ...::TestPerson::test_john - AssertionError

GREEN: make it pass

I change the value of year_of_birth in test_john in tests/test_person.py

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        sex = 'M'
        # year_of_birth = 1580
        year_of_birth = 1980

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

the test passes.

REFACTOR: make it better

I remove the commented line from test_john

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        sex = 'M'
        year_of_birth = 1980

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

I add a test for when the person is older than 120

def test_mary(self):
    ...

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

def test_when_person_is_older_than_120(self):
    src.person.Person(
        first_name='first_name',
        last_name='last_name',
        sex='M',
        year_of_birth=datetime.date.today().year-121
    ).say_hello()

def test_dir_person_class(self):

the terminal is my friend, and shows AssertionError

E       AssertionError

I use datetime.date.today().year - 121 to make sure the person is always older than 120

The short test summary info shows me what test the error happened in

FAILED ...test_when_person_is_older_than_120 - AssertionError

I remove the call to the say_hello method then add a comment about the failure

    def test_when_person_is_older_than_120(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=datetime.date.today().year-121
        )
        # ).say_hello() fails
        # because age > 120

    def test_dir_person_class(self):

the test is green because there are no calls that cause an Exception.

I remove the commented line from the calculate_age function in src/person/__init__.py

def calculate_age(year_of_birth):
    age = (
        datetime.date.today().year
      - year_of_birth
    )
    assert age <= 120
    return age


def say_hello(
        first_name, last_name, year_of_birth,
    ):

I add a git commit message in the other terminal

git commit -am \
'add test_when_person_is_older_than_120'

test_when_year_of_birth_is_the_future

I want the calculate_age function to also make sure that the year of birth of a person is before the current year.

RED: make it fail

I go back to the terminal where the tests are running

I add a new test for when year_of_birth is in the future, in tests/test_person.py

        # ).say_hello() fails
        # because age > 120

    def test_when_year_of_birth_is_the_future(self):
        self.assertEqual(
            src.person.Person(
                first_name='first_name',
                last_name='last_name',
                sex='F',
                year_of_birth=datetime.date.today().year+1,
            ).say_hello(),
            AssertionError
        )

    def test_dir_person_class(self):

the terminal is my friend, and shows AssertionError

AssertionError:
    'Hello, my name is first_name last_name and I am -1.'
 != <class 'AssertionError'>

I use datetime.date.today().year + 1 for all the years of birth in the future.

GREEN: make it pass

I add an assertion to the calculate age function to make sure that it never returns a number that is less than 0, in src/person/__init__.py

def calculate_age(year_of_birth):
    age = (
        datetime.date.today().year
      - year_of_birth
    )
    assert age >= 0
    assert age <= 120
    return age


def say_hello(
        first_name, last_name, year_of_birth
    ):

the terminal is my friend, and shows AssertionError

E       AssertionError

the error message is still a problem. The short test summary info shows me what test the error happened in

FAILED ...test_when_year_of_birth_is_the_future - AssertionError

I remove the assertion and call to the say_hello method in test_when_year_of_birth_is_the_future, in tests/test_person.py

    def test_when_year_of_birth_is_the_future(self):
        # self.assertEqual(
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='F',
            year_of_birth=datetime.date.today().year+1,
        )
            # ).say_hello(),
            # AssertionError
        # )

    def test_dir_person_class(self):

the test is green because there are no calls that cause an Exception.

I remove the commented lines from test_when_year_of_birth_is_the_future then add a comment about the test

    def test_when_year_of_birth_is_the_future(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='F',
            year_of_birth=datetime.date.today().year+1,
        )
        # ).say_hello() fails
        # because age < 0

    def test_dir_person_class(self):

I add a git commit message in the other terminal

git commit -am \
'add test_when_year_of_birth_is_the_future'

extract this_year attribute again

The calculate_age, test_when_person_is_older_than_120 and test_when_year_of_birth_is_the_future all call datetime.date.today() to get the year attribute.

I made a object attribute for this_year earlier to remove the repetition which ended up in the calculate_age method, I can make it again to remove repetition from these three methods

RED: make it fail

I go back to the terminal where the tests are running

I add back the object attribute for the current year to the TestPerson class

class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year

    def assert_person_factory_works(
            self, first_name, last_name,
            sex, year_of_birth
        ):

I use the attribute for datetime.date.today().year in the calculate_age method

    @staticmethod
    def calculate_age(year_of_birth):
        return (
            # datetime.date.today().year
            self.this_year
          - year_of_birth
        )

    def assert_say_hello_works(
            self, first_name, last_name,
            year_of_birth,
        ):

the terminal is my friend, and shows NameError

GREEN: make it pass

I comment out the staticmethod decorator then add self to the parentheses of the calculate_age method

    # @staticmethod
    # def calculate_age(year_of_birth):
    def calculate_age(self, year_of_birth):
        return (
            # datetime.date.today().year
            self.this_year
          - year_of_birth
        )

the tests are green again.

REFACTOR: make it better

I remove the commented lines from the calculate_age method

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

def assert_say_hello_works(
        self, first_name, last_name,
        year_of_birth,
    ):

I use the attribute for datetime.date.today().year in test_when_person_is_older_than_120

    def test_when_person_is_older_than_120(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=datetime.date.today().year-121
            year_of_birth=self.this_year-121
        )
        # ).say_hello() fails
        # because age > 120

the tests are still green.

I remove the new commented line from test_when_person_is_older_than_120

    def test_when_person_is_older_than_120(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=self.this_year-121
        )
        # ).say_hello() fails
        # because age > 120

    def test_when_year_of_birth_is_the_future(self):

I use the attribute for datetime.date.today().year in test_when_year_of_birth_is_the_future

    def test_when_year_of_birth_is_the_future(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='F',
            # year_of_birth=datetime.date.today().year+1,
            year_of_birth=self.this_year+1,
        )
        # ).say_hello() fails
        # because age < 0

    def test_dir_person_class(self):

still green.

I remove the new commented line from test_when_year_of_birth_is_the_future

    def test_when_year_of_birth_is_the_future(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='F',
            year_of_birth=self.this_year+1,
        )
        # ).say_hello() fails
        # because age < 0

    def test_dir_person_class(self):

I add a git commit message in the other terminal

git commit -am \
'extract this_year attribute'

test_when_year_of_birth_is_not_an_integer

I want the calculate_age function to make sure that the value for year_of_birth is an integer (a whole number without decimals).

RED: make it fail

I go back to the terminal where the tests are running

I add a new test for when year_of_birth is not an integer

        # ).say_hello() fails
        # because age < 0

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
        ).say_hello()

    def test_dir_person_class(self):

the terminal is my friend, and shows TypeError

TypeError:
    Person.__init__() missing
    1 required positional argument: 'year_of_birth'

GREEN: make it pass

I make year_of_birth an optional argument in the constructor method of the Person class in src/person/__init__.py

class Person:

    def __init__(
            self, first_name, last_name,
            # sex, year_of_birth,
            sex, year_of_birth=None,
        ):

the terminal shows TypeError

TypeError: unsupported operand type(s) for -:
           'int' and 'NoneType'

because I cannot do Arithmetic with None.

I add an assertion with the isinstance built-in function to make sure the calculate age function only works with integers

def calculate_age(year_of_birth):
    assert isinstance(year_of_birth, int)
    age = (
        datetime.date.today().year
      - year_of_birth
    )
    assert age >= 0
    assert age <= 120
    return age


def say_hello(
        first_name, last_name, year_of_birth
    ):

the terminal is my friend, and shows AssertionError

E       AssertionError

another bad error message. The short test summary info shows me what test the error happened in

FAILED ...test_when_year_of_birth_is_not_an_integer - AssertionError

I add a comment, then add False as the value for if a boolean is given as the value for the year_of_birth parameter in test_when_year_of_birth_is_not_an_integer, in tests/test_person.py

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,       # fails
            year_of_birth=False,
        ).say_hello()

    def test_dir_person_class(self):

the terminal shows AssertionError for the age being greater than 120. Wait a minute! I was expecting that to fail at assert isinstance(year_of_birth, int). This means a boolean is also an integer.

I change year_of_birth from False to a float

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,     # fails
            year_of_birth=2026.0,
        ).say_hello()

    def test_dir_person_class(self):

the terminal shows AssertionError

I add a comment then change year_of_birth to a string

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,     # fails
            # year_of_birth=2026.0,   # fails
            year_of_birth='2026',
        ).say_hello()

    def test_dir_person_class(self):

the terminal shows AssertionError

I add a comment then change year_of_birth to a tuple

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,     # fails
            # year_of_birth=2026.0,   # fails
            # year_of_birth='2026',   # fails
            year_of_birth=(2026,),
        ).say_hello()

    def test_dir_person_class(self):

I comment out the call to the say_hello method then add a comment about the test

    def test_when_year_of_birth_is_not_an_integer(self):
        src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            # year_of_birth=None,     # fails
            # year_of_birth=2026.0,   # fails
            # year_of_birth='2026',   # fails
            # year_of_birth=(2026,),  # fails
        )
        # ).say_hello() fails
        # because year_of_birth is not an integer

    def test_dir_person_class(self):

the test is green because there are no calls that cause an Exception.

I remove the commented line from the Person class in src/person/__init__.py

class Person:

    def __init__(
        self, first_name, last_name,
        sex, year_of_birth=None,
    ):

I add a git commit message in the other terminal

git commit -am \
'add test_when_year_of_birth_is_not_an_integer'

close the project

I close tests/test_person.py and src/person/__init__.py
I click in the terminal where the tests are running
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
```
cd ..
```
the terminal shows
```
...\pumping_python
```
I am back in the pumping_python directory.

review

I can use the datetime library to automatically get the current year for the calculation of a person’s age.
I can use assertions to make sure certain conditions are met before a program does something.
My tests have a new problem - when they cause an Exception the test stops in a RED state. My solution was to add notes and comment out the problems, which means the only way to know that the code causes the Exception is to remove the comments. There has to be a better way
test_joe, test_jane, test_john and test_mary also still have the problem where they are the same three tests. 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 None (the simplest object)?

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.