Enables ability to select from multiple licenses when using Online Licensing.

Author: krisctl

src/jupyter_matlab_kernel/mwi_comm_helpers.py

@@ -34,14 +34,24 @@ def fetch_matlab_proxy_status(url, headers):
     resp = requests.get(url + "/get_status", headers=headers, verify=False)
     if resp.status_code == requests.codes.OK:
         data = resp.json()
-        is_matlab_licensed = data["licensing"] != None
+        is_matlab_licensed = check_licensing_status(data)
+
         matlab_status = data["matlab"]["status"]
         matlab_proxy_has_error = data["error"] != None
         return is_matlab_licensed, matlab_status, matlab_proxy_has_error
     else:
         resp.raise_for_status()
 
 
+def check_licensing_status(data):
+    licensing_status = data["licensing"] != None
+
+    # Check for entitlementId only in the event of online licensing
+    if licensing_status and data["licensing"]["type"] == "mhlm":
+        licensing_status = data["licensing"]["entitlementId"] != None
+    return licensing_status
+
+
 def send_execution_request_to_matlab(url, headers, code):
     """
     Evaluate MATLAB code and capture results.

tests/unit/jupyter_matlab_kernel/mocks/mock_http_responses.py

@@ -24,20 +24,72 @@ def raise_for_status(self):
 class MockMatlabProxyStatusResponse:
     """A mock of a matlab-proxy status response."""
 
-    def __init__(self, is_licensed, matlab_status, has_error) -> None:
+    def __init__(self, lic_type, 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.licensed = self.process_license_type(lic_type)
         self.matlab_status = matlab_status
-        self.error = has_error
+        self.error = MockError("An example error") if has_error else None
 
     status_code = requests.codes.ok
 
+    @staticmethod
+    def handle_entitled_mhlm():
+        return {
+            "type": "mhlm",
+            "emailAddress": "test@mathworks.com",
+            "entitlements": [
+                {
+                    "id": "123456",
+                    "label": "MATLAB - Staff Use",
+                    "license_number": "123456",
+                }
+            ],
+            "entitlementId": "123456",
+        }
+
+    @staticmethod
+    def handle_unentitled_mhlm():
+        return {
+            "type": "mhlm",
+            "emailAddress": "test@mathworks.com",
+            "entitlements": [
+                {
+                    "id": "123456",
+                    "label": "MATLAB - Staff Use",
+                    "license_number": "123456",
+                }
+            ],
+            "entitlementId": None,
+        }
+
+    @staticmethod
+    def handle_nlm():
+        return {"type": "nlm", "connectionString": "123@internal"}
+
+    @staticmethod
+    def handle_existing_license():
+        return {"type": "existing_license"}
+
+    @staticmethod
+    def default():
+        return None
+
+    def process_license_type(self, lic_type):
+        types = {
+            "mhlm_entitled": self.handle_entitled_mhlm,
+            "mhlm_unentitled": self.handle_unentitled_mhlm,
+            "nlm": self.handle_nlm,
+            "existing_license": self.handle_existing_license,
+        }
+        return types.get(lic_type, self.default)()
+
     def json(self):
         """Return a matlab-proxy status JSON object."""
         return {
@@ -74,3 +126,13 @@ def __init__(self, error_message: str) -> None:
     def raise_for_status(self):
         """Raise a HTTPError with custom error message."""
         raise HTTPError(self.error_message)
+
+
+class MockError(Exception):
+    """An example error used for testing purposes
+
+    Args:
+        Exception (Any): Dummy exception
+    """
+
+    pass

tests/unit/jupyter_matlab_kernel/test_mwi_comm_helpers.py

@@ -34,25 +34,39 @@ def mock_get(*args, **kwargs):
     assert MockUnauthorisedRequestResponse().exception_msg in str(exceptionInfo.value)
 
 
-def test_fetch_matlab_proxy_status(monkeypatch):
+@pytest.mark.parametrize(
+    "input_lic_type, expected_license_status",
+    [
+        ("mhlm_entitled", True),
+        ("mhlm_unentitled", False),
+        ("nlm", True),
+        ("existing_license", True),
+        ("default", False),
+    ],
+)
+def test_fetch_matlab_proxy_status(
+    input_lic_type, expected_license_status, monkeypatch
+):
     """
     This test checks that fetch_matlab_proxy_status returns the correct
     values for a valid request to matlab-proxy.
     """
 
     def mock_get(*args, **kwargs):
-        return MockMatlabProxyStatusResponse(True, "up", False)
+        return MockMatlabProxyStatusResponse(
+            lic_type=input_lic_type, matlab_status="up", has_error=False
+        )
 
     monkeypatch.setattr(requests, "get", mock_get)
 
     (
-        is_matlab_licened,
+        is_matlab_licensed,
         matlab_status,
         matlab_proxy_has_error,
     ) = fetch_matlab_proxy_status("", "{}")
-    assert is_matlab_licened == True
+    assert is_matlab_licensed == expected_license_status
     assert matlab_status == "up"
-    assert matlab_proxy_has_error == True
+    assert matlab_proxy_has_error == False
 
 
 def test_interrupt_request_bad_request(monkeypatch):