test functions with unittest

I want to use the unittest library in the functions project. I also want to use object attributes to remove repetition of some values from the tests.

preview

I have these tests by the end of the chapter

functions/tests/test_functions.py

import src.functions
import unittest


def assert_is_none(something):
    assert something is None


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'}

functions/tests/test_functions.py

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

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

functions/tests/test_functions.py

    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
        )

    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
        )

functions/tests/test_functions.py

    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.assertEqual(
            src.functions.identity(object), object
        )

functions/tests/test_functions.py

    def test_why_use_a_function(self):
        def add_x(number):
            return 3 + number

        self.assertEqual(add_x(0), 3)
        self.assertEqual(add_x(1), 4)
        self.assertEqual(add_x(2), 5)
        self.assertEqual(add_x(3), 6)
        self.assertEqual(add_x(4), 7)
        self.assertEqual(add_x(5), 8)
        self.assertEqual(add_x(6), 9)
        self.assertEqual(add_x(7), 10)
        self.assertEqual(add_x(8), 11)
        self.assertEqual(add_x(9), 12)

functions/tests/test_functions.py

    def test_positional_arguments(self):
        positional_arguments = (
            src.functions.positional_arguments
        )

        self.assertEqual(
            positional_arguments(self.first, self.last),
            (self.first, self.last)
        )
        self.assertEqual(
            positional_arguments(self.last, self.first),
            (self.last, self.first)
        )

        self.assertEqual(
            positional_arguments(0, 1), (0, 1)
        )

        self.assertEqual(
            positional_arguments(
                self.a_tuple, self.a_list
            ),
            (self.a_tuple, self.a_list)
        )

        self.assertEqual(
            src.functions.keyword_arguments(
                self.a_set, self.a_dictionary
            ),
            (self.a_set, self.a_dictionary)
        )

functions/tests/test_functions.py

    def test_keyword_arguments(self):
        keyword_arguments = (
            src.functions.keyword_arguments
        )

        self.assertEqual(
            keyword_arguments(
                first_input=self.first,
                last_input=self.last,
            ),
            (self.first, self.last)
        )
        self.assertEqual(
            keyword_arguments(
                last_input=self.last,
                first_input=self.first,
            ),
            (self.first, self.last)
        )

        self.assertEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        self.assertEqual(
            keyword_arguments(
                first_input=self.a_tuple,
                last_input=self.a_list,
            ),
            (self.a_tuple, self.a_list)
        )

        self.assertEqual(
            src.functions.positional_arguments(
                last_input=self.a_dictionary,
                first_input=self.a_set,
            ),
            (self.a_set, self.a_dictionary)
        )

functions/tests/test_functions.py

    def test_args_and_kwargs(self):
        self.assertEqual(
            src.functions.args_and_kwargs(
                self.first, last_input=self.last
            ),
            (self.first, self.last)
        )

functions/tests/test_functions.py

    def test_optional_arguments(self):
        optional_arguments = (
            src.functions.optional_arguments
        )

        first_name, last_name = 'jane', 'doe'
        self.assertEqual(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )

        first_name, blow = 'joe', 'blow'
        self.assertEqual(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )

        first_name = 'john'
        self.assertEqual(
            optional_arguments(
                first_input=first_name,
            ),
            (first_name, last_name)
        )

        last_name = 'smith'
        self.assertEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )

functions/tests/test_functions.py

    def test_unknown_number_of_arguments(self):
        unknown_number_of_arguments = (
            src.functions.unknown_number_of_arguments
        )

        a_tuple = (0, 1)
        a_dictionary = {'a': 2, 'b': 3}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2)
        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2, 'n')
        self.assertEqual(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )

        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
        self.assertEqual(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )

        self.assertEqual(
            unknown_number_of_arguments(), ((), {})
        )


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

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 G.HIs ===================

add TestFunctions class

RED: make it fail

I add an object named Functions to test_functions.py

def assert_is_none(something):
    assert something is None

class Functions(object):

    def test_failure(self):
        self.assertEqual(True, False)

def test_making_a_function_w_pass():
    assert_is_none(src.functions.w_pass())

the test is still green.

I change the name of the object to TestFunctions

def assert_is_none(something):
    assert something is None


# class Functions(object):
class TestFunctions(object):

    def test_failure(self):

the terminal is my friend, and shows AttributeError

AttributeError: 'TestFunctions' object
                has no attribute 'assertEqual'

GREEN: make it pass

I add unittest.TestCase as the parent object of TestFunctions

# class Functions(object):
# class TestFunctions(object):
class TestFunctions(unittest.TestCase):

    def test_failure(self):

the terminal is my friend, and shows NameError

NameError: name 'unittest' is not defined.
           Did you forget to import 'unittest'?

I add an import statement at the top of the file

import src.functions
import unittest


def assert_equal(input_1, input_2):

the terminal is my friend, and shows AssertionError

AssertionError: True != False

I change True to False in the assertion

# class Functions(object):
# class TestFunctions(object):
class TestFunctions(unittest.TestCase):

    def test_failure(self):
        # self.assertEqual(True, False)
        self.assertEqual(False, False)


def test_making_a_function_w_pass():

the test passes.

REFACTOR: make it better

I remove the commented lines

def assert_is_none(something):
    assert something is None

