unittest: Move back to python-stdlib.

In order to make this more suitable for non-unix ports, the discovery
functionality is moved to a separate 'extension' module which can be
optionally installed.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

Author: jimmo

python-stdlib/unittest-discover/manifest.py

@@ -0,0 +1,7 @@
+metadata(version="0.1.0")
+
+require("argparse")
+require("fnmatch")
+require("unittest")
+
+module("unittest_discover.py")

python-stdlib/unittest-discover/tests/isolated.py

@@ -0,0 +1,4 @@
+# Module that is used in both test_isolated_1.py and test_isolated_2.py.
+# The module should be clean reloaded for each.
+
+state = None

python-stdlib/unittest-discover/tests/test_isolated_1.py

@@ -0,0 +1,8 @@
+import unittest
+import isolated
+
+
+class TestUnittestIsolated1(unittest.TestCase):
+    def test_NotChangedByOtherTest(self):
+        self.assertIsNone(isolated.state)
+        isolated.state = True

python-stdlib/unittest-discover/tests/test_isolated_2.py

@@ -0,0 +1,8 @@
+import unittest
+import isolated
+
+
+class TestUnittestIsolated2(unittest.TestCase):
+    def test_NotChangedByOtherTest(self):
+        self.assertIsNone(isolated.state)
+        isolated.state = True

python-stdlib/unittest-discover/unittest_discover.py

@@ -0,0 +1,140 @@
+# Extension for "unittest" that adds the ability to run via "micropython -m unittest".
+
+import argparse
+import os
+import sys
+from fnmatch import fnmatch
+from micropython import const
+
+from unittest import TestRunner, TestResult, TestSuite
+
+
+# Run a single test in a clean environment.
+def _run_test_module(runner: TestRunner, module_name: str, *extra_paths: list[str]):
+    module_snapshot = {k: v for k, v in sys.modules.items()}
+    path_snapshot = sys.path[:]
+    try:
+        for path in reversed(extra_paths):
+            if path:
+                sys.path.insert(0, path)
+
+        module = __import__(module_name)
+        suite = TestSuite(module_name)
+        suite._load_module(module)
+        return runner.run(suite)
+    finally:
+        sys.path[:] = path_snapshot
+        sys.modules.clear()
+        sys.modules.update(module_snapshot)
+
+
+_DIR_TYPE = const(0x4000)
+
+
+def _run_all_in_dir(runner: TestRunner, path: str, pattern: str, top: str):
+    result = TestResult()
+    for fname, ftype, *_ in os.ilistdir(path):
+        if fname in ("..", "."):
+            continue
+        if ftype == _DIR_TYPE:
+            result += _run_all_in_dir(
+                runner=runner,
+                path="/".join((path, fname)),
+                pattern=pattern,
+                top=top,
+            )
+        if fnmatch(fname, pattern):
+            module_name = fname.rsplit(".", 1)[0]
+            result += _run_test_module(runner, module_name, path, top)
+    return result
+
+
+# Implements discovery inspired by https://docs.python.org/3/library/unittest.html#test-discovery
+def _discover(runner: TestRunner):
+    parser = argparse.ArgumentParser()
+    # parser.add_argument(
+    #     "-v",
+    #     "--verbose",
+    #     action="store_true",
+    #     help="Verbose output",
+    # )
+    parser.add_argument(
+        "-s",
+        "--start-directory",
+        dest="start",
+        default=".",
+        help="Directory to start discovery",
+    )
+    parser.add_argument(
+        "-p",
+        "--pattern ",
+        dest="pattern",
+        default="test*.py",
+        help="Pattern to match test files",
+    )
+    parser.add_argument(
+        "-t",
+        "--top-level-directory",
+        dest="top",
+        help="Top level directory of project (defaults to start directory)",
+    )
+    args = parser.parse_args(args=sys.argv[2:])
+
+    path = args.start
+    top = args.top or path
+
+    return _run_all_in_dir(
+        runner=runner,
+        path=path,
+        pattern=args.pattern,
+        top=top,
+    )
+
+
+# TODO: Use os.path for path handling.
+PATH_SEP = getattr(os, "sep", "/")
+
+
+# foo/bar/x.y.z --> foo/bar, x.y
+def _dirname_filename_no_ext(path):
+    # Workaround: The Windows port currently reports "/" for os.sep
+    # (and MicroPython doesn't have os.altsep). So for now just
+    # always work with os.sep (i.e. "/").
+    path = path.replace("\\", PATH_SEP)
+
+    split = path.rsplit(PATH_SEP, 1)
+    if len(split) == 1:
+        dirname, filename = "", split[0]
+    else:
+        dirname, filename = split
+    return dirname, filename.rsplit(".", 1)[0]
+
+
+# This is called from unittest when __name__ == "__main__".
+def discover_main():
+    failures = 0
+    runner = TestRunner()
+
+    if len(sys.argv) == 1 or (
+        len(sys.argv) >= 2
+        and _dirname_filename_no_ext(sys.argv[0])[1] == "unittest"
+        and sys.argv[1] == "discover"
+    ):
+        # No args, or `python -m unittest discover ...`.
+        result = _discover(runner)
+        failures += result.failuresNum or result.errorsNum
+    else:
+        for test_spec in sys.argv[1:]:
+            try:
+                os.stat(test_spec)
+                # File exists, strip extension and import with its parent directory in sys.path.
+                dirname, module_name = _dirname_filename_no_ext(test_spec)
+                result = _run_test_module(runner, module_name, dirname)
+            except OSError:
+                # Not a file, treat as named module to import.
+                result = _run_test_module(runner, test_spec)
+
+            failures += result.failuresNum or result.errorsNum
+
+    # Terminate with non zero return code in case of failures.
+    sys.exit(failures)

