classes

preview

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

import datetime
import random
import src.person
import unittest


def choose(*choices):
    return random.choice(choices)


def this_year():
    return datetime.datetime.now().year


class TestPerson(unittest.TestCase):

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_first_name = choose('jane', 'joe', 'john', 'person')

    def test_factory_takes_keyword_arguments(self):
        a_person = dict(
            first_name=self.random_first_name,
            last_name=choose('doe', 'smith', 'blow', 'public'),
            sex=choose('F', 'M'),
        )

        self.assertEqual(
            src.person.factory(
                **a_person,
                year_of_birth=self.random_year_of_birth,
            ),
            dict(
                **a_person,
                age=this_year()-self.random_year_of_birth,
            )
        )

    def test_factory_w_default_arguments(self):
        self.assertEqual(
            src.person.factory(
                first_name=self.random_first_name,
                year_of_birth=self.random_year_of_birth,
            ),
            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=this_year()-self.random_year_of_birth,
            )
        )


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

requirements

how to make a person

open the project

I change directory to the person folder
```
cd person
```
the terminal shows I am in the person folder
```
.../pumping_python/person
```
I activate the virtual environment
```
source .venv/bin/activate
```
Attention

on Windows without Windows Subsystem for Linux use .venv/bin/activate.ps1 NOT source .venv/bin/activate
```
.venv/scripts/activate.ps1
```
the terminal shows
```
(.venv) .../pumping_python/person
```

I use pytest-watch to run the tests

pytest-watch

the terminal shows

rootdir: .../pumping_python/person
collected 2 items

tests/test_person.py ..                                             [100%]

============================ 2 passed in X.YZs =============================

I hold ctrl on the keyboard and click on tests/test_person.py to open it in the editor

test_factory_person_greeting

I have a function that takes in first name, last name, sex and year of birth for a person and returns a dictionary with the first name, last name, sex and age based on the year of birth.

What if I want the person to send a message about themselves. How would I do that? I can write a function that takes in a person and returns a message

I add a new test where I make a person

            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=this_year()-self.random_year_of_birth,
            )
        )

    def test_factory_person_greeting(self):
        joe = src.person.factory(
            first_name='joe',
            last_name='blow',
            year_of_birth=1996,
        )


# Exceptions seen

the factory function will give joe a default value of 'M' for sex because I did not give a value for it

I add another person

    def test_factory_person_greeting(self):
        joe = src.person.factory(
            first_name='joe',
            last_name='blow',
            year_of_birth=1996,
        )
        jane = src.person.factory(
            first_name='jane',
            sex='F',
            year_of_birth=1991,
        )


# Exceptions

the factory function will give jane a default value of doe for last_name because I did not give a value for it

I add one more person

        jane = src.person.factory(
            first_name='jane',
            sex='F',
            year_of_birth=1991,
        )
        john = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )


# Exceptions seen

RED: make it fail

I add a for loop with the subTest method and an assertion

        john = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )

        for person in (joe, jane, john):
            with self.subTest(name=person.get('first_name')):
                self.assertEqual(
                    src.person.hello(person),
                    None
                )


# Exceptions seen

the terminal shows AttributeError for each one of the people

AttributeError: module 'src.person' has no attribute 'hello'

person.py does not have a function named hello

GREEN: make it pass

I open person.py in the editor

I add the function to person.py

def factory(
        first_name, year_of_birth,
        last_name='doe', sex='M',
    ):
    return {
        'first_name': first_name,
        'last_name': last_name,
        'sex': sex,
        'age': datetime.datetime.today().year - year_of_birth,
    }


def hello():
    return None

the terminal shows TypeError

TypeError: hello() takes 0 positional arguments but 1 was given

I add a name to the definition
```
16def hello(person):
17    return None
```
the test passes

REFACTOR: make it better

I want the hello function to return a message for the person I give as input

I change the expectation in test_factory_person_greeting in test_person.py with an f-string like I did in how to pass values

        for person in (joe, jane, john):
            with self.subTest(name=person.get('first_name')):
                self.assertEqual(
                    src.person.hello(person),
                    (
                        f'Hi, my name is {person.get("first_name")} '
                        f'{person.get("last_name")} '
                        f'and I am {person.get("age")}'
                    )
                )

the terminal shows AssertionError

AssertionError: None != 'Hi, my name is john smith and I am 446'

I copy the value from the terminal and paste it in the return statement in person.py

def hello(person):
    return 'Hi, my name is john smith and I am 446'

the terminal shows AssertionError

E               - Hi, my name is john smith and I am 446
E               + Hi, my name is jane doe and I am 35

the first name, last name and ages are different

I change the string to an f-string with the value for first_name

def hello(person):
    return f'Hi, my name is {person.get("first_name")} smith and I am 446'

the terminal shows AssertionError

E               - Hi, my name is jane smith and I am 446
E               ?                     ^^^^^          ^^^
E               + Hi, my name is jane doe and I am 35
E               ?                     ^^^          ^^

the first name is the same, the last name and ages are different

I change the return statement

def hello(person):
    return (
        f'Hi, my name is {person.get("first_name")} '
        f'{person.get("last_name")} and I am 446'
    )

the terminal shows AssertionError

E               - Hi, my name is jane doe and I am 446
E               ?                                  ^^^
E               + Hi, my name is jane doe and I am 35
E               ?                                  ^^

the age is the only thing that is different now

I add the age to the return statement

def hello(person):
    return (
        f'Hi, my name is {person.get("first_name")} '
        f'{person.get("last_name")} '
        f'and I am {person.get("age")}'
    )

the test passes

The solution works, it needs different functions - one to make the person and one to make the message.

test_classy_person_greeting

I can also make a person with a class

RED: make it fail

I add a new test to test_person.py

        for person in (joe, jane, john):
            with self.subTest(name=person.get('first_name')):
                self.assertEqual(
                    src.person.hello(person),
                    (
                        f'Hi, my name is {person.get("first_name")} '
                        f'{person.get("last_name")} '
                        f'and I am {person.get("age")}'
                    )
                )

    def test_classy_person_greeting(self):
        joe = src.person.Person(
            first_name='joe',
            last_name='blow',
            year_of_birth=1996,
        )


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.person' has no attribute 'Person'

GREEN: make it pass

I add a class in person.py

def hello(person):
    return (
        f'Hi, my name is {person.get("first_name")} '
        f'{person.get("last_name")} '
        f'and I am {person.get("age")}'
    )


class Person:

    pass

the terminal shows TypeError

TypeError: Person() takes no arguments

classes have a constructor method that is used to make copies of the class. I add it

class Person:

    def __init__():
        return None

the terminal shows TypeError

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

I add the name

class Person:

    def __init__(first_name):
        return None

the terminal shows TypeError

TypeError: Person.__init__() got multiple values for argument 'first_name'

The __init__ method takes the class as the first argument. I add self the way I do with all the tests in the book

class Person:

    def __init__(self, first_name):
        return None

