Increased test isolation. Better resource cleanup by using context managers

Author: DrGeoff

src/compiletools/test_base.py

@@ -17,15 +17,17 @@ class BaseCompileToolsTestCase:
     """Base test case with common setup/teardown for compiletools tests"""
 
     def setup_method(self):
-        uth.reset()
         self._tmpdir = tempfile.mkdtemp()
         self._origdir = os.getcwd()
+        uth.delete_existing_parsers()
+        compiletools.apptools.resetcallbacks()
 
     def teardown_method(self):
         os.chdir(self._origdir)
         if hasattr(self, '_tmpdir') and self._tmpdir:
             shutil.rmtree(self._tmpdir, ignore_errors=True)
-        uth.reset()
+        uth.delete_existing_parsers()
+        compiletools.apptools.resetcallbacks()
 
     def _verify_one_exe_per_main(self, relativepaths):
         """Common executable verification logic"""
@@ -93,37 +95,27 @@ def create_header_deps_parser(extraargs=None, cache_home="None", tempdir=None):
 
 def compare_direct_cpp_magic(test_case, relativepath, tempdir=None):
     """Utility to test that DirectMagicFlags and CppMagicFlags produce identical results"""
-    if tempdir is None:
-        tempdir = tempfile.mkdtemp()
-        cleanup_tempdir = True
-    else:
-        cleanup_tempdir = False
-        
-    origdir = os.getcwd()
-    os.chdir(tempdir)
-    
-    try:
+    with uth.TempDirContext() as temp_ctx:
+        if tempdir is not None:
+            # If specific tempdir provided, copy current working dir content there
+            os.chdir(tempdir)
+            
         samplesdir = uth.samplesdir()
         realpath = os.path.join(samplesdir, relativepath)
 
-        # Test direct parser
-        magicparser_direct = create_magic_parser(["--magic", "direct"], tempdir=tempdir)
-        result_direct = magicparser_direct.parse(realpath)
-        
-        # Clear configargparse singleton state to allow second parser creation
-        configargparse._parsers.clear()
+        # Test direct parser with isolated context
+        with uth.ParserContext():
+            magicparser_direct = create_magic_parser(["--magic", "direct"], tempdir=os.getcwd())
+            result_direct = magicparser_direct.parse(realpath)
 
-        # Test cpp parser  
-        magicparser_cpp = create_magic_parser(["--magic", "cpp"], tempdir=tempdir)
-        result_cpp = magicparser_cpp.parse(realpath)
+        # Test cpp parser with fresh isolated context
+        with uth.ParserContext():
+            magicparser_cpp = create_magic_parser(["--magic", "cpp"], tempdir=os.getcwd())
+            result_cpp = magicparser_cpp.parse(realpath)
 
         # Results should be identical
         assert result_direct == result_cpp, \
                            f"DirectMagicFlags and CppMagicFlags gave different results for {relativepath}"
-    finally:
-        os.chdir(origdir)
-        if cleanup_tempdir:
-            shutil.rmtree(tempdir, ignore_errors=True)
 
 
 def compare_direct_cpp_headers(test_case, filename, extraargs=None):

src/compiletools/test_cake.py

@@ -37,14 +37,6 @@ def _call_ct_cake(self, extraargv=[], cache_home="None"):
         uth.reset()
         compiletools.cake.main(self._create_argv(cache_home) + extraargv)
 
-    def _setup_and_chdir_temp_dir(self):
-        """ Returns the original working directory so you can chdir back to that at the end """
-        #TODO Migrate all usage of this to uth.TempDirContext()
-        origdir = os.getcwd()
-        self._tmpdir = tempfile.mkdtemp()
-        os.chdir(self._tmpdir)
-
-        return origdir
 
     def test_no_git_root(self):
         with uth.TempDirContext():
