micropython-lib/python-stdlib/unittest/tests/test_basics.py at 3896096a7565b63b383a10de9c2b9374cb059e4a · micropython/micropython-lib · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
import unittest
import helpers


class Basics(helpers.BaseTestCase):
    def test_bare_function__passes(self):
        class FakeModule:
            @staticmethod
            def test_func1(): ...
            @staticmethod
            def test_func2(): ...

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=2, numFailures=0, numErrors=0, numSkipped=0)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(
            output,
            f"test_func1 ({self.full_test_name()}) ... ok\ntest_func2 ({self.full_test_name()}) ... ok\n",
        )

    def test_bare_function__fail(self):
        class FakeModule:
            @staticmethod
            def test_func_fail():
                assert False

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=1, numErrors=0, numSkipped=0)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(output, f"test_func_fail ({self.full_test_name()}) ... FAIL\n")

    def test_bare_function__error(self):
        class FakeModule:
            @staticmethod
            def test_func_error():
                raise ValueError

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=1, numSkipped=0)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(output, f"test_func_error ({self.full_test_name()}) ... ERROR\n")

    def test_bare_function__expect_failure__fail(self):
        class FakeModule:
            @unittest.expectedFailure
            def test_func_fail():
                assert False

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=0, numSkipped=0)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(output, f"test_func_fail ({self.full_test_name()}) ... ok\n")

    def test_bare_function__expect_failure__error(self):
        class FakeModule:
            @unittest.expectedFailure
            def test_func_error():
                raise ValueError

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=1, numSkipped=0)
        self.assertFalse(result.wasSuccessful())
        self.assertEqual(output, f"test_func_error ({self.full_test_name()}) ... ERROR\n")

    def test_bare_function__expect_failure__skip(self):
        class FakeModule:
            @unittest.expectedFailure
            @unittest.skip("reason1")
            def test_func_error():
                raise ValueError

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=0, numSkipped=1)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(
            output, f"test_func_error ({self.full_test_name()}) ... skipped: reason1\n"
        )

    def test_testcase__expect_failure__skip(self):
        class FakeModule:
            class Test(unittest.TestCase):
                @unittest.expectedFailure
                def test_func_skip_in_test(self):
                    self.skipTest("reason1")

                @unittest.expectedFailure
                @unittest.skip("reason2")
                def test_func_skip_wrap_test(self):
                    pass

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=2, numFailures=0, numErrors=0, numSkipped=2)
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(
            output,
            f"test_func_skip_in_test ({self.full_test_name()}.Test) ... skipped: reason1\n"
            f"test_func_skip_wrap_test ({self.full_test_name()}.Test) ... skipped: reason2\n",
        )


class TestTestCase(helpers.BaseTestCase):
    def test_method_called__passes(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test1(self): ...
                def test2(self): ...

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=2, numFailures=0, numErrors=0, numSkipped=0)
        self.assertEqual(
            output,
            f"test1 ({self.full_test_name()}.Test) ... ok\n"
            f"test2 ({self.full_test_name()}.Test) ... ok\n",
        )

    def test_method_called__fail(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test1(self):
                    self.fail("reason1")

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=1, numErrors=0, numSkipped=0)
        self.assertEqual(output, f"test1 ({self.full_test_name()}.Test) ... FAIL\n")

    def test_method_called__error(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test1(self):
                    raise ValueError("reason1")

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=1, numSkipped=0)
        self.assertEqual(output, f"test1 ({self.full_test_name()}.Test) ... ERROR\n")

    def test_only_calls_methods(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test1(self): ...

                test_copy = test1

                test2 = None

                @property
                def test3(self):
                    raise ValueError

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=2, numFailures=0, numErrors=0, numSkipped=0)
        self.assertEqual(
            output,
            f"test1 ({self.full_test_name()}.Test) ... ok\n"
            f"test_copy ({self.full_test_name()}.Test) ... ok\n",
        )

    def test_prefers_runTest(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test1(self):
                    self.fail("wrong method called")

                def runTest(self):
                    pass

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=0, numErrors=0, numSkipped=0)
        self.assertEqual(output, f"runTest ({self.full_test_name()}.Test) ... ok\n")

    def test_keyboard_interrupt_not_captured(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def test(self):
                    raise KeyboardInterrupt

        with self.assertRaises(KeyboardInterrupt):
            helpers.run_tests_in_module(self, FakeModule)

    def test_run_method_overridable(self):
        class FakeModule:
            class Test(unittest.TestCase):
                def run(self, result: unittest.TestResult | None = None):
                    if result is None:
                        result = self.defaultTestResult()

                    tmp_result = unittest.TestResult(stream=result._stream)
                    super().run(tmp_result)
                    if tmp_result.failures:
                        test, err_msg = tmp_result.failures[-1]
                        err_msg += "\nSome extra debugging info"
                        tmp_result.failures[-1] = test, err_msg
                    result += tmp_result
                    return result

                def test1(self):
                    self.fail("reason1")

        result, output = helpers.run_tests_in_module(self, FakeModule)
        self.assertTestResult(result, testsRun=1, numFailures=1, numErrors=0, numSkipped=0)
        self.assertEqual(output, f"test1 ({self.full_test_name()}.Test) ... FAIL\n")
        self.assertIn("\nSome extra debugging info", result.failures[-1][1])


if __name__ == "__main__":
    unittest.main()