Add comprehensive tests for pinlock loading and fix error handling

Add three new tests to verify pinlock file loading behavior:
- test_load_pinlock_file: validates successful loading of valid lockfile
- test_load_pinlock_missing_file: ensures proper error when file missing
- test_load_pinlock_malformed_file: ensures proper error for invalid data

Fix bug in load_pinlock() where only pydantic.ValidationError was caught,
but Pydantic 2.x also raises PydanticUserError for incomplete models.
Now catches both exception types.

Fix test isolation by clearing ensure_chipflow_root() cache between tests
to prevent environment pollution across test runs.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: robtaylor

chipflow/packaging/utils.py

@@ -36,7 +36,7 @@ def load_pinlock() -> LockFile:
         try:
             json = lockfile.read_text()
             return LockFile.model_validate_json(json)
-        except pydantic.ValidationError:
+        except (pydantic.ValidationError, pydantic.PydanticUserError):
             raise ChipFlowError(
                 "Lockfile `pins.lock` is misformed. "
                 "Please remove and rerun `chipflow pin lock`"

tests/test_pin_lock.py

@@ -1,7 +1,14 @@
 # SPDX-License-Identifier: BSD-2-Clause
+import json
+import os
+import tempfile
 import unittest
+from pathlib import Path
 
 from chipflow.platforms import PACKAGE_DEFINITIONS
+from chipflow.packaging import load_pinlock
+from chipflow.packaging.lockfile import LockFile
+from chipflow import ChipFlowError
 
 
 class TestPinLock(unittest.TestCase):
@@ -20,4 +27,124 @@ def test_package_definitions_structure(self):
             self.assertEqual(package_def.name.lower(), name.lower())
             # Package definitions should have allocation methods
             self.assertTrue(hasattr(package_def, 'allocate_pins'))
-            self.assertTrue(callable(package_def.allocate_pins))
+            self.assertTrue(callable(package_def.allocate_pins))
+
+    def test_load_pinlock_file(self):
+        """Test loading a valid pins.lock file"""
+        # Create a temporary directory with a sample pins.lock file
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Set CHIPFLOW_ROOT to temporary directory
+            old_chipflow_root = os.environ.get('CHIPFLOW_ROOT')
+            os.environ['CHIPFLOW_ROOT'] = tmpdir
+
+            # Clear the cache on ensure_chipflow_root
+            from chipflow.utils import ensure_chipflow_root
+            if hasattr(ensure_chipflow_root, 'root'):
+                delattr(ensure_chipflow_root, 'root')
+
+            try:
+                # Create a minimal valid lockfile
+                lockfile_data = {
+                    "process": "sky130",
+                    "package": {
+                        "package_type": {
+                            "package_type": "QuadPackageDef",
+                            "name": "test_package",
+                            "width": 10,
+                            "height": 10,
+                            "_power": []
+                        }
+                    },
+                    "port_map": {
+                        "ports": {}
+                    },
+                    "metadata": {}
+                }
+
+                lockfile_path = Path(tmpdir) / 'pins.lock'
+                with open(lockfile_path, 'w') as f:
+                    json.dump(lockfile_data, f, indent=2)
+
+                # Test loading the lockfile
+                lockfile = load_pinlock()
+
+                # Validate structure
+                self.assertIsInstance(lockfile, LockFile)
+                self.assertEqual(str(lockfile.process), "sky130")
+                self.assertIsNotNone(lockfile.package)
+                self.assertIsNotNone(lockfile.port_map)
+                self.assertIsInstance(lockfile.metadata, dict)
+
+            finally:
+                # Restore original CHIPFLOW_ROOT
+                if old_chipflow_root is not None:
+                    os.environ['CHIPFLOW_ROOT'] = old_chipflow_root
+                elif 'CHIPFLOW_ROOT' in os.environ:
+                    del os.environ['CHIPFLOW_ROOT']
+
+                # Clear the cache again
+                if hasattr(ensure_chipflow_root, 'root'):
+                    delattr(ensure_chipflow_root, 'root')
+
+    def test_load_pinlock_missing_file(self):
+        """Test that loading fails gracefully when pins.lock doesn't exist"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            old_chipflow_root = os.environ.get('CHIPFLOW_ROOT')
+            os.environ['CHIPFLOW_ROOT'] = tmpdir
+
+            # Clear the cache on ensure_chipflow_root
+            from chipflow.utils import ensure_chipflow_root
+            if hasattr(ensure_chipflow_root, 'root'):
+                delattr(ensure_chipflow_root, 'root')
+
+            try:
+                # Should raise ChipFlowError when pins.lock doesn't exist
+                with self.assertRaises(ChipFlowError) as cm:
+                    load_pinlock()
+
+                self.assertIn("not found", str(cm.exception))
+                self.assertIn("pins.lock", str(cm.exception))
+
+            finally:
+                if old_chipflow_root is not None:
+                    os.environ['CHIPFLOW_ROOT'] = old_chipflow_root
+                elif 'CHIPFLOW_ROOT' in os.environ:
+                    del os.environ['CHIPFLOW_ROOT']
+
+                # Clear the cache again
+                if hasattr(ensure_chipflow_root, 'root'):
+                    delattr(ensure_chipflow_root, 'root')
+
+    def test_load_pinlock_malformed_file(self):
+        """Test that loading fails gracefully with malformed pins.lock"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            old_chipflow_root = os.environ.get('CHIPFLOW_ROOT')
+            os.environ['CHIPFLOW_ROOT'] = tmpdir
+
+            # Clear the cache on ensure_chipflow_root
+            from chipflow.utils import ensure_chipflow_root
+            if hasattr(ensure_chipflow_root, 'root'):
+                delattr(ensure_chipflow_root, 'root')
+
+            try:
+                # Create a malformed lockfile
+                lockfile_path = Path(tmpdir) / 'pins.lock'
+                with open(lockfile_path, 'w') as f:
+                    f.write('{"invalid": "json structure"}\n')
+
+                # Should raise ChipFlowError when pins.lock is malformed
+                with self.assertRaises(ChipFlowError) as cm:
+                    load_pinlock()
+
+                self.assertIn("misformed", str(cm.exception))
+                self.assertIn("pins.lock", str(cm.exception))
+
+            finally:
+                if old_chipflow_root is not None:
+                    os.environ['CHIPFLOW_ROOT'] = old_chipflow_root
+                elif 'CHIPFLOW_ROOT' in os.environ:
+                    del os.environ['CHIPFLOW_ROOT']
+
+                # Clear the cache again
+                if hasattr(ensure_chipflow_root, 'root'):
+                    delattr(ensure_chipflow_root, 'root')