@@ -154,16 +146,12 @@ def _create_recompile_test_files(self, deeper_is_included=False):
             This will allow us to test that editing any of those files 
             triggers a recompile.
         """
-        origdir = self._setup_and_chdir_temp_dir()
-
         self._create_main_cpp()
         self._create_extra_hpp()
         self._create_extra_cpp()
         self._create_deeper_hpp()
         self._create_deeper_cpp()
 
-        os.chdir(origdir)
-
     def _grab_timestamps(self, deeper_is_included=False):
         """ There are 8 files we want timestamps for.  
             main.cpp, extra.hpp, extra.cpp, deeper.hpp, deeper.cpp, deeper.o, main.o, extra.o 
@@ -225,42 +213,37 @@ def _compile_edit_compile(
         self, files_to_edit, expected_changes, deeper_is_included=False
     ):
         """ Test that the compile, edit, compile cycle works as you expect """
-        # print(self._tmpdir)
-        origdir = os.getcwd()
-        self._create_recompile_test_files(deeper_is_included)
-        os.chdir(self._tmpdir)
-
-        # Do an initial build
-        self._config_name = uth.create_temp_config(self._tmpdir)
-        uth.create_temp_ct_conf(
-            tempdir=self._tmpdir,
-            defaultvariant=os.path.basename(self._config_name)[:-5],
-        )
-        self._call_ct_cake(extraargv=[])
+        with uth.TempDirContext() as ctx:
+            self._tmpdir = os.getcwd()
+            self._create_recompile_test_files(deeper_is_included)
 
-        # Grab the timestamps on the build products so that later we can test that only the expected ones changed
-        # deeper_is_included must be false at this point becuase the option to inject it comes later/ver
-        prets = self._grab_timestamps(deeper_is_included=False)
+            # Do an initial build
+            self._config_name = uth.create_temp_config(self._tmpdir)
+            uth.create_temp_ct_conf(
+                tempdir=self._tmpdir,
+                defaultvariant=os.path.basename(self._config_name)[:-5],
+            )
+            self._call_ct_cake(extraargv=[])
 
-        # Edit the files for this test
-        if deeper_is_included:
-            self._inject_deeper_hpp_into_extra_hpp()
+            # Grab the timestamps on the build products so that later we can test that only the expected ones changed
+            # deeper_is_included must be false at this point becuase the option to inject it comes later/ver
+            prets = self._grab_timestamps(deeper_is_included=False)
 
-        for fname in files_to_edit:
-            _touch(fname)
+            # Edit the files for this test
+            if deeper_is_included:
+                self._inject_deeper_hpp_into_extra_hpp()
 
-        # Rebuild
-        self._call_ct_cake(extraargv=[])
+            for fname in files_to_edit:
+                _touch(fname)
 
-        # Grab the timestamps on the build products for comparison
-        postts = self._grab_timestamps(deeper_is_included)
+            # Rebuild
+            self._call_ct_cake(extraargv=[])
 
-        # Check that only the expected timestamps have changed
-        self._verify_timestamps(expected_changes, prets, postts)
+            # Grab the timestamps on the build products for comparison
+            postts = self._grab_timestamps(deeper_is_included)
 
-        # Cleanup
-        os.chdir(origdir)
-        shutil.rmtree(self._tmpdir, ignore_errors=True)
+            # Check that only the expected timestamps have changed
+            self._verify_timestamps(expected_changes, prets, postts)
 
     def test_source_edit_recompiles(self):
         """ Make sure that when the source file is altered that a rebuild occurs """

src/compiletools/test_configutils.py

@@ -12,7 +12,6 @@
 class TestVariant:
     def setup_method(self):
         uth.reset()
-        self._tmpdir = None
 
     def test_extract_value_from_argv(self):
         argv = ['/usr/bin/ct-config', '--pkg-config=fig', '-v']
@@ -44,95 +43,74 @@ def test_extract_variant(self):
 
     def test_extract_variant_from_ct_conf(self):
         # Should find the one in the temp directory ct.conf
