matlab-proxy 0.15.1__tar.gz → 0.17.0__tar.gz

{matlab-proxy-0.15.1/matlab_proxy.egg-info → matlab-proxy-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matlab-proxy
-Version: 0.15.1
+Version: 0.17.0
 Summary: Python® package enables you to launch MATLAB® and access it from a web browser.
 Home-page: https://github.com/mathworks/matlab-proxy/
 Author: The MathWorks, Inc.

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/gui/src/actionCreators/index.js

@@ -35,6 +35,7 @@ import {
     selectIsAuthenticated
 } from '../selectors';
 import sha256 from 'crypto-js/sha256';
+import { MWI_AUTH_TOKEN_NAME_FOR_HTTP } from '../constants';
 
 export function setAuthStatus (authentication) {
     return {
@@ -296,7 +297,7 @@ export function updateAuthStatus (token) {
         const options = {
             method: 'POST',
             headers: {
-                mwi_auth_token: tokenHash
+                [MWI_AUTH_TOKEN_NAME_FOR_HTTP]: tokenHash
             }
         };
         const response = await fetchWithTimeout(dispatch, './authenticate', options, 15000);

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/gui/src/components/App/App.spec.js

@@ -7,6 +7,7 @@ import App from './index';
 import * as actionCreators from '../../actionCreators';
 import state from '../../test/utils/state';
 import { MAX_REQUEST_FAIL_COUNT } from '../../constants';
+import { MWI_AUTH_TOKEN_NAME_FOR_HTTP } from '../../constants';
 
 const _ = require('lodash');
 
@@ -47,7 +48,7 @@ describe('App Component', () => {
     });
 
     it('should render overlayTrigger (after closing the tutorial)', () => {
-    // Hide the tutorial before rendering the component.
+        // Hide the tutorial before rendering the component.
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = false;
 
@@ -64,7 +65,7 @@ describe('App Component', () => {
     });
 
     it('should render LicensingGatherer component within the App component when no licensing is provided and user is authenticated', () => {
-    // Set lincensingInfo to empty object.
+        // Set licensingInfo to empty object.
         initialState.overlayVisibility = true;
         initialState.serverStatus.licensingInfo = {};
         initialState.authentication.enabled = true;
@@ -79,7 +80,7 @@ describe('App Component', () => {
     });
 
     it('should render LicensingGatherer component within the App component when no licensing is provided and authentication is disabled', () => {
-    // Set lincensingInfo to empty object.
+        // Set licensingInfo to empty object.
         initialState.overlayVisibility = true;
         initialState.serverStatus.licensingInfo = {};
         initialState.authentication.enabled = false;
@@ -93,7 +94,7 @@ describe('App Component', () => {
     });
 
     it('should render Information Component within App Component after licensing is provided and user is authenticated', () => {
-    // Hide the tutorial and make the overlay visible.
+        // Hide the tutorial and make the overlay visible.
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = true;
 
@@ -112,7 +113,7 @@ describe('App Component', () => {
     });
 
     it('should render Information Component within App Component after licensing is provided and auth is not enabled', () => {
-    // Hide the tutorial and make the overlay visible.
+        // Hide the tutorial and make the overlay visible.
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = true;
 
@@ -131,7 +132,7 @@ describe('App Component', () => {
     });
 
     it('should display integration terminated error', () => {
-    // Hide the tutorial, make the overlay visible and set fetchFailCount to MAX_REQUEST_FAIL_COUNT
+        // Hide the tutorial, make the overlay visible and set fetchFailCount to MAX_REQUEST_FAIL_COUNT
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = true;
         initialState.serverStatus.fetchFailCount = MAX_REQUEST_FAIL_COUNT;
@@ -173,7 +174,7 @@ describe('App Component', () => {
     });
 
     it('should display Confirmation component ', () => {
-    // Hide the tutorial and make the overlay visible
+        // Hide the tutorial and make the overlay visible
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = true;
 
@@ -196,7 +197,7 @@ describe('App Component', () => {
     });
 
     it('should display Help Component', () => {
-    // Hide the tutorial and make the overlay visible
+        // Hide the tutorial and make the overlay visible
         initialState.tutorialHidden = true;
         initialState.overlayVisibility = true;
 
@@ -230,9 +231,9 @@ describe('App Component', () => {
 
     const tokenInQuery = '12345';
     it.each([
-        [`?mwi_auth_token=${tokenInQuery}&test1=1&test2=2`, tokenInQuery],
-        [`?test1=1&mwi_auth_token=${tokenInQuery}&test2=2`, tokenInQuery],
-        [`?test1=1&test2=2&mwi_auth_token=${tokenInQuery}`, tokenInQuery]
+        [`?${MWI_AUTH_TOKEN_NAME_FOR_HTTP}=${tokenInQuery}&test1=1&test2=2`, tokenInQuery],
+        [`?test1=1&${MWI_AUTH_TOKEN_NAME_FOR_HTTP}=${tokenInQuery}&test2=2`, tokenInQuery],
+        [`?test1=1&test2=2&${MWI_AUTH_TOKEN_NAME_FOR_HTTP}=${tokenInQuery}`, tokenInQuery]
     ])("should pick the token correctly when the query parameters are '%s'", (queryParams, expectedToken) => {
         const url = 'http://localhost.com:5555';
         const mockUpdateAuthStatus = jest.spyOn(actionCreators, 'updateAuthStatus');

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/gui/src/components/App/index.js

@@ -43,6 +43,7 @@ import {
 } from '../../actionCreators';
 import blurredBackground from './MATLAB-env-blur.png';
 import EntitlementSelector from '../EntitlementSelector';
+import { MWI_AUTH_TOKEN_NAME_FOR_HTTP } from '../../constants';
 
 function App () {
     const dispatch = useDispatch();
@@ -165,15 +166,31 @@ function App () {
                     cancel={endSession}
                     title='MATLAB is currently open in another window'
                     cancelButton={wasEverActive ? ('Cancel') : ('Continue in existing window')}
-                    confirmButton = {wasEverActive ? ('Confirm') : ('Continue in this window')}>
+                    confirmButton={wasEverActive ? ('Confirm') : ('Continue in this window')}>
                     {wasEverActive
                         ? 'You have been disconnected because MATLAB is open in another window. Click on Confirm to continue using MATLAB here.'
-                        : <div>MATLAB is open in another window and cannot be opened in a second window or tab at the same time.<br></br>Would you like to continue in this window?</div> }
+                        : <div>MATLAB is open in another window and cannot be opened in a second window or tab at the same time.<br></br>Would you like to continue in this window?</div>}
                 </Confirmation>
             );
         }
     }
 
+    useEffect(() => {
+        const handlePageHide = (event) => {
+            // Performs actions before the component unloads
+            if (isConcurrencyEnabled && !isSessionConcurrent && hasFetchedServerStatus) {
+                // A POST request to clear the active client when the tab/browser is closed
+                navigator.sendBeacon('./clear_client_id');
+            }
+            event.preventDefault();
+            event.returnValue = '';
+        };
+        window.addEventListener('pagehide', handlePageHide);
+        return () => {
+            window.removeEventListener('pagehide', handlePageHide);
+        };
+    }, [isConcurrencyEnabled, isSessionConcurrent, hasFetchedServerStatus]);
+
     useEffect(() => {
         // Initial fetch environment configuration
         if (!hasFetchedEnvConfig) {
@@ -204,7 +221,7 @@ function App () {
 
     useEffect(() => {
         const queryParams = parseQueryParams(window.location);
-        const token = queryParams.get('mwi_auth_token');
+        const token = queryParams.get(MWI_AUTH_TOKEN_NAME_FOR_HTTP);
 
         if (token) {
             dispatch(updateAuthStatus(token));

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/gui/src/constants.js

@@ -4,3 +4,4 @@
 export const STATUS_REQUEST_INTERVAL_MS = 1000;
 // Maximum number of consecutive failed requests allowed before triggering a connection error
 export const MAX_REQUEST_FAIL_COUNT = 60;
+export const MWI_AUTH_TOKEN_NAME_FOR_HTTP = 'mwi-auth-token';

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/matlab_proxy/app.py

@@ -6,7 +6,6 @@ import mimetypes
 import pkgutil
 import secrets
 import sys
-import uuid
 
 import aiohttp
 from aiohttp import client_exceptions, web
@@ -97,16 +96,15 @@ def marshal_error(error):
 
 
 async def create_status_response(
-    app, loadUrl=None, client_id=None, transfer_session=False, is_desktop=False
+    app, loadUrl=None, client_id=None, is_active_client=None
 ):
     """Send a generic status response about the state of server, MATLAB, MATLAB Licensing and the client session status.
 
     Args:
         app (aiohttp.web.Application): Web Server
         loadUrl (String, optional): Represents the root URL. Defaults to None.
-        client_id (String, optional): Represents the unique client_id when concurrency check is enabled. Defaults to None.
-        transfer_session (Boolean, optional): Represents whether the connection should be transfered or not when concurrency check is enabled. Defaults to False.
-        is_desktop (Boolean, optional): Represents whether the request is made by the desktop app or some other kernel. Defaults to False.
+        client_id (String, optional): Represents the generated client_id when concurrency check is enabled and client does not have a client_id. Defaults to None.
+        is_active_client (Boolean, optional): Represents whether the current client is the active_client when concurrency check is enabled. Defaults to None.
 
     Returns:
         JSONResponse: A JSONResponse object containing the generic state of the server, MATLAB, MATLAB Licensing and the client session status.
@@ -124,17 +122,30 @@ async def create_status_response(
         "wsEnv": state.settings.get("ws_env", ""),
     }
 
-    if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
-        if not client_id:
-            client_id = str(uuid.uuid4())
-            status["clientId"] = client_id
+    if client_id:
+        status["clientId"] = client_id
+    if is_active_client is not None:
+        status["isActiveClient"] = is_active_client
 
-        if not state.active_client or transfer_session:
-            state.active_client = client_id
+    return web.json_response(status)
 
-        status["isActiveClient"] = True if state.active_client == client_id else False
 
-    return web.json_response(status)
+@token_auth.authenticate_access_decorator
+async def clear_client_id(req):
+    """API endpoint to reset the active client
+
+    Args:
+        req (HTTPRequest): HTTPRequest Object
+
+    Returns:
+        Response: an empty response in JSON format
+    """
+    # Sleep for one second prior to clearing the client id to ensure that any remaining get_status responses are fully processed first.
+    await asyncio.sleep(1)
+    state = req.app["state"]
+    state.active_client = None
+    # This response is of no relevance to the front-end as the client has already exited
+    return web.json_response({})
 
 
 @token_auth.authenticate_access_decorator
@@ -201,15 +212,17 @@ async def get_status(req):
         JSONResponse: JSONResponse object containing information about the server, MATLAB and MATLAB Licensing.
     """
     # The client sends the CLIENT_ID as a query parameter if the concurrency check has been set to true.
+    state = req.app["state"]
     client_id = req.query.get("MWI_CLIENT_ID", None)
     transfer_session = json.loads(req.query.get("TRANSFER_SESSION", "false"))
     is_desktop = req.query.get("IS_DESKTOP", False)
 
+    generated_client_id, is_active_client = state.get_session_status(
+        is_desktop, client_id, transfer_session
+    )
+
     return await create_status_response(
-        req.app,
-        client_id=client_id,
-        transfer_session=transfer_session,
-        is_desktop=is_desktop,
+        req.app, client_id=generated_client_id, is_active_client=is_active_client
     )
 
 
@@ -773,6 +786,8 @@ async def cleanup_background_tasks(app):
     # Stop any running async tasks
     logger = mwi.logger.get()
     tasks = state.tasks
+    if state.task_detect_client_status:
+        tasks["detect_client_status"] = state.task_detect_client_status
     for task_name, task in tasks.items():
         if not task.cancelled():
             logger.debug(f"Cancelling MWI task: {task_name} : {task} ")
@@ -868,6 +883,7 @@ def create_app(config_name=matlab_proxy.get_default_config_name()):
     app.router.add_route("GET", f"{base_url}/get_auth_token", get_auth_token)
     app.router.add_route("GET", f"{base_url}/get_env_config", get_env_config)
     app.router.add_route("PUT", f"{base_url}/start_matlab", start_matlab)
+    app.router.add_route("POST", f"{base_url}/clear_client_id", clear_client_id)
     app.router.add_route("DELETE", f"{base_url}/stop_matlab", stop_matlab)
     app.router.add_route("PUT", f"{base_url}/set_licensing_info", set_licensing_info)
     app.router.add_route("PUT", f"{base_url}/update_entitlement", update_entitlement)

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/matlab_proxy/app_state.py

@@ -9,14 +9,16 @@ import time
 from collections import deque
 from datetime import datetime, timedelta, timezone
 from typing import Final, Optional
+import uuid
 
 from matlab_proxy import util
-from matlab_proxy.settings import (
-    get_process_startup_timeout,
-)
 from matlab_proxy.constants import (
     CONNECTOR_SECUREPORT_FILENAME,
     MATLAB_LOGS_FILE_NAME,
+    IS_CONCURRENCY_CHECK_ENABLED,
+)
+from matlab_proxy.settings import (
+    get_process_startup_timeout,
 )
 from matlab_proxy.util import mw, mwi, system, windows
 from matlab_proxy.util.mwi import environment_variables as mwi_env
@@ -28,12 +30,11 @@ from matlab_proxy.util.mwi.exceptions import (
     LicensingError,
     MatlabError,
     OnlineLicensingError,
-    XvfbError,
     UIVisibleFatalError,
+    XvfbError,
     log_error,
 )
 
-
 logger = mwi.logger.get()
 
 
@@ -104,6 +105,12 @@ class AppState:
         # connected to the backend
         self.active_client = None
 
+        # Used to detect whether the active client is actively sending out request or is inactive
+        self.active_client_request_detected = False
+
+        # An event loop task to handle the detection of client activity
+        self.task_detect_client_status = None
+
     def __get_cached_config_file(self):
         """Get the cached config file
 
@@ -314,7 +321,11 @@ class AppState:
             [Dict | None]: Returns token authentication headers if any.
         """
         return (
-            {self.settings["mwi_auth_token_name"]: self.settings["mwi_auth_token_hash"]}
+            {
+                self.settings["mwi_auth_token_name_for_http"]: self.settings[
+                    "mwi_auth_token_hash"
+                ]
+            }
             if self.settings["mwi_is_token_auth_enabled"]
             else None
         )
@@ -1301,3 +1312,76 @@ class AppState:
             if err is not None:
                 self.error = err
                 log_error(logger, err)
+
+    def get_session_status(self, is_desktop, client_id, transfer_session):
+        """
+        Determines the session status for a client, potentially generating a new client ID.
+
+        This function is responsible for managing and tracking the session status of a client.
+        It can generate a new client ID if one is not provided and the conditions are met.
+        It also manages the active client status within the session, especially in scenarios
+        involving desktop clients and when concurrency checks are enabled.
+
+        Args:
+            is_desktop (bool): A flag indicating whether the client is a desktop client.
+            client_id (str or None): The client ID. If None, a new client ID may be generated.
+            transfer_session (bool): Indicates whether the session should be transferred to this client.
+
+        Returns:
+            tuple:
+                - A 2-tuple containing the generated client ID (or None if not generated) and
+                a boolean indicating whether the client is considered the active client.
+                - If concurrency checks are not enabled or the client is not a desktop client, it returns None for both
+                the generated client ID and the active client status.
+        """
+        if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
+            generated_client_id = None
+            if not client_id:
+                generated_client_id = str(uuid.uuid4())
+                client_id = generated_client_id
+
+            if not self.active_client or transfer_session:
+                self.active_client = client_id
+
+                if not self.task_detect_client_status:
+                    # Create the loop to detect the active status of the client
+                    loop = util.get_event_loop()
+                    self.task_detect_client_status = loop.create_task(
+                        self.detect_active_client_status()
+                    )
+
+            if self.active_client == client_id:
+                is_active_client = True
+                self.active_client_request_detected = True
+            else:
+                is_active_client = False
+            return generated_client_id, is_active_client
+        return None, None
+
+    async def detect_active_client_status(self, sleep_time=1, max_inactive_count=10):
+        """Detects whether the client is online or not by continuously checking if the active client is making requests
+
+        Args:
+            sleep_time (int): The time in seconds for which the process waits before checking for the next get_status request from the active client.
+            max_inactive_count (int): The maximum number of times the check for the request from the active_client fails before reseting the active client id.
+        """
+        inactive_count = 0
+        while self.active_client:
+            # Check if the get_status request from the active client is received or not
+            await asyncio.sleep(sleep_time)
+            if self.active_client_request_detected:
+                self.active_client_request_detected = False
+                inactive_count = 0
+            else:
+                inactive_count = inactive_count + 1
+            if inactive_count > max_inactive_count:
+                # If no request is received from the active_client for more than 10 seconds then clear the active client id
+                inactive_count = 0
+                self.active_client = None
+        if self.task_detect_client_status:
+            try:
+                # Self cleanup of the task
+                self.task_detect_client_status.cancel()
+                self.task_detect_client_status = None
+            except Exception as e:
+                logger.error("Cleaning of task: 'detect_client_status' failed.")

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/matlab_proxy/constants.py

@@ -26,3 +26,4 @@ SUPPORTED_MATLAB_VERSIONS: Final[List[str]] = [
 
 # This constant when set to True restricts the number of active sessions to one
 IS_CONCURRENCY_CHECK_ENABLED: Final[bool] = True
+MWI_AUTH_TOKEN_NAME_FOR_HTTP = "mwi-auth-token"

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/matlab_proxy/settings.py

@@ -17,6 +17,7 @@ from cryptography.x509.oid import NameOID
 
 import matlab_proxy
 from matlab_proxy import constants
+from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
 from matlab_proxy.util import mwi, system
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi import token_auth
@@ -197,11 +198,12 @@ def get_dev_settings(config):
         "mwi_logs_root_dir": get_mwi_logs_root_dir(dev=True),
         "mw_context_tags": get_mw_context_tags(matlab_proxy.get_default_config_name()),
         "mwi_server_url": None,
-        "mwi_is_token_auth_enabled": mwi_auth_token != None,
+        "mwi_is_token_auth_enabled": mwi_auth_token is not None,
         "mwi_auth_status": False,
         "mwi_auth_token": mwi_auth_token,
         "mwi_auth_token_hash": mwi_auth_token_hash,
-        "mwi_auth_token_name": mwi_env.get_env_name_mwi_auth_token().lower(),
+        "mwi_auth_token_name_for_http": MWI_AUTH_TOKEN_NAME_FOR_HTTP,
+        "mwi_auth_token_name_for_env": mwi_env.get_env_name_mwi_auth_token().lower(),
         "mwi_use_existing_license": mwi.validators.validate_use_existing_licensing(
             os.getenv(mwi_env.get_env_name_mwi_use_existing_license(), "")
         ),
@@ -322,11 +324,12 @@ def get_server_settings(config_name):
         "mw_context_tags": get_mw_context_tags(config_name),
         # The url where the matlab-proxy server is accessible at
         "mwi_server_url": None,
-        "mwi_is_token_auth_enabled": mwi_auth_token != None,
+        "mwi_is_token_auth_enabled": mwi_auth_token is not None,
         "mwi_auth_status": False,
         "mwi_auth_token": mwi_auth_token,
         "mwi_auth_token_hash": mwi_auth_token_hash,
-        "mwi_auth_token_name": mwi_env.get_env_name_mwi_auth_token().lower(),
+        "mwi_auth_token_name_for_http": MWI_AUTH_TOKEN_NAME_FOR_HTTP,
+        "mwi_auth_token_name_for_env": mwi_env.get_env_name_mwi_auth_token().lower(),
         "mwi_use_existing_license": mwi.validators.validate_use_existing_licensing(
             os.getenv(mwi_env.get_env_name_mwi_use_existing_license(), "")
         ),

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/matlab_proxy/util/mwi/token_auth.py

@@ -59,7 +59,7 @@ def generate_mwi_auth_token_and_hash():
 def get_mwi_auth_token_access_str(app_settings):
     """Returns formatted string with mwi token for use with server URL"""
     if app_settings["mwi_is_token_auth_enabled"]:
-        mwi_auth_token_name = app_settings["mwi_auth_token_name"]
+        mwi_auth_token_name = app_settings["mwi_auth_token_name_for_http"]
         mwi_auth_token = app_settings["mwi_auth_token"]
         return f"?{mwi_auth_token_name}={mwi_auth_token}"
 
@@ -134,7 +134,20 @@ async def _get_token_name(request):
         str : token name
     """
     app_settings = request.app["settings"]
-    return app_settings["mwi_auth_token_name"]
+    return app_settings["mwi_auth_token_name_for_env"]
+
+
+def _get_token_name_for_http(request):
+    """Gets the name of the token from settings.
+
+    Args:
+        request (HTTPRequest) : Used to get to app settings
+
+    Returns:
+        str : token name
+    """
+    app_settings = request.app["settings"]
+    return app_settings["mwi_auth_token_name_for_http"]
 
 
 async def _get_token(request):
@@ -238,11 +251,11 @@ async def _is_valid_token_in_url_query(request):
     query_string = request.query_string
     logger.debug(f"url query parameters found:{query_string}")
     if query_string:
-        token_name = await _get_token_name(request)
+        token_name = _get_token_name_for_http(request)
         parsed_token = parse_qs(request.query_string).get(token_name)
         if parsed_token:
             parsed_token = parsed_token[0]
-            logger.debug(f"parsed_token from url query string.")
+            logger.debug("parsed_token from url query string.")
             return await _is_valid_token(parsed_token, request)
 
     logger.debug("Token not found in url query.")
@@ -262,8 +275,9 @@ async def _is_valid_token_in_headers(request):
     """
     logger.debug("Checking for token in request headers...")
     headers = request.headers
-    token_name = await _get_token_name(request)
+    token_name = _get_token_name_for_http(request)
     if token_name in headers:
+        logger.debug(f"Token found in headers: {token_name}")
         is_valid_token = await _is_valid_token(headers[token_name], request)
         if is_valid_token:
             await _store_token_hash_into_session(request)

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0/matlab_proxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matlab-proxy
-Version: 0.15.1
+Version: 0.17.0
 Summary: Python® package enables you to launch MATLAB® and access it from a web browser.
 Home-page: https://github.com/mathworks/matlab-proxy/
 Author: The MathWorks, Inc.

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/setup.py

@@ -70,7 +70,7 @@ long_description = (HERE / "README.md").read_text()
 
 setuptools.setup(
     name="matlab-proxy",
-    version="0.15.1",
+    version="0.17.0",
     url=config["doc_url"],
     author="The MathWorks, Inc.",
     author_email="cloud@mathworks.com",

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/tests/integration/integration_tests_with_license/test_http_end_points.py

@@ -12,7 +12,7 @@ import re
 from requests.adapters import HTTPAdapter, Retry
 from urllib.parse import urlparse, parse_qs
 from tests.utils.logging_util import create_integ_test_logger
-from logging import DEBUG
+from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
 
 _logger = create_integ_test_logger(__name__)
 
@@ -64,9 +64,9 @@ class RealMATLABServer:
         parsed_url = urlparse(utils.get_connection_string(self.mwi_app_port))
 
         self.headers = {
-            "mwi_auth_token": (
-                parse_qs(parsed_url.query)["mwi_auth_token"][0]
-                if "mwi_auth_token" in parse_qs(parsed_url.query)
+            MWI_AUTH_TOKEN_NAME_FOR_HTTP: (
+                parse_qs(parsed_url.query)[MWI_AUTH_TOKEN_NAME_FOR_HTTP][0]
+                if MWI_AUTH_TOKEN_NAME_FOR_HTTP in parse_qs(parsed_url.query)
                 else ""
             )
         }

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/tests/integration/integration_tests_without_license/conftest.py

@@ -6,6 +6,7 @@ import requests
 from tests.utils.logging_util import create_integ_test_logger
 import os
 from urllib.parse import urlparse, parse_qs
+from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
 
 _logger = create_integ_test_logger(__name__)
 
@@ -34,9 +35,9 @@ def parse_matlab_proxy_url():
     parsed_url = urlparse(utils.get_connection_string(mwi_app_port))
 
     headers = {
-        "mwi_auth_token": (
-            parse_qs(parsed_url.query)["mwi_auth_token"][0]
-            if "mwi_auth_token" in parse_qs(parsed_url.query)
+        MWI_AUTH_TOKEN_NAME_FOR_HTTP: (
+            parse_qs(parsed_url.query)[MWI_AUTH_TOKEN_NAME_FOR_HTTP][0]
+            if MWI_AUTH_TOKEN_NAME_FOR_HTTP in parse_qs(parsed_url.query)
             else ""
         )
     }

{matlab-proxy-0.15.1 → matlab-proxy-0.17.0}/tests/unit/test_app.py

@@ -284,6 +284,20 @@ async def test_get_status_route(test_server):
     assert resp.status == HTTPStatus.OK
 
 
+async def test_clear_client_id_route(test_server):
+    """Test to check endpoint: "/clear_client_id"
+
+    Args:
+        test_server (aiohttp_client): A aiohttp_client server for sending POST request.
+    """
+
+    state = test_server.server.app["state"]
+    state.active_client = "mock_client_id"
+    resp = await test_server.post("/clear_client_id")
+    assert resp.status == HTTPStatus.OK
+    assert state.active_client is None
+
+
 async def test_get_env_config(test_server):
     """Test to check endpoint : "/get_env_config"
 
@@ -1031,7 +1045,7 @@ async def test_update_entitlement_with_correct_entitlement(set_licensing_info):
     assert resp.status == HTTPStatus.OK
 
 
-async def test_get_auth_token_route(test_server, monkeypatch):
+async def test_get_auth_token_route(test_server):
     """Test to check endpoint : "/get_auth_token"
 
     Args: