revue des test

Author: PyCompiler ARK++

Tests/test_bcasl_workspace_config_extended.py

@@ -1,44 +1,48 @@
 import unittest
 import json
-import os
-from pathlib import Path
-import tempfile
 
 from bcasl.Loader import _load_workspace_config
+from .workspace_support import get_shared_workspace
+
 
 class TestBCASLWorkspaceConfigExtended(unittest.TestCase):
     def setUp(self):
-        self.orig_cwd = Path.cwd()
-        self.tmpdir = Path(tempfile.mkdtemp(prefix="bcasl_ws_"))
-        os.chdir(self.tmpdir)
+        self.ws = get_shared_workspace()
+        # Clean artifacts possibly left by other tests (but keep baseline ARK_Main_Config.yml)
+        for name in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            p = self.ws / name
+            try:
+                if p.exists():
+                    p.unlink()
+            except Exception:
+                pass
 
     def tearDown(self):
-        os.chdir(self.orig_cwd)
-        # Best-effort cleanup
-        try:
-            for p in sorted(self.tmpdir.rglob("*"), reverse=True):
-                try:
-                    if p.is_file() or p.is_symlink():
-                        p.unlink()
-                    elif p.is_dir():
-                        p.rmdir()
-                except Exception:
-                    pass
-            self.tmpdir.rmdir()
-        except Exception:
-            pass
+        # Remove only files created by this test (keep baseline ARK_Main_Config.yml)
+        for name in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            p = self.ws / name
+            try:
+                if p.exists():
+                    p.unlink()
+            except Exception:
+                pass
 
     def write_yaml(self, name: str, content: str):
-        (self.tmpdir / name).write_text(content, encoding="utf-8")
+        (self.ws / name).write_text(content, encoding="utf-8")
 
     def write_json(self, name: str, obj):
-        (self.tmpdir / name).write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+        (self.ws / name).write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
 
     def test_default_generation_without_configs(self):
-        cfg = _load_workspace_config(self.tmpdir)
+        # Ensure no pre-existing bcasl configs
+        for n in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            p = self.ws / n
+            if p.exists():
+                p.unlink()
+        cfg = _load_workspace_config(self.ws)
         self.assertIsInstance(cfg, dict)
         # Should write a bcasl.json best-effort
-        self.assertTrue((self.tmpdir / "bcasl.json").exists())
+        self.assertTrue((self.ws / "bcasl.json").exists())
         self.assertIn("file_patterns", cfg)
         self.assertIn("exclude_patterns", cfg)
         self.assertIn("options", cfg)
@@ -50,52 +54,71 @@ def test_default_generation_without_configs(self):
     def test_yaml_has_priority_over_json(self):
         self.write_json("bcasl.json", {"options": {"enabled": False}})
         self.write_yaml("bcasl.yaml", "options:\n  enabled: true\n")
-        cfg = _load_workspace_config(self.tmpdir)
+        cfg = _load_workspace_config(self.ws)
         self.assertTrue(cfg["options"]["enabled"])  # YAML wins
 
     def test_json_is_used_when_no_yaml(self):
         self.write_json(".bcasl.json", {"options": {"enabled": False}})
-        cfg = _load_workspace_config(self.tmpdir)
+        cfg = _load_workspace_config(self.ws)
         self.assertFalse(cfg["options"]["enabled"])  # JSON honored
 
     def test_merge_with_ark_config_patterns(self):
