From a48e2f52f6f73e5baf795d781421540ce026b71f Mon Sep 17 00:00:00 2001 From: Steven Silvester Date: Tue, 26 Apr 2022 06:53:31 -0500 Subject: [PATCH] restore pytest settings and remove usages of jp_cleanup_subprocesses --- jupyter_server/pytest_plugin.py | 2 +- pyproject.toml | 4 +- tests/auth/test_authorizer.py | 3 -- tests/services/kernels/test_api.py | 22 +++----- tests/services/kernels/test_cull.py | 8 +-- tests/services/sessions/test_api.py | 82 +++++------------------------ tests/test_terminal.py | 22 +++----- 7 files changed, 31 insertions(+), 112 deletions(-) diff --git a/jupyter_server/pytest_plugin.py b/jupyter_server/pytest_plugin.py index 8ee6d0a582..6208929a84 100644 --- a/jupyter_server/pytest_plugin.py +++ b/jupyter_server/pytest_plugin.py @@ -482,7 +482,7 @@ def jp_server_cleanup(io_loop): @pytest.fixture def jp_cleanup_subprocesses(jp_serverapp): - """Clean up subprocesses started by a Jupyter Server, i.e. kernels and terminal.""" + """DEPRECATED: The jp_server_cleanup fixture automatically cleans up the singleton ServerApp class""" async def _(): pass diff --git a/pyproject.toml b/pyproject.toml index 7f06de0077..6c549dda5b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,9 +13,9 @@ addopts = "-raXs --durations 10 --color=yes --doctest-modules" testpaths = [ "tests/" ] -timeout = 30 +timeout = 300 # Restore this setting to debug failures -timeout_method = "thread" +# timeout_method = "thread" filterwarnings = [ "error", "ignore:There is no current event loop:DeprecationWarning", diff --git a/tests/auth/test_authorizer.py b/tests/auth/test_authorizer.py index 096437b47a..1fc694d3c4 100644 --- a/tests/auth/test_authorizer.py +++ b/tests/auth/test_authorizer.py @@ -205,7 +205,6 @@ async def test_authorized_requests( send_request, tmp_path, jp_serverapp, - jp_cleanup_subprocesses, method, url, body, @@ -275,5 +274,3 @@ async def test_authorized_requests( code = await send_request(url, body=body, method=method) assert code in expected_codes - - await jp_cleanup_subprocesses() diff --git a/tests/services/kernels/test_api.py b/tests/services/kernels/test_api.py index bb91a588e4..058fc4aad9 100644 --- a/tests/services/kernels/test_api.py +++ b/tests/services/kernels/test_api.py @@ -67,7 +67,7 @@ async def test_no_kernels(jp_fetch): @pytest.mark.timeout(TEST_TIMEOUT) -async def test_default_kernels(jp_fetch, jp_base_url, jp_cleanup_subprocesses): +async def test_default_kernels(jp_fetch, jp_base_url): r = await jp_fetch("api", "kernels", method="POST", allow_nonstandard_methods=True) kernel = json.loads(r.body.decode()) assert r.headers["location"] == url_path_join(jp_base_url, "/api/kernels/", kernel["id"]) @@ -79,13 +79,10 @@ async def test_default_kernels(jp_fetch, jp_base_url, jp_cleanup_subprocesses): ["frame-ancestors 'self'", "report-uri " + report_uri, "default-src 'none'"] ) assert r.headers["Content-Security-Policy"] == expected_csp - 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 -): +async def test_main_kernel_handler(jp_fetch, jp_base_url, jp_serverapp, pending_kernel_is_ready): # Start the first kernel r = await jp_fetch( "api", "kernels", method="POST", body=json.dumps({"name": NATIVE_KERNEL_NAME}) @@ -158,11 +155,10 @@ async def test_main_kernel_handler( ) kernel3 = json.loads(r.body.decode()) assert isinstance(kernel3, dict) - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_kernel_handler(jp_fetch, jp_cleanup_subprocesses, pending_kernel_is_ready): +async def test_kernel_handler(jp_fetch, pending_kernel_is_ready): # Create a kernel r = await jp_fetch( "api", "kernels", method="POST", body=json.dumps({"name": NATIVE_KERNEL_NAME}) @@ -206,13 +202,10 @@ async def test_kernel_handler(jp_fetch, jp_cleanup_subprocesses, pending_kernel_ with pytest.raises(tornado.httpclient.HTTPClientError) as e: await jp_fetch("api", "kernels", bad_id, method="DELETE") assert expected_http_error(e, 404, "Kernel does not exist: " + bad_id) - 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 -): +async def test_kernel_handler_startup_error(jp_fetch, jp_serverapp, jp_kernelspecs): if getattr(jp_serverapp.kernel_manager, "use_pending_kernels", False): return @@ -223,7 +216,7 @@ async def test_kernel_handler_startup_error( @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 + jp_fetch, jp_ws_fetch, jp_serverapp, jp_kernelspecs ): if not getattr(jp_serverapp.kernel_manager, "use_pending_kernels", False): return @@ -238,9 +231,7 @@ async def test_kernel_handler_startup_error_pending( @pytest.mark.timeout(TEST_TIMEOUT) -async def test_connection( - jp_fetch, jp_ws_fetch, jp_http_port, jp_auth_header, jp_cleanup_subprocesses -): +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}) @@ -274,4 +265,3 @@ async def test_connection( r = await jp_fetch("api", "kernels", kid, method="GET") model = json.loads(r.body.decode()) assert model["connections"] == 0 - await jp_cleanup_subprocesses() diff --git a/tests/services/kernels/test_cull.py b/tests/services/kernels/test_cull.py index 97f1a57bbe..2aa47bbac3 100644 --- a/tests/services/kernels/test_cull.py +++ b/tests/services/kernels/test_cull.py @@ -43,7 +43,7 @@ ), ], ) -async def test_cull_idle(jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses): +async def test_cull_idle(jp_fetch, jp_ws_fetch): r = await jp_fetch("api", "kernels", method="POST", allow_nonstandard_methods=True) kernel = json.loads(r.body.decode()) kid = kernel["id"] @@ -59,7 +59,6 @@ async def test_cull_idle(jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses): ws.close() culled = await get_cull_status(kid, jp_fetch) # not connected, should be culled assert culled - await jp_cleanup_subprocesses() # Pending kernels was released in Jupyter Client 7.1 @@ -89,9 +88,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 -): +async def test_cull_dead(jp_fetch, jp_ws_fetch, jp_serverapp, jp_kernelspecs): r = await jp_fetch("api", "kernels", method="POST", allow_nonstandard_methods=True) kernel = json.loads(r.body.decode()) kid = kernel["id"] @@ -105,7 +102,6 @@ async def test_cull_dead( assert model["connections"] == 0 culled = await get_cull_status(kid, jp_fetch) # connected, should not be culled assert culled - await jp_cleanup_subprocesses() async def get_cull_status(kid, jp_fetch): diff --git a/tests/services/sessions/test_api.py b/tests/services/sessions/test_api.py index 19c165cbb1..d2a234e4b2 100644 --- a/tests/services/sessions/test_api.py +++ b/tests/services/sessions/test_api.py @@ -211,7 +211,7 @@ def assert_session_equality(actual, expected): @pytest.mark.timeout(TEST_TIMEOUT) -async def test_create(session_client, jp_base_url, jp_cleanup_subprocesses, jp_serverapp): +async def test_create(session_client, jp_base_url, jp_serverapp): # Make sure no sessions exist. resp = await session_client.list() sessions = j(resp) @@ -251,14 +251,9 @@ async def test_create(session_client, jp_base_url, jp_cleanup_subprocesses, jp_s got = j(resp) assert_session_equality(got, new_session) - # Need to find a better solution to this. - 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 -): +async def test_create_bad(session_client, jp_base_url, jp_serverapp, jp_kernelspecs): if getattr(jp_serverapp.kernel_manager, "use_pending_kernels", False): return @@ -272,16 +267,12 @@ async def test_create_bad( with pytest.raises(HTTPClientError): await session_client.create("foo/nb1.ipynb") - # Need to find a better solution to this. - 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, ): @@ -310,14 +301,9 @@ async def test_create_bad_pending( if os.name != "nt": assert "non_existent_path" in session["kernel"]["reason"] - # Need to find a better solution to this. - await jp_cleanup_subprocesses() - @pytest.mark.timeout(TEST_TIMEOUT) -async def test_create_file_session( - session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_create_file_session(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.py", type="file") assert resp.code == 201 newsession = j(resp) @@ -325,41 +311,31 @@ async def test_create_file_session( assert newsession["type"] == "file" sid = newsession["id"] await session_is_ready(sid) - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_create_console_session( - session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_create_console_session(session_client, 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): +async def test_create_deprecated(session_client, jp_serverapp): resp = await session_client.create_deprecated("foo/nb1.ipynb") assert resp.code == 201 newsession = j(resp) assert newsession["path"] == "foo/nb1.ipynb" 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 -): +async def test_create_with_kernel_id(session_client, jp_fetch, jp_base_url, jp_serverapp): # create a new kernel resp = await jp_fetch("api/kernels", method="POST", allow_nonstandard_methods=True) kernel = j(resp) @@ -384,14 +360,10 @@ async def test_create_with_kernel_id( resp = await session_client.get(sid) got = j(resp) assert_session_equality(got, new_session) - # Need to find a better solution to this. - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_create_with_bad_kernel_id( - session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_create_with_bad_kernel_id(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.py", type="file") assert resp.code == 201 newsession = j(resp) @@ -401,11 +373,10 @@ async def test_create_with_bad_kernel_id( # 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): +async def test_delete(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") newsession = j(resp) @@ -422,12 +393,10 @@ async def test_delete(session_client, jp_cleanup_subprocesses, jp_serverapp, ses with pytest.raises(tornado.httpclient.HTTPClientError) as e: await session_client.get(sid) assert expected_http_error(e, 404) - # Need to find a better solution to this. - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_modify_path(session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready): +async def test_modify_path(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") newsession = j(resp) sid = newsession["id"] @@ -437,14 +406,10 @@ async def test_modify_path(session_client, jp_cleanup_subprocesses, jp_serverapp changed = j(resp) assert changed["id"] == sid assert changed["path"] == "nb2.ipynb" - # Need to find a better solution to this. - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_modify_path_deprecated( - session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_modify_path_deprecated(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") newsession = j(resp) sid = newsession["id"] @@ -454,12 +419,10 @@ async def test_modify_path_deprecated( changed = j(resp) assert changed["id"] == sid assert changed["notebook"]["path"] == "nb2.ipynb" - # Need to find a better solution to this. - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_modify_type(session_client, jp_cleanup_subprocesses, jp_serverapp, session_is_ready): +async def test_modify_type(session_client, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") newsession = j(resp) sid = newsession["id"] @@ -469,14 +432,10 @@ async def test_modify_type(session_client, jp_cleanup_subprocesses, jp_serverapp changed = j(resp) assert changed["id"] == sid assert changed["type"] == "console" - # Need to find a better solution to this. - await jp_cleanup_subprocesses() @pytest.mark.timeout(TEST_TIMEOUT) -async def test_modify_kernel_name( - session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_modify_kernel_name(session_client, jp_fetch, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") before = j(resp) sid = before["id"] @@ -497,14 +456,9 @@ async def test_modify_kernel_name( if not getattr(jp_serverapp.kernel_manager, "use_pending_kernels", False): assert kernel_list == [after["kernel"]] - # Need to find a better solution to this. - await jp_cleanup_subprocesses() - @pytest.mark.timeout(TEST_TIMEOUT) -async def test_modify_kernel_id( - session_client, jp_fetch, jp_cleanup_subprocesses, jp_serverapp, session_is_ready -): +async def test_modify_kernel_id(session_client, jp_fetch, jp_serverapp, session_is_ready): resp = await session_client.create("foo/nb1.ipynb") before = j(resp) sid = before["id"] @@ -532,14 +486,9 @@ async def test_modify_kernel_id( if not getattr(jp_serverapp.kernel_manager, "use_pending_kernels", False): assert kernel_list == [kernel] - # Need to find a better solution to this. - 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_is_ready -): +async def test_restart_kernel(session_client, jp_base_url, jp_fetch, jp_ws_fetch, session_is_ready): # Create a session. resp = await session_client.create("foo/nb1.ipynb") assert resp.code == 201 @@ -596,6 +545,3 @@ async def test_restart_kernel( r = await jp_fetch("api", "kernels", kid, method="GET") model = json.loads(r.body.decode()) assert model["connections"] == 1 - - # Need to find a better solution to this. - await jp_cleanup_subprocesses() diff --git a/tests/test_terminal.py b/tests/test_terminal.py index f4bae5e0ca..36535ae767 100644 --- a/tests/test_terminal.py +++ b/tests/test_terminal.py @@ -66,7 +66,7 @@ async def test_no_terminals(jp_fetch): assert len(data) == 0 -async def test_terminal_create(jp_fetch, jp_cleanup_subprocesses): +async def test_terminal_create(jp_fetch): resp = await jp_fetch( "api", "terminals", @@ -87,12 +87,9 @@ async def test_terminal_create(jp_fetch, jp_cleanup_subprocesses): assert len(data) == 1 assert data[0]["name"] == term["name"] - await jp_cleanup_subprocesses() -async def test_terminal_create_with_kwargs( - jp_fetch, jp_ws_fetch, terminal_path, jp_cleanup_subprocesses -): +async def test_terminal_create_with_kwargs(jp_fetch, jp_ws_fetch, terminal_path): resp_create = await jp_fetch( "api", "terminals", @@ -115,12 +112,9 @@ async def test_terminal_create_with_kwargs( data = json.loads(resp_get.body.decode()) assert data["name"] == term_name - await jp_cleanup_subprocesses() -async def test_terminal_create_with_cwd( - jp_fetch, jp_ws_fetch, terminal_path, jp_cleanup_subprocesses -): +async def test_terminal_create_with_cwd(jp_fetch, jp_ws_fetch, terminal_path): resp = await jp_fetch( "api", "terminals", @@ -151,12 +145,11 @@ async def test_terminal_create_with_cwd( ws.close() assert os.path.basename(terminal_path) in message_stdout - await jp_cleanup_subprocesses() @pytest.mark.skip(reason="Not yet working") async def test_terminal_create_with_relative_cwd( - jp_fetch, jp_ws_fetch, jp_root_dir, terminal_root_dir, jp_cleanup_subprocesses + jp_fetch, jp_ws_fetch, jp_root_dir, terminal_root_dir ): resp = await jp_fetch( "api", @@ -189,11 +182,10 @@ async def test_terminal_create_with_relative_cwd( expected = terminal_root_dir.name if sys.platform == "win32" else str(terminal_root_dir) assert expected in message_stdout - await jp_cleanup_subprocesses() @pytest.mark.skip(reason="Not yet working") -async def test_terminal_create_with_bad_cwd(jp_fetch, jp_ws_fetch, jp_cleanup_subprocesses): +async def test_terminal_create_with_bad_cwd(jp_fetch, jp_ws_fetch): non_existing_path = "/tmp/path/to/nowhere" resp = await jp_fetch( "api", @@ -225,7 +217,6 @@ async def test_terminal_create_with_bad_cwd(jp_fetch, jp_ws_fetch, jp_cleanup_su ws.close() assert non_existing_path not in message_stdout - await jp_cleanup_subprocesses() async def test_culling_config(jp_server_config, jp_configurable_serverapp): @@ -237,7 +228,7 @@ async def test_culling_config(jp_server_config, jp_configurable_serverapp): assert terminal_mgr_settings.cull_interval == CULL_INTERVAL -async def test_culling(jp_server_config, jp_fetch, jp_cleanup_subprocesses): +async def test_culling(jp_server_config, jp_fetch): # POST request resp = await jp_fetch( "api", @@ -267,4 +258,3 @@ async def test_culling(jp_server_config, jp_fetch, jp_cleanup_subprocesses): await asyncio.sleep(1) assert culled - await jp_cleanup_subprocesses()