how to test that an Exception is raised¶

preview¶

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

import src.exceptions
import unittest


class TestExceptions(unittest.TestCase):

    def test_catching_module_not_found_error_in_tests(self):
        with self.assertRaises(ModuleNotFoundError):
            import does_not_exist

    def test_catching_name_error_in_tests(self):
        with self.assertRaises(NameError):
            does_not_exist

    def test_catching_attribute_error_in_tests(self):
        with self.assertRaises(AttributeError):
            src.exceptions.does_not_exist

    def test_catching_type_error_in_tests(self):
        with self.assertRaises(TypeError):
            src.exceptions.function_name('the_input')

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        with self.assertRaises(IndexError):
            a_list[-5]

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(KeyError):
            {'key': 'value'}['does_not_exist']

    def test_catching_zero_division_error_in_tests(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0

    def test_catching_exceptions_in_tests(self):
        with self.assertRaises(Exception):
            raise Exception

    def test_catching_exceptions_w_messages(self):
        with self.assertRaisesRegex(
            Exception, 'BOOM!'
        ):
            src.exceptions.raise_exception()

    def test_catching_failure(self):
        self.assertEqual(
            src.exceptions.an_exception_handler(
                src.exceptions.raise_exception
            ),
            'failed'
        )

    def test_catching_success(self):
        self.assertEqual(
            src.exceptions.an_exception_handler(
                src.exceptions.does_not_raise_exception
            ),
            'succeeded'
        )


# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError
# TypeError
# IndexError
# KeyError
# ZeroDivisionError

requirements¶

I open a terminal to run makePythonTdd.sh with exceptions as the name of the project
```
./makePythonTdd.sh exceptions
```
on Windows without Windows Subsystem for Linux use makePythonTdd.ps1 instead of makePythonTdd.sh
```
./makePythonTdd.ps1 exceptions
```
it makes the folders and files that are needed, installs packages, runs the first test, and the terminal shows AssertionError
```
E       AssertionError: True is not false

tests/test_exceptions.py:7: AssertionError
```
I hold ctrl (Windows/Linux) or option or command (MacOS) on the keyboard and use the mouse to click on tests/test_exceptions.py:7 to open it in the editor
then I change True to False to make the test pass
```
7        self.assertFalse(False)
```
I change the name of the class to match the CapWords format to follow Python convention
```
4class TestExceptions(unittest.TestCase):
```

test_catching_module_not_found_error_in_tests¶

RED: make it fail¶

I change test_failure to test_catching_module_not_found_error_in_tests with an import statement

import unittest

class TestExceptions(unittest.TestCase):

    def test_catching_module_not_found_error_in_tests(self):
        import does_not_exist

the terminal shows ModuleNotFoundError

ModuleNotFoundError: No module named 'does_not_exist'

GREEN: make it pass¶

I add it to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError

I can make does_not_exist.py in the src folder (directory) to solve the problem but I want to catch/handle it in the test to show that import does_not_exist raises ModuleNotFoundError when the file does NOT exist. I add the assertRaises method which checks that the code below it the Exception it is given
```
6    def test_catching_module_not_found_error_in_tests(self):
7        with self.assertRaises(ModuleNotFoundError):
8            import does_not_exist
```
the test passes

test_catching_name_error_in_tests¶

RED: make it fail¶

I add another failing test

    def test_catching_module_not_found_error_in_tests(self):
        with self.assertRaises(ModuleNotFoundError):
            import does_not_exist

    def test_catching_name_error_in_tests(self):
        does_not_exist

the terminal shows NameError

NameError: name 'does_not_exist' is not defined

because there is no definition for does_not_exist in test_exceptions.py

I add it to the list of Exceptions encountered

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError

GREEN: make it pass¶

I add assertRaises

      def test_catching_name_error_in_tests(self):
          with self.assertRaises(NameError):
              does_not_exist

the test passes

test_catching_attribute_error_in_tests¶

RED: make it fail¶

I add another failing test, this time for AttributeError

    def test_catching_name_error_in_tests(self):
        with self.assertRaises(NameError):
            does_not_exist

    def test_catching_attribute_error_in_tests(self):
        src.exceptions.does_not_exist

the terminal shows NameError

NameError: name 'src' is not defined

I add an import statement at the top of the file for the module
```
1import src.exceptions
2import unittest
```
the terminal shows AttributeError
```
AttributeError: module 'src.exceptions' has no attribute 'does_not_exist'
```
because I tried to get something that does NOT exist from something that exists

I add the error to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError

GREEN: make it pass¶

then I add the assertRaises method

    def test_catching_attribute_error_in_tests(self):
        with self.assertRaises(AttributeError):
            src.exceptions.does_not_exist

the test passes

test_catching_type_error_in_tests¶

RED: make it fail¶

I add a failing test for TypeError

    def test_catching_attribute_error_in_tests(self):
        with self.assertRaises(AttributeError):
            src.exceptions.does_not_exist

    def test_catching_type_error_in_tests(self):
        src.exceptions.function_name('the_input')

the terminal shows AttributeError

AttributeError: module 'src.exceptions' has no attribute 'function_name'

I open exceptions.py from the src folder to open it in the editor, then add the name
```
1function_name
```
the terminal shows NameError
```
NameError: name 'function_name' is not defined
```
I assign it to None to define it
```
1function_name = None
```
the terminal shows TypeError
```
TypeError: 'NoneType' object is not callable
```

I add it to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError
# TypeError

GREEN: make it pass¶

then I add assertRaises to the test

    def test_catching_type_error_in_tests(self):
        with self.assertRaises(TypeError):
            src.exceptions.function_name('the_input')

the test passes

REFACTOR: make it better¶

when I make function_name a function in exceptions.py
```
1def function_name():
2    return None
```
the terminal still shows green because TypeError is raised since the call from the test - src.exceptions.function_name('the_input') sends 'the_input' as input and the function does not take input
when I add a parameter to the definition
```
1def function_name(the_input):
2    return None
```
the terminal shows AssertionError
```
AssertionError: TypeError not raised
```
because TypeError is NOT raised since the function call matches the definition. I undo the change
```
1def function_name():
2    return None
```
the terminal shows green again

test_catching_index_error_in_tests¶

RED: make it fail¶

I want to test catching IndexError, I add a new test with a list

    def test_catching_type_error_in_tests(self):
        with self.assertRaises(TypeError):
            src.exceptions.function_name('the_input')

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']

the first item in a list has 0 as its index

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        a_list[0]

the terminal shows green. The index for the last item is the total number of items minus 1, which is 3 in this case

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        a_list[3]

still green. When I use a number that is bigger than the index for the last item

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        a_list[4]

the terminal shows IndexError

IndexError: list index out of range

I add it to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError
# TypeError
# IndexError

GREEN: make it pass¶

then I add assertRaises

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]

