refactor(tests): improve unit-tests given new architecture

Author: simonprovost

tests/core/test_config.py

@@ -0,0 +1,138 @@
+import os
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from m3.core.config import M3Config
+from m3.core.utils.exceptions import M3ConfigError
+
+
+@pytest.fixture
+def temp_env_vars():
+    """Fixture to temporarily set environment variables."""
+    original_env = os.environ.copy()
+    yield
+    os.environ.clear()
+    os.environ.update(original_env)
+
+
+class TestM3Config:
+    """Tests for M3Config class."""
+
+    def test_init_default(self):
+        """Test default initialization."""
+        config = M3Config()
+        assert config.log_level == "INFO"
+        assert config.env_vars == {}
+        assert isinstance(config.project_root, Path)
+        assert isinstance(config.data_dir, Path)
+        assert isinstance(config.databases_dir, Path)
+        assert isinstance(config.raw_files_dir, Path)
+
+    def test_init_with_params(self):
+        """Test initialization with parameters."""
+        env_vars = {"TEST_KEY": "value"}
+        config = M3Config(log_level="DEBUG", env_vars=env_vars)
+        assert config.log_level == "DEBUG"
+        assert config.env_vars == env_vars
+
+    def test_to_dict(self):
+        """Test to_dict method."""
+        config = M3Config(env_vars={"KEY": "value"})
+        data = config.to_dict()
+        assert data["log_level"] == "INFO"
+        assert data["env_vars"] == {"KEY": "value"}
+
+    def test_from_dict(self):
+        """Test from_dict class method."""
+        data = {"log_level": "DEBUG", "env_vars": {"KEY": "value"}}
+        config = M3Config.from_dict(data)
+        assert config.log_level == "DEBUG"
+        assert config.env_vars == {"KEY": "value"}
+
+    def test_from_dict_missing_key(self):
+        """Test from_dict raises error on missing key."""
+        data = {"log_level": "INFO"}
+        with pytest.raises(M3ConfigError, match="Missing required config key"):
+            M3Config.from_dict(data)
+
+    def test_get_env_var(self, temp_env_vars):
+        """Test get_env_var method."""
+        os.environ["TEST_ENV"] = "env_value"
+        config = M3Config(env_vars={"CONFIG_KEY": "config_value"})
+        assert config.get_env_var("TEST_ENV") == "env_value"
+        assert config.get_env_var("CONFIG_KEY") == "config_value"
+        assert config.get_env_var("MISSING", default="default") == "default"
+
+    def test_get_env_var_raise_if_missing(self):
+        """Test get_env_var raises if missing and required."""
+        config = M3Config()
+        with pytest.raises(M3ConfigError, match="Missing required env var"):
+            config.get_env_var("MISSING", raise_if_missing=True)
+
+    def test_validate_for_tools_success(self):
+        """Test validate_for_tools method success."""
+        from m3.core.tool.base import BaseTool
+
+        mock_tool = MagicMock(spec=BaseTool)
+        mock_tool.__class__.__name__ = "TestTool"
+        mock_tool.required_env_vars = {"REQUIRED": None}
+        config = M3Config(env_vars={"TESTTOOL_REQUIRED": "value"})
+        config.validate_for_tools([mock_tool])
+
+    def test_validate_for_tools_error(self):
+        """Test validate_for_tools raises on error."""
+        from m3.core.tool.base import BaseTool
+
+        mock_tool = MagicMock(spec=BaseTool)
+        mock_tool.__class__.__name__ = "TestTool"
+        mock_tool.required_env_vars = {"FAKE_MISSING": None}
+        config = M3Config(env_vars={})
+        with pytest.raises(M3ConfigError):
+            config.validate_for_tools([mock_tool])
+
+    def test_merge_env(self):
+        """Test merge_env method."""
+        config = M3Config(env_vars={"EXISTING": "old"})
+        new_env = {"NEW": "value"}
+        config.merge_env(new_env)
+        assert config.env_vars["NEW"] == "value"
+        assert config.env_vars["EXISTING"] == "old"
+
+    def test_merge_env_conflict(self):
+        """Test merge_env raises on conflict."""
+        config = M3Config(env_vars={"KEY": "old"})
+        with pytest.raises(M3ConfigError, match="Env conflict"):
+            config.merge_env({"KEY": "new"})
+
+    @patch("m3.core.config.Path.home")
+    def test_project_root_fallback(self, mock_home):
+        """Test project root fallback to home."""
+        mock_home.return_value = Path("/home/user")
+        with patch("pathlib.Path.exists", return_value=False):
+            config = M3Config()
+            assert config.project_root == Path("/home/user")
+
+    def test_invalid_log_level(self):
+        """Test invalid log level raises error."""
+        with pytest.raises(M3ConfigError, match="Invalid log level"):
+            M3Config(log_level="INVALID")
+
+    def test_get_env_var_error_success(self):
+        """Test _get_env_var_error returns None on success."""
+        config = M3Config(env_vars={"KEY": "value"})
+        assert config._get_env_var_error("KEY", None) is None
+
+    def test_get_env_var_error_missing(self):
+        """Test _get_env_var_error returns error message when missing."""
+        config = M3Config()
+        error = config._get_env_var_error("MISSING", None)
+        assert error is not None
+        assert "Missing required env var" in error
+
+    def test_get_data_dir_with_env(self, temp_env_vars):
+        """Test _get_data_dir uses env var when set."""
+        os.environ["M3_DATA_DIR"] = "/custom/data"
+        config = M3Config()
+        assert config._get_data_dir() == Path("/custom/data")

