Fix more merge conflict markers in test files

Author: robtaylor

tests/test_init.py

@@ -12,179 +12,125 @@
 from chipflow_lib import (
     ChipFlowError,
     _get_cls_by_reference,
-    _ensure_chipflow_root,
-    _parse_config_file,
-    _parse_config
+    ensure_chipflow_root,
+    parse_config,
+    parse_config_file,
 )
 
 
-class TestCoreUtilities(unittest.TestCase):
-    def setUp(self):
-        # Save original environment to restore later
-        self.original_chipflow_root = os.environ.get("CHIPFLOW_ROOT")
-        self.original_sys_path = sys.path.copy()
-<<<<<<< HEAD
-        
-=======
-
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        # Create a temporary directory for tests
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.temp_path = self.temp_dir.name
-
-    def tearDown(self):
-        # Restore original environment
-        if self.original_chipflow_root:
-            os.environ["CHIPFLOW_ROOT"] = self.original_chipflow_root
-        else:
-            os.environ.pop("CHIPFLOW_ROOT", None)
-<<<<<<< HEAD
-        
-=======
+def fixture_path(filename):
+    """Helper to get path to test fixture file"""
+    return os.path.join(os.path.dirname(__file__), "fixtures", filename)
 
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        sys.path = self.original_sys_path
-        self.temp_dir.cleanup()
 
+class TestCoreUtilities(unittest.TestCase):
+    """Test the core utilities in the chipflow_lib package"""
+    
     def test_chipflow_error(self):
-        """Test that ChipFlowError can be raised and caught properly"""
-        with self.assertRaises(ChipFlowError):
-            raise ChipFlowError("Test error")
-
-    def test_get_cls_by_reference_valid(self):
-        """Test retrieving a class by reference when the module and class exist"""
-        # unittest.TestCase is a valid class that should be importable
-        cls = _get_cls_by_reference("unittest:TestCase", "test context")
-        self.assertEqual(cls, unittest.TestCase)
-
-    def test_get_cls_by_reference_module_not_found(self):
-        """Test _get_cls_by_reference when the module doesn't exist"""
-        with self.assertRaises(ChipFlowError) as cm:
-            _get_cls_by_reference("nonexistent_module:SomeClass", "test context")
-<<<<<<< HEAD
-        
-=======
-
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        self.assertIn("Module `nonexistent_module` referenced by test context is not found", str(cm.exception))
-
-    def test_get_cls_by_reference_class_not_found(self):
-        """Test _get_cls_by_reference when the class doesn't exist in the module"""
-        with self.assertRaises(ChipFlowError) as cm:
-            _get_cls_by_reference("unittest:NonExistentClass", "test context")
-<<<<<<< HEAD
+        """Test ChipFlowError exception creation"""
+        # Create with message
+        error = ChipFlowError("Test error message")
+        self.assertEqual(str(error), "Test error message")
 
-=======
-
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        self.assertIn("Module `unittest` referenced by test context does not define `NonExistentClass`", str(cm.exception))
+        # Create with formatted message
+        error = ChipFlowError("Error with {}", "formatting")
+        self.assertEqual(str(error), "Error with formatting")
 
     def test_ensure_chipflow_root_already_set(self):
-        """Test _ensure_chipflow_root when CHIPFLOW_ROOT is already set"""
-        os.environ["CHIPFLOW_ROOT"] = "/test/path"
-        sys.path = ["/some/other/path"]
-<<<<<<< HEAD
-        
-        result = _ensure_chipflow_root()
-        
-=======
-
-        result = _ensure_chipflow_root()
-
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        self.assertEqual(result, "/test/path")
-        self.assertIn("/test/path", sys.path)
+        """Test ensure_chipflow_root when CHIPFLOW_ROOT is already set"""
+        with mock.patch.dict(os.environ, {"CHIPFLOW_ROOT": "/path/to/chipflow"}):
+            # Should not modify the variable
+            ensure_chipflow_root()
+            self.assertEqual(os.environ["CHIPFLOW_ROOT"], "/path/to/chipflow")
 
     def test_ensure_chipflow_root_not_set(self):
-        """Test _ensure_chipflow_root when CHIPFLOW_ROOT is not set"""
-        if "CHIPFLOW_ROOT" in os.environ:
-            del os.environ["CHIPFLOW_ROOT"]
-<<<<<<< HEAD
+        """Test ensure_chipflow_root when CHIPFLOW_ROOT is not set"""
+        # Remove CHIPFLOW_ROOT if present
+        os.environ.pop("CHIPFLOW_ROOT", None)
 
-        with mock.patch("os.getcwd", return_value="/mock/cwd"):
-            result = _ensure_chipflow_root()
+        # Should set it to current directory
+        with mock.patch('os.getcwd', return_value="/current/dir"):
+            ensure_chipflow_root()
+            self.assertEqual(os.environ["CHIPFLOW_ROOT"], "/current/dir")
 
-=======
+        # Clean up
+        os.environ.pop("CHIPFLOW_ROOT", None)
+
+    def test_get_cls_by_reference_valid(self):
+        """Test _get_cls_by_reference with valid reference"""
+        # Test with actual class
+        cls = _get_cls_by_reference("chipflow_lib:ChipFlowError")
+        self.assertEqual(cls, ChipFlowError)
 
