Use pytest-jupyter (#891)

* clean up

* bump version

* cleanup

* fix

* fixup

* debug

* bump ipykernel dep

* fix tests

* try to fix windows

* define override earlier

* bump dep

* try to fix windows

* clean up coverage handling

* fix mypy errors

Author: blink1073

.github/workflows/main.yml

@@ -74,7 +74,7 @@ jobs:
           hatch run cov:nowarn || hatch run test:nowarn --lf
       - name: Code coverage
         run: |
-          pip install codecov
+          pip install codecov coverage[toml]
           codecov
 
   docs:
@@ -95,7 +95,7 @@ jobs:
           dependency_type: minimum
       - name: Run the unit tests
         run: |
-          hatch run test:nowarn || hatch run test:nowarn --lf
+          hatch -vv run test:nowarn || hatch run test:nowarn --lf
 
   test_prereleases:
     name: Test Prereleases

jupyter_client/manager.py

@@ -657,20 +657,20 @@ def _context_default(self) -> zmq.asyncio.Context:
         self._created_context = True
         return zmq.asyncio.Context()
 
-    _launch_kernel = KernelManager._async_launch_kernel
-    start_kernel = KernelManager._async_start_kernel
-    pre_start_kernel = KernelManager._async_pre_start_kernel
-    post_start_kernel = KernelManager._async_post_start_kernel
-    request_shutdown = KernelManager._async_request_shutdown
-    finish_shutdown = KernelManager._async_finish_shutdown
-    cleanup_resources = KernelManager._async_cleanup_resources
-    shutdown_kernel = KernelManager._async_shutdown_kernel
-    restart_kernel = KernelManager._async_restart_kernel
-    _send_kernel_sigterm = KernelManager._async_send_kernel_sigterm
-    _kill_kernel = KernelManager._async_kill_kernel
-    interrupt_kernel = KernelManager._async_interrupt_kernel
-    signal_kernel = KernelManager._async_signal_kernel
-    is_alive = KernelManager._async_is_alive
+    _launch_kernel = KernelManager._async_launch_kernel  # type:ignore[assignment]
+    start_kernel = KernelManager._async_start_kernel  # type:ignore[assignment]
+    pre_start_kernel = KernelManager._async_pre_start_kernel  # type:ignore[assignment]
+    post_start_kernel = KernelManager._async_post_start_kernel  # type:ignore[assignment]
+    request_shutdown = KernelManager._async_request_shutdown  # type:ignore[assignment]
+    finish_shutdown = KernelManager._async_finish_shutdown  # type:ignore[assignment]
+    cleanup_resources = KernelManager._async_cleanup_resources  # type:ignore[assignment]
+    shutdown_kernel = KernelManager._async_shutdown_kernel  # type:ignore[assignment]
+    restart_kernel = KernelManager._async_restart_kernel  # type:ignore[assignment]
+    _send_kernel_sigterm = KernelManager._async_send_kernel_sigterm  # type:ignore[assignment]
+    _kill_kernel = KernelManager._async_kill_kernel  # type:ignore[assignment]
+    interrupt_kernel = KernelManager._async_interrupt_kernel  # type:ignore[assignment]
+    signal_kernel = KernelManager._async_signal_kernel  # type:ignore[assignment]
+    is_alive = KernelManager._async_is_alive  # type:ignore[assignment]
 
 
 KernelManagerABC.register(KernelManager)
@@ -699,14 +699,14 @@ async def start_new_async_kernel(
 ) -> t.Tuple[AsyncKernelManager, KernelClient]:
     """Start a new kernel, and return its Manager and Client"""
     km = AsyncKernelManager(kernel_name=kernel_name)
-    await km.start_kernel(**kwargs)
+    await km.start_kernel(**kwargs)  # type:ignore[has-type]
     kc = km.client()
     kc.start_channels()
     try:
         await kc.wait_for_ready(timeout=startup_timeout)  # type:ignore[attr-defined]
     except RuntimeError:
         kc.stop_channels()
-        await km.shutdown_kernel()
+        await km.shutdown_kernel()  # type:ignore[has-type]
         raise
 
     return (km, kc)

jupyter_client/multikernelmanager.py

@@ -562,7 +562,7 @@ def _context_default(self) -> zmq.asyncio.Context:
         self._created_context = True
         return zmq.asyncio.Context()
 
-    start_kernel = MultiKernelManager._async_start_kernel
-    restart_kernel = MultiKernelManager._async_restart_kernel
-    shutdown_kernel = MultiKernelManager._async_shutdown_kernel
-    shutdown_all = MultiKernelManager._async_shutdown_all
+    start_kernel = MultiKernelManager._async_start_kernel  # type:ignore[assignment]
+    restart_kernel = MultiKernelManager._async_restart_kernel  # type:ignore[assignment]
+    shutdown_kernel = MultiKernelManager._async_shutdown_kernel  # type:ignore[assignment]
+    shutdown_all = MultiKernelManager._async_shutdown_all  # type:ignore[assignment]

pyproject.toml

@@ -50,12 +50,12 @@ Homepage = "https://jupyter.org"
 test = [
     "codecov",
     "coverage",
-    "ipykernel>=6.11",
+    "ipykernel>=6.14",
     "mypy",
     "paramiko; sys_platform == 'win32'",
     "pre-commit",
     "pytest",
-    "pytest-asyncio>=0.19",
+    "pytest-jupyter[client]>=0.4.1",
     "pytest-cov",
     "pytest-timeout",
 ]
@@ -92,7 +92,7 @@ nowarn = "test -W default {args}"
 
 [tool.hatch.envs.cov]
 features = ["test"]
-dependencies = ["coverage", "pytest-cov"]
+dependencies = ["coverage[toml]", "pytest-cov"]
 [tool.hatch.envs.cov.scripts]
 test = "python -m pytest -vv --cov jupyter_client --cov-branch --cov-report term-missing:skip-covered {args}"
 nowarn = "test -W default {args}"
@@ -116,7 +116,6 @@ testpaths = [
 timeout = 100
 # Restore this setting to debug failures
 timeout_method = "thread"
-asyncio_mode = "auto"
 filterwarnings= [
   # Fail on warnings
   "error",

tests/conftest.py

@@ -1,78 +1,18 @@
 import asyncio
-import json
 import os
-import sys
-from pathlib import Path
+
+if os.name == "nt":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 import pytest
 
 # Must be set before importing from `jupyter_core`.
 os.environ['JUPYTER_PLATFORM_DIRS'] = '1'
 
-from jupyter_core import paths
-
-from .utils import test_env
-
-try:
-    import resource
-except ImportError:
-    # Windows
-    resource = None
-
-pjoin = os.path.join
-
-
-# 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))
-
-
-if os.name == "nt" and sys.version_info >= (3, 7):
-    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-
-@pytest.fixture
-def event_loop():
-    # Make sure we test against a selector event loop
-    # since pyzmq doesn't like the proactor loop.
-    # This fixture is picked up by pytest-asyncio
-    if os.name == "nt" and sys.version_info >= (3, 7):
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-    loop = asyncio.SelectorEventLoop()
-    try:
-        yield loop
-    finally:
-        loop.close()
+pytest_plugins = ["pytest_jupyter", "pytest_jupyter.jupyter_client"]
 
 
 @pytest.fixture(autouse=True)
-def env():
-    env_patch = test_env()
-    env_patch.start()
-    yield
-    env_patch.stop()
-
-
-@pytest.fixture()
-def kernel_dir():
-    return pjoin(paths.jupyter_data_dir(), 'kernels')
-
-
-@pytest.fixture
-def kernel_spec(tmpdir):
-    test_dir = Path(tmpdir / "test")
-    test_dir.mkdir()
-    kernel_data = {"argv": [], "display_name": "test", "language": "test"}
-    spec_file_path = Path(test_dir / "kernel.json")
-    spec_file_path.write_text(json.dumps(kernel_data), 'utf8')
-    return str(test_dir)
+def setup_environ(jp_environ):
+    pass

tests/test_client.py

@@ -13,10 +13,8 @@
 from traitlets import DottedObjectName
 from traitlets import Type
 
-from .utils import test_env
 from jupyter_client.client import validate_string_dict
 from jupyter_client.kernelspec import KernelSpecManager
-from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
 from jupyter_client.kernelspec import NoSuchKernel
 from jupyter_client.manager import KernelManager
 from jupyter_client.manager import start_new_async_kernel
@@ -31,17 +29,13 @@
 
 class TestKernelClient(TestCase):
     def setUp(self):
-        self.env_patch = test_env()
-        self.env_patch.start()
-        self.addCleanup(self.env_patch.stop)
         try:
-            KernelSpecManager().get_kernel_spec(NATIVE_KERNEL_NAME)
+            KernelSpecManager().get_kernel_spec("echo")
         except NoSuchKernel:
             pytest.skip()
-        self.km, self.kc = start_new_kernel(kernel_name=NATIVE_KERNEL_NAME)
+        self.km, self.kc = start_new_kernel(kernel_name="echo")
 
     def tearDown(self):
-        self.env_patch.stop()
         self.km.shutdown_kernel()
         self.kc.stop_channels()
         return super().tearDown()
@@ -106,25 +100,28 @@ def test_shutdown_id(self):
 
 
 @pytest.fixture
-async def kc():
-    env_patch = test_env()
-    env_patch.start()
+def kc(jp_asyncio_loop):
     try:
-        KernelSpecManager().get_kernel_spec(NATIVE_KERNEL_NAME)
+        KernelSpecManager().get_kernel_spec("echo")
     except NoSuchKernel:
         pytest.skip()
-    km, kc = await start_new_async_kernel(kernel_name=NATIVE_KERNEL_NAME)
+
+    async def start():
+        return await start_new_async_kernel(kernel_name="echo")
+
+    km, kc = jp_asyncio_loop.run_until_complete(start())
     yield kc
-    env_patch.stop()
-    await km.shutdown_kernel()
+
+    async def stop():
+        await km.shutdown_kernel()
+
+    jp_asyncio_loop.run_until_complete(stop())
     kc.stop_channels()
 
 
 class TestAsyncKernelClient:
     async def test_execute_interactive(self, kc):
-        with capture_output() as io:
-            reply = await kc.execute_interactive("print('hello')", timeout=TIMEOUT)
-        assert "hello" in io.stdout
+        reply = await kc.execute_interactive("hello", timeout=TIMEOUT)
         assert reply["content"]["status"] == "ok"
 
     def _check_reply(self, reply_type, reply):
@@ -225,20 +222,16 @@ class CustomThreadedKernelClient(ThreadedKernelClient):
 
 class TestThreadedKernelClient(TestKernelClient):
     def setUp(self):
-        self.env_patch = test_env()
-        self.env_patch.start()
-        self.addCleanup(self.env_patch.stop)
         try:
-            KernelSpecManager().get_kernel_spec(NATIVE_KERNEL_NAME)
+            KernelSpecManager().get_kernel_spec("echo")
         except NoSuchKernel:
             pytest.skip()
-        self.km = km = ThreadedKernelManager(kernel_name=NATIVE_KERNEL_NAME)
+        self.km = km = ThreadedKernelManager(kernel_name="echo")
         km.start_kernel()
         self.kc = kc = km.client()
         kc.start_channels()
 
     def tearDown(self):
-        self.env_patch.stop()
         self.km.shutdown_kernel()
         self.kc.stop_channels()