the terminal shows TypeError

TypeError: Person.__init__() got an unexpected keyword argument 'last_name'. Did you mean 'first_name'?

I have seen this before, so far it is the same as making the factory function

I add last_name

    def __init__(self, first_name, last_name):
        return None

the terminal shows TypeError

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

still the same as making the factory function

I add year_of_birth to the definition

class Person:

    def __init__(
            self, first_name, last_name,
            year_of_birth,
        ):
        return

the test passes

REFACTOR: make it better

I add the next person to test_classy_person_greeting

    def test_classy_person_greeting(self):
        joe = src.person.Person(
            first_name='joe',
            last_name='blow',
            year_of_birth=1996,
        )
        jane = src.person.Person(
            first_name='jane',
            sex='F',
            year_of_birth=1991,
        )

the terminal shows TypeError

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

I add sex to the __init__ method in person.py

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

the terminal shows TypeError

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

I did not provide a value for sex when I made joe, and the factory function has a default value of 'M' for it

I add a default value for sex in the __init__ method

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

the terminal shows SyntaxError

SyntaxError: parameter without a default follows parameter with a default

I cannot put a parameter that does NOT have a default value after a parameter that has a default value

I add a default value for year_of_birth

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

the test passes

I add the next person

        jane = src.person.Person(
            first_name='jane',
            sex='F',
            year_of_birth=1991,
        )
        john = src.person.Person(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )


# Exceptions seen

the test is still green

I copy the for loop with the assertion from test_factory_person_greeting and paste it in test_classy_person_greeting

        john = src.person.Person(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )

        for person in (joe, jane, john):
            with self.subTest(name=person.get('first_name')):
                self.assertEqual(
                    src.person.hello(person),
                    (
                        f'Hi, my name is {person.get("first_name")} '
                        f'{person.get("last_name")} '
                        f'and I am {person.get("age")}'
                    )
                )


# Exceptions seen

the terminal shows AttributeError

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

the Person class does not have a method named get

I can use class attributes directly with no need for a get method. I change the line for the subTest method

        for person in (joe, jane, john):
            with self.subTest(name=person.first_name):
                self.assertEqual(

the terminal shows AttributeError

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

I add a class attribute to the __init__ method of the Person class in person.py

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

the terminal shows AttributeError

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

the test calls the hello function which takes in a dictionary and calls the get method, the Person object does not have a get method

I can call methods from outside a class the way I use a class attribute. I change the call in the assertion in test_person.py

                self.assertEqual(
                    person.hello(person),
                    (
                        f'Hi, my name is {person.get("first_name")} '
                        f'{person.get("last_name")} '
                        f'and I am {person.get("age")}'
                    )
                )

the terminal shows AttributeError

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

I add the method to the Person class in person.py

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

    def hello():
        return None

the terminal shows TypeError

TypeError: Person.hello() takes 0 positional arguments but 2 were given

the test calls the method with one input and the definition takes no input

I add the staticmethod decorator to the method because it does not use anything in the class

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

    @staticmethod
    def hello():
        return None

the terminal shows TypeError

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

I add a name to the definition

    @staticmethod
    def hello(person):
        return None

the terminal shows AttributeError

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

I change the assertion in test_classy_person_greeting in test_person.py to use the first_name class attribute

                self.assertEqual(
                    person.hello(person),
                    (
                        f'Hi, my name is {person.first_name} '
                        f'{person.get("last_name")} '
                        f'and I am {person.get("age")}'
                    )
                )

the terminal shows AttributeError

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

I make the same change for the last name

                self.assertEqual(
                    person.hello(person),
                    (
                        f'Hi, my name is {person.first_name} '
                        f'{person.last_name} '
                        f'and I am {person.get("age")}'
                    )
                )

the terminal shows AttributeError

AttributeError: 'Person' object has no attribute 'last_name'. Did you mean: 'first_name'?

I add a class attribute for last_name to the __init__ method of the Person class in person.py

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

    @staticmethod
    def hello(person):

the terminal shows AttributeError

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

I want to use a method to calculate the age. I change the assertion in test_person.py

                self.assertEqual(
                    person.hello(person),
                    (
                        f'Hi, my name is {person.first_name} '
                        f'{person.last_name} '
                        f'and I am {person.get_age()}'
                    )
                )

the terminal shows AttributeError

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

I add the method to the Person class in person.py

    @staticmethod
    def hello(person):
        return None

    def get_age():
        return None

the terminal shows TypeError

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

I add the staticmethod decorator

    @staticmethod
    def hello(person):
        return None

    @staticmethod
    def get_age():
        return None

the terminal shows AssertionError

AssertionError: None != 'Hi, my name is john smith and I am None'

I copy and paste the string in the return statement of the hello method

    @staticmethod
    def hello(person):
        return 'Hi, my name is john smith and I am None'

the terminal shows AssertionError

E               - Hi, my name is john smith and I am None
E               ?                  - ^^^^^^
E               + Hi, my name is jane None and I am None
E               ?                 +++++  ^

the value for first name and last name are different

I change the string in the return statement to an f-string with the value for first_name

    @staticmethod
    def hello(person):
        return f'Hi, my name is {person.first_name} smith and I am None'

the terminal shows AssertionError

E               - Hi, my name is jane smith and I am None
E               ?                     ^^^^^
E               + Hi, my name is jane None and I am None
E               ?                     ^^^^

the values for the last name are different

I add it to the f-string

    @staticmethod
    def hello(person):
        return (
            f'Hi, my name is {person.first_name} '
            f'{person.last_name} and I am None'
        )

the test passes

I can call a method that belongs to a class without the need to pass in the class as input since I can use the class with self. I remove the repetition of the Person object in the call to the hello method in test_person.py

        for person in (joe, jane, john):
            with self.subTest(name=person.first_name):
                self.assertEqual(
                    person.hello(),
                    (
                        f'Hi, my name is {person.first_name} '
                        f'{person.last_name} '
                        f'and I am {person.get_age()}'
                    )
                )


# Exceptions seen

the terminal shows TypeError

TypeError: Person.hello() missing 1 required positional argument: 'person'

I remove the staticmethod decorator from the hello method in person.py

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

    def hello(person):
        return (
            f'Hi, my name is {person.first_name} '
            f'{person.last_name} and I am None'
        )

the test passes.

This works because person in the parentheses is for the Person class that the hello method is part of.

When I wrapped the hello function with the staticmethod decorator, it was a function that did not use other parts (class attributes and methods) of the class it belongs to.

I use the Rename Symbol feature of the Integrated Development Environment (IDE) to change the name of the input parameter from person to self to match Python convention
```
34    def hello(self):
35        return (
36            f'Hi, my name is {self.first_name} '
37            f'{self.last_name} and I am None'
38        )
```
the test is still green, and there is a problem with the last name and age.

test_update_factory_person_year_of_birth

I made a person named john in test_factory_person_greeting and test_classy_person_greeting with a year of birth of 1580.

Maybe I made a mistake when typing his age and typed 5 instead of 9. How would I change the year of birth of a person made with the factory function if I cannot change the original year of birth?

I could try updating the year_of_birth
I could try making a function that takes a person and a new year of birth as inputs, and returns the person with the correct age
I could make a new factory function that returns a dictionary with year_of_birth as a key which allows me to change it, then make another function that calculates the age from the returned dictionary - this sounds like a lot of work, I would also have to rewrite the tests. No, thank you
I could make a class

RED: make it fail

I cannot update the year_of_birth key because the function returns a dictionary that does not have a year_of_birth key. I add a new test

          for person in (joe, jane, john):
              with self.subTest(name=person.first_name):
                  self.assertEqual(
                      person.hello(),
                      (
                          f'Hi, my name is {person.first_name} '
                          f'{person.last_name} '
                          f'and I am {person.get_age()}'
                      )
                  )

      def test_update_factory_person_year_of_birth(self):
          person = src.person.factory(
              first_name='john',
              last_name='smith',
              year_of_birth=1580,
          )
          self.assertEqual(person.get('age', 0))


  # Exceptions seen

the terminal shows AssertionError

AssertionError: 446 != 0

GREEN: make it passs

I change the expectation

        self.assertEqual(person.get('age'), 446)

the test passes

REFACTOR: make it better

I try to use the year_of_birth key

        self.assertEqual(person.get('age'), 446)

        person['year_of_birth']

# Exceptions seen

the terminal shows KeyError

KeyError: 'year_of_birth'

there is no year_of_birth key in the dictionary returned by the factory function

I add KeyError to the list of Exceptions seen

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

I add assertRaises

        self.assertEqual(person.get('age'), 446)

        with self.assertRaises(KeyError):
            person['year_of_birth']

# Exceptions seen

the test passes

I add a new value for year_of_birth with the setdefault method

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', 1980),
            None
        )


