Merge pull request #211 from UiPath/test/coverage-boost

test: raise coverage to ~54% (from 32%)

Author: radu-mocanu

tests/test_cli_new.py

@@ -0,0 +1,79 @@
+"""Tests for the `uipath new` MCP middleware."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from uipath._cli.middlewares import MiddlewareResult
+
+from uipath_mcp._cli import cli_new
+
+
+def test_clean_directory_removes_only_py_files(tmp_path: Path):
+    (tmp_path / "a.py").write_text("x")
+    (tmp_path / "b.txt").write_text("x")
+    (tmp_path / "sub").mkdir()
+    cli_new.clean_directory(str(tmp_path))
+    assert not (tmp_path / "a.py").exists()
+    assert (tmp_path / "b.txt").exists()
+    assert (tmp_path / "sub").exists()
+
+
+def test_write_template_file_plain_copy(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "tpl").write_text("hello")
+    target = tmp_path / "out"
+    target.mkdir()
+    monkeypatch.setattr("uipath_mcp._cli.cli_new.os.path.dirname", lambda _: str(src))
+    cli_new.write_template_file(str(target), "tpl", "result.txt", None)
+    assert (target / "result.txt").read_text() == "hello"
+
+
+def test_write_template_file_with_replacements(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "tpl").write_text("name=$name; v=$v")
+    target = tmp_path / "out"
+    target.mkdir()
+    monkeypatch.setattr("uipath_mcp._cli.cli_new.os.path.dirname", lambda _: str(src))
+    cli_new.write_template_file(
+        str(target), "tpl", "result.txt", [("$name", "svc"), ("$v", "1")]
+    )
+    assert (target / "result.txt").read_text() == "name=svc; v=1"
+
+
+def test_generate_files_calls_write_three_times(tmp_path: Path):
+    with patch.object(cli_new, "write_template_file") as wtf:
+        cli_new.generate_files(str(tmp_path), "svc")
+    assert wtf.call_count == 3
+
+
+def test_mcp_new_middleware_happy_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.chdir(tmp_path)
+    with (
+        patch.object(cli_new, "clean_directory") as cd,
+        patch.object(cli_new, "generate_files") as gf,
+    ):
+        result = cli_new.mcp_new_middleware("svc")
+    assert isinstance(result, MiddlewareResult)
+    assert result.should_continue is False
+    cd.assert_called_once()
+    gf.assert_called_once()
+
+
+def test_mcp_new_middleware_error_returns_stacktrace_flag(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    monkeypatch.chdir(tmp_path)
+    with (
+        patch.object(cli_new, "clean_directory", side_effect=OSError("boom")),
+        patch.object(cli_new.console, "error"),
+    ):
+        result = cli_new.mcp_new_middleware("svc")
+    assert result.should_continue is False
+    assert result.should_include_stacktrace is True

tests/test_config.py

@@ -0,0 +1,116 @@
+"""Tests for McpConfig and McpServer."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from uipath_mcp._cli._utils._config import McpConfig, McpServer
+
+
+def test_server_defaults():
+    s = McpServer("svc", {})
+    assert s.name == "svc"
+    assert s.type is None
+    assert s.transport == "stdio"
+    assert s.url is None
+    assert s.command == "None"
+    assert s.args == []
+    assert s.env == {}
+    assert s.file_path is None
+    assert s.is_streamable_http is False
+
+
+def test_server_streamable_http_and_args():
+    s = McpServer(
+        "svc",
+        {
+            "type": "remote",
+            "transport": "streamable-http",
+            "url": "https://x",
+            "command": "node",
+            "args": ["index.js"],
+            "env": {},
+        },
+    )
+    assert s.is_streamable_http is True
+    assert s.file_path == "index.js"
+    d = s.to_dict()
+    assert d["transport"] == "streamable-http"
+    assert d["url"] == "https://x"
+    assert d["command"] == "node"
+    assert "McpServer" in repr(s)
+
+
+def test_server_env_overlay_from_os(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setenv("FOO", "from-env")
+    s = McpServer("svc", {"env": {"FOO": "default", "BAR": "keep"}})
+    assert s.env["FOO"] == "from-env"
+    assert s.env["BAR"] == "keep"
+
+
+def test_validate_server_name_ok():
+    McpConfig.validate_server_name("good-name-1")
+
+
+@pytest.mark.parametrize("bad", ["with space", "under_score", "dots.bad", ""])
+def test_validate_server_name_bad(bad: str):
+    with pytest.raises(ValueError):
+        McpConfig.validate_server_name(bad)
+
+
+def test_config_not_exists(tmp_path: Path):
+    cfg = McpConfig(str(tmp_path / "missing.json"))
+    assert cfg.exists is False
+    assert cfg.get_servers() == []
+    assert cfg.get_server_names() == []
+    assert cfg.get_server("anything") is None
+
+
+def test_config_load_and_lookup(tmp_path: Path):
+    path = tmp_path / "mcp.json"
+    path.write_text(
+        json.dumps(
+            {
+                "servers": {
+                    "alpha": {"command": "a", "args": ["a.py"]},
+                    "beta": {"command": "b"},
+                }
+            }
+        )
+    )
+    cfg = McpConfig(str(path))
+    assert cfg.exists is True
+    assert set(cfg.get_server_names()) == {"alpha", "beta"}
+    assert len(cfg.get_servers()) == 2
+    assert cfg.get_server("alpha").name == "alpha"  # type: ignore[union-attr]
+    assert cfg.get_server("missing") is None
+    raw = cfg.load_config()
+    assert "servers" in raw
+
+
+def test_config_single_server_returned_regardless_of_name(tmp_path: Path):
+    path = tmp_path / "mcp.json"
+    path.write_text(json.dumps({"servers": {"only": {"command": "x"}}}))
+    cfg = McpConfig(str(path))
+    assert cfg.get_server("does-not-matter").name == "only"  # type: ignore[union-attr]
+
+
+def test_config_load_invalid_json(tmp_path: Path):
+    path = tmp_path / "mcp.json"
+    path.write_text("{not json")
+    with pytest.raises(json.JSONDecodeError):
+        McpConfig(str(path))
+
+
+def test_config_load_invalid_name(tmp_path: Path):
+    path = tmp_path / "mcp.json"
+    path.write_text(json.dumps({"servers": {"bad name": {}}}))
+    with pytest.raises(ValueError):
+        McpConfig(str(path))
+
+
+def test_load_config_when_missing_raises(tmp_path: Path):
+    cfg = McpConfig(str(tmp_path / "nope.json"))
+    with pytest.raises(FileNotFoundError):
+        cfg.load_config()

tests/test_context.py

@@ -0,0 +1,39 @@
+"""Tests for UiPathServerType enum."""
+
+import pytest
+
+from uipath_mcp._cli._runtime._context import UiPathServerType
+
+
+def test_enum_values():
+    assert UiPathServerType.UiPath.value == 0
+    assert UiPathServerType.Command.value == 1
+    assert UiPathServerType.Coded.value == 2
+    assert UiPathServerType.SelfHosted.value == 3
+
+
+@pytest.mark.parametrize(
+    "name",
+    ["UiPath", "Command", "Coded", "SelfHosted"],
+)
+def test_from_string_valid(name: str):
+    assert UiPathServerType.from_string(name) == UiPathServerType[name]
+
+
+def test_from_string_invalid():
+    with pytest.raises(ValueError, match="Unknown server type"):
+        UiPathServerType.from_string("Nope")
+
+
+@pytest.mark.parametrize(
+    "server_type",
+    list(UiPathServerType),
+)
+def test_get_description_known(server_type: UiPathServerType):
+    desc = UiPathServerType.get_description(server_type)
+    assert isinstance(desc, str)
+    assert desc != "Unknown server type"
+
+
+def test_get_description_unknown():
+    assert UiPathServerType.get_description("not-an-enum") == "Unknown server type"  # type: ignore[arg-type]

tests/test_exception.py

@@ -0,0 +1,28 @@
+"""Tests for UiPathMcpRuntimeError."""
+
+from uipath.runtime.errors import UiPathErrorCategory
+
+from uipath_mcp._cli._runtime._exception import McpErrorCode, UiPathMcpRuntimeError
+
+
+def test_error_code_values():
+    assert McpErrorCode.CONFIGURATION_ERROR.value == "CONFIGURATION_ERROR"
+    assert McpErrorCode.SERVER_NOT_FOUND.value == "SERVER_NOT_FOUND"
+    assert McpErrorCode.REGISTRATION_ERROR.value == "REGISTRATION_ERROR"
+    assert McpErrorCode.INITIALIZATION_ERROR.value == "INITIALIZATION_ERROR"
+
+
+def test_runtime_error_constructs_with_defaults():
+    err = UiPathMcpRuntimeError(McpErrorCode.CONFIGURATION_ERROR, "title", "detail")
+    assert isinstance(err, Exception)
+
+
+def test_runtime_error_constructs_with_all_args():
+    err = UiPathMcpRuntimeError(
+        McpErrorCode.SERVER_NOT_FOUND,
+        "title",
+        "detail",
+        UiPathErrorCategory.USER,
+        404,
+    )
+    assert isinstance(err, Exception)