class TestFunctions(unittest.TestCase):

    def test_failure(self):
        self.assertEqual(False, False)

def test_making_a_function_w_pass():

I open a new terminal then make sure I am in the functions folder
```
cd functions
```

I add a git commit message in the new terminal

git commit -am \
'add TestFunctions class'

test_making_a_function_w_pass with unittest

RED: make it fail

I go back to the terminal where the tests are running
I remove test_failure

I move test_making_a_function_w_pass to make it a method of the TestFunctions class

class TestFunctions(unittest.TestCase):

    def test_making_a_function_w_pass():
        assert_is_none(src.functions.w_pass())

def test_making_a_function_w_return():

the terminal is my friend, and shows TypeError

TypeError: TestFunctions.test_making_a_function_w_pass() takes
           0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_making_a_function_w_pass

class TestFunctions(unittest.TestCase):

    # def test_making_a_function_w_pass():
    def test_making_a_function_w_pass(self):
        assert_is_none(src.functions.w_pass())

the test is green again.

REFACTOR: make it better

I add a call to the assertIsNot method

    # def test_making_a_function_w_pass():
    def test_making_a_function_w_pass(self):
        assert_is_none(src.functions.w_pass())
        self.assertIsNot(
            src.functions.w_pass(), None
        )


def test_making_a_function_w_return():

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly identical: None

I change assertIsNot to assertIs

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


def test_making_a_function_w_return():

the test passes.

I remove the commented lines from test_making_a_function_w_pass

class TestFunctions(unittest.TestCase):

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


def test_making_a_function_w_return():

I add a git commit message in the other terminal

git commit -am \
'move test_making_a_function_w_pass to TestFunctions'

test_making_a_function_w_return with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_making_a_function_w_return to make it a method of the TestFunctions class

        self.assertIs(src.functions.w_pass(), None)

    def test_making_a_function_w_return():
        assert_is_none(src.functions.w_return())

def test_making_a_function_w_return_none():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_making_a_function_w_return()
    takes 0 positional arguments but 1 was given

because …

GREEN: make it pass

I add self to the parentheses of test_making_a_function_w_return

        self.assertIs(src.functions.w_pass(), None)

    # def test_making_a_function_w_return():
    def test_making_a_function_w_return(self):
        assert_is_none(src.functions.w_return())

green again.

REFACTOR: make it better

I add a call to the assertIsNot method

    # def test_making_a_function_w_return():
    def test_making_a_function_w_return(self):
        assert_is_none(src.functions.w_return())
        self.assertIsNot(
            src.functions.w_return(), None
        )


def test_making_a_function_w_return_none():

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly identical: None

I change assertIsNot to assertIs

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

the test passes.

I remove the commented lines from test_making_a_function_w_return

        self.assertIs(src.functions.w_pass(), None)

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


def test_making_a_function_w_return_none():

I add a git commit message in the other terminal

git commit -am \
'move test_making_a_function_w_return to TestFunctions'

test_making_a_function_w_return_none with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_making_a_function_w_return_none to make it a method of the TestFunctions class

        self.assertIs(
            src.functions.w_return(), None
        )

    def test_making_a_function_w_return_none():
        assert_is_none(src.functions.w_return_none())


def test_what_happens_after_functions_return():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_making_a_function_w_return_none()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_making_a_function_w_return_none

        self.assertIs(
            src.functions.w_return(), None
        )

    # def test_making_a_function_w_return_none():
    def test_making_a_function_w_return_none(self):
        assert_is_none(src.functions.w_return_none())

green.

REFACTOR: make it better

I add a call to the assertIsNot method

    # def 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.assertIsNot(
            src.functions.w_return_none(), None
        )


def test_what_happens_after_functions_return():

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly identical: None

I change assertIsNot to assertIs

    # def 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.assertIsNot(
        self.assertIs(
            src.functions.w_return_none(), None
        )


def test_what_happens_after_functions_return():

the test passes.

I remove the commented lines from test_making_a_function_w_return_none

        self.assertIs(
            src.functions.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
        )


def test_what_happens_after_functions_return():

I add a git commit message in the other terminal

git commit -am \
'move test_making_a_function_w_return_none to TestFunctions'

test_what_happens_after_functions_return with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_what_happens_after_functions_return to make it a method of the TestFunctions class

        self.assertIs(
            src.functions.w_return_none(), None
        )

    def test_what_happens_after_functions_return():
        assert_is_none(
            src.functions.return_leaves_the_function()
        )


def test_constant_function():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_what_happens_after_functions_return()
    takes 0 positional arguments but 1 was given

GREEN: make it pass

I add self to the parentheses of test_what_happens_after_functions_return

        self.assertIs(
            src.functions.w_return_none(), None
        )

    # def test_what_happens_after_functions_return():
    def test_what_happens_after_functions_return(self):
        assert_is_none(
            src.functions.return_leaves_the_function()
        )


def test_constant_function():

green again.

REFACTOR: make it better

I add a call to the assertIsNot method

    # def test_what_happens_after_functions_return():
    def test_what_happens_after_functions_return(self):
        assert_is_none(
            src.functions.return_leaves_the_function()
        )
        self.assertIsNot(
            src.functions.return_leaves_the_function(),
            None
        )


