test functions with None

I want to use the assertIsNotNone and assertIsNone methods for the assertions that check if the result of a function call is None.

preview

I have these tests by the end of the chapter

functions/tests/test_functions.py

import src.functions
import unittest


class TestFunctions(unittest.TestCase):

    first = 'first'
    last = 'last'
    a_tuple = (0, 1, 2, 'n')
    a_list = [0, 1, 2, 'n']
    a_set = {0, 1, 2, 'n'}
    a_dictionary = {'key': 'value'}

    def test_making_a_function_w_pass(self):
        self.assertIsNone(src.functions.w_pass())

functions/tests/test_functions.py

    def test_making_a_function_w_return(self):
        self.assertIsNone(src.functions.w_return())

    def test_making_a_function_w_return_none(self):
        self.assertIsNone(src.functions.w_return_none())

    def test_what_happens_after_functions_return(self):
        self.assertIsNone(
            src.functions.return_leaves_the_function()
        )

functions/tests/test_functions.py

    def test_constant_function(self):
        self.assertEqual(
            src.functions.constant(), 'the same thing'
        )

    def test_identity_function(self):
        self.assertIsNone(src.functions.identity(None))
        self.assertEqual(
            src.functions.identity(object), object
        )

    def test_why_use_a_function(self):

open the project

I open a terminal
I change directory to the project
```
cd functions
```
the terminal shows I am in the functions folder
```
.../pumping_python/functions
```
I open test_functions.py from the tests folder

I use pytest-watcher to run the tests automatically

uv run pytest-watcher . --now

the terminal shows

test_functions.py ............                      [100%]

=================== 12 passed in J.KLs ===================

test w_pass with assertIsNone

RED: make it fail

I add a call to assertIsNotNone in test_making_a_function_w_pass

    def test_making_a_function_w_pass(self):
        assert_is_none(src.functions.w_pass())
        self.assertIs(src.functions.w_pass(), None)
        self.assertIsNotNone(src.functions.w_pass())

    def test_making_a_function_w_return(self):

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly None

GREEN: make it pass

I change assertIsNotNone to assertIsNone

    def test_making_a_function_w_pass(self):
        assert_is_none(src.functions.w_pass())
        self.assertIs(src.functions.w_pass(), None)
        # self.assertIsNotNone(src.functions.w_pass())
        self.assertIsNone(src.functions.w_pass())

    def test_making_a_function_w_return(self):

the test passes.

REFACTOR: make it better

I remove the commented line, the call to my assert_is_none function and self.assertIs(src.functions.w_pass(), None) from test_making_a_function_w_pass since they are repetitions

    def test_making_a_function_w_pass(self):
        self.assertIsNone(src.functions.w_pass())

    def test_making_a_function_w_return(self):

test w_return with assertIsNone

RED: make it fail

I add a call to assertIsNotNone in test_making_a_function_w_return

    def test_making_a_function_w_return(self):
        assert_is_none(src.functions.w_return())
        self.assertIs(
            src.functions.w_return(), None
        )
        self.assertIsNotNone(src.functions.w_return())

    def test_making_a_function_w_return_none(self):

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly None

GREEN: make it pass

I change assertIsNotNone to assertIsNone

    def test_making_a_function_w_return(self):
        assert_is_none(src.functions.w_return())
        self.assertIs(
            src.functions.w_return(), None
        )
        # self.assertIsNotNone(src.functions.w_return())
        self.assertIsNone(src.functions.w_return())

    def test_making_a_function_w_return_none(self):

the test passes.

REFACTOR: make it better

I remove the commented line, the call to my assert_is_none function and self.assertIs(src.functions.w_return(), None) from test_making_a_function_w_return

    def test_making_a_function_w_return(self):
        self.assertIsNone(src.functions.w_return())

    def test_making_a_function_w_return_none(self):

test w_return_none with assertIsNone

RED: make it fail

I add a call to assertIsNotNone in test_making_a_function_w_return_none

    def test_making_a_function_w_return_none(self):
        assert_is_none(src.functions.w_return_none())
        self.assertIs(
            src.functions.w_return_none(), None
        )
        self.assertIsNotNone(src.functions.w_return_none())

    def test_what_happens_after_functions_return(self):

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly None

