TypeError: use unittest

I want to use the unittest library in the type_error project.

preview

I have these tests by the end of the chapter

open the project

  • I open a terminal

  • I change directory to the type_error folder in the pumping_python folder_Make sure you are in the pumping_python folder with pwd in the terminal

    cd type_error

  • I open test_type_error.py

  • I use pytest-watcher to run the tests automatically

    uv run pytest-watcher . --now

    the terminal is my friend, and shows

    tests/test_type_error.py .......             [100%]

================== 7 passed in A.BCs ===================

add TestTypeError class

RED: make it fail

  • I add a class named AssertionError to test_type_error.py

    1class AssertionError(object):
2
3    def test_failure(self):
4        self.assertFalse(True)
5
6
7def test_assert_keyword():

    the test is still green.

  • I change the name of the class to TestTypeError

    1# class AssertionError(object):
2class TestTypeError(object):

    the terminal is my friend, and shows AttributeError

    AttributeError: 'TestTypeError' object
                has no attribute 'assertFalse'

  • I add AttributeError to the list of Exceptions seen

    141# None is None and equal to None
142
143
144# Exceptions seen
145# AssertionError
146# AttributeError

GREEN: make it pass

  • I add unitest.TestCase as the parent class of TestTypeError

    1# class AssertionError(object):
2# class TestTypeError(object):
3class TestTypeError(unittest.TestCase):

    the terminal is my friend, and shows NameError

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

  • I add NameError to the list of Exceptions seen

    145# Exceptions seen
146# AssertionError
147# AttributeError
148# NameError

  • I add an import statement at the top of the file

    1import unittest
2
3
4# class AssertionError(object):

    the terminal is my friend, and shows AssertionError

    AssertionError: True is not false

  • I change True to False in the assertion

    10    def test_failure(self):
11        # self.assertFalse(True)
12        self.assertFalse(False)
13
14
15def test_assert_keyword():

    the test passes.

REFACTOR: make it better

  • I remove the commented lines

     1import unittest
 2
 3
 4class TestTypeError(unittest.TestCase):
 5
 6    def test_failure(self):
 7        self.assertFalse(False)
 8
 9
10def test_assert_keyword():

  • I open a new terminal then make sure I am in the type_error folder

    cd type_error

  • I add a git commit message in the new terminal

    git commit -am \
'add TestTypeError class'

test_assert_keyword

RED: make it fail

  • I go back to the terminal where the tests are running.

  • I move test_assert_keyword to make it a method of the TestTypeError class and replace test_failure

     4class TestTypeError(unittest.TestCase):
 5
 6    def test_assert_keyword():
 7        assert 1 + 1 == 2
 8
 9        assert '1' + '1' == '11'
10
11        assert 'I am' + ' alive' == 'I am alive'
12
13
14def test_type_error_w_none():

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_assert_keyword()
    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.

  • I add TypeError to the list of Exceptions seen

    142# Exceptions seen
143# AssertionError
144# AttributeError
145# NameError
146# TypeError

GREEN: make it pass

I add self to the parentheses of test_assert_keyword

4class TestTypeError(unittest.TestCase):
5
6    # def test_assert_keyword():
7    def test_assert_keyword(self):

the test is green again.

REFACTOR: make it better

  • I add calls to the assertNotEqual method for the three assertions

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        assert 1 + 1 == 2
 9        self.assertNotEqual(1+1, 2)
10
11        assert '1' + '1' == '11'
12        self.assertNotEqual('1'+'1', '11')
13
14        assert 'I am' + ' alive' == 'I am alive'
15        self.assertNotEqual('I am'+' alive', 'I am alive')
16
17
18def test_type_error_w_none():

    the terminal is my friend, and shows AssertionError

    AssertionError: 2 == 2

    compare this with the error message for assert 1 + 1 == 11

    E   assert (1 + 1) == 11

  • I change assertNotEqual to assertEqual for (1+1, 2)

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        assert 1 + 1 == 2
 9        # self.assertNotEqual(1+1, 2)
10        self.assertEqual(1+1, 2)

    the terminal is my friend, and shows AssertionError

    AssertionError: '11' == '11'

  • I change assertNotEqual to assertEqual for ('1'+'1', '11')

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        assert 1 + 1 == 2
 9        # self.assertNotEqual(1+1, 2)
10        self.assertEqual(1+1, 2)
11
12        assert '1' + '1' == '11'
13        # self.assertNotEqual('1'+'1', '11')
14        self.assertEqual('1'+'1', '11')

    the terminal is my friend, and shows AssertionError

    AssertionError: 'I am alive' == 'I am alive'

  • I change assertNotEqual to assertEqual for ('I am'+' alive', 'I am alive')

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        assert 1 + 1 == 2
 9        # self.assertNotEqual(1+1, 2)
10        self.assertEqual(1+1, 2)
11
12        assert '1' + '1' == '11'
13        # self.assertNotEqual('1'+'1', '11')
14        self.assertEqual('1'+'1', '11')
15
16        assert 'I am' + ' alive' == 'I am alive'
17        # self.assertNotEqual('I am'+' alive', 'I am alive')
18        self.assertEqual('I am'+' alive', 'I am alive')
19
20
21def test_type_error_w_none():

    the test passes.

  • I add variables for 'I am' + ' alive' and 'I am alive'

    12        assert '1' + '1' == '11'
13        # self.assertNotEqual('1'+'1', '11')
14        self.assertEqual('1'+'1', '11')
15
16        reality = 'I am' + ' alive'
17        my_expectation = 'I am alive'
18        assert 'I am' + ' alive' == 'I am alive'
19        # self.assertNotEqual('I am'+' alive', 'I am alive')
20        self.assertEqual('I am'+' alive', 'I am alive')
21
22
23def test_type_error_w_none():

  • I use the variables to remove repetition of 'I am' + ' alive' and 'I am alive'

    16        reality = 'I am' + ' alive'
17        my_expectation = 'I am alive'
18        # assert 'I am' + ' alive' == 'I am alive'
19        assert reality == my_expectation
20        # self.assertNotEqual('I am'+' alive', 'I am alive')
21        # self.assertEqual('I am'+' alive', 'I am alive')
22        self.assertEqual(reality, my_expectation)
23
24
25def test_type_error_w_none():

    the test is still green.

  • I add variables for '1' + '1' and '11'

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        assert 1 + 1 == 2
 9        # self.assertNotEqual(1+1, 2)
10        self.assertEqual(1+1, 2)
11
12        reality = '1' + '1'
13        my_expectation = '11'
14        assert '1' + '1' == '11'
15        # self.assertNotEqual('1'+'1', '11')
16        self.assertEqual('1'+'1', '11')

  • I use the variables to remove repetition of '1' + '1' and '11'

    12        reality = '1' + '1'
13        my_expectation = '11'
14        # assert '1' + '1' == '11'
15        assert reality == my_expectation
16        # self.assertNotEqual('1'+'1', '11')
17        # self.assertEqual('1'+'1', '11')
18        self.assertEqual(reality, my_expectation)

    still green.

  • I add variables for 1 + 1 and 2

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        reality = 1 + 1
 9        my_expectation = 2
10        assert 1 + 1 == 2
11        # self.assertNotEqual(1+1, 2)
12        self.assertEqual(1+1, 2)

  • I use the variables to remove repetition of 1 + 1 and 2

     6    # def test_assert_keyword():
 7    def test_assert_keyword(self):
 8        reality = 1 + 1
 9        my_expectation = 2