the test passes

REFACTOR: make it better¶

I can also index with negative numbers, the one for the last item in the list is -1, think reading from right to left

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        a_list[-1]

the terminal still shows passing tests. The index for the first item is negative the total number of items, -4 in this case

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        a_list[-4]

still green. When I use a negative number that is outside the range

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        a_list[-5]

the terminal shows IndexError

IndexError: list index out of range

I add assertRaises

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        with self.assertRaises(IndexError):
            a_list[-5]

the terminal shows green again

It looks like this is a duplication of the assertRaises but it is not, even though the test is green when I remove the second one

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
            a_list[-5]
        # with self.assertRaises(IndexError):

I show why this is not a repetition at the end of the chapter. I undo the change for now

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        with self.assertRaises(IndexError):
            a_list[-5]

test_catching_key_error_in_tests¶

RED: make it fail¶

I add a dictionary to a new test for KeyError

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        with self.assertRaises(IndexError):
            a_list[-5]

    def test_catching_key_error_in_tests(self):
        {'key': 'value'}

when I try to get the value for a key that is in the dictionary

    def test_catching_key_error_in_tests(self):
        {'key': 'value'}['key']

the terminal shows green

when I use a key that is NOT in the dictionary

    def test_catching_key_error_in_tests(self):
        {'key': 'value'}['not_in_dictionary']

the terminal shows KeyError

KeyError: 'not_in_dictionary'

I add it to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError
# TypeError
# IndexError
# KeyError

GREEN: make it pass¶

I add assertRaises to the test

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(KeyError):
            {'key': 'value'}['not_in_dictionary']

the test passes

test_catching_zero_division_error_in_tests¶

RED: make it fail¶

