Add client plugin and echo kernel (#20)

Author: blink1073

README.md

@@ -2,6 +2,9 @@
 
 A set of pytest plugins for Jupyter libraries and extensions.
 
+[![Build Status](https://github.com/jupyter-server/pytest-jupyter/actions/workflows/test.yml/badge.svg?query=branch%3Amain++)](https://github.com/jupyter-server/pytest-jupyter/actions/workflows/test.yml/badge.svg?query=branch%3Amain++)
+[![codecov](https://codecov.io/gh/jupyter-server/pytest-jupyter/branch/main/graph/badge.svg?token=2MY8C1A777)](https://codecov.io/gh/jupyter-server/pytest-jupyter)
+
 ## Basic Usage
 
 First, install `pytest-jupyter` from PyPI using pip:

pyproject.toml

@@ -37,11 +37,11 @@ docs = [
     "Sphinx",
 ]
 client = [
-    "jupyter_client>=7.4.0"
+    "jupyter_client>=7.4.0",
+    "ipykernel>=6.14",
 ]
 server = [
     "jupyter_server>=1.21",
-    "ipykernel>=6.14",
     "nbformat>=5.3",
     "pytest-tornasync>=0.6"
 ]
@@ -54,6 +54,7 @@ Homepage = "http://jupyter.org"
 
 [tool.hatch.version]
 path = "pytest_jupyter/_version.py"
+validate-bump = false
 
 [tool.hatch.build.targets.sdist]
 include = [
@@ -74,23 +75,28 @@ nowarn = "test -W default {args}"
 
 [tool.hatch.envs.cov]
 features = ["test", "server", "client"]
-dependencies = ["coverage", "pytest-cov"]
+dependencies = ["coverage[toml]"]
 [tool.hatch.envs.cov.scripts]
-test = "python -m pytest -vv --cov pytest_jupyter --cov-branch --cov-report term-missing:skip-covered {args}"
+test = "coverage run -m pytest {args}"
 nowarn = "test -W default {args}"
 
+[tool.jupyter-releaser.options]
+post-version-spec = "dev"
+
 [tool.pytest.ini_options]
 addopts = "-raXs --durations 10 --color=yes --doctest-modules"
 testpaths = [
     "tests"
 ]
 asyncio_mode = "auto"
-timeout = 30
+timeout = 10
 # Restore this setting to debug failures
-#timeout_method = "thread"
+timeout_method = "thread"
 filterwarnings= [
   # Fail on warnings
   "error",
+  # TODO: from jupyter_server
+  "always:unclosed <socket.socket:ResourceWarning",
 ]
 
 [tool.coverage.report]

pytest_jupyter/__init__.py

@@ -1,4 +1,12 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 
+import asyncio
+import os
+
 from .jupyter_core import *  # noqa
+
+if os.name == "nt":
+    asyncio.set_event_loop_policy(
+        asyncio.WindowsSelectorEventLoopPolicy()  # type:ignore[attr-defined]
+    )

pytest_jupyter/echo_kernel.py

@@ -0,0 +1,53 @@
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import logging
+
+from ipykernel.kernelapp import IPKernelApp
+from ipykernel.kernelbase import Kernel
+
+
+class EchoKernel(Kernel):
+    implementation = "Echo"
+    implementation_version = "1.0"
+    language = "echo"
+    language_version = "0.1"
+    language_info = {
+        "name": "echo",
+        "mimetype": "text/plain",
+        "file_extension": ".txt",
+    }
+    banner = "Echo kernel - as useful as a parrot"
+
+    def do_execute(
+        self, code, silent, store_history=True, user_expressions=None, allow_stdin=False
+    ):
+        if not silent:
+            stream_content = {"name": "stdout", "text": code}
+            self.send_response(self.iopub_socket, "stream", stream_content)
+
+            # Send a input_request if code contains input command.
+            if allow_stdin and code and code.find("input(") != -1:
+                self._input_request(
+                    "Echo Prompt",
+                    self._parent_ident["shell"],
+                    self.get_parent(channel="shell"),
+                    password=False,
+                )
+
+        return {
+            "status": "ok",
+            # The base class increments the execution count
+            "execution_count": self.execution_count,
+            "payload": [],
+            "user_expressions": {},
+        }
+
+
+class EchoKernelApp(IPKernelApp):
+    kernel_class = EchoKernel
+
+
+if __name__ == "__main__":
+    logging.disable(logging.ERROR)
+    EchoKernelApp.launch_instance()

pytest_jupyter/jupyter_client.py

@@ -0,0 +1,89 @@
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+from jupyter_core import paths
+
+try:
+    import ipykernel  # noqa
+    from jupyter_client.manager import start_new_async_kernel
+except ImportError:
+    import warnings
+
+    warnings.warn(
+        "The client plugin has not been installed. "
+        "If you're trying to use this plugin and you've installed "
+        "`pytest-jupyter`, there is likely one more step "
+        "you need. Try: `pip install 'pytest-jupyter[client]'`"
+    )
+
+try:
+    import resource
+except ImportError:
+    # Windows
+    resource = None  # type: ignore
+
+
+# Handle resource limit
+# Ensure a minimal soft limit of DEFAULT_SOFT if the current hard limit is at least that much.
+if resource is not None:
+    soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+
+    DEFAULT_SOFT = 4096
+    if hard >= DEFAULT_SOFT:
+        soft = DEFAULT_SOFT
+
+    if hard < soft:
+        hard = soft
+
+    resource.setrlimit(resource.RLIMIT_NOFILE, (soft, hard))
+
+
+@pytest.fixture
+def zmq_context():
+    import zmq
+
+    ctx = zmq.asyncio.Context()
+    yield ctx
+    ctx.term()
+
+
+@pytest.fixture
+async def start_kernel(kernel_spec):
+    km = None
+    kc = None
+
+    async def inner(kernel_name="echo", **kwargs):
+        nonlocal km, kc
+        km, kc = await start_new_async_kernel(kernel_name=kernel_name, **kwargs)
+        return km, kc
+
+    yield inner
+
+    if kc and km:
+        kc.stop_channels()
+        await km.shutdown_kernel(now=True)
+        assert km.context.closed
+        km.context.destroy()
+        km.context.term()
+
+
+@pytest.fixture()
+def kernel_dir():
+    return os.path.join(paths.jupyter_data_dir(), "kernels")
+
+
+@pytest.fixture
+def kernel_spec(kernel_dir):
+    test_dir = Path(kernel_dir) / "echo"
+    test_dir.mkdir(parents=True, exist_ok=True)
+    argv = [sys.executable, "-m", "pytest_jupyter.echo_kernel", "-f", "{connection_file}"]
+    kernel_data = {"argv": argv, "display_name": "echo", "language": "echo"}
+    spec_file_path = Path(test_dir / "kernel.json")
+    spec_file_path.write_text(json.dumps(kernel_data), "utf8")
+    return str(test_dir)

pytest_jupyter/jupyter_server.py

@@ -45,6 +45,7 @@
     )
 
 
+from .jupyter_client import kernel_spec  # noqa
 from .utils import mkdir
 
 # List of dependencies needed for this plugin.
@@ -190,6 +191,7 @@ def jp_configurable_serverapp(
     jp_logging_stream,
     asyncio_loop,
     io_loop,
+    kernel_spec,  # noqa
 ):
     """Starts a Jupyter Server instance based on
     the provided configuration values.
@@ -249,7 +251,6 @@ def _configurable_serverapp(
             allow_root=True,
             **kwargs,
         )
-
         app.init_signal = lambda: None
         app.log.propagate = True
         app.log.handlers = []
@@ -410,6 +411,8 @@ def jp_server_cleanup(asyncio_loop):
         asyncio_loop.run_until_complete(app._cleanup())
     except (RuntimeError, SystemExit) as e:
         print("ignoring cleanup error", e)
+    if hasattr(app, "kernel_manager"):
+        app.kernel_manager.context.destroy()
     ServerApp.clear_instance()
 
 

tests/conftest.py

@@ -1,4 +1,8 @@
 import os
 
 os.environ["JUPYTER_PLATFORM_DIRS"] = "1"
-pytest_plugins = ["pytest_jupyter", "pytest_jupyter.jupyter_server"]
+pytest_plugins = [
+    "pytest_jupyter",
+    "pytest_jupyter.jupyter_server",
+    "pytest_jupyter.jupyter_client",
+]

tests/test_jupyter_client.py

@@ -0,0 +1,22 @@
+from unittest.mock import Mock
+
+from jupyter_client.session import Session
+
+from pytest_jupyter.echo_kernel import EchoKernel
+
+
+def test_zmq_context(zmq_context):
+    assert isinstance(zmq_context.underlying, int)
+
+
+async def test_start_kernel(start_kernel):
+    km, kc = await start_kernel()
+    assert km.kernel_name == "echo"
+    msg = await kc.execute("hello", reply=True)
+    assert msg["content"]["status"] == "ok"
+
+
+def test_echo_kernel():
+    kernel = EchoKernel()
+    kernel.session = Mock(spec=Session)
+    kernel.do_execute("foo", False)

tests/test_jupyter_server.py

@@ -2,7 +2,6 @@
 import os
 from unittest.mock import MagicMock
 
-from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
 from jupyter_server.auth import Authorizer
 from jupyter_server.serverapp import ServerApp
 from tornado.websocket import WebSocketHandler
@@ -24,9 +23,7 @@ async def test_send_request(send_request):
 
 async def test_connection(jp_fetch, jp_ws_fetch, jp_http_port, jp_auth_header):
     # Create kernel
-    r = await jp_fetch(
-        "api", "kernels", method="POST", body=json.dumps({"name": NATIVE_KERNEL_NAME})
-    )
+    r = await jp_fetch("api", "kernels", method="POST", body=json.dumps({"name": "echo"}))
     kid = json.loads(r.body.decode())["id"]
 
     # Get kernel info