10        # assert 1 + 1 == 2
11        assert reality == my_expectation
12        # self.assertNotEqual(1+1, 2)
13        # self.assertEqual(1+1, 2)
14        self.assertEqual(reality, my_expectation)

    green.

  • I remove the commented lines

     4class TestTypeError(unittest.TestCase):
 5
 6    def test_assert_keyword(self):
 7        reality = 1 + 1
 8        my_expectation = 2
 9        assert reality == my_expectation
10        self.assertEqual(reality, my_expectation)
11
12        reality = '1' + '1'
13        my_expectation = '11'
14        assert reality == my_expectation
15        self.assertEqual(reality, my_expectation)
16
17        reality = 'I am' + ' alive'
18        my_expectation = 'I am alive'
19        assert reality == my_expectation
20        self.assertEqual(reality, my_expectation)
21
22
23def test_type_error_w_none():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_assert_keyword to TestTypeError'

test_type_error_w_none with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_type_error_w_none to make it a method of TestTypeError

    17        reality = 'I am' + ' alive'
18        my_expectation = 'I am alive'
19        assert reality == my_expectation
20        self.assertEqual(reality, my_expectation)
21
22    def test_type_error_w_none():
23        assert None is None
24
25        assert False is not None
26
27        assert True is not None
28
29        assert 0 is not None
30
31        assert 0.0 is not None
32
33        assert '' is not None
34
35        assert () is not None
36
37        assert [] is not None
38
39        assert set() is not None
40
41        assert {} is not None
42
43
44def test_type_error_w_false():

    Caution

    Indentation matters in Python. It is how it knows what blocks belong to what function/method, class or module (Use 4 spaces)

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_type_error_w_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_type_error_w_none

22    # def test_type_error_w_none():
23    def test_type_error_w_none(self):
24        assert None is None

the test is green again.

REFACTOR: make it better

  • I add calls to the assertIsNot and assertIs methods for the assertions in test_type_error_w_none

    22    # def test_type_error_w_none():
23    def test_type_error_w_none(self):
24        assert None is None
25        self.assertIsNot(None, None)
26
27        assert False is not None
28        self.assertIs(False, None)
29
30        assert True is not None
31        self.assertIs(True, None)
32
33        assert 0 is not None
34        self.assertIs(0, None)
35
36        assert 0.0 is not None
37        self.assertIs(0.0, None)
38
39        assert '' is not None
40        self.assertIs('', None)
41
42        assert () is not None
43        self.assertIs((), None)
44
45        assert [] is not None
46        self.assertIs([], None)
47
48        assert set() is not None
49        self.assertIs(set(), None)
50
51        assert {} is not None
52        self.assertIs({}, None)
53
54
55def test_type_error_w_false():

    the terminal is my friend, and shows AssertionError

    AssertionError: unexpectedly identical: None

    compare this with the error message for assert None is not None

    E       assert None is not None

  • I change assertIsNot to assertIs for (None, None)

    22    # def test_type_error_w_none():
23    def test_type_error_w_none(self):
24        assert None is None
25        # self.assertIsNot(None, None)
26        self.assertIs(None, None)
27
28        assert False is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: False is not None

    compare this with the error message for assert False is None

    E    assert False is None

  • I change assertIs to assertIsNot for (False, None)

    28        assert False is not None
29        # self.assertIs(False, None)
30        self.assertIsNot(False, None)
31
32        assert True is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: True is not None

    compare this with the error message for assert True is None

    E    assert True is None

  • I change assertIsNot to assertIs for (True, None)

    32        assert True is not None
33        # self.assertIs(True, None)
34        self.assertIsNot(True, None)
35
36        assert 0 is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: 0 is not None

  • I change assertIs to assertIsNot for (0, None)

    36        assert 0 is not None
37        # self.assertIs(0, None)
38        self.assertIsNot(0, None)
39
40        assert 0.0 is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: 0.0 is not None

  • I change assertIs to assertIsNot for (0.0, None)

    40        assert 0.0 is not None
41        # self.assertIs(0.0, None)
42        self.assertIsNot(0.0, None)
43
44        assert '' is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: '' is not None

  • I change assertIs to assertIsNot for ('', None)

    44        assert '' is not None
45        # self.assertIs('', None)
46        self.assertIsNot('', None)
47
48        assert () is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: () is not None

  • I change assertIs to assertIsNot for ((), None)

    48        assert () is not None
49        # self.assertIs((), None)
50        self.assertIsNot((), None)
51
52        assert [] is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: [] is not None

  • I change assertIs to assertIsNot for ([], None)

    52        assert [] is not None
53        # self.assertIs([], None)
54        self.assertIsNot([], None)
55
56        assert set() is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: set()  is not None

  • I change assertIs to assertIsNot for (set(), None)

    56        assert set() is not None
57        # self.assertIs(set(), None)
58        self.assertIsNot(set(), None)
59
60        assert {} is not None

    the terminal is my friend, and shows AssertionError

    AssertionError: {} is not None

  • I change assertIs to assertIsNot for ({}, None)

    60        assert {} is not None
61        # self.assertIs({}, None)
62        self.assertIsNot({}, None)
63
64
65def test_type_error_w_false():

    the test passes.

  • I add a variable for {}

    58        self.assertIsNot(set(), None)
59
60        a_dictionary = {}
61        assert {} is not None
62        # self.assertIs({}, None)
63        self.assertIsNot({}, None)
64
65
66def test_type_error_w_false():

  • I use the variable to remove repetition of {}

    58        self.assertIsNot(set(), None)
59
60        a_dictionary = {}
61        # assert {} is not None
62        assert a_dictionary is not None
63        # self.assertIs({}, None)
64        # self.assertIsNot({}, None)
65        self.assertIsNot(a_dictionary, None)
66
67
68def test_type_error_w_false():

    the test is still green.

  • I add a variable for set()

    54        self.assertIsNot([], None)
55
56        a_set = set()
57        assert set() is not None
58        # self.assertIs(set(), None)
59        self.assertIsNot(set(), None)

  • I use the variable to remove repetition of set()

    54        self.assertIsNot([], None)
55
56        a_set = set()
57        # assert set() is not None
58        assert a_set is not None
59        # self.assertIs(set(), None)
60        # self.assertIsNot(set(), None)
61        self.assertIsNot(a_set, None)

    still green.

  • I add a variable for []

    50        self.assertIsNot((), None)
51
52        a_list = []
53        assert [] is not None
54        # self.assertIs([], None)
55        self.assertIsNot([], None)

  • I use the variable to remove repetition of []

    50        self.assertIsNot((), None)
51
52        a_list = []
53        # assert [] is not None
54        assert a_list is not None
55        # self.assertIs([], None)
56        # self.assertIsNot([], None)
57        self.assertIsNot(a_list, None)

    green.

  • I add a variable for ()

    46        self.assertIsNot('', None)
47
48        a_tuple = ()
49        assert () is not None
50        # self.assertIs((), None)
51        self.assertIsNot((), None)

  • I use the variable to remove repetition of ()

    46        self.assertIsNot('', None)
47
48        a_tuple = ()
49        # assert () is not None
50        assert a_tuple is not None
51        # self.assertIs((), None)
52        # self.assertIsNot((), None)
53        self.assertIsNot(a_tuple, None)

    still green.

  • I add a variable for ''

    42        self.assertIsNot(0.0, None)