# Exceptions seen

the terminal shows AssertionError

AssertionError: 1980 != None

I change the expectation

        self.assertEqual(
            person.setdefault('year_of_birth', 1980),
            1980
        )

the test passes because the dictionary now has a key named year_of_birth with the new value

I add an assertion for the age of john smith again

        self.assertEqual(
            person.setdefault('year_of_birth', 1980),
            1980
        )
        self.assertEqual(person.get('age'), 46)

# Exceptions seen

the terminal shows AssertionError

AssertionError: 446 != 46

the factory function uses the value for year_of_birth to calculate the age when it makes the dictionary.

When I change the value or add the key, it does not do anything to the age. There has to be a better way

I change the expectation

self.assertEqual(person.get('age'), 446)

the test passes

I can make a function that takes a person and a new year of birth as inputs, and returns the person with the correct age. I add an assertion

        self.assertEqual(person.get('age'), 446)

        self.assertEqual(
            src.person.update_year_of_birth(person, 1980),
            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                age=this_year()-1980,
            )
        )


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.person' has no attribute 'update_year_of_birth'

I add the function to person.py

def hello(person):
    return (
        f'Hi, my name is {person.get("first_name")} '
        f'{person.get("last_name")} '
        f'and I am {person.get("age")}'
    )


def update_year_of_birth():
    return None


class Person:

the terminal shows TypeError

TypeError: update_year_of_birth() takes 0 positional arguments but 2 were given

I add the two names in parentheses

def update_year_of_birth(person, new_year_of_birth):
    return None

the terminal shows AssertionError

AssertionError: None != {'first_name': 'john', 'last_name': 'smith', 'sex': 'M', 'age': 46}

I change the return statement

def update_year_of_birth(person, new_year_of_birth):
    return factory(
        first_name=person.get('first_name'),
        last_name=person.get('last_name'),
        sex=person.get('sex'),
        year_of_birth=new_year_of_birth,
    )


class Person:

the test passes

time to remove some duplication. I add a variable for the original year of birth in test_update_factory_person_year_of_birth in test_person.py

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580

        person = src.person.factory(

the test is still green

I use the variable in the call to src.person.factory

        original_year_of_birth = 1580

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            # year_of_birth=1580,
            year_of_birth=original_year_of_birth,
        )

still green

I use the variable in the first assertion for the age

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            # year_of_birth=1580,
            year_of_birth=original_year_of_birth,
        )
        # self.assertEqual(person.get('age'), 446)
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        with self.assertRaises(KeyError):

green

I use the variable in the second assertion for the age

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', 1980),
            1980
        )
        # self.assertEqual(person.get('age'), 446)
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        self.assertEqual(

still green

I remove the commented lines

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=original_year_of_birth,
        )
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', 1980),
            1980
        )
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        self.assertEqual(
            src.person.update_year_of_birth(person, 1980),
            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                age=this_year()-1980,
            )
        )


# Exceptions seen

the test is still green

I add a variable for the new year of birth

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580
        new_year_of_birth = 1980

        person = src.person.factory(

still green

I use the variable in the assertion for the call to the setdefault method

          with self.assertRaises(KeyError):
              person['year_of_birth']
          self.assertEqual(
              # person.setdefault('year_of_birth', 1980),
              person.setdefault('year_of_birth', new_year_of_birth),
              # 1980
              new_year_of_birth
          )
          self.assertEqual(

the test is still green

I use the variable in the last assertion

        self.assertEqual(
            # src.person.update_year_of_birth(person, 1980),
            src.person.update_year_of_birth(
                person,
                new_year_of_birth
            ),
            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                # age=this_year()-1980,
                age=this_year()-new_year_of_birth,
            )
        )


# Exceptions seen

still green

I remove the commented lines

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580
        new_year_of_birth = 1980

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=original_year_of_birth,
        )
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', new_year_of_birth),
            new_year_of_birth
        )
        self.assertEqual(
            person.get('age'),
            this_year()-original_year_of_birth
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                person,
                new_year_of_birth
            ),
            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                age=this_year()-new_year_of_birth,
            )
        )


# Exceptions seen

green

I add a variable for the original age calculation

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580
        original_age = this_year() - original_year_of_birth
        new_year_of_birth = 1980

I use the variable in the first assertion for the age

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=original_year_of_birth,
        )
        self.assertEqual(
            person.get('age'),
            # this_year()-original_year_of_birth
            original_age
        )

the test is still green

I use the variable in the second assertion for the age

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', new_year_of_birth),
            new_year_of_birth
        )
        self.assertEqual(
            person.get('age'),
            # this_year()-original_year_of_birth
            original_age
        )

still green

I remove the commented lines

    def test_update_factory_person_year_of_birth(self):
        original_year_of_birth = 1580
        original_age = this_year() - original_year_of_birth
        new_year_of_birth = 1980

        person = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=original_year_of_birth,
        )
        self.assertEqual(
            person.get('age'),
            original_age
        )

        with self.assertRaises(KeyError):
            person['year_of_birth']
        self.assertEqual(
            person.setdefault('year_of_birth', new_year_of_birth),
            new_year_of_birth
        )
        self.assertEqual(
            person.get('age'),
            original_age
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                person,
                new_year_of_birth
            ),
            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                age=this_year()-new_year_of_birth,
            )
        )


