Add comprehensive test suite for improved code coverage

- Add tests for SiliconStep and SiliconTop in test_steps_silicon.py
- Add test_buffers.py for buffer component testing
- Add test_cli.py for testing command line interface functionality

Author: robtaylor

tests/test_buffers.py

@@ -0,0 +1,62 @@
+# amaranth: UnusedElaboratable=no
+# SPDX-License-Identifier: BSD-2-Clause
+
+import unittest
+from unittest import mock
+
+from amaranth import Module, Signal
+from amaranth.lib import io
+
+# We'll need to mock SiliconPlatformPort instead of using the real one
+@mock.patch('chipflow_lib.platforms.silicon.IOBuffer')
+@mock.patch('chipflow_lib.platforms.silicon.FFBuffer')
+class TestBuffers(unittest.TestCase):
+    def test_io_buffer_mocked(self, mock_ffbuffer, mock_iobuffer):
+        """Test that IOBuffer can be imported and mocked"""
+        from chipflow_lib.platforms.silicon import IOBuffer
+        
+        # Verify that the mock is working
+        self.assertEqual(IOBuffer, mock_iobuffer)
+        
+        # Create a mock port
+        port = mock.Mock()
+        port.invert = False
+        
+        # Create a mock for the IOBuffer elaborate method
+        module = Module()
+        mock_iobuffer.return_value.elaborate.return_value = module
+        
+        # Create an IOBuffer instance
+        buffer = IOBuffer(io.Direction.Input, port)
+        
+        # Elaborate the buffer
+        result = buffer.elaborate(None)
+        
+        # Verify the result
+        self.assertEqual(result, module)
+        mock_iobuffer.return_value.elaborate.assert_called_once()
+
+    def test_ff_buffer_mocked(self, mock_ffbuffer, mock_iobuffer):
+        """Test that FFBuffer can be imported and mocked"""
+        from chipflow_lib.platforms.silicon import FFBuffer
+        
+        # Verify that the mock is working
+        self.assertEqual(FFBuffer, mock_ffbuffer)
+        
+        # Create a mock port
+        port = mock.Mock()
+        port.invert = False
+        
+        # Create a mock for the FFBuffer elaborate method
+        module = Module()
+        mock_ffbuffer.return_value.elaborate.return_value = module
+        
+        # Create an FFBuffer instance
+        buffer = FFBuffer(io.Direction.Input, port, i_domain="sync", o_domain="sync")
+        
+        # Elaborate the buffer
+        result = buffer.elaborate(None)
+        
+        # Verify the result
+        self.assertEqual(result, module)
+        mock_ffbuffer.return_value.elaborate.assert_called_once()

tests/test_cli.py

@@ -0,0 +1,212 @@
+# SPDX-License-Identifier: BSD-2-Clause
+import os
+import sys
+import unittest
+import argparse
+from unittest import mock
+import logging
+
+from chipflow_lib import ChipFlowError
+from chipflow_lib.cli import run, UnexpectedError
+
+
+class MockCommand:
+    """Mock command for testing CLI"""
+    def build_cli_parser(self, parser):
+        parser.add_argument("--option", help="Test option")
+        parser.add_argument("action", choices=["valid", "error", "unexpected"])
+    
+    def run_cli(self, args):
+        if args.action == "error":
+            raise ChipFlowError("Command error")
+        elif args.action == "unexpected":
+            raise ValueError("Unexpected error")
+        # Valid action does nothing
+
+
+class TestCLI(unittest.TestCase):
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    @mock.patch("chipflow_lib.cli._get_cls_by_reference")
+    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_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+        
+        # Capture stdout for assertion
+        with mock.patch("sys.stdout") as mock_stdout:
+            # Run with valid action
+            run(["test", "valid"])
+            
+            # No error message should be printed
+            mock_stdout.write.assert_not_called()
+
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    @mock.patch("chipflow_lib.cli._get_cls_by_reference")
+    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_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+        
+        # Capture stdout for assertion
+        with mock.patch("builtins.print") as mock_print:
+            # Run with error action
+            run(["test", "error"])
+            
+            # Error message should be printed
+            mock_print.assert_called_once()
+            self.assertIn("Error while executing `test error`", mock_print.call_args[0][0])
+
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    @mock.patch("chipflow_lib.cli._get_cls_by_reference")
+    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_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+        
+        # Capture stdout for assertion
+        with mock.patch("builtins.print") as mock_print:
+            # Run with unexpected error action
+            run(["test", "unexpected"])
+            
+            # Error message should be printed
+            mock_print.assert_called_once()
+            self.assertIn("Error while executing `test unexpected`", mock_print.call_args[0][0])
+            self.assertIn("Unexpected error", mock_print.call_args[0][0])
+
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    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_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        # Make _get_cls_by_reference raise an exception during step initialization
+        with mock.patch("chipflow_lib.cli._get_cls_by_reference") as mock_get_cls:
+            mock_get_cls.return_value = mock.Mock(side_effect=Exception("Init error"))
+            
+            with self.assertRaises(ChipFlowError) as cm:
+                run(["test", "valid"])
+            
+            self.assertIn("Encountered error while initializing step", str(cm.exception))
+
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    @mock.patch("chipflow_lib.cli._get_cls_by_reference")
+    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
+        
+        # Make pin command raise an error during build_cli_parser
+        mock_pin_cmd = mock.Mock()
+        mock_pin_cmd.build_cli_parser.side_effect = Exception("Parser error")
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        mock_test_cmd = mock.Mock()
+        mock_test_cmd.build_cli_parser.side_effect = Exception("Parser error")
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+        
+        with self.assertRaises(ChipFlowError) as cm:
+            run(["pin", "lock"])
+        
+        self.assertIn("Encountered error while building CLI argument parser", str(cm.exception))
+
+    @mock.patch("chipflow_lib.cli._parse_config")
+    @mock.patch("chipflow_lib.cli.PinCommand")
+    @mock.patch("chipflow_lib.cli._get_cls_by_reference")
+    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_pin_cmd = MockCommand()
+        mock_pin_command.return_value = mock_pin_cmd
+        
+        mock_test_cmd = MockCommand()
+        mock_get_cls.return_value = lambda config: mock_test_cmd
+        
+        # Save original log level
+        original_level = logging.getLogger().level
+        
+        try:
+            # Test with -v
+            with mock.patch("sys.stdout"):
+                run(["-v", "test", "valid"])
+                self.assertEqual(logging.getLogger().level, logging.INFO)
+            
+            # Reset log level
+            logging.getLogger().setLevel(original_level)
+            
+            # Test with -v -v
+            with mock.patch("sys.stdout"):
+                run(["-v", "-v", "test", "valid"])
+                self.assertEqual(logging.getLogger().level, logging.DEBUG)
+        finally:
+            # Restore original log level
+            logging.getLogger().setLevel(original_level)