43
44        a_string = ''
45        assert '' is not None
46        # self.assertIs('', None)
47        self.assertIsNot('', None)

  • I use the variable to remove repetition of ''

    42        self.assertIsNot(0.0, None)
43
44        a_string = ''
45        # assert '' is not None
46        assert a_string is not None
47        # self.assertIs('', None)
48        # self.assertIsNot('', None)
49        self.assertIsNot(a_string, None)

    the test is still green.

  • I add a variable for 0.0

    38        self.assertIsNot(0, None)
39
40        a_float = 0.0
41        assert 0.0 is not None
42        # self.assertIs(0.0, None)
43        self.assertIsNot(0.0, None)

  • I use the variable to remove repetition of 0.0

    38        self.assertIsNot(0, None)
39
40        a_float = 0.0
41        # assert 0.0 is not None
42        assert a_float is not None
43        # self.assertIs(0.0, None)
44        # self.assertIsNot(0.0, None)
45        self.assertIsNot(a_float, None)

    still green.

  • I add a variable for 0

    34        self.assertIsNot(True, None)
35
36        an_integer = 0
37        assert 0 is not None
38        # self.assertIs(0, None)
39        self.assertIsNot(0, None)

  • I use the variable to remove repetition of 0

    34        self.assertIsNot(True, None)
35
36        an_integer = 0
37        # assert 0 is not None
38        assert an_integer is not None
39        # self.assertIs(0, None)
40        # self.assertIsNot(0, None)
41        self.assertIsNot(an_integer, None)

    green.

  • I remove the commented lines from test_type_error_w_none

    20        self.assertEqual(reality, my_expectation)
21
22    def test_type_error_w_none(self):
23        assert None is None
24        self.assertIs(None, None)
25
26        assert False is not None
27        self.assertIsNot(False, None)
28
29        assert True is not None
30        self.assertIsNot(True, None)
31
32        an_integer = 0
33        assert an_integer is not None
34        self.assertIsNot(an_integer, None)
35
36        a_float = 0.0
37        assert a_float is not None
38        self.assertIsNot(a_float, None)
39
40        a_string = ''
41        assert a_string is not None
42        self.assertIsNot(a_string, None)
43
44        a_tuple = ()
45        assert a_tuple is not None
46        self.assertIsNot(a_tuple, None)
47
48        a_list = []
49        assert a_list is not None
50        self.assertIsNot(a_list, None)
51
52        a_set = set()
53        assert a_set is not None
54        self.assertIsNot(a_set, None)
55
56        a_dictionary = {}
57        assert a_dictionary is not None
58        self.assertIsNot(a_dictionary, None)
59
60
61def test_type_error_w_false():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_type_error_w_none to TestTypeError'

test_type_error_w_false with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_type_error_w_false to make it a method of TestTypeError

    58        self.assertIsNot(a_dictionary, None)
59
60    def test_type_error_w_false():
61        assert None is not False
62
63        assert False is False
64
65        assert True is not False
66
67        assert 0 is not False
68
69        assert 0.0 is not False
70
71        assert '' is not False
72
73        assert () is not False
74
75        assert [] is not False
76
77        assert set() is not False
78
79        assert {} is not False
80
81
82def test_type_error_w_true():

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_type_error_w_false()
    takes 0 positional arguments but 1 was given

GREEN: make it pass

I add self to the parentheses of test_type_error_w_false

60    # def test_type_error_w_false():
61    def test_type_error_w_false(self):
62        assert None is not False

the test is green again.

REFACTOR: make it better

  • I add calls to assertIsNot and assertIs to test_type_error_w_false

    60    # def test_type_error_w_false():
61    def test_type_error_w_false(self):
62        assert None is not False
63        self.assertIs(None, False)
64
65        assert False is False
66        self.assertIsNot(False, False)
67
68        assert True is not False
69        self.assertIs(True, False)
70
71        assert 0 is not False
72        self.assertIs(0, False)
73
74        assert 0.0 is not False
75        self.assertIs(0.0, False)
76
77        assert '' is not False
78        self.assertIs('', False)
79
80        assert () is not False
81        self.assertIs((), False)
82
83        assert [] is not False
84        self.assertIs([], False)
85
86        assert set() is not False
87        self.assertIs(set(), False)
88
89        assert {} is not False
90        self.assertIs({}, False)
91
92
93def test_type_error_w_true():

    the terminal is my friend, and shows AssertionError

    AssertionError: None is not False

  • I change assertIs to assert_is_not for (None, False)

    60    # def test_type_error_w_false():
61    def test_type_error_w_false(self):
62        assert None is not False
63        # self.assertIs(None, False)
64        self.assertIsNot(None, False)
65
66        assert False is False

    the terminal is my friend, and shows AssertionError

    AssertionError: unexpectedly identical: False

    compare this with the error message for assert False is not False

    E       assert False is not False

  • I change assertIsNot to assertIs for (False, False)

    66        assert False is False
67        # self.assertIsNot(False, False)
68        self.assertIs(False, False)
69
70        assert True is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: True is not False

  • I change assertIs to assertIsNot for (True, False)

    70        assert True is not False
71        # self.assertIs(True, False)
72        self.assertIsNot(True, False)
73
74        assert 0 is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: 0 is not False

  • I change assertIs to assertIsNot for (0, False)

    74        assert 0 is not False
75        # self.assertIs(0, False)
76        self.assertIsNot(0, False)
77
78        assert 0.0 is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: 0.0 is not False

  • I change assertIs to assertIsNot for (0.0, False)

    78        assert 0.0 is not False
79        # self.assertIs(0.0, False)
80        self.assertIsNot(0.0, False)
81
82        assert '' is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: '' is not False

  • I change assertIs to assertIsNot for ('', False)

    82        assert '' is not False
83        # self.assertIs('', False)
84        self.assertIsNot('', False)
85
86        assert () is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: () is not False

  • I change assertIs to assertIsNot for ((), False)

    86        assert () is not False
87        # self.assertIs((), False)
88        self.assertIsNot((), False)
89
90        assert [] is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: [] is not False

  • I change assertIs to assertIsNot for ([], False)

    90        assert [] is not False
91        # self.assertIs([], False)
92        self.assertIsNot([], False)
93
94        assert set() is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: set() is not False

  • I change assertIs to assertIsNot for (set(), False)

    94        assert set() is not False
95        # self.assertIs(set(), False)
96        self.assertIsNot(set(), False)
97
98        assert {} is not False

    the terminal is my friend, and shows AssertionError

    AssertionError: {} is not False

  • I change assertIs to assertIsNot for ({}, False)

     98        assert {} is not False
 99        # self.assertIs({}, False)
100        self.assertIsNot({}, False)
101
102
103def test_type_error_w_true():

    the test passes.

  • I add a variable for {}

     96        self.assertIsNot(set(), False)
 97
 98        a_dictionary = {}
 99        assert {} is not False
100        # self.assertIs({}, False)
101        self.assertIsNot({}, False)
102
103
104def test_type_error_w_true():

  • I use the variable to remove repetition of {}

     96        self.assertIsNot(set(), False)
 97
 98        a_dictionary = {}
 99        # assert {} is not False
100        assert a_dictionary is not False
101        # self.assertIs({}, False)
102        # self.assertIsNot({}, False)
103        self.assertIsNot(a_dictionary, False)
104
105
106def test_type_error_w_true():

    the test is still green.

  • I add a variable for set()

    92        self.assertIsNot([], False)