# Exceptions seen

I had to make a new person with the same first name, last name, sex and the new year of birth to change the year of birth. How would I solve this problem with a class?

test_update_classy_person_year_of_birth

RED: make it fail

I add a new test

            dict(
                first_name=person.get('first_name'),
                last_name=person.get('last_name'),
                sex=person.get('sex'),
                age=this_year()-new_year_of_birth,
            )
        )

    def test_update_classy_person_year_of_birth(self):
        person = src.person.Person(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )
        self.assertEqual(person.get_age(), 0)


# Exceptions seen

the terminal shows AssertionError

AssertionError: None != 0

the get_age method returns None. I want it to return the difference between this year and the year of birth

GREEN: make it pass

I add a calculation to the get_age method in person.py

    @staticmethod
    def get_age():
        return this_year() - self.year_of_birth

the terminal shows NameError

NameError: name 'this_year' is not defined

I add the function at the top of the file

import datetime

def this_year():
    return datetime.datetime.today().year

def factory(

the terminal shows NameError

NameError: name 'self' is not defined

I add self to the definition of the get_age method parentheses

    @staticmethod
    def get_age(self):
        return this_year() - self.year_of_birth

the terminal shows TypeError

TypeError: Person.get_age() missing 1 required positional argument: 'self'

I remove the staticmethod decorator from the get_age method

    def hello(self):
        return (
            f'Hi, my name is {self.first_name} '
            f'{self.last_name} and I am None'
        )

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

the terminal shows TypeError

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

I add a class attribute to the __init__ method

class Person:

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

    def hello(self):
        return (
            f'Hi, my name is {self.first_name} '
            f'{self.last_name} and I am {self.get_age()}'
        )

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

the terminal shows AssertionError

AssertionError: 446 != 0

I change the expectation in test_person.py

        self.assertEqual(person.get_age(), 446)

the terminal shows AssertionError

E               - Hi, my name is john smith and I am None
E               ?                                    ^^^^
E               + Hi, my name is john smith and I am 446
E               ?                                    ^^^

test_update_factory_person_year_of_birth expects a number, the hello method returns None

I add a call to the get_age method in the hello method in person.py

    def hello(self):
        return (
            f'Hi, my name is {self.first_name} '
            f'{self.last_name} and I am {self.get_age()}'
        )

the test passes

REFACTOR: make it better

I use the this_year function in the factory function in person.py

def factory(
        first_name, year_of_birth,
        last_name='doe', sex='M',
    ):
    return {
        'first_name': first_name,
        'last_name': last_name,
        'sex': sex,
        # 'age': datetime.datetime.today().year - year_of_birth,
        'age': this_year() - year_of_birth,
    }

the test is still green

I remove the commented lines

def factory(
        first_name, year_of_birth,
        last_name='doe', sex='M',
    ):
    return {
        'first_name': first_name,
        'last_name': last_name,
        'sex': sex,
        'age': this_year() - year_of_birth,
    }

I can change the value of a class attribute after the object has been made, kind of like I did in test_setting_items_in_a_list. I add a statement to test_update_classy_person_year_of_birth in test_person.py
```
156        self.assertEqual(person.get_age(), 446)
157
158        person.year_of_birth = 1980
159
160
161# Exceptions seen
```

I add another assertion for the age calculation

        self.assertEqual(person.get_age(), 446)

        person.year_of_birth = 1980
        self.assertEqual(person.get_age(), 446)

# Exceptions seen

the terminal shows AssertionError

AssertionError: 46 != 446

I change the expectation in the assertion
```
159        self.assertEqual(person.get_age(), this_year()-1980)
```
the test passes. Wait! That was a lot simpler than doing it with just functions

I add a variable to remove repetition

        self.assertEqual(person.get_age(), 446)

        new_year_of_birth = 1980
        person.year_of_birth = 1980
        self.assertEqual(person.get_age(), this_year()-1980)


# Exceptions seen

I use the variable

        new_year_of_birth = 1980
        # person.year_of_birth = 1980
        person.year_of_birth = new_year_of_birth
        # self.assertEqual(person.get_age(), this_year()-1980)
        self.assertEqual(
            person.get_age(),
            this_year()-new_year_of_birth
        )


# Exceptions seen

the test is still green

I remove the commented lines

    def test_update_classy_person_year_of_birth(self):
        person = src.person.Person(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )
        self.assertEqual(person.get_age(), 446)

        new_year_of_birth = 1980
        person.year_of_birth = new_year_of_birth
        self.assertEqual(
            person.get_age(),
            this_year()-new_year_of_birth
        )


# Exceptions seen

still green

Note

Classes have attributes that can be changed.
Since the age calculation uses the year_of_birth, and is done when I call it, not when the person is made, it will always calculate the right age.
It is easier to make changes to a person when I use a class than when I use only functions

test with random person

I want to add randomness to the test

I add a class attribute for last_name to the setUp method in test_person.py

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_first_name = choose('jane', 'joe', 'john', 'person')
        self.random_last_name = choose('doe', 'smith', 'blow', 'public')

    def test_factory_takes_keyword_arguments(self):

self.random_first_name and self.random_last_name look the same. I add a class attribute for the values of the names passed to the choose function

class TestPerson(unittest.TestCase):

    RANDOM_NAMES = (
        'jane', 'joe', 'john', 'person',
        'doe', 'smith', 'blow', 'public',
    )

    def setUp(self):

I use RANDOM_NAMES in the calls to the choose function for random_first_name and random_last_name

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        # self.random_first_name = choose('jane', 'joe', 'john', 'person')
        self.random_first_name = choose(*self.RANDOM_NAMES)
        # self.random_last_name = choose('doe', 'smith', 'blow', 'public')
        self.random_last_name = choose(*self.RANDOM_NAMES)

the tests are still green and there are now more names to choose from

I remove the commented lines

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_first_name = choose(*self.RANDOM_NAMES)
        self.random_last_name = choose(*self.RANDOM_NAMES)

    def test_factory_takes_keyword_arguments(self):

I use self.random_last_name in test_factory_takes_keyword_arguments

    def test_factory_takes_keyword_arguments(self):
        a_person = dict(
            first_name=self.random_first_name,
            # last_name=choose('doe', 'smith', 'blow', 'public'),
            last_name=self.random_last_name,
            sex=choose('F', 'M'),
        )

the test is still green

I remove the commented line

    def test_factory_takes_keyword_arguments(self):
        a_person = dict(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            sex=choose('F', 'M'),
        )

still green

I add a class attribute for sex to the setUp method

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_first_name = choose(*self.RANDOM_NAMES)
        self.random_last_name = choose(*self.RANDOM_NAMES)
        self.random_sex = choose('M', 'F')

    def test_factory_takes_keyword_arguments(self):

I use the new class attribute in test_factory_takes_keyword_arguments

    def test_factory_takes_keyword_arguments(self):
        a_person = dict(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            # sex=choose('F', 'M'),
            sex=self.random_sex,
        )

green

I remove the commented line

    def test_factory_takes_keyword_arguments(self):
        a_person = dict(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            sex=self.random_sex,
        )

still green

I make a random person with the factory function in the setUp method

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_first_name = choose(*self.RANDOM_NAMES)
        self.random_last_name = choose(*self.RANDOM_NAMES)
        self.random_sex = choose('M', 'F')
        self.random_factory_person = src.person.factory(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            sex=self.random_sex,
            year_of_birth=self.random_year_of_birth,
        )

    def test_factory_takes_keyword_arguments(self):

I use the random_factory_person class attribute in the expectation of the assertion in test_factory_takes_keyword_arguments

        self.assertEqual(
            src.person.factory(
                **a_person,
                year_of_birth=self.random_year_of_birth,
            ),
            # dict(
            #     **a_person,
            #     age=this_year()-self.random_year_of_birth,
            # )
            self.random_factory_person
        )

    def test_factory_w_default_arguments(self):

the test is still green

I no longer need the a_person variable, I can use the class attributes

        self.assertEqual(
            src.person.factory(
                # **a_person,
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                year_of_birth=self.random_year_of_birth,
            ),
            # dict(
            #     **a_person,
            #     age=this_year()-self.random_year_of_birth,
            # )
            self.random_factory_person
        )

green

I remove the commented lines and the a_person dictionary

    def test_factory_takes_keyword_arguments(self):
        self.assertEqual(
            src.person.factory(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                year_of_birth=self.random_year_of_birth,
            ),
            self.random_factory_person
        )

    def test_factory_w_default_arguments(self):

green again. Do I still need test_factory_takes_keyword_arguments?

I add an assertion with the random_factory_person class attribute to test_factory_person_greeting

        john = src.person.factory(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )

        self.assertEqual(
            src.person.hello(self.random_factory_person),
            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                f'and I am {this_year()-self.random_year_of_birth}'
            )
        )

        for person in (joe, jane, john):