python-stdlib/unittest/manifest.py

@@ -0,0 +1,3 @@
+metadata(version="0.10.0")
+
+module("unittest.py")

unix-ffi/unittest/test_unittest.py renamed to python-stdlib/unittest/tests/test_assertions.py

@@ -1,5 +1,4 @@
 import unittest
-from test_unittest_isolated import global_context
 
 
 class TestUnittestAssertions(unittest.TestCase):
@@ -143,11 +142,6 @@ def testInner():
         else:
             self.fail("Unexpected success was not detected")
 
-    def test_NotChangedByOtherTest(self):
-        global global_context
-        assert global_context is None
-        global_context = True
-
     def test_subtest_even(self):
         """
         Test that numbers between 0 and 5 are all even.
@@ -157,24 +151,5 @@ def test_subtest_even(self):
                 self.assertEqual(i % 2, 0)
 
 
-class TestUnittestSetup(unittest.TestCase):
-    class_setup_var = 0
-
-    def setUpClass(self):
-        TestUnittestSetup.class_setup_var += 1
-
-    def tearDownClass(self):
-        # Not sure how to actually test this, but we can check (in the test case below)
-        # that it hasn't been run already at least.
-        TestUnittestSetup.class_setup_var = -1
-
-    def testSetUpTearDownClass_1(self):
-        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
-
-    def testSetUpTearDownClass_2(self):
-        # Test this twice, as if setUpClass() gets run like setUp() it would be run twice
-        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
-
-
 if __name__ == "__main__":
     unittest.main()

python-stdlib/unittest/tests/test_basics.py

@@ -0,0 +1,29 @@
+import unittest
+
+
+class TestWithRunTest(unittest.TestCase):
+    run = False
+
+    def runTest(self):
+        TestWithRunTest.run = True
+
+    def testRunTest(self):
+        self.fail()
+
+    @staticmethod
+    def tearDownClass():
+        if not TestWithRunTest.run:
+            raise ValueError()
+
+
+def test_func():
+    pass
+
+
+@unittest.expectedFailure
+def test_foo():
+    raise ValueError()
+
+
+if __name__ == "__main__":
+    unittest.main()

python-stdlib/unittest/tests/test_setup.py

@@ -0,0 +1,28 @@
+import unittest
+
+
+class TestUnittestSetup(unittest.TestCase):
+    class_setup_var = 0
+
+    @classmethod
+    def setUpClass(cls):
+        assert cls is TestUnittestSetup
+        TestUnittestSetup.class_setup_var += 1
+
+    @classmethod
+    def tearDownClass(cls):
+        assert cls is TestUnittestSetup
+        # Not sure how to actually test this, but we can check (in the test case below)
+        # that it hasn't been run already at least.
+        TestUnittestSetup.class_setup_var = -1
+
+    def testSetUpTearDownClass_1(self):
+        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
+
+    def testSetUpTearDownClass_2(self):
+        # Test this twice, as if setUpClass() gets run like setUp() it would be run twice
+        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
+
+
+if __name__ == "__main__":
+    unittest.main()