93
94        a_set = set()
95        assert set() is not False
96        # self.assertIs(set(), False)
97        self.assertIsNot(set(), False)

  • I use the variable to remove repetition of set()

    92        self.assertIsNot([], False)
93
94        a_set = set()
95        # assert set() is not False
96        assert a_set is not False
97        # self.assertIs(set(), False)
98        # self.assertIsNot(set(), False)
99        self.assertIsNot(a_set, False)

    still green.

  • I add a variable for []

    88        self.assertIsNot((), False)
89
90        a_list = []
91        assert [] is not False
92        # self.assertIs([], False)
93        self.assertIsNot([], False)

  • I use the variable to remove repetition of []

    88        self.assertIsNot((), False)
89
90        a_list = []
91        # assert [] is not False
92        assert a_list is not False
93        # self.assertIs([], False)
94        # self.assertIsNot([], False)
95        self.assertIsNot(a_list, False)

    green.

  • I add a variable for ()

    84        self.assertIsNot('', False)
85
86        a_tuple = ()
87        assert () is not False
88        # self.assertIs((), False)
89        self.assertIsNot((), False)

  • I use the variable to remove repetition of ()

    84        self.assertIsNot('', False)
85
86        a_tuple = ()
87        # assert () is not False
88        assert a_tuple is not False
89        # self.assertIs((), False)
90        # self.assertIsNot((), False)
91        self.assertIsNot(a_tuple, False)

    still green.

  • I add a variable for ''

    80        self.assertIsNot(0.0, False)
81
82        a_string = ''
83        assert '' is not False
84        # self.assertIs('', False)
85        self.assertIsNot('', False)

  • I use the variable to remove repetition of ''

    80        self.assertIsNot(0.0, False)
81
82        a_string = ''
83        # assert '' is not False
84        assert a_string is not False
85        # self.assertIs('', False)
86        # self.assertIsNot('', False)
87        self.assertIsNot(a_string, False)

    the test is still green.

  • I add a variable for 0.0

    76        self.assertIsNot(0, False)
77
78        a_float = 0.0
79        assert 0.0 is not False
80        # self.assertIs(0.0, False)
81        self.assertIsNot(0.0, False)

  • I use the variable to remove repetition of 0.0

    76        self.assertIsNot(0, False)
77
78        a_float = 0.0
79        # assert 0.0 is not False
80        assert a_float is not False
81        # self.assertIs(0.0, False)
82        # self.assertIsNot(0.0, False)
83        self.assertIsNot(a_float, False)

    still green.

  • I add a variable for 0

    72        self.assertIsNot(True, False)
73
74        an_integer = 0
75        assert 0 is not False
76        # self.assertIs(0, False)
77        self.assertIsNot(0, False)

  • I use the variable to remove repetition of 0

    72        self.assertIsNot(True, False)
73
74        an_integer = 0
75        # assert 0 is not False
76        assert an_integer is not False
77        # self.assertIs(0, False)
78        # self.assertIsNot(0, False)
79        self.assertIsNot(an_integer, False)

    green.

  • I remove the commented lines from test_type_error_w_false

    60    def test_type_error_w_false(self):
61        assert None is not False
62        self.assertIsNot(None, False)
63
64        assert False is False
65        self.assertIs(False, False)
66
67        assert True is not False
68        self.assertIsNot(True, False)
69
70        an_integer = 0
71        assert an_integer is not False
72        self.assertIsNot(an_integer, False)
73
74        a_float = 0.0
75        assert a_float is not False
76        self.assertIsNot(a_float, False)
77
78        a_string = ''
79        assert a_string is not False
80        self.assertIsNot(a_string, False)
81
82        a_tuple = ()
83        assert a_tuple is not False
84        self.assertIsNot(a_tuple, False)
85
86        a_list = []
87        assert a_list is not False
88        self.assertIsNot(a_list, False)
89
90        a_set = set()
91        assert a_set is not False
92        self.assertIsNot(a_set, False)
93
94        a_dictionary = {}
95        assert a_dictionary is not False
96        self.assertIsNot(a_dictionary, False)
97
98
99def test_type_error_w_true():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_type_error_w_false to TestTypeError'

test_type_error_w_true with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_type_error_w_true to make it a method of the TestTypeError class

     96        self.assertIsNot(a_dictionary, False)
 97
 98    def test_type_error_w_true():
 99        assert None is not True
100
101        assert False is not True
102
103        assert True is True
104
105        assert 0 is not True
106
107        assert 0.0 is not True
108
109        assert '' is not True
110
111        assert () is not True
112
113        assert [] is not True
114
115        assert set() is not True
116
117        assert {} is not True
118
119
120def test_type_error_w_equality():

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_type_error_w_true()
    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_type_error_w_true

 98      # def test_type_error_w_true():
 99      def test_type_error_w_true(self):
100          assert None is not True

the test is green again.

REFACTOR: make it better

  • I add calls to assertIsNot and assertIs to test_type_error_w_true

     98    # def test_type_error_w_true():
 99    def test_type_error_w_true(self):
100        assert None is not True
101        self.assertIs(None, True)
102
103        assert False is not True
104        self.assertIs(False, True)
105
106        assert True is True
107        self.assertIsNot(True, True)
108
109        assert 0 is not True
110        self.assertIs(0, True)
111
112        assert 0.0 is not True
113        self.assertIs(0.0, True)
114
115        assert '' is not True
116        self.assertIs('', True)
117
118        assert () is not True
119        self.assertIs((), True)
120
121        assert [] is not True
122        self.assertIs([], True)
123
124        assert set() is not True
125        self.assertIs(set(), True)
126
127        assert {} is not True
128        self.assertIs({}, True)
129
130
131def test_type_error_w_equality():

    the terminal is my friend, and shows AssertionError

    AssertionError: None is not True

  • I change assertIs to assert_is_not for (None, True)

     98    # def test_type_error_w_true():
 99    def test_type_error_w_true(self):
100        assert None is not True
101        # self.assertIs(None, True)
102        self.assertIsNot(None, True)
103
104        assert False is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: False is not True

  • I change assertIs to assertIsNot for (False, True)

    104        assert False is not True
105        # self.assertIs(False, True)
106        self.assertIsNot(False, True)
107
108        assert True is True

    the terminal is my friend, and shows AssertionError

    AssertionError: unexpectedly identical: True

    compare this with the error message for assert True is not True

    E       assert True is not True

  • I change assertIsNot to assertIs for (True, True)

    108        assert True is True
109        # self.assertIsNot(True, True)
110        self.assertIs(True, True)
111
112        assert 0 is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: 0 is not True

  • I change assertIs to assertIsNot for (0, True)

    112        assert 0 is not True
113        # self.assertIs(0, True)
114        self.assertIsNot(0, True)
115
116        assert 0.0 is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: 0.0 is not True

  • I change assertIs to assertIsNot for (0.0, True)

    116        assert 0.0 is not True
117        # self.assertIs(0.0, True)
118        self.assertIsNot(0.0, True)
119
120        assert '' is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: '' is not True

  • I change assertIs to assertIsNot for ('', True)

    120        assert '' is not True
121        # self.assertIs('', True)
122        self.assertIsNot('', True)
123
124        assert () is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: () is not True

  • I change assertIs to assertIsNot for ((), True)

    124        assert () is not True