the test is still green

I remove the 3 people I made with the factory function and the for loop with the assertion because they are no longer needed, the random person covers all their cases and more

    def test_factory_person_greeting(self):
        self.assertEqual(
            src.person.hello(self.random_factory_person),
            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                f'and I am {this_year()-self.random_year_of_birth}'
            )
        )

    def test_classy_person_greeting(self):

still

I have to make a random person with the Person class to do the same thing for test_classy_person_greeting. I will come back to it

I use the random_year_of_birth class attribute in test_update_factory_person_year_of_birth

    def test_update_factory_person_year_of_birth(self):
        # original_year_of_birth = 1580
        original_year_of_birth = self.random_year_of_birth

the test is still green

I use the class attribute in the calculation

    def test_update_factory_person_year_of_birth(self):
        # original_year_of_birth = 1580
        original_year_of_birth = self.random_year_of_birth
        # original_age = this_year() - original_year_of_birth
        original_age = this_year() - self.random_year_of_birth
        new_year_of_birth = 1980

still green

I point person to the self.random_factory_person class attribute

        new_year_of_birth = 1980

        # person = src.person.factory(
        #     first_name='john',
        #     last_name='smith',
        #     year_of_birth=original_year_of_birth,
        # )
        person = self.random_factory_person
        self.assertEqual(

still green

I use the self.random_factory_person class attribute in the first assertion

        person = self.random_factory_person
        self.assertEqual(
            # person.get('age'),
            self.random_factory_person.get('age'),
            original_age
        )

        with self.assertRaises(KeyError):

still green

I remove the commented lines and the original_year_of_birth variable

    def test_update_factory_person_year_of_birth(self):
        original_age = this_year() - self.random_year_of_birth
        new_year_of_birth = 1980

        person = self.random_factory_person
        self.assertEqual(
            self.random_factory_person.get('age'),
            original_age
        )

        with self.assertRaises(KeyError):

I use the class attribute in the assertRaises block

        with self.assertRaises(KeyError):
            # person['year_of_birth']
            self.random_factory_person['year_of_birth']
        self.assertEqual(

still green

I use the self.random_factory_person class attribute in the assertion for the setdefault method

        self.assertEqual(
            # person.setdefault('year_of_birth', new_year_of_birth),
            self.random_factory_person.setdefault(
                'year_of_birth', new_year_of_birth
            ),
            new_year_of_birth
        )

still green

I use self.random_factory_person in the second assertion for the age

        self.assertEqual(
            # person.get('age'),
            self.random_factory_person.get('age'),
            original_age
        )

still green

I remove the commented lines

        with self.assertRaises(KeyError):
            self.random_factory_person['year_of_birth']
        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', new_year_of_birth
            ),
            new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            original_age
        )

the test is still green

I use the class attribute in the call to src.person.update_year_of_birth in the assertion for the year_of_birth update

        self.assertEqual(
            src.person.update_year_of_birth(
                # person,
                self.random_factory_person,
                new_year_of_birth
            ),

still green

I use the other class attributes in the expected dictionary of the assertion

            dict(
                # first_name=person.get('first_name'),
                first_name=self.random_first_name,
                # last_name=person.get('last_name'),
                last_name=self.random_last_name,
                # sex=person.get('sex'),
                sex=self.random_sex,
                age=this_year()-new_year_of_birth,
            )

green

I remove the commented lines and the person variable

    def test_update_factory_person_year_of_birth(self):
        original_age = this_year() - self.random_year_of_birth
        new_year_of_birth = 1980

        self.assertEqual(
            self.random_factory_person.get('age'),
            original_age
        )

        with self.assertRaises(KeyError):
            self.random_factory_person['year_of_birth']
        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', new_year_of_birth
            ),
            new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            original_age
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                self.random_factory_person,
                new_year_of_birth
            ),
            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                age=this_year()-new_year_of_birth,
            )
        )

    def test_update_classy_person_year_of_birth(self):

still green

this_year() - self.random_year_of_birth is in the tests a few times. I add a class attribute for it in the setUp method

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.original_age = this_year() - self.random_year_of_birth
        self.random_first_name = choose(*self.RANDOM_NAMES)
        self.random_last_name = choose(*self.RANDOM_NAMES)

I use the new class attribute in test_factory_w_default_arguments

            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                # age=this_year()-self.random_year_of_birth,
                age=self.original_age,
            )

the test is still green

I remove the commented line

    def test_factory_w_default_arguments(self):
        self.assertEqual(
            src.person.factory(
                first_name=self.random_first_name,
                year_of_birth=self.random_year_of_birth,
            ),
            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=self.original_age,
            )
        )

    def test_factory_person_greeting(self):

green

I use the class attribute in test_factory_person_greeting

            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                # f'and I am {this_year()-self.random_year_of_birth}'
                f'and I am {self.original_age}'
            )

