Adding unit tests for jupyter_matlab_proxy

Author: pauldruce

.gitignore

@@ -9,3 +9,4 @@ htmlcov/
 .coverage
 coverage.xml
 cov_html
+.python-version

src/jupyter_matlab_kernel/kernel.py

@@ -80,6 +80,15 @@ def start_matlab_proxy():
             # Stop iterating over the server list
             break
 
+    # Error out if the server is not found!
+    if found_nb_server == False:
+        raise MATLABConnectionError(
+            """
+            Error: MATLAB Kernel for Jupyter was unable to find the notebook server from which it was spawned!\n
+            Resolution: Please relaunch kernel from JupyterLab or Classic Jupyter Notebook.
+            """
+        )
+
     # Verify that Password is disabled
     if nb_server["password"] is True:
         # TODO: To support passwords, we either need to acquire it from Jupyter or ask the user?
@@ -92,15 +101,6 @@ def start_matlab_proxy():
             """
         )
 
-    # Error out if the server is not found!
-    if found_nb_server == False:
-        raise MATLABConnectionError(
-            """
-            Error: MATLAB Kernel for Jupyter was unable to find the notebook server from which it was spawned!\n
-            Resolution: Please relaunch kernel from JupyterLab or Classic Jupyter Notebook.
-            """
-        )
-
     url = "{protocol}://localhost:{port}{base_url}matlab".format(
         protocol="https" if nb_server["secure"] else "http",
         port=nb_server["port"],

tests/README.md

@@ -0,0 +1,7 @@
+# Testing Information for jupyter-matlab-proxy
+
+The tests in this project are written using the [Pytest](https://docs.pytest.org/en/latest/) framework.
+
+To run the tests in this project follow these steps:
+* From the root directory of this project, run the command `pip install ".[dev]"`
+* Run the command `pytest` to run all Python tests for this project.

tests/__init__.py

@@ -1,6 +1,10 @@
 # Copyright 2020-2023 The MathWorks, Inc.
 
-# Pytest won't include files in the coverage metrics unless they are imported in the tests.
-# By importing the systems under test here, any files not hit by a test point are still included in the code coverage metrics.
+"""Force Pytest to included untested files in coverage calculations.
+
+Pytest won't include files in the coverage metrics unless they are imported in
+the tests. By importing the systems under test here, any files not hit by a test
+point are still included in the code coverage metrics.
+"""
 import jupyter_matlab_kernel
 import jupyter_matlab_proxy

tests/unit/jupyter_matlab_kernel/mocks/mock_http_responses.py

@@ -0,0 +1,76 @@
+# Copyright 2023 The MathWorks, Inc.
+"""Mock matlab-proxy HTTP Responses."""
+
+import requests
+from requests.exceptions import HTTPError
+
+
+class MockUnauthorisedRequestResponse:
+    """
+    Emulates an unauthorized request to matlab-proxy.
+
+    Raises:
+        HTTPError: with code unauthorized.
+    """
+
+    exception_msg = "Mock exception thrown due to unauthorized request status."
+    status_code = requests.codes.unauthorized
+
+    def raise_for_status(self):
+        """Raise a HTTPError with unauthorised request message."""
+        raise HTTPError(self.exception_msg)
+
+
+class MockMatlabProxyStatusResponse:
+    """A mock of a matlab-proxy status response."""
+
+    def __init__(self, is_licensed, matlab_status, has_error) -> None:
+        """Construct a mock matlab-proxy status response.
+
+        Args:
+            is_licensed (bool): indicates if MATLAB is licensed.
+            matlab_status (string): indicates the MATLAB status, i.e. is it "starting", "running" etc.
+            has_error (bool): indicates if there is an error with MATLAB
+        """
+        self.licensed = is_licensed
+        self.matlab_status = matlab_status
+        self.error = has_error
+
+    status_code = requests.codes.ok
+
+    def json(self):
+        """Return a matlab-proxy status JSON object."""
+        return {
+            "licensing": self.licensed,
+            "matlab": {"status": self.matlab_status},
+            "error": self.error,
+        }
+
+
+class MockSimpleOkResponse:
+    """A mock of a successful http request that returns empty json."""
+
+    status_code = requests.codes.ok
+
+    @staticmethod
+    def json():
+        """Return an empty JSON struct."""
+        return {}
+
+
+class MockSimpleBadResponse:
+    """A mock of a bad https request."""
+
+    def __init__(self, error_message: str) -> None:
+        """Construct a mock bad http requests.
+
+        Args:
+            error_message (str): the mock will raise a HTTPError with this error message.
+        """
+        self.error_message = error_message
+
+    status_code = requests.codes.bad
+
+    def raise_for_status(self):
+        """Raise a HTTPError with custom error message."""
+        raise HTTPError(self.error_message)

tests/unit/jupyter_matlab_kernel/mocks/mock_jupyter_server.py

@@ -0,0 +1,66 @@
+# Copyright 2023 The MathWorks, Inc.
+"""Mocks matlab-proxy integration with Jupyter Server.
+
+This module provides a pytest fixture that mocks how matlab-proxy integrates
+with Jupyter server.
+"""
+
+
+import pytest
+
+import requests
+import os
+from jupyter_server import serverapp
+
+PID = "server 1"
+PORT = "1234/"
+BASE_URL = "server_of_nb/"
+SECURE = False
+TEST_TOKEN = "test_token"
+LICENSING = True
+AUTHORISED_HEADERS = {"Authorization": "token test_token"}
+PASSWORD = ""
+
+
+@pytest.fixture
+def MockJupyterServerFixture(monkeypatch):
+    """Mock the matlab-proxy integration with JupyterServer.
+
+    This fixture provides the mocked calls to emulate that an instance of matlab proxy
+    is running.
+    """
+
+    def fake_getppid():
+        return PID
+
+    def fake_list_running_servers(*args, **kwargs):
+        return [
+            {
+                "pid": PID,
+                "port": PORT,
+                "base_url": BASE_URL,
+                "secure": SECURE,
+                "token": TEST_TOKEN,
+                "password": PASSWORD,
+            }
+        ]
+
+    class MockResponse:
+        status_code = requests.codes.ok
+        text = "MWI_MATLAB_PROXY_IDENTIFIER"
+
+        @staticmethod
+        def json():
+            return {
+                "licensing": LICENSING,
+                "matlab": {"status": "up"},
+                "error": False,
+            }
+
+    def mock_get(*args, **kwargs):
+        return MockResponse()
+
+    monkeypatch.setattr(serverapp, "list_running_servers", fake_list_running_servers)
+    monkeypatch.setattr(os, "getppid", fake_getppid)
+    monkeypatch.setattr(requests, "get", mock_get)
+    yield

tests/unit/jupyter_matlab_kernel/test_kernel.py

@@ -0,0 +1,86 @@
+# Copyright 2023 The MathWorks, Inc.
+
+# This file contains tests for jupyter_matlab_kernel.kernel
+from jupyter_matlab_kernel.kernel import (
+    start_matlab_proxy,
+    MATLABConnectionError,
+)
+
+import pytest
+from jupyter_server import serverapp
+from mocks.mock_jupyter_server import MockJupyterServerFixture
+import mocks.mock_jupyter_server as MockJupyterServer
+
+
+def test_start_matlab_proxy_without_jupyter_server():
+    """
+    This test checks that trying to start matlab-proxy outside of a Jupyter environment
+    raises an execption.
+    """
+    with pytest.raises(MATLABConnectionError) as exceptionInfo:
+        start_matlab_proxy()
+
+    assert (
+        "MATLAB Kernel for Jupyter was unable to find the notebook server from which it was spawned!"
+        in str(exceptionInfo.value)
+    )
+
+
+def test_start_matlab_proxy(MockJupyterServerFixture):
+    """
+    This test checks start_matlab_proxy returns a correctly configured URL
+    """
+
+    url, server, headers = start_matlab_proxy()
+    assert server == MockJupyterServer.BASE_URL
+    assert headers == MockJupyterServer.AUTHORISED_HEADERS
+    expected_url = (
+        "http://localhost:"
+        + MockJupyterServer.PORT
+        + MockJupyterServer.BASE_URL
+        + "matlab"
+    )
+    assert url == expected_url
+
+
+def test_start_matlab_proxy_secure(monkeypatch, MockJupyterServerFixture):
+    """
+    This test checks that start_matlab_proxy returns a HTTPS url if configured
+    to do so.
+    """
+
+    def fake_list_running_servers(*args, **kwargs):
+        return [
+            {
+                "pid": MockJupyterServer.PID,
+                "port": MockJupyterServer.PORT,
+                "base_url": MockJupyterServer.BASE_URL,
+                "secure": True,
+                "token": MockJupyterServer.TEST_TOKEN,
+                "password": MockJupyterServer.PASSWORD,
+            }
+        ]
+
+    monkeypatch.setattr(serverapp, "list_running_servers", fake_list_running_servers)
+
+    url, _, _ = start_matlab_proxy()
+    expected_url = (
+        "https://localhost:"
+        + MockJupyterServer.PORT
+        + MockJupyterServer.BASE_URL
+        + "matlab"
+    )
+    assert url == expected_url
+
+
+def test_start_matlab_proxy_jh_api_token(monkeypatch, MockJupyterServerFixture):
+    """
+    The test checks that start_matlab_proxy makes use of the environment variable
+    JUPYTERHUB_API_TOKEN if it is set.
+    """
+
+    monkeypatch.setattr(MockJupyterServer, "TEST_TOKEN", None)
+
+    monkeypatch.setenv("JUPYTERHUB_API_TOKEN", "test_jh_token")
+    _, _, headers = start_matlab_proxy()
+    assert headers == {"Authorization": "token test_jh_token"}

tests/unit/jupyter_matlab_kernel/test_kernel_json.py

@@ -0,0 +1,30 @@
+# Copyright 2023 The MathWorks, Inc.
+import sys
+from jupyter_client import kernelspec
+import pytest
+import os, shutil
+
+TEST_KERNEL_NAME = "jupyter_matlab_kernel_test"
+
+
+@pytest.fixture
+def UninstallKernel():
+    yield
+    kernel_list = kernelspec.find_kernel_specs()
+    kernel_path = kernel_list.get(TEST_KERNEL_NAME)
+    if kernel_path != None and os.path.exists(kernel_path):
+        shutil.rmtree(kernel_path)
+
+
+def test_matlab_kernel_registration(UninstallKernel):
+    """This test checks that the kernel.json file can be installed by JupyterLab."""
+
+    kernelspec.install_kernel_spec(
+        "./src/jupyter_matlab_kernel",
+        kernel_name=TEST_KERNEL_NAME,
+        prefix=sys.prefix,
+    )
+
+    kernel_list = kernelspec.find_kernel_specs()
+
+    assert TEST_KERNEL_NAME in kernel_list