Clean up test suite and get it running

Author: robtaylor

chipflow_lib/platforms/utils.py

@@ -198,6 +198,7 @@ def invert(self) -> Iterable[bool]:
         assert type(self._model['invert']) is tuple
         return self._model['invert']
 
+    @property
     def options(self) -> _IOModelOptions:
         """
         Options set on the io port at construction

chipflow_lib/steps/silicon.py

@@ -37,7 +37,7 @@ def elaborate(self, platform: SiliconPlatform):
 
         # heartbeat led (to confirm clock/reset alive)
         if (self._config.chipflow.silicon.debug and
-           self._config.chipflow.silicon.debug.heartbeat):
+           self._config.chipflow.silicon.debug.get('heartbeat', False)):
             heartbeat_ctr = Signal(23)
             m.d.sync += heartbeat_ctr.eq(heartbeat_ctr + 1)
             m.d.comb += platform.request("heartbeat").o.eq(heartbeat_ctr[-1])

docs/example-chipflow.toml

@@ -4,40 +4,6 @@ project_name = "test-chip"
 [chipflow.top]
 soc = "my_design.design:MySoC"
 
-[chipflow.steps]
-silicon = "chipflow_lib.steps.silicon:SiliconStep"
-
-[chipflow.clocks]
-default = 'sys_clk'
-
-[chipflow.resets]
-default = 'sys_rst_n'
-
 [chipflow.silicon]
 process = "gf130bcd"
 package = "pga144"
-
-[chipflow.silicon.pads]
-# System
-sys_clk   = { type = "clock", loc = "114" }
-sys_rst_n = { type = "reset", loc = "115" }
-
-[chipflow.silicon.power]
-dvss0        = { type = "power", loc =   "1" }
-dvdd0        = { type = "ground", loc =   "9" }
-vss0         = { type = "power", loc =  "17" }
-vdd0         = { type = "ground", loc =  "25" }
-dvss1        = { type = "power", loc =  "33" }
-dvdd1        = { type = "ground", loc =  "41" }
-vss1         = { type = "power", loc =  "49" }
-vdd1         = { type = "ground", loc =  "57" }
-dvss2        = { type = "power", loc =  "65" }
-dvdd2        = { type = "ground", loc =  "73" }
-vss2         = { type = "power", loc =  "81" }
-vdd2         = { type = "ground", loc =  "89" }
-dvss3        = { type = "power", loc =  "97" }
-dvdd3        = { type = "ground", loc = "105" }
-vss3         = { type = "power", loc = "113" }
-vdd3         = { type = "ground", loc = "121" }
-dvss4        = { type = "power", loc = "129" }
-dvdd4        = { type = "ground", loc = "137" }

pdm.lock

@@ -26,7 +26,7 @@ dependencies = [
     "doit>=0.36.0",
     "requests>=2.20",
     "python-dotenv>=1.0.1",
-    "pydantic>=2.8",
+    "pydantic>=2.11",
     "halo>=0.0.31",
     "pyrefly>=0.21.0",
     "amaranth-stubs>=0.1.1",

pyproject.toml

@@ -6,7 +6,7 @@
 
 from chipflow_lib import ChipFlowError
 from chipflow_lib.cli import run
-
+from chipflow_lib.config_models import Config, ChipFlowConfig
 
 class MockCommand:
     """Mock command for testing CLI"""
@@ -22,6 +22,9 @@ def run_cli(self, args):
             raise ValueError("Unexpected error")
         # Valid action does nothing
 
+MOCK_CONFIG = Config(chipflow=ChipFlowConfig(project_name="test",
+                                             steps={"test": "test:MockStep"}
+                                             ))
 
 class TestCLI(unittest.TestCase):
     @mock.patch("chipflow_lib.cli._parse_config")
@@ -30,14 +33,7 @@ class TestCLI(unittest.TestCase):
     def test_run_success(self, mock_get_cls, mock_pin_command, mock_parse_config):
         """Test CLI run with successful command execution"""
         # Setup mocks
-        mock_config = {
-            "chipflow": {
-                "steps": {
-                    "test": "test:MockStep"
-                }
-            }
-        }
-        mock_parse_config.return_value = mock_config
+        mock_parse_config.return_value = MOCK_CONFIG
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -59,14 +55,7 @@ def test_run_success(self, mock_get_cls, mock_pin_command, mock_parse_config):
     def test_run_command_error(self, mock_get_cls, mock_pin_command, mock_parse_config):
         """Test CLI run with command raising ChipFlowError"""
         # Setup mocks
-        mock_config = {
-            "chipflow": {
-                "steps": {
-                    "test": "test:MockStep"
-                }
-            }
-        }
-        mock_parse_config.return_value = mock_config
+        mock_parse_config.return_value = MOCK_CONFIG
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -93,14 +82,7 @@ def test_run_command_error(self, mock_get_cls, mock_pin_command, mock_parse_conf
     def test_run_unexpected_error(self, mock_get_cls, mock_pin_command, mock_parse_config):
         """Test CLI run with command raising unexpected exception"""
         # Setup mocks
-        mock_config = {
-            "chipflow": {
-                "steps": {
-                    "test": "test:MockStep"
-                }
-            }
-        }
-        mock_parse_config.return_value = mock_config
+        mock_parse_config.return_value = MOCK_CONFIG
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -127,14 +109,7 @@ def test_run_unexpected_error(self, mock_get_cls, mock_pin_command, mock_parse_c
     def test_step_init_error(self, mock_pin_command, mock_parse_config):
         """Test CLI run with error initializing step"""
         # Setup mocks
-        mock_config = {
-            "chipflow": {
-                "steps": {
-                    "test": "test:MockStep"
-                }
-            }
-        }
-        mock_parse_config.return_value = mock_config
+        mock_parse_config.return_value = MOCK_CONFIG
 
         mock_pin_cmd = MockCommand()
         mock_pin_command.return_value = mock_pin_cmd
@@ -154,14 +129,7 @@ def test_step_init_error(self, mock_pin_command, mock_parse_config):
     def test_build_parser_error(self, mock_get_cls, mock_pin_command, mock_parse_config):
         """Test CLI run with error building CLI parser"""
         # Setup mocks
-        mock_config = {
-            "chipflow": {
-                "steps": {
-                    "test": "test:MockStep"
-                }
-            }
-        }
-        mock_parse_config.return_value = mock_config
+        mock_parse_config.return_value = MOCK_CONFIG
 
         # Make pin command raise an error during build_cli_parser
         mock_pin_cmd = mock.Mock()
@@ -183,14 +151,7 @@ def test_build_parser_error(self, mock_get_cls, mock_pin_command, mock_parse_con
 #     def test_verbosity_flags(self, mock_get_cls, mock_pin_command, mock_parse_config):
 #         """Test CLI verbosity flags"""
 #         # Setup mocks
-#         mock_config = {
-#             "chipflow": {
-#                 "steps": {
-#                     "test": "test:MockStep"
-#                 }
-#             }
-#         }
-#         mock_parse_config.return_value = mock_config
+#         mock_parse_config.return_value = MOCK_CONFIG
 #
 #         mock_pin_cmd = MockCommand()
 #         mock_pin_command.return_value = mock_pin_cmd

tests/test_cli.py

@@ -11,10 +11,11 @@
     ChipFlowError,
     _get_cls_by_reference,
     _ensure_chipflow_root,
-    _parse_config_file,
     _parse_config
 )
-from chipflow_lib.config_model import Config, ChipFlowConfig
+from chipflow_lib.config import _parse_config_file
+from chipflow_lib.config_models import Config, ChipFlowConfig
+from chipflow_lib.platforms import Process
 
 
 class TestCoreUtilities(unittest.TestCase):
@@ -67,7 +68,7 @@ def test_ensure_chipflow_root_already_set(self):
         os.environ["CHIPFLOW_ROOT"] = "/test/path"
         sys.path = ["/some/other/path"]
 
-        _ensure_chipflow_root.root = None
+        _ensure_chipflow_root.root = None  #type: ignore
         result = _ensure_chipflow_root()
 
         self.assertEqual(result, Path("/test/path"))
@@ -77,7 +78,7 @@ 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"]
-        _ensure_chipflow_root.root = None
+        _ensure_chipflow_root.root = None  #type: ignore
 
         with mock.patch("os.getcwd", return_value="/mock/cwd"):
             result = _ensure_chipflow_root()
@@ -107,15 +108,16 @@ def test_parse_config_file_valid(self):
         config = _parse_config_file(config_path)
 
         assert config.chipflow
+        assert config.chipflow.silicon
         self.assertEqual(config.chipflow.project_name, "test_project")
-        self.assertEqual(config.chipflow.silicon.process, "sky130")
+        self.assertEqual(config.chipflow.silicon.process, Process.SKY130)
 
     @mock.patch("chipflow_lib._ensure_chipflow_root")
-    @mock.patch("chipflow_lib._parse_config_file")
+    @mock.patch("chipflow_lib.config._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 = Config(chipflow=ChipFlowConfig(project_name='test', top={'test','test'}))
+        mock_parse_config_file.return_value = Config(chipflow=ChipFlowConfig(project_name='test', top={'test': 'test'}))
 
         config = _parse_config()
 
@@ -126,4 +128,4 @@ def test_parse_config(self, mock_parse_config_file, mock_ensure_chipflow_root):
                         else mock_parse_config_file.call_args[0][0],
                         "/mock/chipflow/root/chipflow.toml")
         self.assertEqual(config.chipflow.project_name, "test")
-        self.assertEqual(config.chipflow.project_name.top, {'test': 'test'})
+        self.assertEqual(config.chipflow.top, {'test': 'test'})