-        with mock.patch("os.getcwd", return_value="/mock/cwd"):
-            result = _ensure_chipflow_root()
+    def test_get_cls_by_reference_module_not_found(self):
+        """Test _get_cls_by_reference with non-existent module"""
+        with self.assertRaises(ChipFlowError):
+            _get_cls_by_reference("nonexistent_module:SomeClass")
 
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-            self.assertEqual(result, "/mock/cwd")
-            self.assertEqual(os.environ["CHIPFLOW_ROOT"], "/mock/cwd")
-            self.assertIn("/mock/cwd", sys.path)
+    def test_get_cls_by_reference_class_not_found(self):
+        """Test _get_cls_by_reference with non-existent class"""
+        with self.assertRaises(ChipFlowError):
+            _get_cls_by_reference("chipflow_lib:NonExistentClass")
 
-    def test_parse_config_file_valid(self):
-        """Test _parse_config_file with a valid config file"""
-        # Create a temporary config file
-        config_content = """
+    def test_parse_config(self):
+        """Test parse_config using a fixture file"""
+        # Create temporary file for testing
+        with tempfile.NamedTemporaryFile(suffix=".toml", delete=False) as temp_file:
+            temp_file.write(b'''
 [chipflow]
 project_name = "test_project"
-steps = { silicon = "chipflow_lib.steps.silicon:SiliconStep" }
-clocks = { default = "sys_clk" }
-resets = { default = "sys_rst_n" }
-
-[chipflow.silicon]
-process = "sky130"
-package = "caravel"
-"""
-        config_path = os.path.join(self.temp_path, "chipflow.toml")
-        with open(config_path, "w") as f:
-            f.write(config_content)
-<<<<<<< HEAD
+process = "sky130A"
+package = "cf20"
+silicon.debug.heartbeat = true
+
+[chipflow.steps]
+silicon = "chipflow_lib.steps.silicon:SiliconStep"
+            ''')
+            temp_file_path = temp_file.name
 
-        config = _parse_config_file(config_path)
-        
-=======
+        try:
+            # Test parsing
+            with mock.patch('os.path.isfile', return_value=True):
+                config = parse_config(config_path=temp_file_path)
+                
+                # Verify config contents
+                self.assertEqual(config["chipflow"]["project_name"], "test_project")
+                self.assertEqual(config["chipflow"]["process"], "sky130A")
+                self.assertEqual(config["chipflow"]["silicon"]["debug"]["heartbeat"], True)
+                self.assertEqual(config["chipflow"]["steps"]["silicon"], 
+                                "chipflow_lib.steps.silicon:SiliconStep")
+        finally:
+            # Clean up temporary file
+            os.unlink(temp_file_path)
 
-        config = _parse_config_file(config_path)
+    def test_parse_config_file_valid(self):
+        """Test parse_config_file with valid TOML"""
+        valid_toml = '''
+[chipflow]
+project_name = "test_project"
+process = "sky130A"
+package = "cf20"
 
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        self.assertIn("chipflow", config)
+[chipflow.steps]
+silicon = "chipflow_lib.steps.silicon:SiliconStep"
+        '''
+        
+        config = parse_config_file(valid_toml)
         self.assertEqual(config["chipflow"]["project_name"], "test_project")
-        self.assertEqual(config["chipflow"]["silicon"]["process"], "sky130")
+        self.assertEqual(config["chipflow"]["steps"]["silicon"], 
+                        "chipflow_lib.steps.silicon:SiliconStep")
 
     def test_parse_config_file_invalid_schema(self):
-        """Test _parse_config_file with an invalid config file (schema validation fails)"""
-        # Create a temporary config file with missing required fields
-        config_content = """
+        """Test parse_config_file with TOML not matching schema"""
+        invalid_toml = '''
 [chipflow]
-project_name = "test_project"
-# Missing required fields: steps, silicon
-"""
-        config_path = os.path.join(self.temp_path, "chipflow.toml")
-        with open(config_path, "w") as f:
-            f.write(config_content)
-<<<<<<< HEAD
-        
-        with self.assertRaises(ChipFlowError) as cm:
-            _parse_config_file(config_path)
-        
-=======
-
-        with self.assertRaises(ChipFlowError) as cm:
-            _parse_config_file(config_path)
-
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        self.assertIn("Syntax error in `chipflow.toml`", str(cm.exception))
-
-    @mock.patch("chipflow_lib._ensure_chipflow_root")
-    @mock.patch("chipflow_lib._parse_config_file")
-    def test_parse_config(self, mock_parse_config_file, mock_ensure_chipflow_root):
-        """Test _parse_config which uses _ensure_chipflow_root and _parse_config_file"""
-        mock_ensure_chipflow_root.return_value = "/mock/chipflow/root"
-        mock_parse_config_file.return_value = {"chipflow": {"test": "value"}}
-<<<<<<< HEAD
-        
-        config = _parse_config()
+# Missing required fields: project_name, process, package
+steps = {} # Steps in wrong format
+        '''
 
-        mock_ensure_chipflow_root.assert_called_once()
-        # We're expecting a string, not a Path
-=======
-
-        config = _parse_config()
-
-        mock_ensure_chipflow_root.assert_called_once()
->>>>>>> bd941c3 (Add comprehensive test suite for improved code coverage)
-        mock_parse_config_file.assert_called_once_with("/mock/chipflow/root/chipflow.toml")
-        self.assertEqual(config, {"chipflow": {"test": "value"}})
+        # Should raise error about missing required fields
+        with self.assertRaises(ChipFlowError) as ctx:
+            parse_config_file(invalid_toml)
+            
+        # Error message should mention the validation error
+        self.assertIn("validation error", str(ctx.exception))