make unit tests backwards compatible without pending kernels (#669)

Author: Zsailer

.github/workflows/python-linux.yml

@@ -72,7 +72,7 @@ jobs:
           ./test_install/bin/python -m pip install -U pip
           ./test_install/bin/python -m pip install ".[test]"
           pushd test_install
-          ./bin/pytest --pyargs jupyter_server
+          ./bin/pytest --pyargs jupyter_server --capture=no
           popd
       - name: Test the docs
         run: |

jupyter_server/pytest_plugin.py

@@ -476,6 +476,20 @@ def jp_cleanup_subprocesses(jp_serverapp):
     async def _():
         terminal_cleanup = jp_serverapp.web_app.settings["terminal_manager"].terminate_all
         kernel_cleanup = jp_serverapp.kernel_manager.shutdown_all
+
+        async def kernel_cleanup_steps():
+            # Try a graceful shutdown with a timeout
+            try:
+                await asyncio.wait_for(kernel_cleanup(), timeout=15.0)
+            except asyncio.TimeoutError:
+                # Now force a shutdown
+                try:
+                    await asyncio.wait_for(kernel_cleanup(now=True), timeout=15.0)
+                except asyncio.TimeoutError:
+                    print(Exception("Kernel never shutdown!"))
+            except Exception as e:
+                print(e)
+
         if asyncio.iscoroutinefunction(terminal_cleanup):
             try:
                 await terminal_cleanup()
@@ -487,10 +501,7 @@ async def _():
             except Exception as e:
                 print(e)
         if asyncio.iscoroutinefunction(kernel_cleanup):
-            try:
-                await kernel_cleanup()
-            except Exception as e:
-                print(e)
+            await kernel_cleanup_steps()
         else:
             try:
                 kernel_cleanup()

jupyter_server/tests/services/kernels/test_api.py

@@ -12,6 +12,9 @@
 from jupyter_server.utils import url_path_join
 
 
+TEST_TIMEOUT = 20
+
+
 @pytest.fixture
 def pending_kernel_is_ready(jp_serverapp):
     async def _(kernel_id):
@@ -63,6 +66,7 @@ async def test_no_kernels(jp_fetch):
     assert kernels == []
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_default_kernels(jp_fetch, jp_base_url, jp_cleanup_subprocesses):
     r = await jp_fetch("api", "kernels", method="POST", allow_nonstandard_methods=True)
     kernel = json.loads(r.body.decode())
@@ -78,6 +82,7 @@ async def test_default_kernels(jp_fetch, jp_base_url, jp_cleanup_subprocesses):
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_main_kernel_handler(
     jp_fetch, jp_base_url, jp_cleanup_subprocesses, jp_serverapp, pending_kernel_is_ready
 ):
@@ -146,6 +151,7 @@ async def test_main_kernel_handler(
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_kernel_handler(jp_fetch, jp_cleanup_subprocesses, pending_kernel_is_ready):
     # Create a kernel
     r = await jp_fetch(
@@ -193,6 +199,7 @@ async def test_kernel_handler(jp_fetch, jp_cleanup_subprocesses, pending_kernel_
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_kernel_handler_startup_error(
     jp_fetch, jp_cleanup_subprocesses, jp_serverapp, jp_kernelspecs
 ):
@@ -204,6 +211,7 @@ async def test_kernel_handler_startup_error(
         await jp_fetch("api", "kernels", method="POST", body=json.dumps({"name": "bad"}))
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_kernel_handler_startup_error_pending(
     jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses, jp_serverapp, jp_kernelspecs
 ):
@@ -219,6 +227,7 @@ async def test_kernel_handler_startup_error_pending(
         await jp_ws_fetch("api", "kernels", kid, "channels")
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_connection(
     jp_fetch, jp_ws_fetch, jp_http_port, jp_auth_header, jp_cleanup_subprocesses
 ):

jupyter_server/tests/services/kernels/test_cull.py

@@ -89,6 +89,7 @@ async def test_cull_idle(jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses):
         )
     ],
 )
+@pytest.mark.timeout(30)
 async def test_cull_dead(
     jp_fetch, jp_ws_fetch, jp_serverapp, jp_cleanup_subprocesses, jp_kernelspecs
 ):

jupyter_server/tests/services/sessions/test_api.py

@@ -17,6 +17,9 @@
 from jupyter_server.utils import url_path_join
 
 
+TEST_TIMEOUT = 20
+
+
 j = lambda r: json.loads(r.body.decode())
 
 
@@ -142,12 +145,14 @@ def session_is_ready(jp_serverapp):
     """
 
     async def _(session_id):
-        sm = jp_serverapp.session_manager
         mkm = jp_serverapp.kernel_manager
-        session = await sm.get_session(session_id=session_id)
-        kernel_id = session["kernel"]["id"]
-        kernel = mkm.get_kernel(kernel_id)
-        await kernel.ready
+        if getattr(mkm, "use_pending_kernels", False):
+            sm = jp_serverapp.session_manager
+            session = await sm.get_session(session_id=session_id)
+            kernel_id = session["kernel"]["id"]
+            kernel = mkm.get_kernel(kernel_id)
+            if getattr(kernel, "ready"):
+                await kernel.ready
 
     return _
 
@@ -195,9 +200,8 @@ def assert_session_equality(actual, expected):
     assert_kernel_equality(actual["kernel"], expected["kernel"])
 
 
-async def test_create(
-    session_client, jp_base_url, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
-):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_create(session_client, jp_base_url, jp_cleanup_subprocesses, jp_serverapp):
     # Make sure no sessions exist.
     resp = await session_client.list()
     sessions = j(resp)
@@ -241,6 +245,7 @@ async def test_create(
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_create_bad(
     session_client, jp_base_url, jp_cleanup_subprocesses, jp_serverapp, jp_kernelspecs
 ):
@@ -261,6 +266,7 @@ async def test_create_bad(
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_create_bad_pending(
     session_client, jp_base_url, jp_ws_fetch, jp_cleanup_subprocesses, jp_serverapp, jp_kernelspecs
 ):
@@ -293,25 +299,36 @@ async def test_create_bad_pending(
     await jp_cleanup_subprocesses()
 
 
-async def test_create_file_session(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_create_file_session(
+    session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/nb1.py", type="file")
     assert resp.code == 201
     newsession = j(resp)
     assert newsession["path"] == "foo/nb1.py"
     assert newsession["type"] == "file"
+    sid = newsession["id"]
+    await session_is_ready(sid)
     await jp_cleanup_subprocesses()
 
 
-async def test_create_console_session(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_create_console_session(
+    session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/abc123", type="console")
     assert resp.code == 201
     newsession = j(resp)
     assert newsession["path"] == "foo/abc123"
     assert newsession["type"] == "console"
     # Need to find a better solution to this.
+    sid = newsession["id"]
+    await session_is_ready(sid)
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_create_deprecated(session_client, jp_cleanup_subprocesses, jp_serverapp):
     resp = await session_client.create_deprecated("foo/nb1.ipynb")
     assert resp.code == 201
@@ -320,9 +337,11 @@ async def test_create_deprecated(session_client, jp_cleanup_subprocesses, jp_ser
     assert newsession["type"] == "notebook"
     assert newsession["notebook"]["path"] == "foo/nb1.ipynb"
     # Need to find a better solution to this.
+    sid = newsession["id"]
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_create_with_kernel_id(
     session_client, jp_fetch, jp_base_url, jp_cleanup_subprocesses, jp_serverapp
 ):
@@ -354,16 +373,23 @@ async def test_create_with_kernel_id(
     await jp_cleanup_subprocesses()
 
 
-async def test_create_with_bad_kernel_id(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_create_with_bad_kernel_id(
+    session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/nb1.py", type="file")
     assert resp.code == 201
     newsession = j(resp)
+    sid = newsession["id"]
+    await session_is_ready(sid)
+
     # TODO
     assert newsession["path"] == "foo/nb1.py"
     assert newsession["type"] == "file"
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_delete(session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready):
     resp = await session_client.create("foo/nb1.ipynb")
 
@@ -385,10 +411,12 @@ async def test_delete(session_client, jp_cleanup_subprocesses, jp_serverapp, ses
     await jp_cleanup_subprocesses()
 
 
-async def test_modify_path(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_modify_path(session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready):
     resp = await session_client.create("foo/nb1.ipynb")
     newsession = j(resp)
     sid = newsession["id"]
+    await session_is_ready(sid)
 
     resp = await session_client.modify_path(sid, "nb2.ipynb")
     changed = j(resp)
@@ -398,10 +426,14 @@ async def test_modify_path(session_client, jp_cleanup_subprocesses, jp_serverapp
     await jp_cleanup_subprocesses()
 
 
-async def test_modify_path_deprecated(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_modify_path_deprecated(
+    session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/nb1.ipynb")
     newsession = j(resp)
     sid = newsession["id"]
+    await session_is_ready(sid)
 
     resp = await session_client.modify_path_deprecated(sid, "nb2.ipynb")
     changed = j(resp)
@@ -411,10 +443,12 @@ async def test_modify_path_deprecated(session_client, jp_cleanup_subprocesses, j
     await jp_cleanup_subprocesses()
 
 
-async def test_modify_type(session_client, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_modify_type(session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready):
     resp = await session_client.create("foo/nb1.ipynb")
     newsession = j(resp)
     sid = newsession["id"]
+    await session_is_ready(sid)
 
     resp = await session_client.modify_type(sid, "console")
     changed = j(resp)
@@ -424,10 +458,14 @@ async def test_modify_type(session_client, jp_cleanup_subprocesses, jp_serverapp
     await jp_cleanup_subprocesses()
 
 
-async def test_modify_kernel_name(session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_modify_kernel_name(
+    session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/nb1.ipynb")
     before = j(resp)
     sid = before["id"]
+    await session_is_ready(sid)
 
     resp = await session_client.modify_kernel_name(sid, before["kernel"]["name"])
     after = j(resp)
@@ -448,10 +486,14 @@ async def test_modify_kernel_name(session_client, jp_fetch, jp_cleanup_subproces
     await jp_cleanup_subprocesses()
 
 
-async def test_modify_kernel_id(session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp):
+@pytest.mark.timeout(TEST_TIMEOUT)
+async def test_modify_kernel_id(
+    session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp, session_is_ready
+):
     resp = await session_client.create("foo/nb1.ipynb")
     before = j(resp)
     sid = before["id"]
+    await session_is_ready(sid)
 
     # create a new kernel
     resp = await jp_fetch("api/kernels", method="POST", allow_nonstandard_methods=True)
@@ -479,8 +521,9 @@ async def test_modify_kernel_id(session_client, jp_fetch, jp_cleanup_subprocesse
     await jp_cleanup_subprocesses()
 
 
+@pytest.mark.timeout(TEST_TIMEOUT)
 async def test_restart_kernel(
-    session_client, jp_base_url, jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses
+    session_client, jp_base_url, jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses, session_is_ready
 ):
     # Create a session.
     resp = await session_client.create("foo/nb1.ipynb")
@@ -492,6 +535,8 @@ async def test_restart_kernel(
     assert resp.headers["Location"] == url_path_join(
         jp_base_url, "/api/sessions/", new_session["id"]
     )
+    sid = new_session["id"]
+    await session_is_ready(sid)
 
     kid = new_session["kernel"]["id"]
 

setup.cfg

@@ -50,6 +50,7 @@ test =
     pytest>=6.0
     pytest-cov
     pytest-mock
+    pytest-timeout
     requests
     pytest-tornasync
     pytest-console-scripts