Merge pull request #627 from kevin-bates/mkm-subclass-testing

Add tests to ensure MultiKernelManager subclass methods are called

Author: davidbrochart

jupyter_client/tests/test_kernelmanager.py

@@ -22,7 +22,7 @@
 
 from ..manager import start_new_kernel, start_new_async_kernel
 from ..manager import _ShutdownStatus
-from .utils import test_env, SyncKernelManagerSubclass, AsyncKernelManagerSubclass, AsyncKernelManagerWithCleanup
+from .utils import test_env, SyncKMSubclass, AsyncKMSubclass, AsyncKernelManagerWithCleanup
 
 pjoin = os.path.join
 
@@ -106,7 +106,7 @@ def km(config):
 
 @pytest.fixture
 def km_subclass(config):
-    km = SyncKernelManagerSubclass(config=config)
+    km = SyncKMSubclass(config=config)
     return km
 
 
@@ -118,15 +118,15 @@ def zmq_context():
     ctx.term()
 
 
-@pytest.fixture(params=[AsyncKernelManager, AsyncKernelManagerSubclass, AsyncKernelManagerWithCleanup])
+@pytest.fixture(params=[AsyncKernelManager, AsyncKMSubclass, AsyncKernelManagerWithCleanup])
 def async_km(request, config):
     km = request.param(config=config)
     return km
 
 
 @pytest.fixture
 def async_km_subclass(config):
-    km = AsyncKernelManagerSubclass(config=config)
+    km = AsyncKMSubclass(config=config)
     return km
 
 
@@ -173,6 +173,7 @@ def test_signal_kernel_subprocesses(self, name, install, expected):
 
         assert km._shutdown_status == expected
 
+    @pytest.mark.asyncio
     @pytest.mark.skipif(
         sys.platform == "win32", reason="Windows doesn't support signals"
     )
@@ -452,7 +453,7 @@ async def test_get_connect_info(self, async_km):
         ])
         assert keys == expected
 
-    async def test_subclasses(self, async_km):
+    async def test_subclass_deprecations(self, async_km):
         await async_km.start_kernel(stdout=PIPE, stderr=PIPE)
         is_alive = await async_km.is_alive()
         assert is_alive
@@ -464,7 +465,7 @@ async def test_subclasses(self, async_km):
 
         if isinstance(async_km, AsyncKernelManagerWithCleanup):
             assert async_km.which_cleanup == "cleanup"
-        elif isinstance(async_km, AsyncKernelManagerSubclass):
+        elif isinstance(async_km, AsyncKMSubclass):
             assert async_km.which_cleanup == "cleanup_resources"
         else:
             assert hasattr(async_km, "which_cleanup") is False

jupyter_client/tests/test_multikernelmanager.py

@@ -9,9 +9,9 @@
 from unittest import TestCase
 from tornado.testing import AsyncTestCase, gen_test
 from traitlets.config.loader import Config
-from jupyter_client import KernelManager, AsyncKernelManager
+from jupyter_client import KernelManager
 from jupyter_client.multikernelmanager import MultiKernelManager, AsyncMultiKernelManager
-from .utils import skip_win32
+from .utils import skip_win32, SyncMKMSubclass, AsyncMKMSubclass, SyncKMSubclass, AsyncKMSubclass
 from ..localinterfaces import localhost
 
 TIMEOUT = 30
@@ -26,6 +26,12 @@ def _get_tcp_km():
         km = MultiKernelManager(config=c)
         return km
 
+    @staticmethod
+    def _get_tcp_km_sub():
+        c = Config()
+        km = SyncMKMSubclass(config=c)
+        return km
+
     # static so picklable for multiprocessing on Windows
     @staticmethod
     def _get_ipc_km():
@@ -153,6 +159,61 @@ def test_start_parallel_process_kernels(self):
 
         assert proc.exitcode == 0
 
