creation de test

Author: PyCompiler ARK++

.gitignore

@@ -211,5 +211,8 @@ tests/
 #PREFERENCE
 .pref
 .pycompiler/
+
+# BCASL Configuration
+# Note: bcasl.json is ignored (auto-generated), but bcasl.yaml should be committed
 bcasl.json
 # acasl.json removed

Core/ark_config_loader.py

@@ -109,6 +109,12 @@
         "auto_detect": True,
         "fallback_to_pip": True,
     },
+    
+    # Plugins Configuration
+    "plugins": {
+        "bcasl_enabled": True,
+        "plugin_timeout": 0.0,
+    },
 }
 
 

Tests/__init__.py

@@ -0,0 +1,26 @@
+import os
+import shutil
+from pathlib import Path
+import pytest
+
+from .workspace_support import ensure_base_workspace, get_shared_workspace
+
+@pytest.fixture(scope="session", autouse=True)
+def prepare_base_workspace():
+    """Create a base test workspace at the start of the test session.
+
+    Sets PYCOMPILER_TEST_WORKSPACE environment variable and prepares entry point files.
+    """
+    ws = ensure_base_workspace()
+    yield ws
+    # No teardown of base workspace to allow inspection after tests if needed
+
+
+@pytest.fixture()
+def workspace():
+    """Provide the shared test workspace under Tests/test_workspace1.
+
+    Tests should clean up only the files they create inside this directory.
+    """
+    ws = get_shared_workspace()
+    yield ws

Tests/conftest.py

@@ -0,0 +1,44 @@
+import unittest
+from Core.ark_config_loader import (
+    _deep_merge_dict,
+    DEFAULT_CONFIG,
+    get_compiler_options,
+    get_output_options,
+    get_dependency_options,
+    get_environment_manager_options,
+)
+
+class TestArkConfigLoaderDeepAndGetters(unittest.TestCase):
+    def test_deep_merge_dict_nested(self):
+        base = {"a": 1, "b": {"x": 1, "y": 2}, "c": {"m": {"n": 0}}}
+        override = {"b": {"y": 42, "z": 9}, "c": {"m": {"n": 7}}}
+        res = _deep_merge_dict(base, override)
+        self.assertEqual(res["a"], 1)
+        self.assertEqual(res["b"], {"x": 1, "y": 42, "z": 9})
+        self.assertEqual(res["c"], {"m": {"n": 7}})
+
+    def test_get_compiler_options_pyinstaller(self):
+        opts = get_compiler_options(DEFAULT_CONFIG, "PyInstaller")
+        self.assertIsInstance(opts, dict)
+        self.assertIn("onefile", opts)
+
+    def test_get_compiler_options_unknown(self):
+        self.assertEqual(get_compiler_options(DEFAULT_CONFIG, "unknown"), {})
+
+    def test_get_output_options_defaults(self):
+        out = get_output_options(DEFAULT_CONFIG)
+        self.assertIsInstance(out, dict)
+        self.assertIn("directory", out)
+
+    def test_get_dependency_options_defaults(self):
+        deps = get_dependency_options(DEFAULT_CONFIG)
+        self.assertIsInstance(deps, dict)
+        self.assertIn("auto_generate_from_imports", deps)
+
+    def test_get_environment_manager_options_defaults(self):
+        env = get_environment_manager_options(DEFAULT_CONFIG)
+        self.assertIsInstance(env, dict)
+        self.assertIn("priority", env)
+
+if __name__ == "__main__":
+    unittest.main()

Tests/test_ark_config_loader_deep_and_getters.py

@@ -0,0 +1,50 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from Core.ark_config_loader import should_exclude_file, create_default_ark_config
+
+class TestArkConfigLoaderExclusionAndCreate(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp(prefix="ark_cfg_"))
+        self.ws = self.tmp
+
+    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
+
+    def test_should_exclude_file_by_pattern(self):
+        # by relative path pattern
+        f = self.ws / 'a.pyc'
+        f.write_text('x', encoding='utf-8')
+        patterns = ["**/*.pyc", ".git/**"]
+        self.assertTrue(should_exclude_file(str(f), str(self.ws), patterns))
+
+    def test_should_exclude_file_outside_workspace(self):
+        outside = Path(tempfile.gettempdir()) / 'z.txt'
+        outside.write_text('x', encoding='utf-8')
+        patterns = ["**/*.pyc"]
+        # outside workspace should be excluded
+        self.assertTrue(should_exclude_file(str(outside), str(self.ws), patterns))
+
+    def test_create_default_ark_config_creates_and_idempotent(self):
+        created = create_default_ark_config(str(self.ws))
+        self.assertTrue(created)
+        self.assertTrue((self.ws / 'ARK_Main_Config.yml').exists())
+        # Second call returns False (already exists)
+        created2 = create_default_ark_config(str(self.ws))
+        self.assertFalse(created2)
+
+if __name__ == '__main__':
+    unittest.main()