def test_constant_function():

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly identical: None

I change assertIsNot to assertIs

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

the test passes.

I remove the commented lines from test_what_happens_after_functions_return

        self.assertIs(
            src.functions.w_return_none(), None
        )

    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
        )


def test_constant_function():

I add a git commit message in the other terminal

git commit -am \
'move test_what_happens_after_functions_return to TestFunctions'

test_constant_function with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_constant_function to make it a method of the TestFunctions class

        self.assertIs(
            src.functions.return_leaves_the_function(),
            None
        )

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


def test_identity_function():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_constant_function()
    takes 0 positional arguments but 1 was given

because a method of an instance…

GREEN: make it pass

I add self to the parentheses of test_constant_function

        self.assertIs(
            src.functions.return_leaves_the_function(),
            None
        )

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

green again.

REFACTOR: make it better

I add a call to the assertNotEqual method

    # def test_constant_function():
    def test_constant_function(self):
        assert_equal(
            src.functions.constant(), 'the same thing'
        )
        self.assertNotEqual(
            src.functions.constant(), 'the same thing'
        )


def test_identity_function():

the terminal is my friend, and shows AssertionError

AssertionError: 'the same thing' == 'the same thing'

I change assertNotEqual to assertEqual

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

the test passes.

I remove the commented lines and the call to my assert_equal function (since it is now a repetition) from test_constant_function

        self.assertIs(
            src.functions.return_leaves_the_function(),
            None
        )

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


def test_identity_function():

I add a git commit message in the other terminal

git commit -am \
'move test_constant_function to TestFunctions'

test_identity_function with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_identity_function to make it a method of the TestFunctions class

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

    def test_identity_function():
        assert_is_none(src.functions.identity(None))
        assert_equal(
            src.functions.identity(object), object
        )


def test_why_use_a_function():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_identity_function()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_identity_function

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

    # def test_identity_function():
    def test_identity_function(self):
        assert_is_none(src.functions.identity(None))

the test is green again.

REFACTOR: make it better

I add calls to the assertIsNot and assertNotEqual methods

    # def test_identity_function():
    def test_identity_function(self):
        assert_is_none(src.functions.identity(None))
        self.assertIsNot(
            src.functions.identity(None), None
        )

        assert_equal(
            src.functions.identity(object), object
        )
        self.assertNotEqual(
            src.functions.identity(object), object
        )


def test_why_use_a_function():

the terminal is my friend, and shows AssertionError

AssertionError: unexpectedly identical: None

I change assertIsNot to assertIs for the first assertion in test_identity_function

    # def test_identity_function():
    def test_identity_function(self):
        assert_is_none(src.functions.identity(None))
        # self.assertIsNot(
        self.assertIs(
            src.functions.identity(None), None
        )

        assert_equal(
            src.functions.identity(object), object
        )

the terminal is my friend, and shows AssertionError

AssertionError: <class 'object'> == <class 'object'>

I change assertNotEqual to assertEqual for the second assertion in test_identity_function

        assert_equal(
            src.functions.identity(object), object
        )
        # self.assertNotEqual(
        self.assertEqual(
            src.functions.identity(object), object
        )


def test_why_use_a_function():

the test passes.

I remove the commented lines and the call to my assert_equal function from 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.assertEqual(
            src.functions.identity(object), object
        )


def test_why_use_a_function():

I add a git commit message in the other terminal

git commit -am \
'move test_identity_function to TestFunctions'

test_why_use_a_function with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_why_use_a_function to make it a method of the TestFunctions class

        self.assertEqual(
            src.functions.identity(object), object
        )

    def test_why_use_a_function():
        def add_x(number):
            return 3 + number

        assert_equal(add_x(0), 3)
        assert_equal(add_x(1), 4)
        assert_equal(add_x(2), 5)
        assert_equal(add_x(3), 6)
        assert_equal(add_x(4), 7)
        assert_equal(add_x(5), 8)
        assert_equal(add_x(6), 9)
        assert_equal(add_x(7), 10)
        assert_equal(add_x(8), 11)
        assert_equal(add_x(9), 12)


def test_positional_arguments():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_why_use_a_function()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_why_use_a_function

        self.assertEqual(
            src.functions.identity(object), object
        )

    # def test_why_use_a_function():
    def test_why_use_a_function(self):
        def add_x(number):
            return 3 + number

green again.

REFACTOR: make it better

I add calls to the assertNotEqual method in test_why_use_a_function

    # def test_why_use_a_function():
    def test_why_use_a_function(self):
        def add_x(number):
            return 3 + number

        assert_equal(add_x(0), 3)
        self.assertNotEqual(add_x(0), 3)
        assert_equal(add_x(1), 4)
        self.assertNotEqual(add_x(1), 4)

        assert_equal(add_x(2), 5)
        self.assertNotEqual(add_x(2), 5)
        assert_equal(add_x(3), 6)
        self.assertNotEqual(add_x(3), 6)
        assert_equal(add_x(4), 7)
        self.assertNotEqual(add_x(4), 7)
        assert_equal(add_x(5), 8)
        self.assertNotEqual(add_x(5), 8)

        assert_equal(add_x(6), 9)
        self.assertNotEqual(add_x(6), 9)
        assert_equal(add_x(7), 10)
        self.assertNotEqual(add_x(7), 10)
        assert_equal(add_x(8), 11)
        self.assertNotEqual(add_x(8), 11)
        assert_equal(add_x(9), 12)
        self.assertNotEqual(add_x(9), 12)