the test is still green

I remove the commented line

    def test_factory_person_greeting(self):
        self.assertEqual(
            src.person.hello(self.random_factory_person),
            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                f'and I am {self.original_age}'
            )
        )

    def test_classy_person_greeting(self):

still green

I use self.original_age in test_update_factory_person_year_of_birth

    def test_update_factory_person_year_of_birth(self):
        # original_age = this_year() - self.random_year_of_birth
        original_age = self.original_age
        new_year_of_birth = 1980

the test is still green

I use self.original_age in the first assertion

        new_year_of_birth = 1980

        self.assertEqual(
            self.random_factory_person.get('age'),
            # original_age
            self.original_age
        )

green

I use it in the second assertion for the age

        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', new_year_of_birth
            ),
            new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            # original_age
            self.original_age
        )

        self.assertEqual(

still green

I remove the commented line and the original_age variable

    def test_update_factory_person_year_of_birth(self):
        new_year_of_birth = 1980

        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        with self.assertRaises(KeyError):
            self.random_factory_person['year_of_birth']
        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', new_year_of_birth
            ),
            new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                self.random_factory_person,
                new_year_of_birth
            ),
            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                age=this_year()-new_year_of_birth,
            )
        )

    def test_update_classy_person_year_of_birth(self):

I add a random person made with the Person class to the setUp method

        self.random_factory_person = src.person.factory(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            sex=self.random_sex,
            year_of_birth=self.random_year_of_birth,
        )
        self.random_classy_person = src.person.Person(
            first_name=self.random_first_name,
            last_name=self.random_last_name,
            sex=self.random_sex,
            year_of_birth=self.random_year_of_birth,
        )

    def test_factory_takes_keyword_arguments(self):

I add an assertion with the new class attribute to test_classy_person_greeting

        john = src.person.Person(
            first_name='john',
            last_name='smith',
            year_of_birth=1580,
        )

        self.assertEqual(
            self.random_classy_person.hello(),
            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                f'and I am {self.original_age}'
            )
        )

        for person in (joe, jane, john):

still green

I remove the 3 people I made with the Person class and the for loop with its assertion because they are no longer needed, the random person covers those cases and more

    def test_classy_person_greeting(self):
        self.assertEqual(
            self.random_classy_person.hello(),
            (
                f'Hi, my name is {self.random_first_name} '
                f'{self.random_last_name} '
                f'and I am {self.original_age}'
            )
        )

    def test_update_factory_person_year_of_birth(self):

still green

the expected message in test_classy_person_greeting and test_factory_person_greeting are now the same. I add a method to remove the repetition

            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=self.original_age
            )
        )

    def expected_greeting(self):
        return (
            f'Hi, my name is {self.random_first_name} '
            f'{self.random_last_name} '
            f'and I am {self.original_age}'
        )

    def test_factory_person_greeting(self):

I use the new method in test_factory_person_greeting

    def test_factory_person_greeting(self):
        self.assertEqual(
            src.person.hello(self.random_factory_person),
            # (
            #     f'Hi, my name is {self.random_first_name} '
            #     f'{self.random_last_name} '
            #     f'and I am {self.original_age}'
            # )
            self.expected_greeting()
        )

    def test_classy_person_greeting(self):

the test is still green

I use it in test_classy_person_greeting

    def test_classy_person_greeting(self):
        self.assertEqual(
            self.random_classy_person.hello(),
            # (
            #     f'Hi, my name is {self.random_first_name} '
            #     f'{self.random_last_name} '
            #     f'and I am {self.original_age}'
            # )
            self.expected_greeting()
        )

    def test_update_factory_person_year_of_birth(self):

still green

I remove the commented lines

    def expected_greeting(self):
        return (
            f'Hi, my name is {self.random_first_name} '
            f'{self.random_last_name} '
            f'and I am {self.original_age}'
        )

    def test_factory_person_greeting(self):
        self.assertEqual(
            src.person.hello(self.random_factory_person),
            self.expected_greeting()
        )

    def test_classy_person_greeting(self):
        self.assertEqual(
            self.random_classy_person.hello(),
            self.expected_greeting()
        )

    def test_update_factory_person_year_of_birth(self):

green

I use the random_classy_person class attribute in test_update_classy_person_year_of_birth

    def test_update_classy_person_year_of_birth(self):
        # person = src.person.Person(
        #     first_name='john',
        #     last_name='smith',
        #     year_of_birth=1580,
        # )
        person = self.random_classy_person
        self.assertEqual(person.get_age(), 446)

the terminal shows AssertionError

AssertionError: X != 446

I use self.original_age in the first assertion for the age

        person = self.random_classy_person
        # self.assertEqual(person.get_age(), 446)
        self.assertEqual(person.get_age(), self.original_age)

        new_year_of_birth = 1980

the test is green again

I remove the commented lines then use self.random_classy_person in the first assertion

    def test_update_classy_person_year_of_birth(self):
        person = self.random_classy_person
        self.assertEqual(
            # person.get_age(),
            self.random_classy_person.get_age(),
            self.original_age
        )

        new_year_of_birth = 1980

the test is still green

I use the new year of birth as the value for the year_of_birth attribute of self.random_classy_person

        new_year_of_birth = 1980
        # person.year_of_birth = new_year_of_birth
        self.random_classy_person.year_of_birth = new_year_of_birth
        self.assertEqual(
            person.get_age(),
            this_year()-new_year_of_birth
        )

green

I use self.random_classy_person in the second assertion

        new_year_of_birth = 1980
        # person.year_of_birth = new_year_of_birth
        self.random_classy_person.year_of_birth = new_year_of_birth
        self.assertEqual(
            # person.get_age(),
            self.random_classy_person.get_age(),
            this_year()-new_year_of_birth
        )


# Exceptions seen

the test is still green

I remove the commented lines and the person variable

    def test_update_classy_person_year_of_birth(self):
        self.assertEqual(
            self.random_classy_person.get_age(),
            self.original_age
        )

        new_year_of_birth = 1980
        self.random_classy_person.year_of_birth = new_year_of_birth
        self.assertEqual(
            self.random_classy_person.get_age(),
            this_year()-new_year_of_birth
        )


# Exceptions seen

still green

the new_year_of_birth variable is the same in test_update_factory_person_year_of_birth and test_update_classy_person_year_of_birth. I add a new class attribute to the setUp method because I want to use random numbers for it

    def setUp(self):
        self.random_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.random_new_year_of_birth = random.randint(
            this_year()-120, this_year()
        )
        self.original_age = this_year() - self.random_year_of_birth

this is also doing the same thing two times, even though the results are different

I make a function to remove the repetition

def this_year():
    return datetime.datetime.now().year


def random_year_of_birth():
    return random.randint(
        this_year()-120, this_year()
    )


class TestPerson(unittest.TestCase):