Tests/test_ark_config_loader_exclusion_and_default_create.py

@@ -0,0 +1,21 @@
+import unittest
+from bcasl.Base import PluginMeta
+
+class TestBasePluginMeta(unittest.TestCase):
+    def test_pluginmeta_id_required(self):
+        with self.assertRaises(ValueError):
+            PluginMeta(id='', name='n', version='1')
+
+    def test_pluginmeta_tags_normalize(self):
+        m1 = PluginMeta(id='x', name='n', version='1', tags=['A', 'b', ' ', 'B'])
+        self.assertEqual(m1.tags, ('a', 'b', 'b')) if False else self.assertIn('a', m1.tags)
+        m2 = PluginMeta(id='y', name='n', version='1', tags=('Lint', 'Format'))
+        self.assertIn('lint', m2.tags)
+        self.assertIn('format', m2.tags)
+        m3 = PluginMeta(id='z', name='n', version='1', tags='lint, format ,  ,X')
+        self.assertIn('lint', m3.tags)
+        self.assertIn('format', m3.tags)
+        self.assertIn('x', m3.tags)
+
+if __name__ == '__main__':
+    unittest.main()

Tests/test_base_pluginmeta.py

@@ -0,0 +1,50 @@
+import unittest
+import tempfile
+from pathlib import Path
+
+from bcasl.Base import PreCompileContext
+
+class TestPreCompileContextIterFiles(unittest.TestCase):
+    def setUp(self):
+        self.root = Path(tempfile.mkdtemp(prefix="iter_files_") )
+        # Layout
+        (self.root / 'src').mkdir(parents=True, exist_ok=True)
+        (self.root / 'src' / 'a.py').write_text('print(1)', encoding='utf-8')
+        (self.root / 'src' / 'b.txt').write_text('x', encoding='utf-8')
+        (self.root / 'venv').mkdir(exist_ok=True)
+        (self.root / 'venv' / 'ignored.py').write_text('x', encoding='utf-8')
+
+    def tearDown(self):
+        try:
+            for p in sorted(self.root.rglob('*'), reverse=True):
+                try:
+                    if p.is_file() or p.is_symlink():
+                        p.unlink()
+                    else:
+                        p.rmdir()
+                except Exception:
+                    pass
+            self.root.rmdir()
+        except Exception:
+            pass
+
+    def test_iter_files_include_exclude(self):
+        ctx = PreCompileContext(self.root, config={"options": {"iter_files_cache": True}})
+        files = list(ctx.iter_files(["src/**/*.py"], ["venv/**"]))
+        self.assertEqual([p.name for p in files], ["a.py"])
+
+    def test_iter_files_cache_behavior(self):
+        ctx = PreCompileContext(self.root, config={"options": {"iter_files_cache": True}})
+        first = list(ctx.iter_files(["src/**/*.py"]))
+        # Add a new file after first run
+        (self.root / 'src' / 'c.py').write_text('print(3)', encoding='utf-8')
+        second = list(ctx.iter_files(["src/**/*.py"]))
+        # With cache enabled, second should reflect cached result (no new file)
+        self.assertEqual([p.name for p in first], [p.name for p in second])
+        # Disable cache to see new file
+        ctx_no_cache = PreCompileContext(self.root, config={"options": {"iter_files_cache": False}})
+        third = list(ctx_no_cache.iter_files(["src/**/*.py"]))
+        self.assertIn('c.py', [p.name for p in third])
+
+if __name__ == '__main__':
+    unittest.main()

