how to make a person with conditions

I want to be able to check if a person can vote, and if they can get a license. Which means I want something in the person project to make decisions based on conditions

If a person is younger than 18, the person cannot get a license.
If a person is younger than 18, the person cannot vote.
If a person is 18 or older and passes a test, the person can get a license.
If a person is 18 or older and the person is a citizen, the person can vote.

preview

I have these tests by the end of the chapter

person/tests/test_person.py

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

        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
        )

        joe = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(joe.can_vote(), True)
        self.assertEqual(joe.can_get_license(), False)

person/tests/test_person.py

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

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

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            passed_test=True,
        )
        self.assertEqual(jane.can_vote(), True)
        self.assertEqual(jane.can_get_license(), True)

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

        john = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
            passed_test=False,
        )
        self.assertEqual(john.can_vote(), False)
        self.assertEqual(john.can_get_license(), False)

person/tests/test_person.py

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

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

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

person/tests/test_person.py

    def test_underage_citizen(self):
        underage = src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=self.this_year-17,
            is_citizen=True,
            passed_test=True,
        )
        self.assertEqual(underage.can_vote(), False)
        self.assertEqual(underage.can_get_license(), False)

person/tests/test_person.py

    @unittest.skip('fails because age > 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
        )

person/tests/test_person.py

    @unittest.skip('fails because age < 0')
    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,
        )

person/tests/test_person.py

    @unittest.skip(
        'fails because year_of_birth is not an integer'
    )
    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
        )

person/tests/test_person.py

    def test_dir_person_class(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',
            ]
        )


# 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%]

=================== 9 passed in P.QRs ====================

add can_vote method

RED: make it fail

I add a call to can_vote from test_joe

  def test_joe(self):
      first_name = 'joe'
      last_name = 'blow'
      ...

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

      joe = src.person.Person(
          first_name=first_name,
          last_name=last_name,
          sex=sex,
          year_of_birth=year_of_birth,
      )
      self.assertEqual(joe.can_vote(), True)

  def test_jane(self):

the terminal is my friend, and shows AttributeError

AttributeError: 'Person' object
                has no attribute 'can_vote'

GREEN: make it pass

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

I add a method definition to the Person class in src/person/__init__.py

class Person:

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

    def can_vote():
        return True

    def say_hello(self):

the terminal is my friend, and shows TypeError

TypeError: Person.can_vote() takes
           0 positional arguments but 1 was given

I add the staticmethod decorator

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

    @staticmethod
    def can_vote():
        return True

    def say_hello(self):

the terminal is my friend, and shows AssertionError

FAILED ...::TestPerson::test_dir_person_class -
    AssertionError: assert
        ['__class__',...'__eq__', ...] ==...
FAILED ...::TestPerson::test_dir_person_instance -
    AssertionError: assert
        ['__class__',...'__eq__', ...] ==...

the tests for the attributes and methods of the Person class and an instance of it are failing because I added a method to it.

I add can_vote to test_dir_person_class in tests/test_person.py

    def test_dir_person_class(self):
        self.assertEqual(
            dir(src.person.Person),
            [
                '__class__', '__delattr__', '__dict__',
                ...

                '__static_attributes__', '__str__',
                '__subclasshook__', '__weakref__',
                'can_vote', 'say_hello',
            ]
        )

    def test_dir_person_instance(self):

I add can_vote to test_dir_person_instance

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

                '__subclasshook__', '__weakref__',
                'can_vote', 'first_name', 'last_name',
                'say_hello', 'sex', 'year_of_birth',
            ]
        )


# Exceptions seen

the test passes.

test_dir_person_class and test_dir_person_instance are good because they help document what is in the object and catch its changes immediately.