125        # self.assertIs((), True)
126        self.assertIsNot((), True)
127
128        assert [] is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: [] is not True

  • I change assertIs to assertIsNot for ([], True)

    128        assert [] is not True
129        # self.assertIs([], True)
130        self.assertIsNot([], True)
131
132        assert set() is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: set() is not True

  • I change assertIs to assertIsNot for (set(), True)

    132        assert set() is not True
133        # self.assertIs(set(), True)
134        self.assertIsNot(set(), True)
135
136        assert {} is not True

    the terminal is my friend, and shows AssertionError

    AssertionError: {} is not True

  • I change assertIs to assertIsNot for ({}, True)

    136        assert {} is not True
137        # self.assertIs({}, True)
138        self.assertIsNot({}, True)
139
140
141def test_type_error_w_equality():

    the test passes.

  • I add a variable for {}

    134        self.assertIsNot(set(), True)
135
136        a_dictionary = {}
137        assert {} is not True
138        # self.assertIs({}, True)
139        self.assertIsNot({}, True)
140
141
142def test_type_error_w_equality():

  • I use the variable to remove repetition of {}

    134        self.assertIsNot(set(), True)
135
136        a_dictionary = {}
137        # assert {} is not True
138        assert a_dictionary is not True
139        # self.assertIs({}, True)
140        # self.assertIsNot({}, True)
141        self.assertIsNot(a_dictionary, True)
142
143
144def test_type_error_w_equality():

    the test is still green.

  • I add a variable for set()

    130        self.assertIsNot([], True)
131
132        a_set = set()
133        assert set() is not True
134        # self.assertIs(set(), True)
135        self.assertIsNot(set(), True)

  • I use the variable to remove repetition of set()

    130        self.assertIsNot([], True)
131
132        a_set = set()
133        # assert set() is not True
134        assert a_set is not True
135        # self.assertIs(set(), True)
136        # self.assertIsNot(set(), True)
137        self.assertIsNot(a_set, True)

    still green.

  • I add a variable for []

    126        self.assertIsNot((), True)
127
128        a_list = []
129        assert [] is not True
130        # self.assertIs([], True)
131        self.assertIsNot([], True)

  • I use the variable to remove repetition of []

    126        self.assertIsNot((), True)
127
128        a_list = []
129        # assert [] is not True
130        assert a_list is not True
131        # self.assertIs([], True)
132        # self.assertIsNot([], True)
133        self.assertIsNot(a_list, True)

    green.

  • I add a variable for ()

    122        self.assertIsNot('', True)
123
124        a_tuple = ()
125        assert () is not True
126        # self.assertIs((), True)
127        self.assertIsNot((), True)

  • I use the variable to remove repetition of ()

    122        self.assertIsNot('', True)
123
124        a_tuple = ()
125        # assert () is not True
126        assert a_tuple is not True
127        # self.assertIs((), True)
128        # self.assertIsNot((), True)
129        self.assertIsNot(a_tuple, True)

    still green.

  • I add a variable for ''

    118        self.assertIsNot(0.0, True)
119
120        a_string = ''
121        assert '' is not True
122        # self.assertIs('', True)
123        self.assertIsNot('', True)

  • I use the variable to remove repetition of ''

    118        self.assertIsNot(0.0, True)
119
120        a_string = ''
121        # assert '' is not True
122        assert a_string is not True
123        # self.assertIs('', True)
124        # self.assertIsNot('', True)
125        self.assertIsNot(a_string, True)

    the test is still green.

  • I add a variable for 0.0

    114        self.assertIsNot(0, True)
115
116        a_float = 0.0
117        assert 0.0 is not True
118        # self.assertIs(0.0, True)
119        self.assertIsNot(0.0, True)

  • I use the variable to remove repetition of 0.0

    114        self.assertIsNot(0, True)
115
116        a_float = 0.0
117        # assert 0.0 is not True
118        assert a_float is not True
119        # self.assertIs(0.0, True)
120        # self.assertIsNot(0.0, True)
121        self.assertIsNot(a_float, True)

    still green.

  • I add a variable for 0

    110        self.assertIsNot(True, True)
111
112        an_integer = 0
113        assert 0 is not True
114        # self.assertIs(0, True)
115        self.assertIsNot(0, True)

  • I use the variable to remove repetition of 0

    110        self.assertIs(True, True)
111
112        an_integer = 0
113        # assert 0 is not True
114        assert an_integer is not True
115        # self.assertIs(0, True)
116        # self.assertIsNot(0, True)
117        self.assertIsNot(an_integer, True)

    green.

  • I remove the commented lines from test_type_error_w_true

     96        self.assertIsNot(a_dictionary, False)
 97
 98    def test_type_error_w_true(self):
 99        assert None is not True
100        self.assertIsNot(None, True)
101
102        assert False is not True
103        self.assertIsNot(False, True)
104
105        assert True is True
106        self.assertIs(True, True)
107
108        an_integer = 0
109        assert an_integer is not True
110        self.assertIsNot(an_integer, True)
111
112        a_float = 0.0
113        assert a_float is not True
114        self.assertIsNot(a_float, True)
115
116        a_string = ''
117        assert a_string is not True
118        self.assertIsNot(a_string, True)
119
120        a_tuple = ()
121        assert a_tuple is not True
122        self.assertIsNot(a_tuple, True)
123
124        a_list = []
125        assert a_list is not True
126        self.assertIsNot(a_list, True)
127
128        a_set = set()
129        assert a_set is not True
130        self.assertIsNot(a_set, True)
131
132        a_dictionary = {}
133        assert a_dictionary is not True
134        self.assertIsNot(a_dictionary, True)
135
136
137def test_type_error_w_equality():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_type_error_w_true to TestTypeError'

test_type_error_w_equality with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_type_error_w_equality to make it a method of the TestTypeError

    134        self.assertIsNot(a_dictionary, True)
135
136    def test_type_error_w_equality():
137        assert None == None
138
139        assert False != None
140
141        assert False != True
142
143        assert False == False
144
145        assert True != None
146
147        assert True == True
148
149
150def test_type_error_w_is_vs_equal():

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_type_error_w_equality()
    takes 0 positional arguments but 1 was given

GREEN: make it pass

I add self to the parentheses of test_type_error_w_equality

134        self.assertIsNot(a_dictionary, True)
135
136    # def test_type_error_w_equality():
137    def test_type_error_w_equality(self):
138        assert None == None

the test is green again.

REFACTOR: make it better

  • I add calls to assertNotEqual and assertEqual to test_type_error_w_equality

    136    # def test_type_error_w_equality():
137    def test_type_error_w_equality(self):
138        assert None == None
139        self.assertNotEqual(None, None)
140
141        assert False != None
142        self.assertEqual(False, None)
143
144        assert False != True
145        self.assertEqual(False, True)
146
147        assert False == False
148        self.assertNotEqual(False, False)
149
150        assert True != None
151        self.assertEqual(True, None)
152
153        assert True == True
154        self.assertNotEqual(True, True)
155
156
157def test_type_error_w_is_vs_equal():

    the terminal is my friend, and shows AssertionError

    AssertionError: None == None

    compare this with the error for assert None != None

    E   assert None != None

  • I change assertNotEqual to assertEqual for (None, None)

    136    # def test_type_error_w_equality():
137    def test_type_error_w_equality(self):
138        assert None == None
139        # self.assertNotEqual(None, None)
140        self.assertEqual(None, None)
141
142        assert False != None

    the terminal is my friend, and shows AssertionError

    AssertionError: False != None

  • I change assertEqual to assertNotEqual for (False, None)

    142        assert False != None
