Python & js linting.Updated tests

Author: diningPhilosopher64

src/jupyter_matlab_kernel/kernels/__init__.py

@@ -2,4 +2,4 @@
 
 from .jsp_kernel import MATLABKernelUsingJSP
 from .mpm_kernel import MATLABKernelUsingMPM
-from .kernel_factory import KernelFactory
+from .kernel_factory import KernelFactory

src/jupyter_matlab_kernel/kernels/jsp_kernel.py

@@ -89,7 +89,7 @@ def start_matlab_proxy(logger=_logger):
         pass
 
     # Use parent process id of the kernel to filter Jupyter Server from the list.
-    jupyter_server_pid = base._get_parent_pid(logger)
+    jupyter_server_pid = base._get_parent_pid()
     logger.debug(f"Resolved jupyter server pid: {jupyter_server_pid}")
 
     nb_server = dict()

src/jupyter_matlab_kernel/kernels/labextension_comm/communication.py

@@ -1,6 +1,7 @@
 # Copyright 2025 The MathWorks, Inc.
 
 from ipykernel.comm import Comm
+import time
 
 
 class LabExtensionCommunication:
@@ -27,7 +28,14 @@ def comm_open(self, stream, ident, msg):
 
     async def comm_msg(self, stream, ident, msg):
         """Handler to execute when labextension sends a message with 'comm_msg' type."""
-        pass
+        # As per jupyter messaging protocol https://jupyter-client.readthedocs.io/en/latest/messaging.html#custom-messages
+        # 'content' will be present in msg, 'comm_id' and 'data' will be present in content.
+        payload = msg["content"]["data"]
+        action_type, action_data = payload["action"], payload["data"]
+
+        self.log.debug(
+            f"Received action_type:{action_type} with data:{action_data} from the lab extension"
+        )
 
     def comm_close(self, stream, ident, msg):
         """Handler to execute when labextension sends a message with 'comm_close' type."""

src/jupyter_matlab_kernel/mwi_comm_helpers.py

@@ -388,7 +388,7 @@ async def _send_jupyter_request_to_matlab(self, request_type, inputs, http_clien
             )
 
         # The 'else' condition is an artifact and is present here incase we ever want to test
-        # eval execution. 
+        # eval execution.
         else:
             user_mcode = inputs[2]
             # Construct a string which can be evaluated in MATLAB. For example

src/jupyter_matlab_labextension/src/plugins/matlabCommunication.ts

@@ -128,23 +128,22 @@ implements
 
                 // Handle comm close
                 comm.onClose = (msg) => {
-                    console.debug('Comm closed:', msg);
+                    console.debug(`Received data:${msg} for comm close event.`);
+                    console.log(`Comm with ID:${comm.commId} closed.`);
                 };
 
                 this._comms.set(panel.id, comm);
-
-                // Clean up when notebook is disposed
-                panel.disposed.connect(() => {
-                    this._comms.delete(panel.id);
-                });
             })
             .catch((error) => {
                 console.error('Notebook panel was not ready', error);
             });
 
         return new DisposableDelegate(() => {
-            this._comms.get(panel.id)?.close();
-            this._comms.delete(panel.id);
+            const comm = this._comms.get(panel.id);
+            if (comm && !comm.isDisposed) {
+                comm.close();
+                this._comms.delete(panel.id);
+            }
         });
     }
 

src/jupyter_matlab_labextension/src/utils/notebook.ts