I point self.random_year_of_birth to the result of calling the new function in the setUp method

    def setUp(self):
        # self.random_year_of_birth = random.randint(
        #     this_year()-120, this_year()
        # )
        self.random_year_of_birth = random_year_of_birth()
        self.random_new_year_of_birth = random.randint(

the test is still green

I call the function for the new_year_of_birth attribute

    def setUp(self):
        # self.random_year_of_birth = random.randint(
        #     this_year()-120, this_year()
        # )
        self.random_year_of_birth = random_year_of_birth()
        # self.random_new_year_of_birth = random.randint(
        #     this_year()-120, this_year()
        # )
        self.random_new_year_of_birth = random_year_of_birth()
        self.original_age = this_year() - self.random_year_of_birth

green

I remove the commented lines

    def setUp(self):
        self.random_year_of_birth = random_year_of_birth()
        self.random_new_year_of_birth = random_year_of_birth()
        self.original_age = this_year() - self.random_year_of_birth
        self.random_first_name = choose(*self.RANDOM_NAMES)

I use self.random_new_year_of_birth in test_update_factory_person_year_of_birth

    def test_update_factory_person_year_of_birth(self):
        # new_year_of_birth = 1980
        new_year_of_birth = self.random_new_year_of_birth

still green

I use the class attribute in the assertion for the call to the setdefault method

        self.assertEqual(
            self.random_factory_person.setdefault(
                # 'year_of_birth', new_year_of_birth
                'year_of_birth', self.random_new_year_of_birth
            ),
            new_year_of_birth
        )

the test is still green

I use the class attribute as the expectation of the assertion for the call to the setdefault method

        self.assertEqual(
            self.random_factory_person.setdefault(
                # 'year_of_birth', new_year_of_birth
                'year_of_birth', self.random_new_year_of_birth
            ),
            # new_year_of_birth
            self.random_new_year_of_birth
        )

still green

I use the class attribute in the call to src.person.update_year_of_birth

        self.assertEqual(
            src.person.update_year_of_birth(
                self.random_factory_person,
                # new_year_of_birth
                self.random_new_year_of_birth
            ),

still green

I use the class attribute in the calculation for the new age

            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                # age=this_year()-new_year_of_birth,
                age=this_year()-self.random_new_year_of_birth,
            )

the test is still green

I remove the commented lines and the new_year_of_birth variable

    def test_update_factory_person_year_of_birth(self):
        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        with self.assertRaises(KeyError):
            self.random_factory_person['year_of_birth']
        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', self.random_new_year_of_birth
            ),
            self.random_new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                self.random_factory_person,
                self.random_new_year_of_birth
            ),
            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                age=this_year()-self.random_new_year_of_birth,
            )
        )

    def test_update_classy_person_year_of_birth(self):

green around the rosie, a pocket full of posies

on to test_update_classy_person_year_of_birth. I point the new_year_of_birth variable to the class attribute

    def test_update_classy_person_year_of_birth(self):
        self.assertEqual(
            self.random_classy_person.get_age(),
            self.original_age
        )

        # new_year_of_birth = 1980
        new_year_of_birth = self.random_new_year_of_birth
        self.random_classy_person.year_of_birth = new_year_of_birth

the test is still green

I use the class attribute in the assignment of the new value

        # new_year_of_birth = 1980
        new_year_of_birth = self.random_new_year_of_birth
        # self.random_classy_person.year_of_birth = new_year_of_birth
        self.random_classy_person.year_of_birth = self.random_new_year_of_birth
        self.assertEqual(

still green

I use the class attribute in the assertion

        # new_year_of_birth = 1980
        new_year_of_birth = self.random_new_year_of_birth
        # self.random_classy_person.year_of_birth = new_year_of_birth
        self.random_classy_person.year_of_birth = self.random_new_year_of_birth
        self.assertEqual(
            self.random_classy_person.get_age(),
            # this_year()-new_year_of_birth
            this_year()-self.random_new_year_of_birth
        )

green

I remove the commented lines and the new_year_of_birth variable

    def test_update_classy_person_year_of_birth(self):
        self.assertEqual(
            self.random_classy_person.get_age(),
            self.original_age
        )

        self.random_classy_person.year_of_birth = self.random_new_year_of_birth
        self.assertEqual(
            self.random_classy_person.get_age(),
            this_year()-self.random_new_year_of_birth
        )


# Exceptions seen

the test is still green

There are two calculations that happen in the tests, one for the new age and another for the original age

this_year() - self.random_year_of_birth
this_year() - self.random_new_year_of_birth

I add a function that does the calculation to test_person.py

def random_year_of_birth():
    return random.randint(
        this_year()-120, this_year()
    )


def get_age(year_of_birth):
    return this_year() - year_of_birth


class TestPerson(unittest.TestCase):

I point self.original_age in the setUp method to the result of calling the function with self.random_year_of_birth

    def setUp(self):
        self.random_year_of_birth = random_year_of_birth()
        self.random_new_year_of_birth = random_year_of_birth()
        # self.original_age = this_year() - self.random_year_of_birth
        self.original_age = get_age(self.random_year_of_birth)
        self.random_first_name = choose(*self.RANDOM_NAMES)

the test is still green

I remove the commented line then add a new class attribute for the calculation of the new age

    def setUp(self):
        self.random_year_of_birth = random_year_of_birth()
        self.random_new_year_of_birth = random_year_of_birth()
        self.original_age = get_age(self.random_year_of_birth)
        self.new_age = get_age(self.random_new_year_of_birth)
        self.random_first_name = choose(*self.RANDOM_NAMES)

I use the new class attribute in test_update_factory_person_year_of_birth

            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                # age=this_year()-self.random_new_year_of_birth,
                age=self.new_age,
            )

the test is still green

I remove the commented line

    def test_update_factory_person_year_of_birth(self):
        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        with self.assertRaises(KeyError):
            self.random_factory_person['year_of_birth']
        self.assertEqual(
            self.random_factory_person.setdefault(
                'year_of_birth', self.random_new_year_of_birth
            ),
            self.random_new_year_of_birth
        )
        self.assertEqual(
            self.random_factory_person.get('age'),
            self.original_age
        )

        self.assertEqual(
            src.person.update_year_of_birth(
                self.random_factory_person,
                self.random_new_year_of_birth
            ),
            dict(
                first_name=self.random_first_name,
                last_name=self.random_last_name,
                sex=self.random_sex,
                age=self.new_age,
            )
        )

    def test_update_classy_person_year_of_birth(self):

green

use the class attribute in test_update_classy_person_year_of_birth

        self.assertEqual(
            self.random_classy_person.get_age(),
            # this_year()-self.random_new_year_of_birth
            self.new_age
        )

still green

I remove the commented line

    def test_update_classy_person_year_of_birth(self):
        self.assertEqual(
            self.random_classy_person.get_age(),
            self.original_age
        )

        self.random_classy_person.year_of_birth = self.random_new_year_of_birth
        self.assertEqual(
            self.random_classy_person.get_age(),
            self.new_age
        )