def test_positional_arguments():

the terminal is my friend, and shows AssertionError.

I change the calls from assertNotEqual to assertEqual in test_why_use_a_function

        assert_equal(add_x(0), 3)
        # self.assertNotEqual(add_x(0), 3)
        self.assertEqual(add_x(0), 3)
        assert_equal(add_x(1), 4)
        # self.assertNotEqual(add_x(1), 4)
        self.assertEqual(add_x(1), 4)

        assert_equal(add_x(2), 5)
        # self.assertNotEqual(add_x(2), 5)
        self.assertEqual(add_x(2), 5)
        assert_equal(add_x(3), 6)
        # self.assertNotEqual(add_x(3), 6)
        self.assertEqual(add_x(3), 6)

        assert_equal(add_x(4), 7)
        # self.assertNotEqual(add_x(4), 7)
        self.assertEqual(add_x(4), 7)
        assert_equal(add_x(5), 8)
        # self.assertNotEqual(add_x(5), 8)
        self.assertEqual(add_x(5), 8)

        assert_equal(add_x(6), 9)
        # self.assertNotEqual(add_x(6), 9)
        self.assertEqual(add_x(6), 9)
        assert_equal(add_x(7), 10)
        # self.assertNotEqual(add_x(7), 10)
        self.assertEqual(add_x(7), 10)

        assert_equal(add_x(8), 11)
        # self.assertNotEqual(add_x(8), 11)
        self.assertEqual(add_x(8), 11)
        assert_equal(add_x(9), 12)
        # self.assertNotEqual(add_x(9), 12)
        self.assertEqual(add_x(9), 12)


def test_positional_arguments():

the test passes.

I remove the commented lines and the calls to my assert_equal function from test_why_use_a_function

        self.assertEqual(
            src.functions.identity(object), object
        )

    def test_why_use_a_function(self):
        def add_x(number):
            return 3 + number

        self.assertEqual(add_x(0), 3)
        self.assertEqual(add_x(1), 4)
        self.assertEqual(add_x(2), 5)
        self.assertEqual(add_x(3), 6)
        self.assertEqual(add_x(4), 7)
        self.assertEqual(add_x(5), 8)
        self.assertEqual(add_x(6), 9)
        self.assertEqual(add_x(7), 10)
        self.assertEqual(add_x(8), 11)
        self.assertEqual(add_x(9), 12)


def test_positional_arguments():

I add a git commit message in the other terminal

git commit -am \
'move test_why_use_a_function to TestFunctions'

test_positional_arguments with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_positional_arguments to make it a method of the TestFunctions class

        self.assertEqual(add_x(9), 12)

    def test_positional_arguments():
        positional_arguments = (
            src.functions.positional_arguments
        )
        first, last = 'first', 'last'

        assert_equal(
            positional_arguments(first, last),
            (first, last)
        )
        assert_equal(
            positional_arguments(last, first),
            (last, first)
        )

        assert_equal(
            positional_arguments(0, 1), (0, 1)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.keyword_arguments(
                a_set, a_dictionary,
            ),
            (a_set, a_dictionary)
        )


def test_keyword_arguments():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_positional_arguments()
    takes 0 positional arguments but 1 was given

because …

GREEN: make it pass

I add self to the parentheses of test_positional_arguments

        self.assertEqual(add_x(9), 12)

    # def test_positional_arguments():
    def test_positional_arguments(self):
        positional_arguments = (
            src.functions.positional_arguments
        )

green.

REFACTOR: make it better

I add calls to the assertNotEqual method in test_positional_arguments

        assert_equal(
            positional_arguments(first, last),
            (first, last)
        )
        self.assertNotEqual(
            positional_arguments(first, last),
            (first, last)
        )
        assert_equal(
            positional_arguments(last, first),
            (last, first)
        )
        self.assertNotEqual(
            positional_arguments(last, first),
            (last, first)
        )

        assert_equal(
            positional_arguments(0, 1), (0, 1)
        )
        self.assertNotEqual(
            positional_arguments(0, 1), (0, 1)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )
        self.assertNotEqual(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.keyword_arguments(
                a_set, a_dictionary,
            ),
            (a_set, a_dictionary)
        )
        self.assertNotEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )


def test_keyword_arguments():

the terminal is my friend, and shows AssertionError.