-        origdir = self._setup_and_chdir_temp_dir()
-        local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(self._tmpdir)
-        variant = compiletools.configutils.extract_item_from_ct_conf(
-            key="variant",
-            user_config_dir="/var",
-            system_config_dir="/var",
-            exedir=uth.cakedir(),
-            gitroot=self._tmpdir,
-        )
-        assert "debug" == variant
-
-        # Cleanup
-        os.chdir(origdir)
-        shutil.rmtree(self._tmpdir, ignore_errors=True)
+        with uth.TempDirContext() as ctx:
+            local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(os.getcwd())
+            variant = compiletools.configutils.extract_item_from_ct_conf(
+                key="variant",
+                user_config_dir="/var",
+                system_config_dir="/var",
+                exedir=uth.cakedir(),
+                gitroot=os.getcwd(),
+            )
+            assert "debug" == variant
 
     def test_extract_variant_from_blank_argv(self):
         # Force to find the temp directory ct.conf
-        origdir = self._setup_and_chdir_temp_dir()
-        local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(self._tmpdir)
-        variant = compiletools.configutils.extract_variant(
-            user_config_dir="/var",
-            system_config_dir="/var",
-            exedir=uth.cakedir(),
-            verbose=0,
-            gitroot=self._tmpdir,
-        )
-        assert "debug" == variant
-
-        # Cleanup
-        os.chdir(origdir)
-        shutil.rmtree(self._tmpdir, ignore_errors=True)
-
-    def _setup_and_chdir_temp_dir(self):
-        """ Returns the original working directory so you can chdir back to that at the end """
-        origdir = os.getcwd()
-        self._tmpdir = tempfile.mkdtemp()
-        os.chdir(self._tmpdir)
-        return origdir
+        with uth.TempDirContext() as ctx:
+            local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(os.getcwd())
+            variant = compiletools.configutils.extract_variant(
+                argv=[],
+                user_config_dir="/var",
+                system_config_dir="/var",
+                exedir=uth.cakedir(),
+                verbose=0,
+                gitroot=os.getcwd(),
+            )
+            assert "debug" == variant
+
 
     def test_default_configs(self):
-        origdir = self._setup_and_chdir_temp_dir()
-        local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(self._tmpdir)
-        local_config_name = compiletools.unittesthelper.create_temp_config(self._tmpdir)
-
-        configs = compiletools.configutils.defaultconfigs(
-            user_config_dir="/var",
-            system_config_dir="/var",
-            exedir=uth.cakedir(),
-            verbose=0,
-            gitroot=self._tmpdir,
-        )
-
-        assert [
-                os.path.join(self._tmpdir, "ct.conf"),
-            ] == \
-            configs
-
-        # Cleanup
-        os.chdir(origdir)
-        shutil.rmtree(self._tmpdir, ignore_errors=True)
+        with uth.TempDirContext() as ctx:
+            local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(os.getcwd())
+            local_config_name = compiletools.unittesthelper.create_temp_config(os.getcwd())
+
+            configs = compiletools.configutils.defaultconfigs(
+                user_config_dir="/var",
+                system_config_dir="/var",
+                exedir=uth.cakedir(),
+                verbose=0,
+                gitroot=os.getcwd(),
+            )
+
+            assert [
+                    os.path.join(os.getcwd(), "ct.conf"),
+                ] == \
+                configs
 
     def test_config_files_from_variant(self):
