Adding in local changes after testing

Not sure these are really needed but I wanted to save them for later in
case we do need them.

Author: davidpcls

bluesky_httpserver/authenticators.py

@@ -152,7 +152,10 @@ def __init__(
     def _config_from_oidc_url(self) -> dict[str, Any]:
         response: httpx.Response = httpx.get(self._well_known_url)
         response.raise_for_status()
-        return response.json()
+        json_data = response.json()
+        print("OIDC URL Data:")
+        print(json_data)
+        return json_data
 
     @functools.cached_property
     def client_id(self) -> str:
@@ -194,6 +197,9 @@ def keys(self) -> List[str]:
         return httpx.get(self.jwks_uri).raise_for_status().json().get("keys", [])
 
     def decode_token(self, token: str) -> dict[str, Any]:
+        print("Comparing JWT token")
+        print(f"Issuer: {self.issuer}")
+        print(f"Audience: {self._audience}")
         return jwt.decode(
             token,
             key=self.keys(),

bluesky_httpserver/tests/conftest.py

@@ -1,16 +1,35 @@
 import os
+import socket
 import time as ttime
 
 import pytest
 import requests
 from bluesky_queueserver.manager.comms import zmq_single_request
-from bluesky_queueserver.manager.tests.common import set_qserver_zmq_encoding  # noqa: F401
+from bluesky_queueserver.manager.tests.common import (  # noqa: F401
+    ReManager,
+    condition_manager_idle,
+    set_qserver_zmq_address,
+    set_qserver_zmq_encoding,
+    wait_for_condition,
+)
 from xprocess import ProcessStarter
 
 import bluesky_httpserver.server as bqss
 
-SERVER_ADDRESS = "localhost"
-SERVER_PORT = "60610"
+
+def _get_free_tcp_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("", 0))
+        sock.listen(1)
+        return sock.getsockname()[1]
+
+
+SERVER_BIND_HOST = os.getenv("QSERVER_HTTP_TEST_BIND_HOST", "127.0.0.1")
+SERVER_ADDRESS = os.getenv("QSERVER_HTTP_TEST_HOST", "localhost")
+SERVER_PORT = os.getenv("QSERVER_HTTP_TEST_PORT", str(_get_free_tcp_port()))
+
+QSERVER_TEST_REDIS_ADDR = os.getenv("QSERVER_TEST_REDIS_ADDR", "localhost")
+QSERVER_TEST_ZMQ_CLIENT_HOST = os.getenv("QSERVER_TEST_ZMQ_CLIENT_HOST", "localhost")
 
 # Single-user API key used for most of the tests
 API_KEY_FOR_TESTS = "APIKEYFORTESTS"
@@ -41,7 +60,7 @@ class Starter(ProcessStarter):
         env["QSERVER_HTTP_SERVER_SINGLE_USER_API_KEY"] = API_KEY_FOR_TESTS
 
         pattern = "Bluesky HTTP Server started successfully"
-        args = f"uvicorn --host={SERVER_ADDRESS} --port {SERVER_PORT} {bqss.__name__}:app".split()
+        args = f"uvicorn --host={SERVER_BIND_HOST} --port {SERVER_PORT} {bqss.__name__}:app".split()
         # args = f"start-bluesky-httpserver --host={SERVER_ADDRESS} --port {SERVER_PORT}".split()
 
     xprocess.ensure("fastapi_server", Starter)
@@ -60,7 +79,7 @@ def fastapi_server_fs(xprocess):
     to perform additional steps (such as setting environmental variables) before the server is started.
     """
 
-    def start(http_server_host=SERVER_ADDRESS, http_server_port=SERVER_PORT, api_key=API_KEY_FOR_TESTS):
+    def start(http_server_host=SERVER_BIND_HOST, http_server_port=SERVER_PORT, api_key=API_KEY_FOR_TESTS):
         class Starter(ProcessStarter):
             max_read_lines = 53
 
@@ -79,6 +98,100 @@ class Starter(ProcessStarter):
     xprocess.getinfo("fastapi_server").terminate()
 
 
+def _reset_queue_mode():
+    """Reset queue mode to default mode."""
+    response, message = zmq_single_request("queue_mode_set", {"mode": "default"})
+    if response["success"] is not True:
+        raise RuntimeError(message)
+
+
+def _build_re_manager_params(params=None):
+    params = list(params or [])
+
+    if not any(_.startswith("--zmq-control-addr") for _ in params):
+        control_port = _get_free_tcp_port()
+        params.append(f"--zmq-control-addr=tcp://*:{control_port}")
+    else:
+        control_port = int(next(_.split(":")[-1] for _ in params if _.startswith("--zmq-control-addr")).strip())
+
+    if not any(_.startswith("--zmq-info-addr") for _ in params):
+        info_port = _get_free_tcp_port()
+        params.append(f"--zmq-info-addr=tcp://*:{info_port}")
+
+    if not any(_.startswith("--redis-addr") for _ in params):
+        params.append(f"--redis-addr={QSERVER_TEST_REDIS_ADDR}")
+
+    if not any(_.startswith("--redis-name-prefix") for _ in params):
+        params.append(f"--redis-name-prefix=qs_unit_tests_{control_port}")
+
+    client_zmq_address = f"tcp://{QSERVER_TEST_ZMQ_CLIENT_HOST}:{control_port}"
+    return params, client_zmq_address
+
+
+@pytest.fixture
+def re_manager(monkeypatch):
+    """Start RE Manager on dynamically assigned ports for each test."""
+    params, client_zmq_address = _build_re_manager_params()
+    set_qserver_zmq_address(monkeypatch, zmq_server_address=client_zmq_address)
+
+    manager = ReManager(params)
+    failed_to_start = False
+
+    if not wait_for_condition(time=10, condition=condition_manager_idle):
+        failed_to_start = True
+        manager.kill_manager()
+        raise TimeoutError("Timeout: RE Manager failed to start.")
+
+    _reset_queue_mode()
+
+    yield manager
+
+    if not failed_to_start:
+        manager.stop_manager()
+    else:
+        manager.kill_manager()
+
+
+@pytest.fixture
+def re_manager_cmd(monkeypatch):
+    """Create RE Manager with dynamic ports and return handle factory."""
+    state = {"manager": None}
+    failed_to_start = False
+
+    def _close():
+        manager = state["manager"]
+        if manager is not None:
+            if not failed_to_start:
+                manager.stop_manager()
+            else:
+                manager.kill_manager()
+            state["manager"] = None
+
+    def create_re_manager(params=None, *, stdout=None, stderr=None, set_redis_name_prefix=True):
+        nonlocal failed_to_start
+        _close()
+        params_built, client_zmq_address = _build_re_manager_params(params=params)
+        set_qserver_zmq_address(monkeypatch, zmq_server_address=client_zmq_address)
+        state["manager"] = ReManager(
+            params_built,
+            stdout=stdout,
+            stderr=stderr,
+            set_redis_name_prefix=set_redis_name_prefix,
+        )
+
+        if not wait_for_condition(time=10, condition=condition_manager_idle):
+            failed_to_start = True
+            state["manager"].kill_manager()
+            raise TimeoutError("Timeout: RE Manager failed to start.")
+
+        failed_to_start = False
+        _reset_queue_mode()
+        return state["manager"]
+
+    yield create_re_manager
+    _close()
+
+
 def setup_server_with_config_file(*, config_file_str, tmpdir, monkeypatch):
     """
     Creates config file for the server in ``tmpdir/config/`` directory and

bluesky_httpserver/tests/test_authenticators.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 from typing import Any, Tuple
 
@@ -13,17 +14,17 @@
 # fmt: off
 from ..authenticators import LDAPAuthenticator, OIDCAuthenticator, ProxiedOIDCAuthenticator, UserSessionState
 
+LDAP_TEST_HOST = os.getenv("QSERVER_TEST_LDAP_HOST", "localhost")
+LDAP_TEST_PORT = int(os.getenv("QSERVER_TEST_LDAP_PORT", "1389"))
+
 
 @pytest.mark.parametrize("ldap_server_address, ldap_server_port", [
-    ("localhost", 1389),
-    ("localhost:1389", 904),  # Random port, ignored
-    ("localhost:1389", None),
-    ("127.0.0.1", 1389),
-    ("127.0.0.1:1389", 904),
-    (["localhost"], 1389),
-    (["localhost", "127.0.0.1"], 1389),
-    (["localhost", "127.0.0.1:1389"], 1389),
-    (["localhost:1389", "127.0.0.1:1389"], None),
+    (LDAP_TEST_HOST, LDAP_TEST_PORT),
+    (f"{LDAP_TEST_HOST}:{LDAP_TEST_PORT}", 904),  # Random port, ignored
+    (f"{LDAP_TEST_HOST}:{LDAP_TEST_PORT}", None),
+    ([LDAP_TEST_HOST], LDAP_TEST_PORT),
+    ([LDAP_TEST_HOST, f"{LDAP_TEST_HOST}:{LDAP_TEST_PORT}"], LDAP_TEST_PORT),
+    ([f"{LDAP_TEST_HOST}:{LDAP_TEST_PORT}", f"{LDAP_TEST_HOST}:{LDAP_TEST_PORT}"], None),
 ])
 # fmt: on
 @pytest.mark.parametrize("use_tls,use_ssl", [(False, False)])