@@ -93,15 +93,13 @@ export class NotebookInfo {
     */
     async update (panel: NotebookPanel | null): Promise<void> {
         if (panel) {
-            this._panel = panel;
-            this._isMatlabNotebook =
-        panel.context.model.metadata.kernelspec?.language === 'matlab';
-            const context = panel.context;
             // Wait for session context to be ready
             if (!panel.sessionContext.isReady) {
                 await panel.sessionContext.ready;
             }
-
+            this._panel = panel;
+            this._isMatlabNotebook = panel.sessionContext.kernelDisplayName === 'MATLAB Kernel';
+            const context = panel.context;
             this._isBusy = panel.sessionContext.session?.kernel?.status === 'busy';
             this._notebookName = context.path;
         } else {

tests/unit/jupyter_matlab_kernel/test_labextension_communication.py

@@ -86,7 +86,7 @@ def test_comm_open_creates_comm(
 
 @pytest.mark.asyncio
 async def test_comm_msg_with_valid_comm(
-    labext_comm, mocker, mock_stream, mock_ident, mock_comm
+    labext_comm, mock_stream, mock_ident, mock_comm
 ):
     """Test that comm_msg processes messages when comm is available."""
     # Arrange
@@ -111,38 +111,7 @@ async def test_comm_msg_with_valid_comm(
     )
 
 
-@pytest.mark.asyncio
-async def test_comm_msg_without_comm_raises_exception(
-    labext_comm, mocker, mock_stream, mock_ident
-):
-    """Test that comm_msg raises exception when no comm is available."""
-    # Ensure comms is empty
-    labext_comm.comms = {}
-    comm_id = "test-comm-id"
-
-    # Prepare test data
-    test_action = "test-action"
-    test_data = {"key": "value"}
-    msg = {
-        "content": {
-            "comm_id": comm_id,
-            "data": {"action": test_action, "data": test_data},
-        }
-    }
-
-    # Call the method and expect exception
-    with pytest.raises(Exception, match="No Communcation channel available"):
-        await labext_comm.comm_msg(mock_stream, mock_ident, msg)
-
-    # Verify error logging
-    labext_comm.log.error.assert_called_once_with(
-        "Received comm_msg but no communication channel is available"
-    )
-
-
-def test_comm_close_with_valid_comm_id(
-    labext_comm, mocker, mock_stream, mock_ident, mock_comm
-):
+def test_comm_close_with_valid_comm_id(labext_comm, mock_stream, mock_ident, mock_comm):
     """Test that comm_close closes the correct communication channel."""
     # Arrange
     # Set up a mock comm with matching ID
@@ -164,7 +133,7 @@ def test_comm_close_with_valid_comm_id(
 
 
 def test_comm_close_with_non_matching_comm_id(
-    labext_comm, mocker, mock_stream, mock_ident, mock_comm
+    labext_comm, mock_stream, mock_ident, mock_comm
 ):
     """Test that comm_close warns when trying to close unknown comm."""
     # Arrange
@@ -184,12 +153,12 @@ def test_comm_close_with_non_matching_comm_id(
     assert labext_comm.comms[different_comm_id] is mock_comm
 
     # Verify warning logging
-    labext_comm.log.warning.assert_called_once_with(
+    labext_comm.log.debug.assert_called_once_with(
         f"Attempted to close unknown comm_id: {comm_id}"
     )
 
 
-def test_comm_close_with_no_comm(labext_comm, mocker, mock_stream, mock_ident):
+def test_comm_close_with_no_comm(labext_comm, mock_stream, mock_ident):
     """Test that comm_close warns when no comm exists."""
     # Arrange
     # Ensure comms is empty
@@ -205,14 +174,14 @@ def test_comm_close_with_no_comm(labext_comm, mocker, mock_stream, mock_ident):
     assert labext_comm.comms == {}
 
     # Verify warning logging
-    labext_comm.log.warning.assert_called_once_with(
+    labext_comm.log.debug.assert_called_once_with(
         f"Attempted to close unknown comm_id: {test_comm_id}"
     )
 
 
 @pytest.mark.asyncio
 async def test_comm_msg_extracts_data_correctly(
-    labext_comm, mocker, mock_stream, mock_ident, mock_comm
+    labext_comm, mock_stream, mock_ident, mock_comm
 ):
     """Test that comm_msg correctly extracts action and data from message."""
     # Arrange