+    def test_subclass_callables(self):
+        km = self._get_tcp_km_sub()
+
+        km.reset_counts()
+        kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
+        assert km.call_count('start_kernel') == 1
+        assert isinstance(km.get_kernel(kid), SyncKMSubclass)
+        assert km.get_kernel(kid).call_count('start_kernel') == 1
+        assert km.get_kernel(kid).call_count('_launch_kernel') == 1
+
+        assert km.is_alive(kid)
+        assert kid in km
+        assert kid in km.list_kernel_ids()
+        assert len(km) == 1, f'{len(km)} != {1}'
+
+        km.get_kernel(kid).reset_counts()
+        km.reset_counts()
+        km.restart_kernel(kid, now=True)
+        assert km.call_count('restart_kernel') == 1
+        assert km.call_count('get_kernel') == 1
+        assert km.get_kernel(kid).call_count('restart_kernel') == 1
+        assert km.get_kernel(kid).call_count('shutdown_kernel') == 1
+        assert km.get_kernel(kid).call_count('interrupt_kernel') == 1
+        assert km.get_kernel(kid).call_count('_kill_kernel') == 1
+        assert km.get_kernel(kid).call_count('cleanup_resources') == 1
+        assert km.get_kernel(kid).call_count('start_kernel') == 1
+        assert km.get_kernel(kid).call_count('_launch_kernel') == 1
+
+        assert km.is_alive(kid)
+        assert kid in km.list_kernel_ids()
+
+        km.get_kernel(kid).reset_counts()
+        km.reset_counts()
+        km.interrupt_kernel(kid)
+        assert km.call_count('interrupt_kernel') == 1
+        assert km.call_count('get_kernel') == 1
+        assert km.get_kernel(kid).call_count('interrupt_kernel') == 1
+
+        km.get_kernel(kid).reset_counts()
+        km.reset_counts()
+        k = km.get_kernel(kid)
+        assert isinstance(k, SyncKMSubclass)
+        assert km.call_count('get_kernel') == 1
+
+        km.get_kernel(kid).reset_counts()
+        km.reset_counts()
+        km.shutdown_all(now=True)
+        assert km.call_count('shutdown_kernel') == 0
+        assert km.call_count('remove_kernel') == 1
+        assert km.call_count('request_shutdown') == 1
+        assert km.call_count('finish_shutdown') == 1
+        assert km.call_count('cleanup_resources') == 0
+
+        assert kid not in km, f'{kid} not in {km}'
+
 
 class TestAsyncKernelManager(AsyncTestCase):
 
@@ -163,6 +224,12 @@ def _get_tcp_km():
         km = AsyncMultiKernelManager(config=c)
         return km
 
+    @staticmethod
+    def _get_tcp_km_sub():
+        c = Config()
+        km = AsyncMKMSubclass(config=c)
+        return km
+
     # static so picklable for multiprocessing on Windows
     @staticmethod
     def _get_ipc_km():
@@ -347,3 +414,59 @@ async def test_start_parallel_process_kernels(self):
             thread.join()
 
         assert proc.exitcode == 0
+
+    @gen_test
+    async def test_subclass_callables(self):
+        mkm = self._get_tcp_km_sub()
+
+        mkm.reset_counts()
+        kid = await mkm.start_kernel(stdout=PIPE, stderr=PIPE)
+        assert mkm.call_count('start_kernel') == 1
+        assert isinstance(mkm.get_kernel(kid), AsyncKMSubclass)
+        assert mkm.get_kernel(kid).call_count('start_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('_launch_kernel') == 1
+
+        assert await mkm.is_alive(kid)
+        assert kid in mkm
+        assert kid in mkm.list_kernel_ids()
+        assert len(mkm) == 1, f'{len(mkm)} != {1}'
+
+        mkm.get_kernel(kid).reset_counts()
+        mkm.reset_counts()
+        await mkm.restart_kernel(kid, now=True)
+        assert mkm.call_count('restart_kernel') == 1
+        assert mkm.call_count('get_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('restart_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('shutdown_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('interrupt_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('_kill_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('cleanup_resources') == 1
+        assert mkm.get_kernel(kid).call_count('start_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('_launch_kernel') == 1
+
+        assert await mkm.is_alive(kid)
+        assert kid in mkm.list_kernel_ids()
+
+        mkm.get_kernel(kid).reset_counts()
+        mkm.reset_counts()
+        await mkm.interrupt_kernel(kid)
+        assert mkm.call_count('interrupt_kernel') == 1
+        assert mkm.call_count('get_kernel') == 1
+        assert mkm.get_kernel(kid).call_count('interrupt_kernel') == 1
+
+        mkm.get_kernel(kid).reset_counts()
+        mkm.reset_counts()
+        k = mkm.get_kernel(kid)
+        assert isinstance(k, AsyncKMSubclass)
+        assert mkm.call_count('get_kernel') == 1
+
+        mkm.get_kernel(kid).reset_counts()
+        mkm.reset_counts()
+        await mkm.shutdown_all(now=True)
+        assert mkm.call_count('shutdown_kernel') == 1
+        assert mkm.call_count('remove_kernel') == 1
+        assert mkm.call_count('request_shutdown') == 0
+        assert mkm.call_count('finish_shutdown') == 0
+        assert mkm.call_count('cleanup_resources') == 0
+
+        assert kid not in mkm, f'{kid} not in {mkm}'