I change the calls from assertNotEqual to assertEqual in test_positional_arguments

        assert_equal(
            positional_arguments(first, last),
            (first, last)
        )
        # self.assertNotEqual(
        self.assertEqual(
            positional_arguments(first, last),
            (first, last)
        )
        assert_equal(
            positional_arguments(last, first),
            (last, first)
        )
        # self.assertNotEqual(
        self.assertEqual(
            positional_arguments(last, first),
            (last, first)
        )

        assert_equal(
            positional_arguments(0, 1), (0, 1)
        )
        # self.assertNotEqual(
        self.assertEqual(
            positional_arguments(0, 1), (0, 1)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )
        # self.assertNotEqual(
        self.assertEqual(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.keyword_arguments(
                a_set, a_dictionary,
            ),
            (a_set, a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )


def test_keyword_arguments():

the test passes.

I remove the commented lines and the calls to my assert_equal function from test_positional_arguments

        self.assertEqual(add_x(9), 12)

    def test_positional_arguments(self):
        positional_arguments = (
            src.functions.positional_arguments
        )
        first, last = 'first', 'last'

        self.assertEqual(
            positional_arguments(first, last),
            (first, last)
        )
        self.assertEqual(
            positional_arguments(last, first),
            (last, first)
        )

        self.assertEqual(
            positional_arguments(0, 1), (0, 1)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        self.assertEqual(
            positional_arguments(a_tuple, a_list),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )


def test_keyword_arguments():

I add a git commit message in the other terminal

git commit -am \
'move test_positional_arguments to TestFunctions'

test_keyword_arguments with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_keyword_arguments to make it a method of the TestFunctions class

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )

    def test_keyword_arguments():
        keyword_arguments = (
            src.functions.keyword_arguments
        )
        first, last = 'first', 'last'

        assert_equal(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        assert_equal(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )

        assert_equal(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )


def test_args_and_kwargs():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_keyword_arguments()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_keyword_arguments

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )

    # def test_keyword_arguments():
    def test_keyword_arguments(self):
        keyword_arguments = (
            src.functions.keyword_arguments
        )
        first, last = 'first', 'last'v

green again.

REFACTOR: make it better

I add calls to the assertNotEqual method in test_keyword_arguments

        assert_equal(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        self.assertNotEqual(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        assert_equal(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )
        self.assertNotEqual(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )

        assert_equal(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )
        self.assertNotEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )
        self.assertNotEqual(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )
        self.assertNotEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )


def test_args_and_kwargs():

the terminal is my friend, and shows AssertionError.

I change the calls from assertNotEqual to assertEqual in test_keyword_arguments

        assert_equal(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        # self.assertNotEqual(
        self.assertEqual(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        assert_equal(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )
        # self.assertNotEqual(
        self.assertEqual(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )

        assert_equal(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )
        # self.assertNotEqual(
        self.assertEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        assert_equal(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )
        # self.assertNotEqual(
        self.assertEqual(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        assert_equal(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )


def test_args_and_kwargs():

the test passes.

I remove the commented lines and the calls to my assert_equal function from test_keyword_arguments

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                a_set, a_dictionary
            ),
            (a_set, a_dictionary)
        )

    def test_keyword_arguments(self):
        keyword_arguments = (
            src.functions.keyword_arguments
        )
        first, last = 'first', 'last'

        self.assertEqual(
            keyword_arguments(
                first_input=first, last_input=last,
            ),
            (first, last)
        )
        self.assertEqual(
            keyword_arguments(
                last_input=last, first_input=first,
            ),
            (first, last)
        )

        self.assertEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        self.assertEqual(
            keyword_arguments(
                first_input=a_tuple,
                last_input=a_list,
            ),
            (a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )


def test_args_and_kwargs():

I add a git commit message in the other terminal

git commit -am \
'move test_keyword_arguments to TestFunctions'

test_args_and_kwargs with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_args_and_kwargs to make it a method of the TestFunctions class

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )

    def test_args_and_kwargs():
        first, last = 'first', 'last'

        assert_equal(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )


def test_optional_arguments():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_args_and_kwargs()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_args_and_kwargs

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )

    # def test_args_and_kwargs():
    def test_args_and_kwargs(self):
        first, last = 'first', 'last'

the test is green again.

REFACTOR: make it better

I add a call to the assertNotEqual method in test_args_and_kwargs

    # def test_args_and_kwargs():
    def test_args_and_kwargs(self):
        first, last = 'first', 'last'

        assert_equal(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )
        self.assertNotEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )


def test_optional_arguments():

the terminal is my friend, and shows AssertionError

AssertionError: ('first', 'last') == ('first', 'last')

I change the call from assertNotEqual to assertEqual in test_args_and_kwargs

        assert_equal(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )
        # self.assertNotEqual(
        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )

the test passes.

I add variables for the call to src.functions.args_and_kwargs and my expectation

        assert_equal(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )
        # self.assertNotEqual(
        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )

I remove the commented lines and the call to my assert_equal function from test_args_and_kwargs

        a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                first_input=a_set,
            ),
            (a_set, a_dictionary)
        )

    def test_args_and_kwargs(self):
        first, last = 'first', 'last'

        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )


def test_optional_arguments():

I add a git commit message in the other terminal

git commit -am \
'move test_args_and_kwargs to TestFunctions'

test_optional_arguments with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_optional_arguments to make it a method of the TestFunctions class

        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )

    def test_optional_arguments():
        optional_arguments = (
            src.functions.optional_arguments
        )

        first_name, last_name = 'jane', 'doe'
        assert_equal(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )

        first_name, blow = 'joe', 'blow'
        assert_equal(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )

        first_name = 'john'
        assert_equal(
            optional_arguments(
                first_input=first_name,
            ),
            (first_name, last_name)
        )

        last_name = 'smith'
        assert_equal(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )


def test_unknown_number_of_arguments():

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_optional_arguments()
    takes 0 positional arguments but 1 was given

GREEN: make it pass

