TypeError: tests and solution

TypeError tests

the code in type_error/tests/test_type_error.py from TypeError

 1import src.type_error
 2import unittest
 3
 4
 5class TestTypeError(unittest.TestCase):
 6
 7    def test_type_error_w_the_uncallables(self):
 8        src.type_error.none()
 9        src.type_error.false()
10        src.type_error.true()
11        src.type_error.an_integer()
12        src.type_error.a_float()
13        src.type_error.a_string()
14        src.type_error.a_tuple()
15        src.type_error.a_list()
16        src.type_error.a_set()
17        src.type_error.a_dictionary()
18
19    def test_type_error_w_function_signatures(self):
20        src.type_error.function_00('a')
21        src.type_error.function_01('a', 'b')
22        src.type_error.function_02('a', 'b', 'c')
23        src.type_error.function_03('a', 'b', 'c', 'd')
24
25    def test_type_error_w_objects_that_do_not_mix(self):
26        with self.assertRaises(TypeError):
27            None + False
28        with self.assertRaises(TypeError):
29            True - 'text'
30        with self.assertRaises(TypeError):
31            (0, 1, 2, 'n') * [0, 1, 2, 'n']
32        with self.assertRaises(TypeError):
33            {0, 1, 2, 'n'} / {'key': 'value'}
34
35
36# Exceptions seen
37# AssertionError
38# AttributeError
39# TypeError

TypeError solutions

the solution in type_error/src/type_error.py from TypeError

 1def none():
 2    return None
 3
 4
 5def true():
 6    return True
 7
 8
 9def false():
10    return False
11
12
13def a_list():
14    return [1, 2, 3, 4]
15
16
17def a_dictionary():
18    return {'key': 'value'}
19
20
21def function_00():
22    return None
23
24
25def function_01(the_input):
26    return None
27
28
29def function_02(argument1, argument2):
30    return None
31
32
33def function_03(
34        argument1, argument2,
35        argument3
36    ):
37    return None

TypeError with the Calculator tests

the code in calculator/tests/test_calculator.py from TypeError

 1import random
 2import src.calculator
 3import unittest
 4
 5
 6def a_random_number():
 7    return random.triangular(-1000.0, 1000.0)
 8
 9
10class TestCalculator(unittest.TestCase):
11
12    random_first_number = a_random_number()
13    random_second_number = a_random_number()
14
15    def test_addition(self):
16        self.assertEqual(
17            src.calculator.add(
18                self.random_first_number,
19                self.random_second_number
20            ),
21            self.random_first_number+self.random_second_number
22        )
23
24    def test_subtraction(self):
25        self.assertEqual(
26            src.calculator.subtract(
27                self.random_first_number,
28                self.random_second_number
29            ),
30            self.random_first_number-self.random_second_number
31        )
32
33    def test_multiplication(self):
34        self.assertEqual(
35            src.calculator.multiply(
36                self.random_first_number,
37                self.random_second_number
38            ),
39            self.random_first_number*self.random_second_number
40        )
41
42    def test_division(self):
43        try:
44            self.assertEqual(
45                src.calculator.divide(
46                    self.random_first_number,
47                    self.random_second_number
48                ),
49                self.random_first_number/self.random_second_number
50            )
51        except ZeroDivisionError:
52            self.assertEqual(
53                src.calculator.divide(self.random_first_number, 0),
54                'brmph?! cannot divide by 0. Try again...'
55            )
56
57    def test_calculator_sends_message_when_input_is_not_a_number(self):
58        error_message = 'Excuse me?! Numbers only! try again...'
59
60        self.assertEqual(
61            src.calculator.add(None, None),
62            error_message
63        )
64        self.assertEqual(
65            src.calculator.divide(None, None),
66            error_message
67        )
68        self.assertEqual(
69            src.calculator.multiply(None, None),
70            error_message
71        )
72        self.assertEqual(
73            src.calculator.subtract(None, None),
74            error_message
75        )
76        self.assertEqual(
77            src.calculator.add('1', '1'),
78            error_message
79        )
80        self.assertEqual(
81            src.calculator.divide('1', '1'),
82            error_message
83        )
84        self.assertEqual(
85            src.calculator.multiply('1', '1'),
86            error_message
87        )
88        self.assertEqual(
89            src.calculator.subtract('1', '1'),
90            error_message
91        )
92
93
94# Exceptions seen
95# AssertionError
96# NameError
97# AttributeError
98# TypeError
99# ZeroDivisionError

TypeError with the Calculator solutions

the solution in calculator/src/calculator.py from TypeError

 1def only_takes_numbers(function):
 2    def wrapper(first_input, second_input):
 3        error_message = 'Excuse me?! Numbers only! try again...'
 4        if isinstance(first_input, str) or isinstance(second_input, str):
 5            return error_message
 6        else:
 7            try:
 8                return function(first_input, second_input)
 9            except TypeError:
10                return error_message
11    return wrapper
12
13
14@only_takes_numbers
15def subtract(first_input, second_input):
16    return first_input - second_input
17
18
19@only_takes_numbers
20def multiply(first_input, second_input):
21    return first_input * second_input
22
23
24@only_takes_numbers
25def divide(first_input, second_input):
26    try:
27        return first_input / second_input
28    except ZeroDivisionError:
29        return 'brmph?! cannot divide by 0. Try again...'
30
31
32@only_takes_numbers
33def add(first_input, second_input):
34    return first_input + second_input