143        # self.assertEqual(False, None)
144        self.assertNotEqual(False, None)
145
146        assert False != True

    the terminal is my friend, and shows AssertionError

    AssertionError: False != True

    compare this with the error for assert False == True

    E    assert False == True

  • I change assertEqual to assertNotEqual for (False, True)

    146        assert False != True
147        # self.assertEqual(False, True)
148        self.assertNotEqual(False, True)
149
150        assert False == False

    the terminal is my friend, and shows AssertionError

    AssertionError: False == False

  • I change assertNotEqual to assertEqual for (False, False)

    150        assert False == False
151        # self.assertNotEqual(False, False)
152        self.assertEqual(False, False)
153
154        assert True != None

    the terminal is my friend, and shows AssertionError

    AssertionError: True != None

  • I change assertEqual to assertNotEqual for (True, None)

    154        assert True != None
155        # self.assertEqual(True, None)
156        self.assertNotEqual(True, None)
157
158        assert True == True

    the terminal is my friend, and shows AssertionError

    AssertionError: True == True

  • I change assertEqual to assertNotEqual for (True, True)

    158        assert True == True
159        # self.assertNotEqual(True, True)
160        self.assertEqual(True, True)
161
162
163def test_type_error_w_is_vs_equal():

    the test passes.

  • I remove the commented lines from test_type_error_w_equality

    134        self.assertIsNot(a_dictionary, True)
135
136    def test_type_error_w_equality(self):
137        assert None == None
138        self.assertEqual(None, None)
139
140        assert False != None
141        self.assertNotEqual(False, None)
142
143        assert False != True
144        self.assertNotEqual(False, True)
145
146        assert False == False
147        self.assertEqual(False, False)
148
149        assert True != None
150        self.assertNotEqual(True, None)
151
152        assert True == True
153        self.assertEqual(True, True)
154
155
156def test_type_error_w_is_vs_equal():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_type_error_w_equality to TestTypeError'

test_type_error_w_is_vs_equal with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_type_error_w_is_vs_equal to make it a method of TestTypeError

    153        self.assertEqual(True, True)
154
155    def test_type_error_w_is_vs_equal():
156        assert 0 is not 0.0
157
158        assert 0 == 0.0
159
160
161def will_not_run():

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_type_error_w_is_vs_equal()
    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 definition of test_type_error_w_is_vs_equal

153        self.assertEqual(True, True)
154
155    # def test_type_error_w_is_vs_equal():
156    def test_type_error_w_is_vs_equal(self):
157        assert 0 is not 0.0

the test is green again.

REFACTOR: make it better

  • I add a call to assertIs for assert 0 is not 0.0

    155    # def test_type_error_w_is_vs_equal():
156    def test_type_error_w_is_vs_equal(self):
157        assert 0 is not 0.0
158        self.assertIs(0, 0.0)

    the terminal is my friend, and shows AssertionError

    AssertionError: 0 is not 0.0

    compare the assertions: assertIs(0, 0.0) vs assert 0 is 0.0.

  • I change assertIs to assertIsNot

    155    # def test_type_error_w_is_vs_equal():
156    def test_type_error_w_is_vs_equal(self):
157        assert 0 is not 0.0
158        # self.assertIs(0, 0.0)
159        self.assertIsNot(0, 0.0)
160
161        assert 0 == 0.0

    the test passes. Compare the assertions: assertIsNot(0, 0.0) vs assert 0 is not 0.0.

  • I add a call to assertNotEqual for assert 0 == 0.0

    155    # def test_type_error_w_is_vs_equal():
156    def test_type_error_w_is_vs_equal(self):
157        assert 0 is not 0.0
158        # self.assertIs(0, 0.0)
159        self.assertIsNot(0, 0.0)
160
161        assert 0 == 0.0
162        self.assertNotEqual(0, 0.0)
163
164
165def will_not_run():

    the terminal is my friend, and shows AssertionError

    AssertionError: 0 == 0.0

    compare the assertions: assertNotEqual(0, 0.0) vs assert 0 != 0.0.

  • I change assertNotEqual to assertEqual

    155    # def test_type_error_w_is_vs_equal():
156    def test_type_error_w_is_vs_equal(self):
157        assert 0 is not 0.0
158        # self.assertIs(0, 0.0)
159        self.assertIsNot(0, 0.0)
160
161        assert 0 == 0.0
162        # self.assertNotEqual(0, 0.0)
163        self.assertEqual(0, 0.0)
164
165
166def will_not_run():

    the test passes. Compare the assertions: assertIsNot(0, 0.0) vs assert 0 is not 0.0.

  • I remove the commented lines from test_type_error_w_is_vs_equal

    153        self.assertEqual(True, True)
154
155    def test_type_error_w_is_vs_equal(self):
156        assert 0 is not 0.0
157        self.assertIsNot(0, 0.0)
158
159        assert 0 == 0.0
160        self.assertEqual(0, 0.0)
161
162
163def will_not_run():

  • I add a git commit message in the other terminal

    git commit -am \
'move test_type_error_w_is_vs_equal to TestTypeError'

will_not_run with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move will not run to the TestTypeError class

    160        self.assertEqual(0, 0.0)
161
162    def will_not_run():
163        assert False == True
164
165
166def test_failure():

    the test is still green.

  • I add a call to test_assert_equal

    160        self.assertEqual(0, 0.0)
161
162    def will_not_run():
163        assert False == True
164        self.assertEqual(False, True)
165
166
167def test_failure():

    still green.

  • I add self to the parentheses of will not run

    162        self.assertEqual(0, 0.0)
163
164    # def will_not_run():
165    def will_not_run(self):
166        assert False == True
167        self.assertEqual(False, True)
168
169
170def test_failure():

    green.

  • I change the name from will not run to test_will_not_run

    162        self.assertEqual(0, 0.0)
163
164    # def will_not_run():
165    # def will_not_run(self):
166    def test_will_not_run(self):
167        assert False == True
168        self.assertEqual(False, True)
169
170
171def test_failure():

    the terminal is my friend, and shows AssertionError

    E       assert False == True

    a reminder that the test only runs if the method/function name starts with test.

GREEN: make it pass

I undo the change

160        self.assertEqual(0, 0.0)
161
162    def will_not_run():
163    # def will_not_run(self):
164    # def test_will_not_run(self):
165        assert False == True
166        self.assertEqual(False, True)
167
168
169def test_failure():

the test is green again.

REFACTOR: make it better

  • I remove the commented lines from will not run

    160        self.assertEqual(0, 0.0)
161
162    def will_not_run():
163        assert False == True
164        self.assertEqual(False, True)
165
166
167def test_failure():

  • I add a git commit message in the other terminal

    git commit -am \
'move will_not_run to TestTypeError'

test_failure with unittest

RED: make it fail

  • I go back to the terminal where the tests are running

  • I move test_failure to TestTypeError

    162    def will_not_run():
163        assert False == True
164        self.assertEqual(False, True)
165
166    def test_failure():
167        # assert False == True
168        assert False == False
169
170
171# NOTES

    the terminal is my friend, and shows TypeError

    TypeError:
    TestTypeError.test_failure()
    takes 0 positional arguments but 1 was given

    because …

GREEN: make it pass

I add self to the parentheses of test_failure to TestTypeError