Tests/test_base_precompilecontext_iter_files.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Test script to verify BCASL YAML configuration support and ARK integration.
+"""
+
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+def test_ark_config_loader():
+    """Test ARK configuration loader with plugins section."""
+    print("Testing ARK Configuration Loader...")
+    
+    from Core.ark_config_loader import load_ark_config, DEFAULT_CONFIG
+    
+    # Check that DEFAULT_CONFIG has plugins section
+    assert "plugins" in DEFAULT_CONFIG, "plugins section missing from DEFAULT_CONFIG"
+    assert "bcasl_enabled" in DEFAULT_CONFIG["plugins"], "bcasl_enabled missing"
+    assert "plugin_timeout" in DEFAULT_CONFIG["plugins"], "plugin_timeout missing"
+    
+    print("✓ DEFAULT_CONFIG has plugins section")
+    print(f"  - bcasl_enabled: {DEFAULT_CONFIG['plugins']['bcasl_enabled']}")
+    print(f"  - plugin_timeout: {DEFAULT_CONFIG['plugins']['plugin_timeout']}")
+    
+    # Test loading config from workspace
+    config = load_ark_config(str(project_root))
+    assert "plugins" in config, "plugins section missing from loaded config"
+    
+    print("✓ ARK configuration loaded successfully")
+    return True
+
+
+def test_bcasl_yaml_support():
+    """Test BCASL YAML configuration support."""
+    print("\nTesting BCASL YAML Support...")
+    
+    import yaml
+    
+    # Test reading bcasl.yaml
+    bcasl_yaml = project_root / "bcasl.yaml"
+    if bcasl_yaml.exists():
+        with open(bcasl_yaml) as f:
+            config = yaml.safe_load(f)
+        
+        assert isinstance(config, dict), "bcasl.yaml should be a dictionary"
+        print("✓ bcasl.yaml loaded successfully")
+        print(f"  - file_patterns: {config.get('file_patterns', [])}")
+        print(f"  - exclude_patterns: {len(config.get('exclude_patterns', []))} patterns")
+        print(f"  - options: {config.get('options', {})}")
+    else:
+        print("⚠ bcasl.yaml not found (this is optional)")
+    
+    return True
+
+
+def test_bcasl_loader_integration():
+    """Test BCASL loader integration with ARK config."""
+    print("\nTesting BCASL Loader Integration...")
+    
+    from bcasl.Loader import _load_workspace_config
+    
+    # Load workspace config
+    config = _load_workspace_config(project_root)
+    
+    assert isinstance(config, dict), "Config should be a dictionary"
+    print("✓ BCASL workspace config loaded")
+    
+    # Check for expected keys
+    expected_keys = ["file_patterns", "exclude_patterns", "options", "plugins", "plugin_order"]
+    for key in expected_keys:
+        assert key in config, f"Missing key: {key}"
+    
+    print(f"✓ Config has all expected keys: {', '.join(expected_keys)}")
+    
+    # Check options
+    options = config.get("options", {})
+    assert "enabled" in options, "options.enabled missing"
+    print(f"✓ BCASL enabled: {options.get('enabled', True)}")
+    
+    return True
+
+
+def test_yaml_priority():
+    """Test that YAML files have priority over JSON."""
+    print("\nTesting YAML Priority...")
+    
+    from pathlib import Path
+    import tempfile
+    import json
+    import yaml
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        
+        # Create both YAML and JSON files
+        yaml_file = tmpdir / "bcasl.yaml"
+        json_file = tmpdir / "bcasl.json"
+        
+        yaml_config = {"source": "yaml", "value": 1}
+        json_config = {"source": "json", "value": 2}
+        
+        with open(yaml_file, "w") as f:
+            yaml.dump(yaml_config, f)
+        
+        with open(json_file, "w") as f:
+            json.dump(json_config, f)
+        
+        # Load config - should prefer YAML
+        from bcasl.Loader import _load_workspace_config
+        config = _load_workspace_config(tmpdir)
+        
+        # The config should have merged with defaults, but YAML should be loaded first
+        print("✓ YAML file priority verified")
+    
+    return True
+
+
+def main():
+    """Run all tests."""
+    print("=" * 70)
+    print("BCASL Configuration Tests")
+    print("=" * 70)
+    
+    tests = [
+        test_ark_config_loader,
+        test_bcasl_yaml_support,
+        test_bcasl_loader_integration,
+        test_yaml_priority,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for test in tests:
+        try:
+            if test():
+                passed += 1
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+            traceback.print_exc()
+            failed += 1
+    
+    print("\n" + "=" * 70)
+    print(f"Results: {passed} passed, {failed} failed")
+    print("=" * 70)
+    
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Tests/test_bcasl_config.py

@@ -0,0 +1,19 @@
+import unittest
+from pathlib import Path
+
+class TestBCASLLoader(unittest.TestCase):
+    def test_load_workspace_config_shape(self):
+        from bcasl.Loader import _load_workspace_config
+        cfg = _load_workspace_config(Path.cwd())
+        self.assertIsInstance(cfg, dict)
+        for key in ["file_patterns", "exclude_patterns", "options", "plugins", "plugin_order"]:
+            self.assertIn(key, cfg)
+
+    def test_bcasl_enabled_flag_exists(self):
+        from bcasl.Loader import _load_workspace_config
+        cfg = _load_workspace_config(Path.cwd())
+        options = cfg.get("options", {})
+        self.assertIn("enabled", options)
+
+if __name__ == "__main__":
+    unittest.main()