tests/core/test_mcp_config_generator.py

@@ -0,0 +1,160 @@
+import os
+from pathlib import Path
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+
+from m3.core.mcp_config_generator.mcp_config_generators.claude_mcp_config import (
+    ClaudeConfigGenerator,
+)
+from m3.core.mcp_config_generator.mcp_config_generators.fast_mcp_config import (
+    FastMCPConfigGenerator,
+)
+from m3.core.utils.exceptions import M3ValidationError
+from m3.m3 import M3
+
+
+@pytest.fixture
+def mock_m3() -> M3:
+    """Fixture for mock M3 instance."""
+    from m3.core.config import M3Config
+
+    config = M3Config(env_vars={"TEST_ENV": "value"})
+    m3 = M3(config=config)
+    return m3
+
+
+class TestClaudeConfigGenerator:
+    """Tests for ClaudeConfigGenerator."""
+
+    @patch(
+        "shutil.which",
+        return_value="/usr/bin/python",
+    )
+    @patch("os.path.isdir", return_value=True)
+    @patch(
+        "m3.core.mcp_config_generator.mcp_config_generators.claude_mcp_config.ClaudeConfigGenerator._get_claude_config_path"
+    )
+    def test_generate_with_defaults(
+        self,
+        mock_get_path: MagicMock,
+        mock_isdir: MagicMock,
+        mock_which: MagicMock,
+        mock_m3: M3,
+        tmp_path: Path,
+    ) -> None:
+        """Test generating config with defaults."""
+        mock_get_path.return_value = None
+        config = ClaudeConfigGenerator.generate(mock_m3)
+        assert isinstance(config, dict)
+        assert "mcpServers" in config
+        assert "m3" in config["mcpServers"]
+        server = config["mcpServers"]["m3"]
+        assert server["command"].endswith("python")
+        assert server["args"] == ["-m", "m3.core.server"]
+        assert os.path.isdir(server["cwd"])
+        assert "TEST_ENV" in server["env"]
+
+    @patch("shutil.which", return_value=None)
+    def test_invalid_command_raises_error(
+        self, mock_which: MagicMock, mock_m3: M3
+    ) -> None:
+        """Test invalid command raises error."""
+        with pytest.raises(M3ValidationError, match="Invalid command"):
+            ClaudeConfigGenerator.generate(mock_m3, command="/invalid/python")
+
+    @patch("os.path.isdir", return_value=False)
+    def test_invalid_cwd_raises_error(self, mock_isdir: MagicMock, mock_m3: M3) -> None:
+        """Test invalid cwd raises error."""
+        with pytest.raises(M3ValidationError, match="Invalid cwd"):
+            ClaudeConfigGenerator.generate(mock_m3, cwd="/invalid/dir")
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("json.load")
+    @patch("json.dump")
+    @patch(
+        "m3.core.mcp_config_generator.mcp_config_generators.claude_mcp_config.ClaudeConfigGenerator._get_claude_config_path"
+    )
+    @patch("pathlib.Path.exists")
+    def test_merge_with_existing_config(
+        self,
+        mock_exists: MagicMock,
+        mock_get_path: MagicMock,
+        mock_dump: MagicMock,
+        mock_load: MagicMock,
+        mock_open_file: MagicMock,
+        mock_m3: M3,
+        tmp_path: Path,
+    ) -> None:
+        """Test merging with existing Claude config."""
+        mock_path = tmp_path / "claude_config.json"
+        mock_get_path.return_value = mock_path
+        mock_exists.return_value = True
+        mock_load.return_value = {"mcpServers": {"existing": {}}}
+        _config = ClaudeConfigGenerator.generate(mock_m3)
+        mock_dump.assert_called_once()
+        dumped_config = mock_dump.call_args[0][0]
+        assert "existing" in dumped_config["mcpServers"]
+        assert "m3" in dumped_config["mcpServers"]
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("json.dump")
+    def test_save_to_custom_path(
+        self,
+        mock_dump: MagicMock,
+        mock_open_file: MagicMock,
+        mock_m3: M3,
+        tmp_path: Path,
+    ) -> None:
+        """Test saving to custom path."""
+        save_path = tmp_path / "custom.json"
+        config = ClaudeConfigGenerator.generate(mock_m3, save_path=str(save_path))
+        mock_dump.assert_called_once_with(config, mock_open_file(), indent=2)
+
+
+class TestFastMCPConfigGenerator:
+    """Tests for FastMCPConfigGenerator."""
+
+    @patch("shutil.which", return_value="/usr/bin/python")
+    @patch("os.path.isdir", return_value=True)
+    def test_generate_with_defaults(
+        self, mock_isdir: MagicMock, mock_which: MagicMock, mock_m3: M3
+    ) -> None:
+        """Test generating config with defaults."""
+        config = FastMCPConfigGenerator.generate(mock_m3)
+        assert isinstance(config, dict)
+        assert "mcpServers" in config
+        assert "m3" in config["mcpServers"]
+        server = config["mcpServers"]["m3"]
+        assert server["command"].endswith("python")
+        assert server["args"] == ["-m", "m3.core.server"]
+        assert os.path.isdir(server["cwd"])
+        assert "TEST_ENV" in server["env"]
+
+    @patch("shutil.which", return_value=None)
+    def test_invalid_command_raises_error(
+        self, mock_which: MagicMock, mock_m3: M3
+    ) -> None:
+        """Test invalid command raises error."""
+        with pytest.raises(M3ValidationError, match="Invalid command"):
+            FastMCPConfigGenerator.generate(mock_m3, command="/invalid/python")
+
+    @patch("os.path.isdir", return_value=False)
+    def test_invalid_cwd_raises_error(self, mock_isdir: MagicMock, mock_m3: M3) -> None:
+        """Test invalid cwd raises error."""
+        with pytest.raises(M3ValidationError, match="Invalid cwd"):
+            FastMCPConfigGenerator.generate(mock_m3, cwd="/invalid/dir")
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("json.dump")
+    def test_save_to_custom_path(
+        self,
+        mock_dump: MagicMock,
+        mock_open_file: MagicMock,
+        mock_m3: M3,
+        tmp_path: Path,
+    ) -> None:
+        """Test saving to custom path."""
+        save_path = tmp_path / "custom.json"
+        config = FastMCPConfigGenerator.generate(mock_m3, save_path=str(save_path))
+        mock_dump.assert_called_once_with(config, mock_open_file(), indent=2)