-        # Create ARK_Main_Config.yml to add patterns
-        ark = (
-            "inclusion_patterns:\n  - 'src/**/*.py'\n"
-            "exclusion_patterns:\n  - '.venv/**'\n  - 'build/**'\n"
-            "plugins:\n  bcasl_enabled: true\n  plugin_timeout: 1.5\n"
-        )
-        self.write_yaml("ARK_Main_Config.yml", ark)
-        # Create minimal bcasl.yaml to be merged
-        self.write_yaml("bcasl.yaml", "file_patterns:\n  - '**/*.py'\nexclude_patterns:\n  - '.git/**'\n")
-        cfg = _load_workspace_config(self.tmpdir)
-        # inclusion_patterns from ARK should override into file_patterns
-        self.assertIn("src/**/*.py", cfg.get("file_patterns", []))
-        # exclusion merged should contain both
-        ex = cfg.get("exclude_patterns", [])
-        self.assertIn(".venv/**", ex)
-        self.assertIn("build/**", ex)
-        self.assertIn(".git/**", ex)
-        # plugin options merged
-        self.assertTrue(cfg.get("options", {}).get("enabled", True))
-        self.assertEqual(cfg.get("options", {}).get("plugin_timeout_s"), 1.5)
+        # Backup existing ARK and restore after
+        ark_path = self.ws / "ARK_Main_Config.yml"
+        backup = None
+        try:
+            if ark_path.exists():
+                backup = ark_path.read_text(encoding="utf-8")
+        except Exception:
+            backup = None
+
+        try:
+            # Write a custom ARK for this test
+            ark = (
+                "inclusion_patterns:\n  - 'src/**/*.py'\n"
+                "exclusion_patterns:\n  - '.venv/**'\n  - 'build/**'\n"
+                "plugins:\n  bcasl_enabled: true\n  plugin_timeout: 1.5\n"
+            )
+            self.write_yaml("ARK_Main_Config.yml", ark)
+            # Create minimal bcasl.yaml to be merged
+            self.write_yaml("bcasl.yaml", "file_patterns:\n  - '**/*.py'\nexclude_patterns:\n  - '.git/**'\n")
+            cfg = _load_workspace_config(self.ws)
+            # inclusion_patterns from ARK should override into file_patterns
+            self.assertIn("src/**/*.py", cfg.get("file_patterns", []))
+            # exclusion merged should contain both
+            ex = cfg.get("exclude_patterns", [])
+            self.assertIn(".venv/**", ex)
+            self.assertIn("build/**", ex)
+            self.assertIn(".git/**", ex)
+            # plugin options merged
+            self.assertTrue(cfg.get("options", {}).get("enabled", True))
+            self.assertEqual(cfg.get("options", {}).get("plugin_timeout_s"), 1.5)
+        finally:
+            try:
+                if backup is not None:
+                    ark_path.write_text(backup, encoding="utf-8")
+            except Exception:
+                pass
 
     def test_required_files_detection(self):
-        # Ensure detection when generating default
-        (self.tmpdir / "main.py").write_text("print('x')", encoding="utf-8")
-        (self.tmpdir / "requirements.txt").write_text("", encoding="utf-8")
-        cfg = _load_workspace_config(self.tmpdir)
+        # Remove any pre-existing bcasl configs to force generation
+        for n in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            p = self.ws / n
+            if p.exists():
+                p.unlink()
+        cfg = _load_workspace_config(self.ws)
         req = cfg.get("required_files", [])
         self.assertIn("main.py", req)
         self.assertIn("requirements.txt", req)
 
     def test_options_defaults_and_types(self):
-        cfg = _load_workspace_config(self.tmpdir)
+        cfg = _load_workspace_config(self.ws)
         opts = cfg.get("options", {})
         self.assertIsInstance(opts.get("enabled", True), bool)
         self.assertIsInstance(opts.get("plugin_timeout_s", 0.0), float)
         self.assertIn("sandbox", opts)
         self.assertIn("iter_files_cache", opts)
 
+
 if __name__ == "__main__":
     unittest.main()

Tests/test_loader_timeout_and_run_paths.py

@@ -1,59 +1,74 @@
 import os
 import json
-import tempfile
 import unittest
-from pathlib import Path
 
 from bcasl.Loader import resolve_bcasl_timeout, run_pre_compile
+from .workspace_support import get_shared_workspace
+
 
 class Dummy:
     def __init__(self, workspace_dir=None):
         self.workspace_dir = workspace_dir
