feat(tests): add 66+% cov tests

Author: simonprovost

README.md

@@ -17,6 +17,7 @@
 </a>
 <img alt="ruff" src="https://img.shields.io/badge/Ruff-lint%2Fformat-9C27B0?style=for-the-badge&logo=ruff&logoColor=white">
 <img alt="python" src="https://img.shields.io/badge/Python-3.10%2B-3776AB?style=for-the-badge&logo=python&logoColor=white">
+<img alt="pytest coverage" src="https://img.shields.io/badge/Coverage-66%25-brightgreen?style=for-the-badge&logo=pytest">
 <img alt="license" src="https://img.shields.io/badge/License-MIT-success?style=for-the-badge">
 
 </div>

pyproject.toml

@@ -26,7 +26,7 @@ dependencies = [
   "mcpstack>=0.0.2",
 ]
 
-[project.optional-dependencies]
+[dependency-groups]
 dev = [
   "pytest>=7.4",
   "ruff>=0.4.0",

tests/__init__.py

@@ -0,0 +1,56 @@
+import sys
+import types
+import contextlib
+from typing import Iterable
+
+import pytest
+
+from mcpstack_jupyter.tools.jupyter.utils.config_loader import load_known_tools
+
+
+def _make_fn(name: str):
+    def _fn(*args, **kwargs):
+        return {"__tool_name__": name}
+    _fn.__name__ = name
+    return _fn
+
+
+@contextlib.contextmanager
+def install_fake_jupyter_server(tool_names: Iterable[str]):
+    pkg_name = "jupyter_mcp_server"
+    mod_name = "jupyter_mcp_server.server"
+
+    pkg = types.ModuleType(pkg_name)
+    server = types.ModuleType(mod_name)
+
+    server.PROVIDER = None
+    server.DOCUMENT_URL = None
+    server.DOCUMENT_ID = None
+    server.DOCUMENT_TOKEN = None
+    server.RUNTIME_URL = None
+    server.RUNTIME_ID = None
+    server.RUNTIME_TOKEN = None
+
+    for n in tool_names:
+        setattr(server, n, _make_fn(n))
+
+    prev_pkg = sys.modules.get(pkg_name)
+    prev_mod = sys.modules.get(mod_name)
+    sys.modules[pkg_name] = pkg
+    sys.modules[mod_name] = server
+    try:
+        yield server
+    finally:
+        if prev_pkg is not None:
+            sys.modules[pkg_name] = prev_pkg
+        else:
+            sys.modules.pop(pkg_name, None)
+        if prev_mod is not None:
+            sys.modules[mod_name] = prev_mod
+        else:
+            sys.modules.pop(mod_name, None)
+
+
+@pytest.fixture(scope="session")
+def known_tools():
+    return load_known_tools()["known_tools"]

tests/conftest.py

@@ -0,0 +1,21 @@
+from mcpstack_jupyter.tools.jupyter.utils.config_loader import (
+    load_known_tools,
+    load_env_defaults,
+    load_cli_defaults,
+)
+
+def test_known_tools_and_read_only_lists():
+    data = load_known_tools()
+    known = data["known_tools"]
+    ro = data["read_only"]
+    assert isinstance(known, list) and len(known) > 0
+    assert "append_markdown_cell" in known
+    assert "read_all_cells" in known
+    assert set(ro).issubset(set(known))
+
+def test_env_and_cli_defaults_present():
+    env = load_env_defaults()
+    cli = load_cli_defaults()
+    assert "provider" in env
+    assert "document_url" in env
+    assert "output_filename" in cli

tests/test_config_loader.py

@@ -0,0 +1,79 @@
+import pytest
+
+from mcpstack_jupyter.tools.jupyter.jupyter import Jupyter
+from mcpstack_jupyter.tools.jupyter.utils.config_loader import load_env_defaults
+from tests.conftest import install_fake_jupyter_server
+
+
+def action_names(bound_fns):
+    return [fn.__name__ for fn in bound_fns]
+
+
+def test_bind_all_known_tools(known_tools):
+    with install_fake_jupyter_server(known_tools) as server:
+        tool = Jupyter()
+        tool.initialize()  # import & bind
+        names = action_names(tool.actions())
+        assert sorted(names) == sorted(known_tools)
+        for n in known_tools:
+            assert hasattr(server, n)
+
+
+def test_include_subset_only_binds_subset(known_tools):
+    subset = known_tools[:3]
+    with install_fake_jupyter_server(known_tools):
+        tool = Jupyter(include=subset)
+        tool.initialize()
+        names = action_names(tool.actions())
+        assert sorted(names) == sorted(subset)
+
+
+def test_missing_upstream_tool_raises_attribute_error(known_tools):
+    missing = known_tools[-1]
+    present = known_tools[:-1]
+    with install_fake_jupyter_server(present):
+        tool = Jupyter()
+        with pytest.raises(AttributeError) as ei:
+            tool.initialize()
+        assert missing in str(ei.value)
+
+
+def test_env_mapping_defaults_and_overrides(monkeypatch, known_tools):
+    defaults = load_env_defaults()
+    with install_fake_jupyter_server(known_tools) as server:
+        for k in ["PROVIDER","DOCUMENT_URL","DOCUMENT_ID","DOCUMENT_TOKEN",
+                  "RUNTIME_URL","RUNTIME_ID","RUNTIME_TOKEN"]:
+            monkeypatch.delenv(k, raising=False)
+        tool = Jupyter()
+        tool.initialize()
+
+        assert server.PROVIDER == defaults.get("provider", "jupyter")
+        assert server.DOCUMENT_URL == defaults.get("document_url", "http://127.0.0.1:8888")
+        assert server.DOCUMENT_ID == defaults.get("document_id", "notebook.ipynb")
+        assert server.RUNTIME_URL == defaults.get("runtime_url") or server.DOCUMENT_URL
+
+    with install_fake_jupyter_server(known_tools) as server:
+        monkeypatch.setenv("PROVIDER", "custom")
+        monkeypatch.setenv("DOCUMENT_URL", "http://10.0.0.1:9999")
+        monkeypatch.setenv("DOCUMENT_ID", "foo.ipynb")
+        monkeypatch.setenv("DOCUMENT_TOKEN", "DOC1234")
+        monkeypatch.setenv("RUNTIME_URL", "http://10.0.0.2:8888")
+        monkeypatch.setenv("RUNTIME_ID", "kernel-abc")
+        monkeypatch.setenv("RUNTIME_TOKEN", "RUN5678")
+
+        tool = Jupyter()
+        tool.initialize()
+
+        assert server.PROVIDER == "custom"
+        assert server.DOCUMENT_URL == "http://10.0.0.1:9999"
+        assert server.DOCUMENT_ID == "foo.ipynb"
+        assert server.DOCUMENT_TOKEN == "DOC1234"
+        assert server.RUNTIME_URL == "http://10.0.0.2:8888"
+        assert server.RUNTIME_ID == "kernel-abc"
+        assert server.RUNTIME_TOKEN == "RUN5678"
+
+
+def test_to_from_dict_roundtrip():
+    src = {"include": ["read_all_cells", "get_notebook_info"]}
+    tool = Jupyter.from_dict(src)
+    assert tool.to_dict() == src

tests/test_jupyter_bindings.py

@@ -0,0 +1,22 @@
+import re
+
+from mcpstack_jupyter.tools.jupyter.cli import JupyterCLI
+from tests.conftest import install_fake_jupyter_server
+
+
+def test_status_warns_when_tools_missing(known_tools, capsys, monkeypatch):
+    present = known_tools[:-1]
+    missing = known_tools[-1]
+    with install_fake_jupyter_server(present):
+        JupyterCLI.status(verbose=False)
+        out = capsys.readouterr().out
+        assert "Missing upstream tools" in out
+        assert missing in out
+
+
+def test_status_verbose_lists_availability(known_tools, capsys):
+    with install_fake_jupyter_server(known_tools):
+        JupyterCLI.status(verbose=True)
+        out = capsys.readouterr().out
+        assert "Upstream Tool Availability" in out
+        assert re.search(r"\byes\b", out, re.IGNORECASE)