I add self to the parentheses of test_optional_arguments

        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )

    # def test_optional_arguments():
    def test_optional_arguments(self):
        optional_arguments = (
            src.functions.optional_arguments
        )

green again.

REFACTOR: make it better

I add calls to the assertNotEqual method in test_optional_arguments

        first_name, last_name = 'jane', 'doe'
        assert_equal(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )
        self.assertNotEqual(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )

        first_name, blow = 'joe', 'blow'
        assert_equal(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )
        self.assertNotEqual(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )

        first_name = 'john'
        assert (
            optional_arguments(
                first_input=first_name
            )
        == (first_name, last_name)
        )
        self.assertNotEqual(
            optional_arguments(
                first_input=first_name
            ),
            (first_name, last_name)
        )

        last_name = 'smith'
        assert (
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            )
        == (first_name, last_name)
        )
        self.assertNotEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )


def test_unknown_number_of_arguments():

the terminal is my friend, and shows AssertionError.

I change the calls from assertNotEqual to assertEqual in test_optional_arguments

        first_name, last_name = 'jane', 'doe'
        assert_equal(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )
        # self.assertNotEqual(
        self.assertEqual(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )

        first_name, blow = 'joe', 'blow'
        assert_equal(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )
        # self.assertNotEqual(
        self.assertEqual(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )

        first_name = 'john'
        assert_equal(
            optional_arguments(
                first_input=first_name,
            ),
            (first_name, last_name)
        )
        # self.assertNotEqual(
        self.assertEqual(
            optional_arguments(
                first_input=first_name,
            ),
            (first_name, last_name)
        )

            last_name = 'smith'
            assert_equal(
                optional_arguments(
                    last_input=last_name,
                    first_input=first_name,
                ),
                (first_name, last_name)
            )
            # self.assertNotEqual(
            self.assertEqual(
                optional_arguments(
                    last_input=last_name,
                    first_input=first_name,
                ),
                (first_name, last_name)
            )


    def test_unknown_number_of_arguments():

the test passes.

I remove the commented lines and the calls to my assert_equal function from test_optional_arguments

        self.assertEqual(
            src.functions.args_and_kwargs(
                first, last_input=last
            ),
            (first, last)
        )

    def test_optional_arguments(self):
        optional_arguments = (
            src.functions.optional_arguments
        )

        first_name, last_name = 'jane', 'doe'
        self.assertEqual(
            optional_arguments(
                first_name,
            ),
            (first_name, last_name)
        )

        first_name, blow = 'joe', 'blow'
        self.assertEqual(
            optional_arguments(
                first_name, blow
            ),
            (first_name, blow)
        )

        first_name = 'john'
        self.assertEqual(
            optional_arguments(
                first_input=first_name,
            ),
            (first_name, last_name)
        )

        last_name = 'smith'
        self.assertEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )


def test_unknown_number_of_arguments():

I add a git commit message in the other terminal

git commit -am \
'move test_optional_arguments to TestFunctions'

test_unknown_number_of_arguments with unittest

RED: make it fail

I go back to the terminal where the tests are running

I move test_unknown_number_of_arguments to make it a method of the TestFunctions class

        last_name = 'smith'
        self.assertEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )

    def test_unknown_number_of_arguments():
        unknown_number_of_arguments = (
            src.functions.unknown_number_of_arguments
        )

        a_tuple = (0, 1)
        a_dictionary = {'a': 2, 'b': 3}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary,
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2)
        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2, 'n')
        assert_equal(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )

        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
        assert_equal(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )

        assert_equal(
            unknown_number_of_arguments(), ((), {})
        )


# Exceptions seen

the terminal is my friend, and shows TypeError

TypeError:
    TestFunctions.test_unknown_number_of_arguments()
    takes 0 positional arguments but 1 was given

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

GREEN: make it pass

I add self to the parentheses of test_unknown_number_of_arguments

        last_name = 'smith'
        self.assertEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )

    # def test_unknown_number_of_arguments():
    def test_unknown_number_of_arguments(self):
        unknown_number_of_arguments = (
            src.functions.unknown_number_of_arguments
        )

green.

REFACTOR: make it better

I add calls to the assertNotEqual method in test_unknown_number_of_arguments

        a_tuple = (0, 1)
        a_dictionary = {'a': 2, 'b': 3}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )
        self.assertNotEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary,
            ),
            (a_tuple, a_dictionary)
        )
        self.assertNotEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2)
        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )
        self.assertNotEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2, 'n')
        assert_equal(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )
        self.assertNotEqual(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )

        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
        assert_equal(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )
        self.assertNotEqual(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )

        assert_equal(
            unknown_number_of_arguments(), ((), {})
        )
        self.assertNotEqual(
            unknown_number_of_arguments(), ((), {})
        )


# Exceptions seen

the terminal is my friend, and shows AssertionError.

I change the calls from assertNotEqual to assertEqual in test_unknown_number_of_arguments

        a_tuple = (0, 1)
        a_dictionary = {'a': 2, 'b': 3}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary,
            ),
            (a_tuple, a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2)
        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
        assert_equal(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2, 'n')
        assert_equal(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )

        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
        assert_equal(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )

        assert_equal(
            unknown_number_of_arguments(), ((), {})
        )
        # self.assertNotEqual(
        self.assertEqual(
            unknown_number_of_arguments(), ((), {})
        )