+
         class L:
             def __init__(self):
                 self._data = []
+
             def append(self, s):
                 self._data.append(s)
+
         self.log = L()
 
+
 class TestLoaderTimeoutAndRunPaths(unittest.TestCase):
     def setUp(self):
-        self.tmp = Path(tempfile.mkdtemp(prefix='bcasl_ws_'))
+        self.ws = get_shared_workspace()
+        # Clean artifacts between runs (keep baseline ARK_Main_Config.yml)
+        for name in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            try:
+                p = self.ws / name
+                if p.exists():
+                    p.unlink()
+            except Exception:
+                pass
+        os.environ.pop("PYCOMPILER_BCASL_PLUGIN_TIMEOUT", None)
 
     def tearDown(self):
-        try:
-            for p in sorted(self.tmp.rglob('*'), reverse=True):
-                try:
-                    if p.is_file() or p.is_symlink():
-                        p.unlink()
-                    else:
-                        p.rmdir()
-                except Exception:
-                    pass
-            self.tmp.rmdir()
-        except Exception:
-            pass
-        os.environ.pop('PYCOMPILER_BCASL_PLUGIN_TIMEOUT', None)
+        # Only remove artifacts we created
+        for name in ("bcasl.yaml", "bcasl.yml", "bcasl.json", ".bcasl.json"):
+            try:
+                p = self.ws / name
+                if p.exists():
+                    p.unlink()
+            except Exception:
+                pass
+        os.environ.pop("PYCOMPILER_BCASL_PLUGIN_TIMEOUT", None)
 
     def test_resolve_bcasl_timeout_config_over_env(self):
-        ws = self.tmp
         # Config timeout should win over env
-        (ws / 'bcasl.json').write_text(json.dumps({"options": {"plugin_timeout_s": 2.5}}, indent=2), encoding='utf-8')
-        os.environ['PYCOMPILER_BCASL_PLUGIN_TIMEOUT'] = '10'
-        d = Dummy(str(ws))
+        (self.ws / "bcasl.json").write_text(
+            json.dumps({"options": {"plugin_timeout_s": 2.5}}, indent=2),
+            encoding="utf-8",
+        )
+        os.environ["PYCOMPILER_BCASL_PLUGIN_TIMEOUT"] = "10"
+        d = Dummy(str(self.ws))
         self.assertEqual(resolve_bcasl_timeout(d), 2.5)
 
     def test_resolve_bcasl_timeout_env_used_when_config_zero(self):
-        ws = self.tmp
-        (ws / 'bcasl.json').write_text(json.dumps({"options": {"plugin_timeout_s": 0.0}}, indent=2), encoding='utf-8')
-        os.environ['PYCOMPILER_BCASL_PLUGIN_TIMEOUT'] = '3.3'
-        d = Dummy(str(ws))
+        (self.ws / "bcasl.json").write_text(
+            json.dumps({"options": {"plugin_timeout_s": 0.0}}, indent=2),
+            encoding="utf-8",
+        )
+        os.environ["PYCOMPILER_BCASL_PLUGIN_TIMEOUT"] = "3.3"
+        d = Dummy(str(self.ws))
         self.assertEqual(resolve_bcasl_timeout(d), 3.3)
 
     def test_run_pre_compile_skips_when_disabled(self):
-        ws = self.tmp
-        (ws / 'bcasl.json').write_text(json.dumps({"options": {"enabled": False}}, indent=2), encoding='utf-8')
-        d = Dummy(str(ws))
+        (self.ws / "bcasl.json").write_text(
+            json.dumps({"options": {"enabled": False}}, indent=2),
+            encoding="utf-8",
+        )
+        d = Dummy(str(self.ws))
         rep = run_pre_compile(d)
         self.assertIsNone(rep)
 
@@ -62,5 +77,6 @@ def test_run_pre_compile_no_workspace(self):
         rep = run_pre_compile(d)
         self.assertIsNone(rep)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     unittest.main()