Refactor fixtures (#26)

Author: blink1073

pytest_jupyter/__init__.py

@@ -1,12 +1,4 @@
 # 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/jupyter_client.py

@@ -1,13 +1,7 @@
 # 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
@@ -22,32 +16,12 @@
         "you need. Try: `pip install 'pytest-jupyter[client]'`"
     )
 
+# Bring in core plugins.
 from pytest_jupyter import *  # noqa
 
-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():
+def jp_zmq_context():
     import zmq
 
     ctx = zmq.asyncio.Context()
@@ -56,7 +30,7 @@ def zmq_context():
 
 
 @pytest.fixture
-def start_kernel(echo_kernel_spec, asyncio_loop):
+def jp_start_kernel(jp_environ, jp_asyncio_loop):
     kms = []
     kcs = []
 
@@ -72,21 +46,5 @@ async def inner(kernel_name="echo", **kwargs):
         kc.stop_channels()
 
     for km in kms:
-        asyncio_loop.run_until_complete(km.shutdown_kernel(now=True))
+        jp_asyncio_loop.run_until_complete(km.shutdown_kernel(now=True))
         assert km.context.closed
-
-
-@pytest.fixture()
-def kernel_dir():
-    return os.path.join(paths.jupyter_data_dir(), "kernels")
-
-
-@pytest.fixture
-def echo_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_core.py

@@ -1,13 +1,67 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
+import asyncio
+import json
 import os
 import sys
+from pathlib import Path
 
 import jupyter_core
 import pytest
 
 from .utils import mkdir
 
+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))
+
+
+if os.name == "nt":
+    asyncio.set_event_loop_policy(
+        asyncio.WindowsSelectorEventLoopPolicy()  # type:ignore[attr-defined]
+    )
+
+
+@pytest.fixture
+def jp_asyncio_loop():
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    yield loop
+    loop.close()
+
+
+@pytest.fixture(autouse=True)
+def io_loop(jp_asyncio_loop):
+    """Override the io_loop for pytest_tornasync.  This is a no-op
+    if tornado is not installed."""
+
+    async def get_tornado_loop():
+        try:
+            from tornado.ioloop import IOLoop
+
+            return IOLoop.current()
+        except ImportError:
+            pass
+
+    return jp_asyncio_loop.run_until_complete(get_tornado_loop())
+
 
 @pytest.fixture
 def jp_home_dir(tmp_path):
@@ -57,6 +111,22 @@ def jp_env_config_path(tmp_path):
     return mkdir(tmp_path, "env", "etc", "jupyter")
 
 