-        origdir = self._setup_and_chdir_temp_dir()
-        local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(self._tmpdir)
-        # Deliberately call the next config gcc.debug.conf to verify that
-        # the hierarchy of directories is working
-        local_config_name = compiletools.unittesthelper.create_temp_config(
-            self._tmpdir, "gcc.debug.conf"
-        )
-
-        configs = compiletools.configutils.config_files_from_variant(
-            variant="gcc.debug",
-            argv=[],
-            user_config_dir="/var",
-            system_config_dir="/var",
-            exedir=uth.cakedir(),
-            verbose=0,
-            gitroot=self._tmpdir,
-        )
-
-        assert [
-                os.path.join(self._tmpdir, "ct.conf"),
-                os.path.join(self._tmpdir, "gcc.debug.conf"),
-            ] == \
-            configs
-
-        # Cleanup
-        os.chdir(origdir)
-        shutil.rmtree(self._tmpdir, ignore_errors=True)
+        with uth.TempDirContext() as ctx:
+            local_ct_conf = compiletools.unittesthelper.create_temp_ct_conf(os.getcwd())
+            # Deliberately call the next config gcc.debug.conf to verify that
+            # the hierarchy of directories is working
+            local_config_name = compiletools.unittesthelper.create_temp_config(
+                os.getcwd(), "gcc.debug.conf"
+            )
+
+            configs = compiletools.configutils.config_files_from_variant(
+                variant="gcc.debug",
+                argv=[],
+                user_config_dir="/var",
+                system_config_dir="/var",
+                exedir=uth.cakedir(),
+                verbose=0,
+                gitroot=os.getcwd(),
+            )
+
+            assert [
+                    os.path.join(os.getcwd(), "ct.conf"),
+                    os.path.join(os.getcwd(), "gcc.debug.conf"),
+                ] == \
+                configs
 
     def teardown_method(self):
         uth.reset()

src/compiletools/test_cppdeps.py

@@ -16,38 +16,38 @@
 import compiletools.unittesthelper as uth
 
 
-def _reload_ct(cache_home):
+def _reload_ct_with_cache(cache_home):
     """ Set the CTCACHE environment variable to cache_home
         and reload the compiletools.* modules
     """
-    os.environ["CTCACHE"] = cache_home
-    reload(compiletools.headerdeps)
-    reload(compiletools.cppdeps)
+    with uth.EnvironmentContext({"CTCACHE": cache_home}):
+        reload(compiletools.headerdeps)
+        reload(compiletools.cppdeps)
+        return cache_home
 
 
 def test_cppdeps():
     uth.reset()
 
-    tempdir = tempfile.mkdtemp()
-    try:
-        _reload_ct(tempdir)
-        uth.reset()
-        
-        output_buffer = io.StringIO()
-        with redirect_stdout(output_buffer):
-            compiletools.cppdeps.main(
-                [os.path.join(uth.samplesdir(), "numbers/test_direct_include.cpp")]
-            )
-        
-        output = output_buffer.getvalue().strip().split()
-        expected_output = [
-            os.path.join(uth.samplesdir(), "numbers/get_double.hpp"),
-            os.path.join(uth.samplesdir(), "numbers/get_int.hpp"),
-            os.path.join(uth.samplesdir(), "numbers/get_numbers.hpp"),
-        ]
-        assert sorted(expected_output) == sorted(output)
-    finally:
-        shutil.rmtree(tempdir)
+    with uth.TempDirContext() as ctx:
+        with uth.EnvironmentContext({"CTCACHE": os.getcwd()}):
+            reload(compiletools.headerdeps)
+            reload(compiletools.cppdeps)
+            uth.reset()
+            
+            output_buffer = io.StringIO()
+            with redirect_stdout(output_buffer):
+                compiletools.cppdeps.main(
+                    [os.path.join(uth.samplesdir(), "numbers/test_direct_include.cpp")]
+                )
+            
+            output = output_buffer.getvalue().strip().split()
+            expected_output = [
+                os.path.join(uth.samplesdir(), "numbers/get_double.hpp"),
+                os.path.join(uth.samplesdir(), "numbers/get_int.hpp"),
+                os.path.join(uth.samplesdir(), "numbers/get_numbers.hpp"),
+            ]
+            assert sorted(expected_output) == sorted(output)
         uth.reset()