# Exceptions seen

I wonder what red and yellow look like, that was a lot of green.

test_class_w_default_arguments

In test_factory_w_default_arguments, I tested what happens when I call the factory function without giving a value for last_name and sex.

In those cases the functions uses default values of 'doe' for last_name and 'M' for sex.

I want to add a test for the Person class to make sure it does the same thing when I do not provide a value for last_name or sex when making a person.

RED: make it fail

I add a new test with a person made with the Person class without a value for last_name and sex and an assertion for the value of the last_name

            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=self.original_age
            )
        )

    def test_class_w_default_arguments(self):
        person = src.person.Person(
            first_name=self.random_first_name,
            year_of_birth=self.random_year_of_birth,
        )
        self.assertEqual(person.first_name, None)

    def expected_greeting(self):

the terminal shows AssertionError

AssertionError: X != None

GREEN: make it pass

I use the class attribute for random_first_name to make the expectation match

          self.assertEqual(person.first_name, self.random_first_name)

the test passes

REFACTOR: make it better

I add an assertion for the value of the last_name

        self.assertEqual(person.first_name, self.random_first_name)
        self.assertEqual(person.last_name, 'doe')

    def expected_greeting(self):

the terminal shows AssertionError

AssertionError: None != 'doe'

I change the default value for last_name in the __init__ method of the Person class in person.py

class Person:

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

the test passes

I add another assertion for the value of sex in test_person.py

        self.assertEqual(person.first_name, self.random_first_name)
        self.assertEqual(person.last_name, 'doe')
        self.assertEqual(person.sex, 'M')

    def expected_greeting(self):

the terminal shows AttributeError

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

I add the class attribute to the __init__ method of the Person class in person.py

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

the terminal shows AssertionError

AssertionError: None != 'M'

I change the default value for sex

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

the test passes

There is a problem with the year_of_birth, its default value is None, which means if I do not give a value for it when I make a person with the factory function or Person class, TypeError will be raised.

I remove year_of_birth from the call to the Person class in test_class_w_default_arguments in test_person.py

    def test_class_w_default_arguments(self):
        person = src.person.Person(
            first_name=self.random_first_name,
            # year_of_birth=self.random_year_of_birth,
        )

the test is still green

I remove the commented line then add an assertion for the age

    def test_class_w_default_arguments(self):
        person = src.person.Person(self.random_first_name)
        self.assertEqual(person.first_name, self.random_first_name)
        self.assertEqual(person.last_name, 'doe')
        self.assertEqual(person.sex, 'M')
        self.assertEqual(person.get_age(), None)

    def expected_greeting(self):

the terminal shows TypeError

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

because the get_age method tries to subtract year_of_birth from this year, and year_of_birth is None

I add a default value for year_of_birth in the __init__ method of the Person class in person.py

    def __init__(
            self, first_name, last_name='doe',
            year_of_birth=this_year(), sex='M',
        ):

the terminal shows AssertionError

AssertionError: 0 != None

I change the expectation in test_person.py

        self.assertEqual(person.sex, 'M')
        self.assertEqual(person.get_age(), 0)

    def expected_greeting(self):

the test passes

I remove the value for year_of_birth in the call to src.person.factory in test_factory_w_default_arguments

    def test_factory_w_default_arguments(self):
        self.assertEqual(
            src.person.factory(
                first_name=self.random_first_name,
                # year_of_birth=self.random_year_of_birth,
            ),

the terminal shows TypeError

TypeError: factory() missing 1 required positional argument: 'year_of_birth'

I add a default value for year_of_birth to make it a choice in the factory function in person.py

def factory(
        first_name, year_of_birth=None,
        last_name='doe', sex='M',
    ):

the terminal shows TypeError

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

I change the default value for year_of_birth to this year

def factory(
        first_name, year_of_birth=this_year(),
        last_name='doe', sex='M',
    ):

the terminal shows AssertionError

E       - {'age': 0, 'first_name': Y, 'last_name': 'doe', 'sex': 'M'}
E       ?         ^
E
E       + {'age': X, 'first_name': Y, 'last_name': 'doe', 'sex': 'M'}
E       ?         ^

I change the expectation in test_factory_w_default_arguments in test_person.py

            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                # age=self.original_age
                age=0
            )

the test passes

I remove the commented lines

    def test_factory_w_default_arguments(self):
        self.assertEqual(
            src.person.factory(self.random_first_name),
            dict(
                first_name=self.random_first_name,
                last_name='doe',
                sex='M',
                age=0
            )
        )

    def test_class_w_default_arguments(self):

the tests are still green

The tests so far have a problem, they check that the input and the output are the same, with no checks for what type of input it is. This means I can use a data type that is not a string for first_name and last_name and sex and the tests would still pass. I would only get TypeError when I use a value for year_of_birth that is not a number, though if I use a boolean, the calculation would still work.

You know enough to add tests for these problems, to make sure that the right inputs are always used. Send me your solutions when you do, I would love to see them.

test_attributes_and_methods_of_classes

I used the dir built-in function in lists and dictionaries to show their attributes and methods. I can also use it with the Person class

RED: make it fail

I add a new test

          self.assertEqual(
              self.random_classy_person.get_age(),
              self.new_age
          )

      def test_attributes_and_methods_of_a_class(self):
          self.assertEqual(
              dir(src.person.Person),
              []
          )


  # Exceptions seen

the terminal shows AssertionError

AssertionError: Lists differ: ['__class__', '__delattr__', '__dict__', '[377 chars]llo'] != []

GREEN: make it pass

I copy and paste the values from the terminal and remove the extra characters I do not need with the find and replace feature of the Integrated Development Environment (IDE)

      def test_attributes_and_methods_of_a_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__',
                  'get_age',
                  'hello'
              ]
          )


  # Exceptions seen

the test passes

The attributes I defined in the __init__ method are not in the list, because I called dir on src.person.Person which is the class definition, not on an instance (copy) of the class where I would have to provide values for the first_name, last_name, sex and year_of_birth attributes.

What is the difference between dir(src.person.Person) and dir(src.person.Person('jane'))?

The 3 methods I defined in the Person class in person.py

__init__
get_age
hello

are in the list, and there are others which I never defined, which leads to the question of where did they come from?

close the project

I close test_person.py and person.py in the editors
I click in the terminal and exit the tests with ctrl+c on the keyboard
I deactivate the virtual environment
```
deactivate
```
the terminal goes back to the command line, (.venv) is no longer on the left side
```
.../pumping_python/person
```
I change directory to the parent of person
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

code from the chapter

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

review

A class is attributes and methods that belong together
A class can be used to represent something
classes can be an easier way to manage data than functions
classes make it easier to write tests for something

Tip

when I find myself writing or doing the same thing two times, I write a function
when I find I have two functions that use the same information, I write a class

what is next?

you have gone through a lot of things and know

Would you like to know where the extra attributes and methods of the Person class came from?

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

what is a class?

family ties