GREEN: make it pass

I change assertIsNotNone to assertIsNone

    def test_making_a_function_w_return_none(self):
        assert_is_none(src.functions.w_return_none())
        self.assertIs(
            src.functions.w_return_none(), None
        )
        # self.assertIsNotNone(src.functions.w_return_none())
        self.assertIsNone(src.functions.w_return_none())

    def test_what_happens_after_functions_return(self):

the test passes.

REFACTOR: make it better

I remove the commented line, the call to my assert_is_none function and self.assertIs(src.functions.w_return_none(), None) from test_making_a_function_w_return_none

    def test_making_a_function_w_return_none(self):
        self.assertIsNone(src.functions.w_return_none())

    def test_what_happens_after_functions_return(self):

test return_leaves_the_function with assertIsNone

RED: make it fail

I add a call to assertIsNotNone in test_what_happens_after_functions_return

    def test_what_happens_after_functions_return(self):
        assert_is_none(
            src.functions.return_leaves_the_function()
        )
        self.assertIs(
            src.functions.return_leaves_the_function(),
            None
        )
        self.assertIsNotNone(
            src.functions.return_leaves_the_function()
        )

    def test_constant_function(self):

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly None

GREEN: make it pass

I change assertIsNotNone to assertIsNone

    def test_what_happens_after_functions_return(self):
        assert_is_none(
            src.functions.return_leaves_the_function()
        )
        self.assertIs(
            src.functions.return_leaves_the_function(),
            None
        )
        # self.assertIsNotNone(
        self.assertIsNone(
            src.functions.return_leaves_the_function()
        )

    def test_constant_function(self):

the test passes.

REFACTOR: make it better

I remove the commented line, the call to my assert_is_none function and self.assertIs(src.functions.return_leaves_the_function(), None) from test_what_happens_after_functions_return

    def test_what_happens_after_functions_return(self):
        self.assertIsNone(
            src.functions.return_leaves_the_function()
        )

    def test_constant_function(self):

test identity with assertIsNone

RED: make it fail

I add a call to assertIsNotNone in test_identity_function

    def test_constant_function(self):
        self.assertEqual(
            src.functions.constant(), 'the same thing'
        )

    def test_identity_function(self):
        assert_is_none(src.functions.identity(None))
        self.assertIs(
            src.functions.identity(None), None
        )
        self.assertIsNotNone(src.functions.identity(None))
        self.assertEqual(
            src.functions.identity(object), object
        )

    def test_why_use_a_function(self):

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly None

GREEN: make it pass

I change assertIsNotNone to assertIsNone

    def test_identity_function(self):
        assert_is_none(src.functions.identity(None))
        self.assertIs(
            src.functions.identity(None), None
        )
        # self.assertIsNotNone(src.functions.identity(None))
        self.assertIsNone(src.functions.identity(None))
        self.assertEqual(
            src.functions.identity(object), object
        )

the test passes.

REFACTOR: make it better

I remove the commented line, the call to my assert_is_none function and self.assertIs(src.functions.identity(None), None) from test_identity_function

    def test_identity_function(self):
        self.assertIsNone(src.functions.identity(None))
        self.assertEqual(
            src.functions.identity(object), object
        )

    def test_why_use_a_function(self):

I remove my assert_is_none function since it is no longer used

import src.functions
import unittest


class TestFunctions(unittest.TestCase):

I open a new terminal then change directories to functions
```
cd functions
```
I add a git commit message in the new terminal
```
git commit -am 'use assertIsNone'
```

close the project

I close test_functions.py
I click in the terminal where the tests are running
I use q on the keyboard to leave the tests. The terminal goes back to the command line.
I change directory to the parent of functions
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory.

review

I can use assertIsNone and assertIsNotNone methods for assertions that test if something is None or not - assertIs(x, None) and assertIsNot(x, None).

code from the chapter

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

what is next?

Would you like to test the person project with conditions?

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.