test_dir_person_class and test_dir_person_instance are a problem because object attributes can change from one Python version to another, I have to remember the correct order of names and I am keeping two lists. There has to be a better way.

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 'add can_vote method'
```

add is_citizen attribute

I want can_vote to return

False for no the person cannot vote if the person is not a citizen.
True for yes the person can vote if the person is a citizen.

RED: make it fail

I go back to the terminal where the tests are running

I add a call to can_vote from test_mary

    def test_mary(self):
        first_name = 'mary'
        last_name = 'public'
        ...

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

        mary = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth
        )
        self.assertEqual(mary.can_vote(), False)

    def test_when_person_is_older_than_120(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

The can_vote method has to make a decision based on something.

GREEN: make it pass

I add is_citizen to the instance of the Person class for mary

        mary = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
        )
        self.assertEqual(mary.can_vote(), False)

the terminal is my friend, and shows TypeError

TypeError: Person.__init__() got
           an unexpected keyword argument
           'is_citizen'

because the definition for the __init__ method of the Person class only takes five inputs (self, first_name, last_name, sex and year_of_birth) and it got called it with is_citizen which is not one of those names.

I add is_citizen to the parentheses of the __init__ method, in src/person/__init__.py

class Person:

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

the terminal is my friend, and shows SyntaxError

SyntaxError: parameter without a default
     follows parameter with a default

because parameters without default values must come before parameters with default values.

I give is_citizen a value to make it optional

class Person:

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

the terminal goes back to the AssertionError.

I add an instance attribute for is_citizen so I can use it in the can_vote method

class Person:

    def __init__(
            self, first_name, last_name,
            sex, year_of_birth=None,
            is_citizen=True,
        ):
        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

    @staticmethod
    def can_vote():

still AssertionError.

I use the object attribute in the can_vote method

    @staticmethod
    def can_vote():
        return self.is_citizen
        return True

the terminal is my friend, and shows NameError

NameError: name 'self' is not defined

I remove the staticmethod decorator from the can_vote method then add self to the parentheses
```
17    # @staticmethod
18    # def can_vote():
19    def can_vote(self):
20        return self.is_citizen
21        return True
```
the terminal is my friend, and shows AssertionError for test_dir_person_instance because I added a new attribute (is_citizen).

I add is_citizen to the expectation of the assertion in test_dir_person_instance in 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__',
                ...

                '__subclasshook__', '__weakref__',
                'can_vote', 'first_name', 'is_citizen',
                'last_name', 'say_hello', 'sex',
                'year_of_birth',
            ]
        )


# Exceptions seen

the test passes.

I remove the commented lines and the second return statement from the can_vote method in src/person/__init__.py

    def __init__(
            self, first_name, last_name,
            sex, year_of_birth=None,
            is_citizen=True,
        ):
        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

    def can_vote(self):
        return self.is_citizen

    def say_hello(self):

REFACTOR: make it better

I add a call to can_vote from test_john, in tests/test_person.py

    def test_john(self):
        first_name = 'john'
        last_name = 'smith'
        ...

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

        john = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(john.can_vote(), False)

    def test_mary(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

I add is_citizen to the instance of the Person class for john

        john = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
        )
        self.assertEqual(john.can_vote(), False)

the test passes.

I add a call to can_vote from test_jane

    def test_jane(self):
        first_name = 'jane'
        last_name = 'doe'
        ...

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

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(jane.can_vote(), False)

    def test_john(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

because a method uses the default value for a parameter when it is called without the parameter and the default value for is_citizen is True.

I change the expectation of the assertion in test_jane

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        # self.assertEqual(jane.can_vote(), False)
        self.assertEqual(jane.can_vote(), True)

    def test_john(self):

the test passes.

I remove the commented line from test_jane

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(jane.can_vote(), True)

joe and jane do not need to pass a value for the is_citizen parameter because a method uses the default value for a parameter when it is called without the parameter.

I add a git commit message in the other terminal

git commit -am \
'add is_citizen attribute'

add condition to can_vote

I want the can_vote method to use two conditions to make a decision

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

I can do that with an if statement

RED: make it fail

I go back to the terminal where the tests are running

I add a test for a person who is a citizen and younger than 18

        self.assertEqual(mary.can_vote(), False)

    def test_underage_citizen(self):
        underage = src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=self.this_year-17,
            is_citizen=True,
        )
        self.assertEqual(underage.can_vote(), False)

    def test_when_person_is_older_than_120(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

because can_vote returns the value of is_citizen, it does not care about the age of the person.
I use a calculation (datetime.date.today().year-17) as the year of birth so that the person will always be younger than 18 in any year the test is run.

GREEN: make it pass

I add an if statement with a call to the calculate_age function from the can_vote method in src/person/__init__.py

    def can_vote(self):
        age = calculate_age(self.year_of_birth)
        if age < 18:
            return False
        return self.is_citizen

    def say_hello(self):

the test passes because Python checks if age (which is the result of calculate_age(self.year_of_birth)) is less than 18, when if age < 18: runs

If age is less than 18, it goes to the next line - return False, which returns False as the output, then leaves the function since the return statement is the last thing to run in a function.

self.is_citizen = False
age < 18

person.can_vote() -> False
  └── class Person:
      └── def can_vote(self):
          └── if age < 18:
              └── return False
              return self.is_citizen

self.is_citizen = True
age < 18

person.can_vote() -> False
  └── class Person:
      └── def can_vote(self):
          └── if age < 18:
              └── return False
              return self.is_citizen

If age is greater than or equal to 18, it leaves the if statement and continues to run the rest of the method - return self.is_citizen, which returns

False as the output if the person is not a citizen

self.is_citizen = False
age >= 18

person.can_vote() -> False
└── class Person:
    └── def can_vote(self):
        ├── if age < 18:
        │      return False
        └── return self.is_citizen

True as the output, if the person is a citizen

self.is_citizen = True
age >= 18

person.can_vote() -> True
└── class Person:
    └── def can_vote(self):
        ├── if age < 18:
        │      return False
        └── return self.is_citizen

then leaves the function since the return statement is the last thing to run in a function.

I add a git commit message in the other terminal

git commit -am \
'add condition to can_vote'

add can_get_license method

RED: make it fail

I go back to the terminal where the tests are running

I add a call to can_get_license from test_mary in tests/test_person.py

        mary = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
        )
        self.assertEqual(mary.can_vote(), False)
        self.assertEqual(mary.can_get_license(), True)

    def test_underage_citizen(self):

the terminal is my friend, and shows AttributeError

AttributeError: 'Person' object
                has no attribute 'can_get_license'

GREEN: make it pass

I add a method definition for can_get_license to the Person class in src/person/__init__.py

    def __init__(
            self, first_name, last_name,
            sex, year_of_birth=None,
            is_citizen=True,
        ):
        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

    def can_get_license():
        return False

    def can_vote(self):

the terminal is my friend, and shows TypeError

TypeError: Person.can_get_license()
           takes 0 positional arguments but 1 was given

I add the staticmethod decorator

        self.is_citizen = is_citizen

    @staticmethod
    def can_get_license():
        return True

the terminal is my friend, and shows AssertionError for test_dir_person_class and test_dir_person_instance.

I add can_get_license to test_dir_person_class in tests/test_person.py

    def test_dir_person_class(self):
        self.assertEqual(
            dir(src.person.Person),
            [
                '__class__', '__delattr__', '__dict__',
                ...

                '__subclasshook__', '__weakref__',
                'can_get_license', 'can_vote', 'say_hello'
            ]
        )

    def test_dir_person_instance(self):

I add can_get_license to test_dir_person_instance

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

                '__subclasshook__', '__weakref__',
                'can_get_license', 'can_vote', 'first_name',
                'is_citizen', 'last_name', 'say_hello',
                'sex', 'year_of_birth',
            ]
        )


# Exceptions seen

the test passes.

I add a git commit message in the other terminal

git commit -am \
'add can_get_license method'

add passed_test attribute

I want can_get_license to return

False for no the person cannot get a license if the person did not pass the test.
True for yes the person can get a license if the person passed the test.

RED: make it fail

I go back to the terminal where the tests are running

I add a call to can_get_license from test_john

        john = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
        )
        self.assertEqual(john.can_vote(), False)
        self.assertEqual(john.can_get_license(), False)

    def test_mary(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

GREEN: make it pass

I add passed_test to the instance of the Person class for john

        john = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            is_citizen=False,
            passed_test=False,
        )
        self.assertEqual(john.can_vote(), False)
        self.assertEqual(john.can_get_license(), False)

the terminal is my friend, and shows TypeError

TypeError: Person.__init__() got
           an unexpected keyword argument
           'passed_test'

because the definition for the __init__ method only allows six inputs (self, first_name, last_name, sex, year_of_birth and is_citizen) and it got called with passed_test which is not one of those names.

I add passed_test to the parentheses of the __init__ method, in src/person/__init__.py

class Person:

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

the terminal is my friend, and shows SyntaxError

SyntaxError: parameter without a default
     follows parameter with a default

because parameters without default values must come before parameters with default values.

I give passed_test a value to make it optional

class Person:

    def __init__(
            self, first_name, last_name,
            sex, year_of_birth=None,
            is_citizen=True, passed_test=False,
        ):

the terminal goes back to the AssertionError.

I use self.passed_test in the can_get_license method

    @staticmethod
    def can_get_license():
        return self.passed_test
        return True

the terminal is my friend, and shows NameError

NameError: name 'self' is not defined

I remove the staticmethod decorator from the can_get_license method then add self to the parentheses

    # @staticmethod
    # def can_get_license():
    def can_get_license(self):
        return self.passed_test
        return True

the terminal is my friend, and shows AttributeError

AttributeError: 'Person' object has no attribute 'passed_test'

I add an instance attribute for passed_test so I can use it in the can_get_license method

    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

    @staticmethod
    def can_get_license():

the terminal shows AssertionError for test_mary

AssertionError: False != True

I add passed_test to the instance of the Person class for mary

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

the terminal shows AssertionError for test_dir_person_instance because I added a new attribute (passed_test).

I add passed_test to the expectation of the assertion in test_dir_person_instance in 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__',
                ...

                'can_get_license', 'can_vote', 'first_name',
                'is_citizen', 'last_name', 'passed_test',
                'say_hello', 'sex', 'year_of_birth',
            ]
        )


# Exceptions seen

the test passes.

REFACTOR: make it better

I remove the commented lines and the second return statement from the can_get_license method in src/person/__init__.py

        self.is_citizen = is_citizen
        self.passed_test = passed_test

    def can_get_license(self):
        return self.passed_test

    def can_vote(self):

I add a call to can_get_license from test_jane, in tests/test_person.py

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(jane.can_vote(), True)
        self.assertEqual(jane.can_get_license(), True)

    def test_john(self):

the terminal is my friend, and shows AssertionError

AssertionError: False != True

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

I add passed_test to the instance of the Person class for jane

        jane = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
            passed_test=True,
        )
        self.assertEqual(jane.can_vote(), True)
        self.assertEqual(jane.can_get_license(), True)

the test passes.

I add a call to can_get_license from test_joe

        joe = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(joe.can_vote(), True)
        self.assertEqual(joe.can_get_license(), True)

    def test_jane(self):

the terminal is my friend, and shows AssertionError

AssertionError: False != True

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

I change the expectation of the assertion for the can_get_license method in test_joe

        self.assertEqual(joe.can_vote(), True)
        # self.assertEqual(joe.can_get_license(), True)
        self.assertEqual(joe.can_get_license(), False)

    def test_jane(self):

the test passes.

I remove the commented line from test_joe

        joe = src.person.Person(
            first_name=first_name,
            last_name=last_name,
            sex=sex,
            year_of_birth=year_of_birth,
        )
        self.assertEqual(joe.can_vote(), True)
        self.assertEqual(joe.can_get_license(), False)

I add a git commit message in the other terminal

git commit -am \
'add passed_test attribute'

john and joe do not need to pass a value for the passed_test parameter because a method uses the default value for a parameter when it is called without the parameter.

add condition to can_get_license

I want the can_get_license method to use two conditions to make a decision

did the person pass the test?
is the person 18 or older?

RED: make it fail

I go back to the terminal where the tests are running

I add an assertion to test_underage_citizen for a person who is younger than 18 and passed the test

    def test_underage_citizen(self):
        underage = src.person.Person(
            first_name='first_name',
            last_name='last_name',
            sex='M',
            year_of_birth=self.this_year-17,
            is_citizen=True,
            passed_test=True,
        )
        self.assertEqual(underage.can_vote(), False)
        self.assertEqual(underage.can_get_license(), False)

    def test_when_person_is_older_than_120(self):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

because can_get_license currently returns the value of passed_test. It does not care about the age of the person.

GREEN: make it pass

I add an if statement with a call to the calculate_age function from the can_get_license method in src/person/__init__.py

    def can_get_license(self):
        age = calculate_age(self.year_of_birth)
        if age < 18:
            return False
        return self.passed_test

    def can_vote(self):

the test passes because Python checks if age (the result of calculate_age(self.year_of_birth)) is less than 18, when if age < 18: runs

If age is less than 18, it goes to the next line - return False, which returns False as the output, then leaves the function since the return statement is the last thing to run in a function.

self.passed_test = False
age < 18

person.can_get_license() -> False
└── class Person:
    └── def can_get_license(self):
        └── if age < 18:
            └── return False
            return self.passed_test

self.passed_test = True
age < 18

person.can_get_license() -> False
└── class Person:
    └── def can_get_license(self):
        └── if age < 18:
            └── return False
            return self.passed_test

If age is greater than or equal to 18, it leaves the if statement and continues to run the rest of the method - return self.passed_test, which returns

False as the output, if the person failed the test

self.passed_test = False
age >= 18

person.can_get_license() -> False
└── class Person:
    └── def can_get_license(self):
        ├── if age < 18:
        │      return False
        └── return self.passed_test

True as the output, if the person passed the test

self.passed_test = True
age >= 18

person.can_get_license() -> True
└── class Person:
    └── def can_get_license(self):
        ├── if age < 18:
        │      return False
        └── return self.passed_test

then leaves the function since the return statement is the last thing to run in a function.

I add a git commit message in the other terminal

git commit -am \
'add condition to can_get_license'

extract age instance attribute

The can_get_license, can_vote and say_hello methods of the Person class all call the calculate_age function.

I can make an attribute to remove the repetition of the calls to the calculate_age function.

RED: make it fail

I go back to the terminal where the tests are running

I add an instance attribute to the __init__ method so that the age is calculated once when an instance is made, not every time one of the methods is called.

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

the terminal is my friend, and shows AssertionError

FAILED ...test_dir_person_instance - AssertionError:
    Lists differ: ['__c[396 chars]_', 'age', 'can_ge...
FAILED ...test_when_person_is_older_than_120 - AssertionError
FAILED ...test_when_year_of_birth_is_not_an_integer - AssertionError
FAILED ...test_when_year_of_birth_is_the_future - AssertionError

test_when_year_of_birth_is_the_future fails because the age is smaller than 0.
test_when_year_of_birth_is_not_an_integer fails because an instance of the Person class is made with a year_of_birth (None) that is not an integer.
test_when_person_is_older_than_120 fails because the age is bigger than 120.
test_dir_person_instance fails because I just added a new object attribute.

how to skip a test

I can use unittest.skip decorator to skip a test. The problem with skipping tests is that I will no longer know if the program does the thing the skipped tests were written for.

GREEN: make it pass

I add the unittest.skip decorator to test_when_person_is_older_than_120 with a note that it fails because the age is bigger than 120, in tests/test_person.py

        self.assertEqual(underage.can_vote(), False)
        self.assertEqual(underage.can_get_license(), False)

    @unittest.skip('fails because age > 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 remove the comments from test_when_person_is_older_than_120 because they are a repetition of the message in the unittest.skip decorator

    @unittest.skip('fails because age > 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
        )

    def test_when_year_of_birth_is_the_future(self):

I add the unittest.skip decorator to test_when_year_of_birth_is_the_future with a message that it will always fail since it uses a year of birth that is in the future

    @unittest.skip('fails because age < 0')
    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

I remove the comments from test_when_year_of_birth_is_the_future

    @unittest.skip('fails because age < 0')
    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,
        )

    def test_when_year_of_birth_is_not_an_integer(self):

I add the unittest.skip decorator to test_when_year_of_birth_is_not_an_integer with a message

    @unittest.skip(
        'fails because year_of_birth is not an integer'
    )
    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):

I remove the repeated message from test_when_year_of_birth_is_not_an_integer

    @unittest.skip(
        'fails because year_of_birth is not an integer'
    )
    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):

the terminal is my friend, and shows AssertionError

================ short test summary info =================
FAILED ...::TestPerson::test_dir_person_instance -
    AssertionError: assert ['__class__',...'__eq__', ...]
                        == ['__class__',...'__eq__', ...]
======== 1 failed, 6 passed, 3 skipped in S.TUs ==========

I add age to the expectation of the assertion in test_dir_person_instance

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

                '__subclasshook__', '__weakref__',
                'age', 'can_get_license', 'can_vote',
                'first_name', 'is_citizen', 'last_name',
                'passed_test', 'say_hello', 'sex',
                'year_of_birth',
            ]
        )


# Exceptions seen

the test passes.

REFACTOR: make it better

I use self.age in the can_get_license method in src/person/__init__.py

    def can_get_license(self):
        # age = calculate_age(self.year_of_birth)
        # if age < 18:
        if self.age < 18:
            return False
        return self.passed_test

    def can_vote(self):

the tests are still green.

I use self.age in the can_vote method

    def can_vote(self):
        # age = calculate_age(self.year_of_birth)
        # if age < 18:
        if self.age < 18:
            return False
        return self.is_citizen

    def say_hello(self):

still green.

I use self.age in 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)}.'
            f' {self.age}.'
        )


def calculate_age(year_of_birth):

green.

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


def calculate_age(year_of_birth):

I add a git commit message in the other terminal

git commit -am \
'extract age instance attribute'

extract check_age method

can_get_license and can_vote look the same, they both

return False if self.age is less than 18
return something else if self.age is NOT less than 18

if self.age < 18:
    return False
return something_else

I can make a method that removes the repetition.

RED: make it fail

I add a method to the Person class that checks if the age is less than 18 and returns something else if it is not

          self.passed_test = passed_test
          self.age = calculate_age(year_of_birth)

      def check_age(status):
          if self.age < 18:
              return False
          return status

      def can_get_license(self):

the terminal is my friend, and shows AssertionError

FAILED ...test_dir_person_class - AssertionError:
    Lists differ: ['__c[393 chars]ef__', 'can_get_li...
FAILED ...test_dir_person_instance - AssertionError:
    Lists differ: ['__c[434 chars]e', 'check_age', '...

because I added a new method.

GREEN: make it pass

I add check_age to the expectation of the assertion in test_dir_person_instance

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

                '__subclasshook__', '__weakref__',
                'age', 'can_get_license', 'can_vote',
                'check_age', 'first_name', 'is_citizen',
                'last_name', 'passed_test', 'say_hello',
                'sex', 'year_of_birth',
            ]
        )


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

I add check_age to the expectation of the assertion in test_dir_person_class in tests/test_person.py

    def test_dir_person_class(self):
        self.assertEqual(
            dir(src.person.Person),
            [
                '__class__', '__delattr__', '__dict__',
                ...

                '__subclasshook__', '__weakref__',
                'can_get_license', 'can_vote', 'check_age',
                'say_hello'
            ]
        )

    def test_dir_person_instance(self):

the test passes.

REFACTOR: make it better

I call the check_age method from the can_get_license method in src/person/__init__.py

    def can_get_license(self):
        return self.check_age(self.passed_test)
        # age = calculate_age(self.year_of_birth)
        # if age < 18:
        if self.age < 18:
            return False
        return self.passed_test

    def can_vote(self):

the terminal is my friend, and shows TypeError

TypeError: Person.check_age() takes
           1 positional arguments but 2 were given

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

I add self to the parentheses of the check_age method

        self.passed_test = passed_test
        self.age = calculate_age(year_of_birth)

    def check_age(self, status):
        if self.age < 18:
            return False
        return status

    def can_get_license(self):

the test passes.

I remove the other statements from the can_get_license method

    def can_get_license(self):
        return self.check_age(self.passed_test)

    def can_vote(self):

I call the check_age method from the can_vote method

    def can_vote(self):
        return self.check_age(self.is_citizen)
        # age = calculate_age(self.year_of_birth)
        # if age < 18:
        if self.age < 18:
            return False
        return self.is_citizen

    def say_hello(self):

the tests are still green.

I remove the other statements from the can_vote method

    def can_vote(self):
        return self.check_age(self.is_citizen)

    def say_hello(self):

I add a git commit message in the other terminal

git commit -am \
'extract check_age method'

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 if statements to write a program that makes decisions based on conditions.

My tests have problems:

The attribute tests - test_dir_person_class and test_dir_person_instance catch changes to the attributes and methods of the Person class and they are a problem to maintain. There has to be a better way.
I skipped test_when_person_is_older_than_120, test_when_year_of_birth_is_the_future and test_when_year_of_birth_is_not_an_integer because they are always in a RED state since they cause an Exception. The only way to know that the code causes the Exception is to remove the unittest.skip decorator. 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 booleans (there are only two)?

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.