# Exceptions seen

the test passes.

I remove the commented lines and the calls to my assert_equal function from test_unknown_number_of_arguments

        last_name = 'smith'
        self.assertEqual(
            optional_arguments(
                last_input=last_name,
                first_input=first_name,
            ),
            (first_name, last_name)
        )

    def test_unknown_number_of_arguments(self):
        unknown_number_of_arguments = (
            src.functions.unknown_number_of_arguments
        )

        a_tuple = (0, 1)
        a_dictionary = {'a': 2, 'b': 3}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_dictionary = {'a': 2, 'b': 3, 'c': 4}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2)
        a_dictionary = {'a': 3, 'b': 4, 'c': 5}
        self.assertEqual(
            unknown_number_of_arguments(
                *a_tuple, **a_dictionary
            ),
            (a_tuple, a_dictionary)
        )

        a_tuple = (0, 1, 2, 'n')
        self.assertEqual(
            unknown_number_of_arguments(*a_tuple),
            (a_tuple, {})
        )

        a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
        self.assertEqual(
            unknown_number_of_arguments(**a_dictionary),
            ((), a_dictionary)
        )

        self.assertEqual(
            unknown_number_of_arguments(), ((), {})
        )


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

I remove my assert_equal function since it is no longer used

import src.functions
import unittest

def assert_is_none(something):
    assert something is None

class TestFunctions(unittest.TestCase):

I add a git commit message in the other terminal

git commit -am \
'move test_unknown_number_of_arguments to TestFunctions'

extract first, last object attributes

I want to use object attributes to remove repetition from the tests.

I go back to the terminal where the tests are running

I add object attributes for 'first' and 'last'

class TestFunctions(unittest.TestCase):

    first = 'first'
    last = 'last'

    def test_making_a_function_w_pass(self):

I use the object attributes for first and last in test_positional_arguments

    def test_positional_arguments(self):
        positional_arguments = (
            src.functions.positional_arguments
        )
        # first, last = 'first', 'last'

        self.assertEqual(
            # positional_arguments(first, last),
            positional_arguments(self.first, self.last),
            # (first, last)
            (self.first, self.last)
        )
        self.assertEqual(
            # positional_arguments(last, first),
            positional_arguments(self.last, self.first),
            # (last, first)
            (self.last, self.first)
        )

the test is still green.

I use the object attributes for first and last in test_keyword_arguments

    def test_keyword_arguments(self):
        keyword_arguments = (
            src.functions.keyword_arguments
        )
        # first, last = 'first', 'last'

        self.assertEqual(
            keyword_arguments(
                # first_input=first, last_input=last,
                first_input=self.first,
                last_input=self.last,
            ),
            # (first, last)
            (self.first, self.last)
        )
        self.assertEqual(
            keyword_arguments(
                # last_input=last, first_input=first,
                last_input=self.last,
                first_input=self.first,
            ),
            # (first, last)
            (self.first, self.last)
        )

still green.

I use the object attributes for first and last in test_args_and_kwargs

    def test_args_and_kwargs(self):
        # first, last = 'first', 'last'

        self.assertEqual(
            src.functions.args_and_kwargs(
                # first, last_input=last
                self.first, last_input=self.last
            ),
            # (first, last)
            (self.first, self.last)
        )

    def test_optional_arguments(self):

green.

I remove the commented lines from test_args_and_kwargs

    def test_args_and_kwargs(self):
        self.assertEqual(
            src.functions.args_and_kwargs(
                self.first, last_input=self.last
            ),
            (self.first, self.last)
        )

    def test_optional_arguments(self):

I add a git commit message in the other terminal

git commit -am \
'extract first, last object attributes'

extract a_tuple object attribute

I add a object attribute for (0, 1, 2, 'n')

class TestFunctions(unittest.TestCase):

    first = 'first'
    last = 'last'
    a_tuple = (0, 1, 2, 'n')

    def test_making_a_function_w_pass(self):

I use the new object attribute for a_tuple in test_positional_arguments

        self.assertEqual(
            positional_arguments(0, 1), (0, 1)
        )

        # a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        self.assertEqual(
            # positional_arguments(a_tuple, a_list),
            positional_arguments(
                self.a_tuple, a_list
            ),
            # (a_tuple, a_list)
            (self.a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}

still green.

I use the new object attribute for a_tuple in test_keyword_arguments

        self.assertEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        # a_tuple = (0, 1, 2, 'n')
        a_list = [0, 1, 2, 'n']
        self.assertEqual(
            keyword_arguments(
                # first_input=a_tuple,
                first_input=self.a_tuple,
                last_input=a_list,
            ),
            # (a_tuple, a_list)
            (self.a_tuple, a_list)
        )

        a_set = {0, 1, 2, 'n'}

the test is still green.

I add a git commit message in the other terminal

git commit -am \
'extract a_tuple object attribute'

extract a_list object attribute

I add a object attribute for [0, 1, 2, 'n']

class TestFunctions(unittest.TestCase):

    first = 'first'
    last = 'last'
    a_tuple = (0, 1, 2, 'n')
    a_list = [0, 1, 2, 'n']

    def test_making_a_function_w_pass(self):

