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 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):

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

    def test_joe(self):
        first_name = 'joe'
        last_name = 'blow'
        sex = 'M'
        year_of_birth = 1996

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

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

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

        reality = joe.say_hello()
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

    def test_jane(self):
        first_name = 'jane'
        last_name = 'doe'
        sex = 'F'
        year_of_birth = 1991

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

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

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

        reality = jane.say_hello()
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        sex = 'M'
        year_of_birth = 1980
        # year_of_birth = 1580
        # raises AssertionError
        # because older than 120

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

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

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

        reality = john.say_hello()
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

    def test_mary(self):
        first_name = 'mary'
        last_name = 'public'
        sex = 'F'
        year_of_birth = 2000

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

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

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

        reality = mary.say_hello()
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

    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
        )

    def test_dir_person_class(self):
        reality = dir(src.person.Person)
        my_expectation = [
            '__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__',
            'say_hello'
        ]
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

    def test_dir_person_instance(self):
        an_instance_of_person = src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=2026,
        )

        reality = dir(an_instance_of_person)
        my_expectation = [
            '__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__',
            'first_name',
            'last_name',
            'say_hello',
            'sex',
            'year_of_birth',
        ]
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)


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

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 test_person.py

        self.assertEqual(reality, my_expectation)

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


# 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 my_expectation and remove the extra characters

        self.assertEqual(reality, my_expectation)

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


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

Caution

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

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 test_person.py

        self.assertEqual(reality, my_expectation)

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


# 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

        self.assertEqual(reality, my_expectation)

    def test_dir_datetime_date(self):
        reality = dir(datetime.date)
        my_expectation = []
        self.maxDiff = None
        self.assertEqual(reality, my_expectation)


# 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 2 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):
        reality = dir(datetime.date)
        my_expectation = [
            '__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'
        ]
        self.maxDiff = None
        self.assertEqual(reality, my_expectation)


# 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 test_person.py

        self.assertEqual(reality, my_expectation)

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


# 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 value of reality to datetime.date.year

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

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

I try calling date

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


# Exceptions seen

the terminal is my friend, and shows TypeError

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

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 test_person.py

          self.assertEqual(reality, my_expectation)

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


  # 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 change the value of reality to a call to datetime.date.today

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


# 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 is datetime.date(YYYY, MM, DD) which looks like a call to datetime.date(). I wonder if it also has a year attribute

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


# 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_today(self):
        # reality = dir(datetime.date.year)
        # reality = datetime.date.year
        # reality = datetime.date().year
        # reality = datetime.date.today
        # reality = datetime.date.today()
        reality = dir(datetime.date.today())
        my_expectation = []
        self.maxDiff = None
        self.assertEqual(reality, my_expectation)


# 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 my_expectation

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


# 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 class of the datetime module (datetime.date.today().year) in test_person.py

          self.assertEqual(reality, my_expectation)

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


  # 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

            'first_name',
            'last_name',
            'say_hello',
            'sex',
            'year_of_birth',
        ]
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)


# Exceptions seen

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

test age with current year

I change the age calculation in my_expectation of say_hello in test_joe with datetime.date.today().year

      reality = src.person.say_hello(
          first_name=first_name,
          last_name=last_name,
          year_of_birth=year_of_birth,
      )
      my_expectation = (
          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}.'
      )
      assert reality == my_expectation
      self.assertEqual(reality, my_expectation)

      joe = src.person.Person(

the test is still green.

I change the age calculation in my_expectation of say_hello in test_jane with datetime.date.today().year

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        jane = src.person.Person(

still green.

I change the age calculation in my_expectation of say_hello in test_john with datetime.date.today().year

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        john = src.person.Person(

green.

I change the age calculation in my_expectation of say_hello in test_mary with datetime.date.today().year

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        mary = src.person.Person(

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

Each test calls datetime.date.today() to get the year attribute.

I go back to the terminal where the tests are running

I add a class attribute to TestPerson for the current year

class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year

    def test_joe(self):

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        joe = src.person.Person(

still green.

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        jane = src.person.Person(

green.

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        john = src.person.Person(

still green.

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        mary = src.person.Person(

the test is still green.

I add a git commit message in the other terminal

git commit -am \
'extract this_year attribute'

extract calculate_age method

Each test does a calculation for the age. I can make 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

class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year

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

    def test_joe(self):

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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)}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        joe = src.person.Person(

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

  class TestPerson(unittest.TestCase):

      this_year = datetime.date.today().year

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

      def test_joe(self):

the test passes.

REFACTOR: make it better

I remove the commented lines from test_joe

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

        joe = src.person.Person(

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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)}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        jane = src.person.Person(

the test is still green.

I remove the commented lines from test_jane

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

        jane = src.person.Person(

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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)}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        john = src.person.Person(

still green.

I remove the commented lines from test_john

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

        john = src.person.Person(

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

        reality = src.person.say_hello(
            first_name=first_name,
            last_name=last_name,
            year_of_birth=year_of_birth,
        )
        my_expectation = (
            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)}.'
        )
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

        mary = src.person.Person(

green.

I remove the commented lines from test_mary

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

        mary = src.person.Person(

The this_year class attribute is now used in only one place the calculate_age method. I can call what it points to directly

class TestPerson(unittest.TestCase):

    this_year = datetime.date.today().year

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

I add the staticmethod decorator since calculate_age no longer uses anything from 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'

because a method of an instance takes the instance of the class (self) it belongs to as the first argument.

I remove self from the parentheses

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

the test is green again.

I remove the commented lines and this_year attribute since it is no longer used

class TestPerson(unittest.TestCase):

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

    def test_joe(self):

this works because Python follows the following path when self.calculate_age(year_of_birth) is called

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
            )

when datetime.date.today() runs, I imagine Python follows this path

datetime.date.today()
datetime
    └── class date
        └── today()
            └── return self.date(YYYY, MM, DD)

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 person/__init__.py from 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

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

still green.

I remove the commented line

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 factory(

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

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

    def test_joe(self):

The terminal is my friend, and shows AssertionError for all four people.
The ages of the expectations are all negative numbers, 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'

assert person is alive

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 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 test_person.py

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

the test passes.

REFACTOR: make it better

I add a comment about the bad year_of_birth

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        sex = 'M'
        year_of_birth = 1980
        # year_of_birth = 1580
        # raises AssertionError
        # because older than 120

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 'assert person is alive'
```

test_when_year_of_birth_is_not_an_integer

I want the Person class to make sure that the value for year_of_birth is an integer (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

        reality = mary.say_hello()
        assert reality == my_expectation
        self.assertEqual(reality, my_expectation)

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

    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 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 function only gets integers

def calculate_age(year_of_birth):
    assert isinstance(year_of_birth, int)
    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

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

I add a comment, then change year_of_birth from the default value to a boolean in test_when_year_of_birth_is_not_an_integer, in test_person.py

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

    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 to a float

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

    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):
        person = 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',
        )

    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):
        person = 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,),
        )

    def test_dir_person_class(self):

I add a comment

    def test_when_year_of_birth_is_not_an_integer(self):
        person = 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
        )

    def test_dir_person_class(self):

the test is green because there is no assertion or calls that cause AssertionError.

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