Fix tests and coverage

Author: fleming79

.github/workflows/ci.yml

@@ -49,7 +49,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - name: Run tests with coverage
-        run: uv run pytest -vv --cov
+        run: uv run pytest -vv --cov --cov-fail-under=100
 
   pre-commit:
     runs-on: ubuntu-latest

.vscode/settings.json

@@ -18,5 +18,5 @@
     "tag:yaml.org,2002:python/object/apply:pymdownx.slugs.slugify mapping"
   ],
   "spellright.language": ["en"],
-  "spellright.documentTypes": ["markdown", "latex", "plaintext", "python"]
+  "spellright.documentTypes": ["markdown", "latex", "plaintext"]
 }

src/async_kernel/kernel.py

@@ -605,8 +605,9 @@ async def handle_message_request(self, job: Job, /) -> None:
         try:
             msg_type = MsgType(job["msg"]["header"]["msg_type"])
             socket_id = job["socket_id"]
-            handler = self.get_handler(socket_id, msg_type)
+            handler = self.get_handler(msg_type)
         except (ValueError, TypeError):
+            self.log.debug("Invalid job %s", job)
             return
         run_mode = self.get_run_mode(msg_type, socket_id=socket_id, job=job)
         self.log.debug("%s  %s run mode %s handler: %s", socket_id, msg_type, run_mode, handler)
@@ -702,9 +703,9 @@ def all_concurrency_run_modes(
         data_ = zip(*data, strict=True)
         return dict(zip(["SocketID", "KernelConcurrencyMode", "MsgType", "RunMode"], data_, strict=True))
 
-    def get_handler(self, socket_id: SocketID, msg_type: MsgType) -> HandlerType:
+    def get_handler(self, msg_type: MsgType) -> HandlerType:
         if not callable(f := getattr(self, msg_type, None)):
-            msg = "A handler was not found for "
+            msg = f"A handler was not found for {msg_type=}"
             raise TypeError(msg)
         return f  # pyright: ignore[reportReturnType]
 
@@ -778,11 +779,11 @@ def topic(self, topic) -> bytes:
         """prefixed topic for IOPub messages"""
         return (f"kernel.{topic}").encode()
 
-    async def kernel_info_request(self, job: Job[Content]) -> Content:
+    async def kernel_info_request(self, job: Job[Content], /) -> Content:
         """Handle a ke[rnel info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-info)."""
         return self.kernel_info
 
-    async def comm_info_request(self, job: Job[Content]) -> Content:
+    async def comm_info_request(self, job: Job[Content], /) -> Content:
         """Handle a [comm info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-info)."""
         c = job["msg"]["content"]
         target_name = c.get("target_name", None)
@@ -793,7 +794,7 @@ async def comm_info_request(self, job: Job[Content]) -> Content:
         }
         return {"comms": comms}
 
-    async def execute_request(self, job: Job[ExecuteContent]) -> Content:
+    async def execute_request(self, job: Job[ExecuteContent], /) -> Content:
         """Handle a [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
         c = job["msg"]["content"]
         if (
@@ -857,7 +858,7 @@ async def execute_request(self, job: Job[ExecuteContent]) -> Content:
                     self._stop_on_error_time = time.monotonic()
         return content
 
-    async def complete_request(self, job: Job[Content]) -> Content:
+    async def complete_request(self, job: Job[Content], /) -> Content:
         """Handle a [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
         c = job["msg"]["content"]
         code: str = c["code"]
@@ -883,15 +884,15 @@ async def complete_request(self, job: Job[Content]) -> Content:
             "metadata": {"_jupyter_types_experimental": comps},
         }
 