I use the new object attribute for a_list in test_positional_arguments

        # a_tuple = (0, 1, 2, 'n')
        # a_list = [0, 1, 2, 'n']
        self.assertEqual(
            # positional_arguments(a_tuple, a_list),
            positional_arguments(
                # self.a_tuple, a_list
                self.a_tuple, self.a_list
            ),
            # (a_tuple, a_list)
            # (self.a_tuple, a_list)
            (self.a_tuple, self.a_list)
        )

        a_set = {0, 1, 2, 'n'}

still green.

I use the new object attribute for a_list in test_keyword_arguments

        # a_tuple = (0, 1, 2, 'n')
        # a_list = [0, 1, 2, 'n']
        self.assertEqual(
            keyword_arguments(
                # first_input=a_tuple,
                first_input=self.a_tuple,
                # last_input=a_list,
                last_input=self.a_list,
            ),
            # (a_tuple, a_list)
            # (self.a_tuple, a_list)
            (self.a_tuple, self.a_list)
        )

        a_set = {0, 1, 2, 'n'}

green.

I add a git commit message in the other terminal

git commit -am \
'extract a_list object attribute'

extract a_set object attribute

I add a object attribute for {0, 1, 2, 'n'}

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'}

    def test_making_a_function_w_pass(self):

I use the new object attribute to remove repetition of {0, 1, 2, 'n'} from test_positional_arguments

        # a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                # a_set, a_dictionary
                self.a_set, a_dictionary
            ),
            # (a_set, a_dictionary)
            (self.a_set, a_dictionary)
        )

    def test_keyword_arguments(self):

still green.

I use the new object attributes to remove repetition of {0, 1, 2, 'n'} from test_keyword_arguments

        # a_set = {0, 1, 2, 'n'}
        a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                last_input=a_dictionary,
                # first_input=a_set,
                first_input=self.a_set,
            ),
            # (a_set, a_dictionary)
            (self.a_set, a_dictionary)
        )

    def test_args_and_kwargs(self):

still green

I add a git commit message in the other terminal

git commit -am \
'extract a_set object attribute'

extract a_dictionary object attribute

I add a object attribute for a_dictionary

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

I use the new object attribute for a_dictionary in test_positional_arguments

        # a_set = {0, 1, 2, 'n'}
        # a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.keyword_arguments(
                # a_set, a_dictionary
                # self.a_set, a_dictionary
                self.a_set, self.a_dictionary
            ),
            # (a_set, a_dictionary)
            # (self.a_set, a_dictionary)
            (self.a_set, self.a_dictionary)
        )

    def test_keyword_arguments(self):

the test is still green.

I remove the commented lines from test_positional_arguments

    def test_positional_arguments(self):
        positional_arguments = (
            src.functions.positional_arguments
        )

        self.assertEqual(
            positional_arguments(self.first, self.last),
            (self.first, self.last)
        )
        self.assertEqual(
            positional_arguments(self.last, self.first),
            (self.last, self.first)
        )

        self.assertEqual(
            positional_arguments(0, 1), (0, 1)
        )

        self.assertEqual(
            positional_arguments(
                self.a_tuple, self.a_list
            ),
            (self.a_tuple, self.a_list)
        )

        self.assertEqual(
            src.functions.keyword_arguments(
                self.a_set, self.a_dictionary
            ),
            (self.a_set, self.a_dictionary)
        )

    def test_keyword_arguments(self):

I use the new object attributes for a_dictionary in test_keyword_arguments

        # a_set = {0, 1, 2, 'n'}
        # a_dictionary = {'key': 'value'}
        self.assertEqual(
            src.functions.positional_arguments(
                # last_input=a_dictionary,
                last_input=self.a_dictionary,
                # first_input=a_set,
                first_input=self.a_set,
            ),
            # (a_set, a_dictionary)
            # (self.a_set, a_dictionary)
            (self.a_set, self.a_dictionary)
        )

    def test_args_and_kwargs(self):

the test is still green.

I remove the commented lines from test_keyword_arguments

    def test_keyword_arguments(self):
        keyword_arguments = (
            src.functions.keyword_arguments
        )

        self.assertEqual(
            keyword_arguments(
                first_input=self.first,
                last_input=self.last,
            ),
            (self.first, self.last)
        )
        self.assertEqual(
            keyword_arguments(
                last_input=self.last,
                first_input=self.first,
            ),
            (self.first, self.last)
        )

        self.assertEqual(
            keyword_arguments(
                last_input=0, first_input=1,
            ),
            (1, 0)
        )

        self.assertEqual(
            keyword_arguments(
                first_input=self.a_tuple,
                last_input=self.a_list,
            ),
            (self.a_tuple, self.a_list)
        )

        self.assertEqual(
            src.functions.positional_arguments(
                last_input=self.a_dictionary,
                first_input=self.a_set,
            ),
            (self.a_set, self.a_dictionary)
        )

    def test_args_and_kwargs(self):

I add a git commit message in the other terminal

git commit -am \
'extract a_dictionary object attribute'

I can use object attributes to remove repetition

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 the unittest library to write tests with the methods of the unittest.TestCase class or I can write them with bare assert statements.
I can use object attributes for things that repeat so that methods of the same object can use them.

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 the unittest library?

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.