166    # def test_failure():
167    def test_failure(self):
168        # assert False == True
169        assert False == False
170
171
172# NOTES

the test is green again.

REFACTOR: make it better

  • I add a call to the assertNotEqual method

    166    # def test_failure():
167    def test_failure(self):
168        # assert False == True
169        assert False == False
170        self.assertNotEqual(False, False)
171
172
173# NOTES

    the terminal is my friend, and shows AssertionError

    AssertionError: False == False

  • I change assertNotEqual to assertEqual

    166    # def test_failure():
167    def test_failure(self):
168        # assert False == True
169        assert False == False
170        # self.assertNotEqual(False, False)
171        self.assertEqual(False, False)
172
173
174# NOTES

    the test passes.

  • I remove the commented lines from test_failure

    162    def will_not_run():
163        assert False == True
164        self.assertEqual(False, True)
165
166    def test_failure(self):
167        assert False == False
168        self.assertEqual(False, False)
169
170
171# NOTES

  • I add a git commit message in the other terminal

    git commit -am \
'move test_failure to TestTypeError'

remove repetition with class attributes

Three of the tests have the exact same variables. I can make them class attributes to remove repetition of making the same variables in the tests.

  • I add a class attribute for an_integer = 0 to TestTypeError

    4class TestTypeError(unittest.TestCase):
5
6    an_integer = 0
7
8    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of an_integer = 0 from test_type_error_w_none

    24    def test_type_error_w_none(self):
25        assert None is None
26        self.assertIs(None, None)
27
28        assert False is not None
29        self.assertIsNot(False, None)
30
31        assert True is not None
32        self.assertIsNot(True, None)
33
34        # an_integer = 0
35        # assert an_integer is not None
36        # self.assertIsNot(an_integer, None)
37        assert self.an_integer is not None
38        self.assertIsNot(self.an_integer, None)
39
40        a_float = 0.0

    the test is still green.

  • I use the class attribute to remove repetition of an_integer = 0 from test_type_error_w_false

    62        self.assertIsNot(a_dictionary, None)
63
64    def test_type_error_w_false(self):
65        assert None is not False
66        self.assertIsNot(None, False)
67
68        assert False is False
69        self.assertIs(False, False)
70
71        assert True is not False
72        self.assertIsNot(True, False)
73
74        # an_integer = 0
75        # assert an_integer is not False
76        # self.assertIsNot(an_integer, False)
77        assert self.an_integer is not False
78        self.assertIsNot(self.an_integer, False)
79
80        a_float = 0.0

    still green.

  • I use the class attribute to remove repetition of an_integer = 0 from test_type_error_w_true

    102        self.assertIsNot(a_dictionary, False)
103
104    def test_type_error_w_true(self):
105        assert None is not True
106        self.assertIsNot(None, True)
107
108        assert False is not True
109        self.assertIsNot(False, True)
110
111        assert True is True
112        self.assertIs(True, True)
113
114        # an_integer = 0
115        # assert an_integer is not True
116        # self.assertIsNot(an_integer, True)
117        assert self.an_integer is not True
118        self.assertIsNot(self.an_integer, True)
119
120        a_float = 0.0

    green.

  • I add a class attribute for a_float = 0.0

    4class TestTypeError(unittest.TestCase):
5
6    an_integer = 0
7    a_float = 0.0
8
9    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_float = 0.0 from test_type_error_w_none

    39        self.assertIsNot(self.an_integer, None)
40
41        # a_float = 0.0
42        # assert a_float is not None
43        # self.assertIsNot(a_float, None)
44        assert self.a_float is not None
45        self.assertIsNot(self.a_float, None)
46
47        a_string = ''

    still green.

  • I use the class attribute to remove repetition of a_float = 0.0 from test_type_error_w_false

    81        self.assertIsNot(self.an_integer, False)
82
83        # a_float = 0.0
84        # assert a_float is not False
85        # self.assertIsNot(a_float, False)
86        assert self.a_float is not False
87        self.assertIsNot(self.a_float, False)
88
89        a_string = ''

    the test is still green.

  • I use the class attribute to remove repetition of a_float = 0.0 from test_type_error_w_true

    123        self.assertIsNot(self.an_integer, True)
124
125        # a_float = 0.0
126        # assert a_float is not True
127        # self.assertIsNot(a_float, True)
128        assert self.a_float is not True
129        self.assertIsNot(self.a_float, True)
130
131        a_string = ''

    still green.

  • I add a class attribute for a_string = ''

     4class TestTypeError(unittest.TestCase):
 5
 6    an_integer = 0
 7    a_float = 0.0
 8    a_string = ''
 9
10    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_string = '' from test_type_error_w_none

    46        self.assertIsNot(self.a_float, None)
47
48        # a_string = ''
49        # assert a_string is not None
50        # self.assertIsNot(a_string, None)
51        assert self.a_string is not None
52        self.assertIsNot(self.a_string, None)
53
54        a_tuple = ()

    green.

  • I use the class attribute to remove repetition of a_string = '' from test_type_error_w_false

    90        self.assertIsNot(self.a_float, False)
91
92        # a_string = ''
93        # assert a_string is not False
94        # self.assertIsNot(a_string, False)
95        assert self.a_string is not False
96        self.assertIsNot(self.a_string, False)
97
98        a_tuple = ()

    still green.

  • I use the class attribute to remove repetition of a_string = '' from test_type_error_w_true

    134        self.assertIsNot(self.a_float, True)
135
136        # a_string = ''
137        # assert a_string is not True
138        # self.assertIsNot(a_string, True)
139        assert self.a_string is not True
140        self.assertIsNot(self.a_string, True)
141
142        a_tuple = ()

    the test is still green.

  • I add a class attribute for a_tuple = ()

     4class TestTypeError(unittest.TestCase):
 5
 6    an_integer = 0
 7    a_float = 0.0
 8    a_string = ''
 9    a_tuple = ()
10
11    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_tuple = () from test_type_error_w_none

    53        self.assertIsNot(self.a_string, None)
54
55        # a_tuple = ()
56        # assert a_tuple is not None
57        # self.assertIsNot(a_tuple, None)
58        assert self.a_tuple is not None
59        self.assertIsNot(self.a_tuple, None)
60
61        a_list = []

    still green.

  • I use the class attribute to remove repetition of a_tuple = () from test_type_error_w_false

     99        self.assertIsNot(self.a_string, False)
100
101        # a_tuple = ()
102        # assert a_tuple is not False
103        # self.assertIsNot(a_tuple, False)
104        assert self.a_tuple is not False
105        self.assertIsNot(self.a_tuple, False)
106
107        a_list = []

    green.

  • I use the class attribute to remove repetition of a_tuple = () from test_type_error_w_true

    145        self.assertIsNot(self.a_string, True)
146
147        # a_tuple = ()
148        # assert a_tuple is not True
149        # self.assertIsNot(a_tuple, True)
150        assert self.a_tuple is not True
151        self.assertIsNot(self.a_tuple, True)
152
153        a_list = []

    still green.

  • I add a class attribute for a_list = []

     4class TestTypeError(unittest.TestCase):
 5
 6    an_integer = 0
 7    a_float = 0.0
 8    a_string = ''
 9    a_tuple = ()
10    a_list = []
11
12    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_list = [] from test_type_error_w_none

    60        self.assertIsNot(self.a_tuple, None)