tests/core/test_server.py

@@ -0,0 +1,61 @@
+import os
+from unittest.mock import Mock, patch
+
+import pytest
+
+from m3.core.utils.exceptions import M3ValidationError
+from m3.m3 import M3
+
+
+class TestMCPServer:
+    """Tests for MCP server."""
+
+    def test_server_can_be_imported_as_module(self) -> None:
+        """Test that the server can be imported as a module."""
+        import m3.core.server
+
+        assert hasattr(m3.core.server, "main")
+        assert callable(m3.core.server.main)
+
+    @patch.dict(os.environ, {"M3_CONFIG_PATH": "test_config.json"})
+    @patch("m3.core.server.M3.load")
+    def test_main_success(self, mock_load: Mock) -> None:
+        """Test main function with valid config."""
+        mock_m3 = Mock(spec=M3)
+        mock_load.return_value = mock_m3
+        from m3.core.server import main
+
+        main()
+        mock_load.assert_called_once_with("test_config.json")
+        mock_m3.build.assert_called_once()
+        mock_m3.run.assert_called_once()
+
+    @patch.dict(os.environ, clear=True)
+    def test_main_no_config_path(self) -> None:
+        """Test main raises error when M3_CONFIG_PATH is not set."""
+        from m3.core.server import main
+
+        with pytest.raises(M3ValidationError, match="M3_CONFIG_PATH env var not set"):
+            main()
+
+    @patch.dict(os.environ, {"M3_CONFIG_PATH": "invalid.json"})
+    @patch("m3.core.server.M3.load")
+    def test_main_load_failure(self, mock_load: Mock) -> None:
+        """Test main handles load failure."""
+        mock_load.side_effect = FileNotFoundError("Config not found")
+        from m3.core.server import main
+
+        with pytest.raises(FileNotFoundError):
+            main()
+
+    @patch.dict(os.environ, {"M3_CONFIG_PATH": "test.json"})
+    @patch("m3.core.server.M3.load")
+    def test_main_build_failure(self, mock_load: Mock) -> None:
+        """Test main handles build failure."""
+        mock_m3 = Mock(spec=M3)
+        mock_load.return_value = mock_m3
+        mock_m3.build.side_effect = M3ValidationError("Build failed")
+        from m3.core.server import main
+
+        with pytest.raises(M3ValidationError):
+            main()