+@pytest.fixture()
+def jp_kernel_dir(jp_data_dir):
+    return mkdir(jp_data_dir, "kernels")
+
+
+@pytest.fixture
+def echo_kernel_spec(jp_kernel_dir):
+    test_dir = Path(jp_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.fixture
 def jp_environ(
     monkeypatch,
@@ -65,6 +135,7 @@ def jp_environ(
     jp_data_dir,
     jp_config_dir,
     jp_runtime_dir,
+    echo_kernel_spec,
     jp_system_jupyter_path,
     jp_system_config_path,
     jp_env_jupyter_path,

pytest_jupyter/jupyter_server.py

@@ -1,7 +1,6 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import asyncio
 import importlib
 import io
 import logging
@@ -45,26 +44,17 @@
     )
 
 
+# Bring in core plugins.
+from pytest_jupyter import *  # noqa
 from pytest_jupyter.utils import mkdir
 
 # List of dependencies needed for this plugin.
-pytest_plugins = ["pytest_tornasync", "pytest_jupyter.jupyter_client"]
+pytest_plugins = ["pytest_tornasync"]
 
 
-@pytest.fixture
-def asyncio_loop():
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    yield loop
-    loop.close()
-
-
-@pytest.fixture(autouse=True)
-def io_loop(asyncio_loop):
-    async def get_tornado_loop():
-        return tornado.ioloop.IOLoop.current()
-
-    return asyncio_loop.run_until_complete(get_tornado_loop())
+# Override some of the fixtures from pytest_tornasync
+# The io_loop fixture is overidden in jupyter_core.py so it
+# can be shared by other plugins that need it (e.g. jupyter_client.py).
 
 
 @pytest.fixture
@@ -100,6 +90,9 @@ async def get_server():
     http_server_port[0].close()
 
 
+# End pytest_tornasync overrides
+
+
 @pytest.fixture
 def jp_server_config():
     """Allows tests to setup their specific configuration values."""
@@ -132,19 +125,19 @@ def jp_argv():
     return []
 
 
-@pytest.fixture
-def jp_extension_environ(jp_env_config_path, monkeypatch):
-    """Monkeypatch a Jupyter Extension's config path into each test's environment variable"""
-    monkeypatch.setattr(serverextension, "ENV_CONFIG_PATH", [str(jp_env_config_path)])
-
-
-@pytest.fixture
+@pytest.fixture()
 def jp_http_port(http_server_port):
     """Returns the port value from the http_server_port fixture."""
     yield http_server_port[-1]
     http_server_port[0].close()
 
 
+@pytest.fixture
+def jp_extension_environ(jp_env_config_path, monkeypatch):
+    """Monkeypatch a Jupyter Extension's config path into each test's environment variable"""
+    monkeypatch.setattr(serverextension, "ENV_CONFIG_PATH", [str(jp_env_config_path)])
+
+
 @pytest.fixture
 def jp_nbconvert_templates(jp_data_dir):
     """Setups up a temporary directory consisting of the nbconvert templates."""
@@ -192,9 +185,8 @@ def jp_configurable_serverapp(
     tmp_path,
     jp_root_dir,
     jp_logging_stream,
-    asyncio_loop,
+    jp_asyncio_loop,
     io_loop,
-    echo_kernel_spec,  # noqa
 ):
     """Starts a Jupyter Server instance based on
     the provided configuration values.
@@ -261,14 +253,14 @@ def _configurable_serverapp(
         app.log.propagate = True
         app.log.handlers = []
         # Initialize app without httpserver
-        if asyncio_loop.is_running():
+        if jp_asyncio_loop.is_running():
             app.initialize(argv=argv, new_httpserver=False)
         else:
 
             async def initialize_app():
                 app.initialize(argv=argv, new_httpserver=False)
 
-            asyncio_loop.run_until_complete(initialize_app())
+            jp_asyncio_loop.run_until_complete(initialize_app())
         # Reroute all logging StreamHandlers away from stdin/stdout since pytest hijacks
         # these streams and closes them at unfortunate times.
         stream_handlers = [h for h in app.log.handlers if isinstance(h, logging.StreamHandler)]
@@ -410,11 +402,11 @@ def inner(nbpath):
 
 
 @pytest.fixture(autouse=True)
-def jp_server_cleanup(asyncio_loop):
+def jp_server_cleanup(jp_asyncio_loop):
     yield
     app: ServerApp = ServerApp.instance()
     try:
-        asyncio_loop.run_until_complete(app._cleanup())
+        jp_asyncio_loop.run_until_complete(app._cleanup())
     except (RuntimeError, SystemExit) as e:
         print("ignoring cleanup error", e)
     if hasattr(app, "kernel_manager"):

tests/test_jupyter_client.py

@@ -5,17 +5,17 @@
 from pytest_jupyter.echo_kernel import EchoKernel
 
 
-def test_zmq_context(zmq_context):
-    assert isinstance(zmq_context.underlying, int)
+def test_zmq_context(jp_zmq_context):
+    assert isinstance(jp_zmq_context.underlying, int)
 
 
-async def test_start_kernel(start_kernel):
-    km, kc = await start_kernel()
+async def test_start_kernel(jp_start_kernel):
+    km, kc = await jp_start_kernel()
     assert km.kernel_name == "echo"
     msg = await kc.execute("hello", reply=True)
     assert msg["content"]["status"] == "ok"
 
-    km, kc = await start_kernel("python3")
+    km, kc = await jp_start_kernel("python3")
     assert km.kernel_name == "python3"
     msg = await kc.execute("print('hi')", reply=True)
     assert msg["content"]["status"] == "ok"