-    async def is_complete_request(self, job: Job[Content]) -> Content:
+    async def is_complete_request(self, job: Job[Content], /) -> Content:
         """Handle a [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
         status, indent_spaces = self.shell.input_transformer_manager.check_complete(job["msg"]["content"]["code"])
         content = {"status": status}
         if status == "incomplete":
             content["indent"] = " " * indent_spaces
         return content
 
-    async def inspect_request(self, job: Job[Content]) -> Content:
+    async def inspect_request(self, job: Job[Content], /) -> Content:
         """Handle a [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
         c = job["msg"]["content"]
         detail_level = int(c.get("detail_level", 0))
@@ -910,7 +911,7 @@ async def inspect_request(self, job: Job[Content]) -> Content:
             content["found"] = False
         return content
 
-    async def history_request(self, job: Job[Content]) -> Content:
+    async def history_request(self, job: Job[Content], /) -> Content:
         """Handle a [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
         c = job["msg"]["content"]
         history_manager = self.shell.history_manager
@@ -929,19 +930,19 @@ async def history_request(self, job: Job[Content]) -> Content:
             hist = []
         return {"history": list(hist)}
 
-    async def comm_open(self, job: Job[Content]) -> None:
+    async def comm_open(self, job: Job[Content], /) -> None:
         """Handle a [comm open request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#opening-a-comm)."""
         self.comm_manager.comm_open(stream=job["socket"], ident=job["ident"], msg=job["msg"])  # pyright: ignore[reportArgumentType]
 
-    async def comm_msg(self, job: Job[Content]) -> None:
+    async def comm_msg(self, job: Job[Content], /) -> None:
         """Handle a [comm msg request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-messages)."""
         self.comm_manager.comm_msg(stream=job["socket"], ident=job["ident"], msg=job["msg"])  # pyright: ignore[reportArgumentType]
 
-    async def comm_close(self, job: Job[Content]) -> None:
+    async def comm_close(self, job: Job[Content], /) -> None:
         """Handle a [comm close request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#tearing-down-comms)."""
         self.comm_manager.comm_close(stream=job["socket"], ident=job["ident"], msg=job["msg"])  # pyright: ignore[reportArgumentType]
 
-    async def interrupt_request(self, job: Job[Content]) -> Content:
+    async def interrupt_request(self, job: Job[Content], /) -> Content:
         """Handle a [interrupt request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-interrupt) (control only)."""
         self._interrupt_requested = True
         if sys.platform == "win32":
@@ -953,13 +954,13 @@ async def interrupt_request(self, job: Job[Content]) -> Content:
             interrupter()
         return {}
 
-    async def shutdown_request(self, job: Job[Content]) -> Content:
+    async def shutdown_request(self, job: Job[Content], /) -> Content:
         """Handle a [shutdown request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-shutdown) (control only)."""
         await self.debugger.disconnect()
         Caller().call_no_context(self.stop)
         return {"status": "ok", "restart": job["msg"]["content"].get("restart", False)}
 
-    async def debug_request(self, job: Job[Content]) -> Content:
+    async def debug_request(self, job: Job[Content], /) -> Content:
         """Handle a [debug request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#debug-request) (control only)."""
         return await self.debugger.process_request(job["msg"]["content"])
 

tests/conftest.py

@@ -32,7 +32,6 @@
 @pytest.hookimpl
 def pytest_configure(config):
     os.environ["PYTEST_TIMEOUT"] = str(1e6) if async_kernel.utils.LAUNCHED_BY_DEBUGPY else str(utils.TIMEOUT)
-    os.environ["MPLBACKEND"] = utils.MATPLOTLIB_INLINE_BACKEND
 
 
 @pytest.fixture(scope="module")
@@ -52,6 +51,7 @@ async def kernel(anyio_backend, transport: str, tmp_path_factory):
     os.environ["IPYTHONDIR"] = str(tmp_path_factory.mktemp("ipython_config"))
     kernel = Kernel()
     kernel.connection_file = str(connection_file.resolve())
+    os.environ["MPLBACKEND"] = utils.MATPLOTLIB_INLINE_BACKEND  # Set this implicitly
     kernel.transport = transport
     async with kernel.start_in_context():
         yield kernel

tests/test_debugger.py

@@ -68,6 +68,9 @@ async def test_debugger(subprocess_kernels_client):
     assert reply["status"] == "ok"
     assert reply["success"]
 
+    reply = await send_debug_request(client, "configurationDone")
+    assert reply["status"] == "ok"
+
     # Debugger needs to be stopped on a breakpoint
     # The steps below expect the 'debugger' to be in a various state (stopped or running)
     code = """

tests/test_kernel.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import inspect
 import logging
 import pathlib
 import threading
@@ -349,14 +350,16 @@ async def test_interrupt_request_blocking_exec_request(subprocess_kernels_client
 
 
 async def test_interrupt_request_blocking_task(subprocess_kernels_client):
-    code = f"""
-    {RunMode.task}
-    time.sleep(100)
+    code = """
+    import time
+    from async_kernel import Caller
+    await Caller().call_soon(time.sleep, 100)
     """
     client = subprocess_kernels_client
     msg_id = client.execute(code, reply=False)
     await utils.check_pub_message(client, msg_id, execution_state="busy")
     await utils.check_pub_message(client, msg_id, msg_type="execute_input")
+    await anyio.sleep(0.2)
     for _ in range(2):  # Blocking calls in tasks need to be interrupted twice
         await utils.send_control_message(client, MsgType.interrupt_request)
     reply = await utils.get_reply(client, msg_id)
@@ -509,6 +512,18 @@ async def test_invalid_message(client, channel):
     await utils.clear_iopub(client)
 
 
+async def test_kernel_get_handler(kernel: Kernel):
+    with pytest.raises(TypeError):
+        kernel.get_handler("invalid mode")  # pyright: ignore[reportArgumentType]
+    for msg_type in MsgType:
+        handler = kernel.get_handler(msg_type)
+        assert inspect.iscoroutinefunction(handler)
+        sig = inspect.signature(handler)
+        assert len(sig.parameters) == 1
+        param = sig.parameters["job"]
+        assert param.kind == param.POSITIONAL_ONLY
+
+
 @pytest.mark.parametrize(
     ("code", "silent", "socket_id", "expected"),
     [