test(fix): debug tests

Author: afinkbeiner86

.github/workflows/tests.yml

@@ -31,22 +31,28 @@ jobs:
   python-tests:
     name: Python Tests
     runs-on: ubuntu-latest
+    env:
+      CI: true
+
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
 
     steps:
       - uses: actions/checkout@v4
 
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.x'
+          python-version: ${{ matrix.python-version }}
 
       - name: Run bump-version tests
         run: python -m unittest tests/test_bump_version.py -v
 
       - name: Test bump-version script syntax
         run: python -m py_compile scripts/bump-version.py
 
-      - name: Validate version format
+      - name: Smoke test bump-version script
         run: |
-          # Test that the script runs with --help would work (basic smoke test)
-          python scripts/bump-version.py 1.0.0 || echo "Expected to fail without files, that's ok for syntax check"
+          python scripts/bump-version.py 1.0.0 || \
+            echo "Expected failure due to missing files"

tests/test_bump_version.py

@@ -8,97 +8,116 @@
 import sys
 import tempfile
 import unittest
+from contextlib import contextmanager
 from pathlib import Path
 
 BASE_DIR = Path(__file__).parent.parent
 SCRIPT_PATH = BASE_DIR / "scripts" / "bump-version.py"
 
-spec = importlib.util.spec_from_file_location("bump_version", str(SCRIPT_PATH))
-bump_version = importlib.util.module_from_spec(spec)
-# Assigning spec to the module is required for importlib.reload() to work
-bump_version.__spec__ = spec
-sys.modules["bump_version"] = bump_version
-spec.loader.exec_module(bump_version)
+
+def load_bump_version(*, ci: bool = False):
+    """
+    Load bump-version.py as a fresh module instance.
+    Optionally simulates CI environment.
+    """
+    module_name = "bump_version_test_instance"
+
+    @contextmanager
+    def ci_env():
+        if ci:
+            os.environ["CI"] = "true"
+        try:
+            yield
+        finally:
+            if ci:
+                os.environ.pop("CI", None)
+
+    with ci_env():
+        spec = importlib.util.spec_from_file_location(module_name, SCRIPT_PATH)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules.pop(module_name, None)
+        spec.loader.exec_module(module)
+        return module
 
 
 class BaseBumpTest(unittest.TestCase):
     """Shared environment setup for file-based tests."""
 
     def setUp(self):
-        """Create temporary directory and switch CWD"""
         self.tmp_dir = tempfile.TemporaryDirectory()
         self.test_path = Path(self.tmp_dir.name)
         self.original_cwd = Path.cwd()
         os.chdir(self.test_path)
 
+        self.bump_version = load_bump_version()
+
     def tearDown(self):
-        """Restore CWD and cleanup temp files"""
         os.chdir(self.original_cwd)
         self.tmp_dir.cleanup()
 
     def create_mock_project(self, version="2.8.0"):
-        """Helper to scaffold standard test files."""
         (self.test_path / "ConsumableManager.toc").write_text(
-            f"## Version: {version}\n## Interface: 30300", encoding="utf-8"
+            f"## Version: {version}\n## Interface: 30300",
+            encoding="utf-8",
         )
         (self.test_path / "ConsumableManager.lua").write_text(
-            f"-- Version: {version}\nlocal v = 'v{version}'", encoding="utf-8"
+            f"-- Version: {version}\nlocal v = 'v{version}'",
+            encoding="utf-8",
         )
 
 
 class TestVersionValidation(unittest.TestCase):
     """Test version format validation"""
 
     def test_validation(self):
-        """Test that valid and invalid semantic versions are handled"""
+        bump_version = load_bump_version()
+
         cases = [
             ("1.0.0", True),
             ("2.9.0", True),
             ("1.0", False),
             ("v1.0.0", False),
             ("", False),
         ]
+
         for version, expected in cases:
             with self.subTest(version=version):
-                self.assertEqual(bump_version.validate_version(version), expected)
+                self.assertEqual(
+                    bump_version.validate_version(version),
+                    expected,
+                )
 
 
 class TestBumpLogic(BaseBumpTest):
     """Test the core version bumping functionality"""
 
     def test_successful_bump(self):
-        """Test happy path: reading current and updating to new version."""
         self.create_mock_project("2.8.0")
-        self.assertEqual(bump_version.get_current_version(), "2.8.0")
-        self.assertEqual(bump_version.bump_version("2.9.0"), 0)
 
-        toc_content = (self.test_path / "ConsumableManager.toc").read_text()
-        lua_content = (self.test_path / "ConsumableManager.lua").read_text()
+        self.assertEqual(self.bump_version.get_current_version(), "2.8.0")
+        self.assertEqual(self.bump_version.bump_version("2.9.0"), 0)
+
+        toc = (self.test_path / "ConsumableManager.toc").read_text()
+        lua = (self.test_path / "ConsumableManager.lua").read_text()
 
-        self.assertIn("## Version: 2.9.0", toc_content)
-        self.assertIn("-- Version: 2.9.0", lua_content)
-        self.assertIn("'v2.9.0'", lua_content)
+        self.assertIn("## Version: 2.9.0", toc)
+        self.assertIn("-- Version: 2.9.0", lua)
+        self.assertIn("'v2.9.0'", lua)
 
     def test_missing_files(self):
-        """Verify error code 2 when files are missing."""
-        self.assertEqual(bump_version.bump_version("2.9.0"), 2)
+        self.assertEqual(self.bump_version.bump_version("2.9.0"), 2)
 
 
 class TestCIEnvironment(unittest.TestCase):
     """Test behavior in CI environment"""
 
     def test_colors_disabled_in_ci(self):
-        """Verify reload() functionality with registered sys.modules."""
-        import importlib
+        bump_version = load_bump_version(ci=True)
 
-        os.environ["CI"] = "true"
-        # Reloading now works because __spec__ was assigned during import
-        importlib.reload(bump_version)
-        try:
-            self.assertEqual(bump_version.Colors.RED, "")
-        finally:
-            del os.environ["CI"]
-            importlib.reload(bump_version)
+        self.assertEqual(bump_version.Colors.RED, "")
+        self.assertEqual(bump_version.Colors.GREEN, "")
+        self.assertEqual(bump_version.Colors.YELLOW, "")
+        self.assertEqual(bump_version.Colors.NC, "")
 
 
 if __name__ == "__main__":