I add another failing test, this time for the Exception that happened in how to make a calculator when testing division

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(KeyError):
            {'key': 'value'}['not_in_dictionary']

    def test_catching_zero_division_error_in_tests(self):
        1 / 0

any number divided by 0 the terminal shows ZeroDivisionError

ZeroDivisionError: division by zero

I add it to the list of Exceptions encountered in test_exceptions.py

# Exceptions Encountered
# AssertionError
# ModuleNotFoundError
# NameError
# AttributeError
# TypeError
# IndexError
# KeyError
# ZeroDivisionError

GREEN: make it pass¶

I add assertRaises

    def test_catching_zero_division_error_in_tests(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0

the test passes

test_catching_exceptions_in_tests¶

RED: make it fail¶

I add a failing test with the raise statement

    def test_catching_zero_division_error_in_tests(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0

    def test_catching_exceptions_in_tests(self):
        raise Exception

the terminal shows Exception

Exception

Exception is the mother of all the Exceptions covered so far, they inherit from it

I can use the raise statement to cause any Exception I want intentionally

    def test_catching_exceptions_in_tests(self):
        raise AssertionError

and the terminal shows the Exception I give the raise statement

AssertionError

I change the Exception back

    def test_catching_exceptions_in_tests(self):
        raise Exception

the terminal shows Exception

Exception

GREEN: make it pass¶

I add the assertRaises method

    def test_catching_exceptions_in_tests(self):
        with self.assertRaises(Exception):
            raise Exception

the terminal shows all tests are passing. The assertRaises method checks that the code under it raises the Exception it is given.

REFACTOR: make it better¶

I can use Exception to catch any of the Exceptions that inherit from it - its children

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(Exception):
            {'key': 'value'}['not_in_dictionary']

    def test_catching_zero_division_error_in_tests(self):
        with self.assertRaises(Exception):
            1 / 0

all the tests are still green.

The problem with using Exception to catch its children, is it does not tell anyone that reads the code what the actual error is or which line caused it, especially when there is more than one line of code in the context.

It is better to be specific, from the Zen of Python: Explicit is better than implicit

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(KeyError):
            {'key': 'value'}['not_in_dictionary']

    def test_catching_zero_division_error_in_tests(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0

I cannot use sibling or cousin Exceptions to catch other Exceptions

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(ModuleNotFoundError):
            {'key': 'value'}['not_in_dictionary']

the terminal shows KeyError

KeyError: 'not_in_dictionary'

because it is not ModuleNotFoundError even though they are both Exceptions. I undo the change

    def test_catching_key_error_in_tests(self):
        with self.assertRaises(KeyError):
            {'key': 'value'}['not_in_dictionary']

the test passes

I cannot use children Exceptions to catch parent Exceptions

    def test_catching_exceptions_in_tests(self):
        with self.assertRaises(ZeroDivisionError):
            raise Exception

the terminal shows Exception

Exception

because it is not ZeroDivisionError even though it is an Exception. I undo the change

    def test_catching_exceptions_in_tests(self):
        with self.assertRaises(Exception):
            raise Exception

the test passes

As promised here is why the second AssertRaises in test_catching_index_error_in_tests is not a repetition, even though the test still passes when I remove it

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
            a_list[-5]
        # with self.assertRaises(IndexError):

If I add a raise statement between the 2 lines

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
            raise Exception
            a_list[-5]
        # with self.assertRaises(IndexError):

the terminal still shows green, even though Exception is not IndexError, it does NOT get raised. The assertRaises exits after the first line that causes IndexError and does NOT run the other lines.

When I move the raise statement above the first IndexError

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            raise Exception
            a_list[4]
            a_list[-5]
        # with self.assertRaises(IndexError):

the terminal shows Exception

Exception

because it is NOT IndexError, this is the expected behavior

as a rule of thumb I write one line of code for one Exception, this way I always know exactly which line caused which Exception

    def test_catching_index_error_in_tests(self):
        a_list = [1, 2, 3, 'n']
        with self.assertRaises(IndexError):
            a_list[4]
        with self.assertRaises(IndexError):
            a_list[-5]

all tests are passing! I know how to test that an Exception is raised

review¶

I have a way to catch Exceptions in tests and tested the following

Would you like to test handling Exceptions in programs?

Click Here to see the code from this chapter