61
62        # a_list = []
63        # assert a_list is not None
64        # self.assertIsNot(a_list, None)
65        assert self.a_list is not None
66        self.assertIsNot(self.a_list, None)
67
68        a_set = set()

    the test is still green.

  • I use the class attribute to remove repetition of a_list = [] from test_type_error_w_false

    108        self.assertIsNot(self.a_tuple, False)
109
110        # a_list = []
111        # assert a_list is not False
112        # self.assertIsNot(a_list, False)
113        assert self.a_list is not False
114        self.assertIsNot(self.a_list, False)
115
116        a_set = set()

    still green.

  • I use the class attribute to remove repetition of a_list = [] from test_type_error_w_true

    156        self.assertIsNot(self.a_tuple, True)
157
158        # a_list = []
159        # assert a_list is not True
160        # self.assertIsNot(a_list, True)
161        assert self.a_list is not True
162        self.assertIsNot(self.a_list, True)
163
164        a_set = set()

    green.

  • I add a class attribute for a_set = set()

     4class TestTypeError(unittest.TestCase):
 5
 6    an_integer = 0
 7    a_float = 0.0
 8    a_string = ''
 9    a_tuple = ()
10    a_list = []
11    a_set = set()
12
13    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_set = set() from test_type_error_w_none

    67        self.assertIsNot(self.a_list, None)
68
69        # a_set = set()
70        # assert a_set is not None
71        # self.assertIsNot(a_set, None)
72        assert self.a_set is not None
73        self.assertIsNot(self.a_set, None)
74
75        a_dictionary = {}

    still green.

  • I use the class attribute to remove repetition of a_set = set() from test_type_error_w_false

    117        self.assertIsNot(self.a_list, False)
118
119        # a_set = set()
120        # assert a_set is not False
121        # self.assertIsNot(a_set, False)
122        assert self.a_set is not False
123        self.assertIsNot(self.a_set, False)
124
125        a_dictionary = {}

    the test is still green.

  • I use the class attribute to remove repetition of a_set = set() from test_type_error_w_true

    167        self.assertIsNot(self.a_list, True)
168
169        # a_set = set()
170        # assert a_set is not True
171        # self.assertIsNot(a_set, True)
172        assert self.a_set is not True
173        self.assertIsNot(self.a_set, True)
174
175        a_dictionary = {}

    still green.

  • I add a class attribute for a_dictionary = {}

     4class TestTypeError(unittest.TestCase):
 5
 6    an_integer = 0
 7    a_float = 0.0
 8    a_string = ''
 9    a_tuple = ()
10    a_list = []
11    a_set = set()
12    a_dictionary = {}
13
14    def test_assert_keyword(self):

  • I use the class attribute to remove repetition of a_dictionary = {} from test_type_error_w_none

    74        self.assertIsNot(self.a_set, None)
75
76        # a_dictionary = {}
77        # assert a_dictionary is not None
78        # self.assertIsNot(a_dictionary, None)
79        assert self.a_dictionary is not None
80        self.assertIsNot(self.a_dictionary, None)
81
82    def test_type_error_w_false(self):

    the test is still green.

  • I use the class attribute to remove repetition of a_dictionary = {} from test_type_error_w_false

    126        self.assertIsNot(self.a_set, False)
127
128        # a_dictionary = {}
129        # assert a_dictionary is not False
130        # self.assertIsNot(a_dictionary, False)
131        assert self.a_dictionary is not False
132        self.assertIsNot(self.a_dictionary, False)
133
134    def test_type_error_w_true(self):

    still green.

  • I use the class attribute to remove repetition of a_dictionary = {} from test_type_error_w_true

    178        self.assertIsNot(self.a_set, True)
179
180        # a_dictionary = {}
181        # assert a_dictionary is not True
182        # self.assertIsNot(a_dictionary, True)
183        assert self.a_dictionary is not True
184        self.assertIsNot(self.a_dictionary, True)
185
186    def test_type_error_w_equality(self):

    green.

  • I remove the commented lines from test_type_error_w_true

    134    def test_type_error_w_true(self):
135        assert None is not True
136        self.assertIsNot(None, True)
137
138        assert False is not True
139        self.assertIsNot(False, True)
140
141        assert True is True
142        self.assertIs(True, True)
143
144        assert self.an_integer is not True
145        self.assertIsNot(self.an_integer, True)
146
147        assert self.a_float is not True
148        self.assertIsNot(self.a_float, True)
149
150        assert self.a_string is not True
151        self.assertIsNot(self.a_string, True)
152
153        assert self.a_tuple is not True
154        self.assertIsNot(self.a_tuple, True)
155
156        assert self.a_list is not True
157        self.assertIsNot(self.a_list, True)
158
159        assert self.a_set is not True
160        self.assertIsNot(self.a_set, True)
161
162        assert self.a_dictionary is not True
163        self.assertIsNot(self.a_dictionary, True)
164
165    def test_type_error_w_equality(self):

  • I remove the commented lines from test_type_error_w_false

     82    def test_type_error_w_false(self):
 83        assert None is not False
 84        self.assertIsNot(None, False)
 85
 86        assert False is False
 87        self.assertIs(False, False)
 88
 89        assert True is not False
 90        self.assertIsNot(True, False)
 91
 92        assert self.an_integer is not False
 93        self.assertIsNot(self.an_integer, False)
 94
 95        assert self.a_float is not False
 96        self.assertIsNot(self.a_float, False)
 97
 98        assert self.a_string is not False
 99        self.assertIsNot(self.a_string, False)
100
101        assert self.a_tuple is not False
102        self.assertIsNot(self.a_tuple, False)
103
104        assert self.a_list is not False
105        self.assertIsNot(self.a_list, False)
106
107        assert self.a_set is not False
108        self.assertIsNot(self.a_set, False)
109
110        assert self.a_dictionary is not False
111        self.assertIsNot(self.a_dictionary, False)
112
113    def test_type_error_w_true(self):

  • I remove the commented lines from test_type_error_w_none

    30    def test_type_error_w_none(self):
31        assert None is None
32        self.assertIs(None, None)
33
34        assert False is not None
35        self.assertIsNot(False, None)
36
37        assert True is not None
38        self.assertIsNot(True, None)
39
40        assert self.an_integer is not None
41        self.assertIsNot(self.an_integer, None)
42
43        assert self.a_float is not None
44        self.assertIsNot(self.a_float, None)
45
46        assert self.a_string is not None
47        self.assertIsNot(self.a_string, None)
48
49        assert self.a_tuple is not None
50        self.assertIsNot(self.a_tuple, None)
51
52        assert self.a_list is not None
53        self.assertIsNot(self.a_list, None)
54
55        assert self.a_set is not None
56        self.assertIsNot(self.a_set, None)
57
58        assert self.a_dictionary is not None
59        self.assertIsNot(self.a_dictionary, None)
60
61    def test_type_error_w_false(self):

  • I add a git commit message in the other terminal

    git commit -am 'extract class attributes'

I can use class attributes to remove repetition. I make them once and other things in the class can reference them.

close the project

  • I close test_type_error.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 type_error

    cd ..

    the terminal is my friend, and shows

    .../pumping_python

    I am back in the pumping_python directory.

review

I can use class attributes for things that repeat, which allows methods of the same class to use them.

code from the chapter

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

what is next?

As a reminder, you know

Would you like to use unittest with the type_error project?

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.

CLICK HERE to leave a 5 star review of pumping python, if this has been a 7 star experience for you