Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DiamondLightSource_python-murfey /tests /instrument_server /test_init.py
| import logging | |
| import sys | |
| from typing import Optional | |
| from unittest.mock import MagicMock | |
| from urllib.parse import urlparse | |
| import pytest | |
| import uvicorn | |
| from fastapi import FastAPI | |
| from fastapi.testclient import TestClient | |
| from packaging.version import Version | |
| from pytest_mock import MockerFixture | |
| import murfey | |
| from murfey.client.update import UPDATE_SUCCESS | |
| from murfey.instrument_server import check_for_updates, run | |
| from murfey.server.api.bootstrap import pypi as pypi_router, version as version_router | |
| from murfey.util.api import url_path_for | |
| from murfey.util.logging import HTTPSHandler | |
| # Set up a test router with only the essential endpoints | |
| app = FastAPI() | |
| for router in [pypi_router, version_router]: | |
| app.include_router(router) | |
| client = TestClient(app) | |
| base_url = str(client.base_url) | |
| check_for_updates_test_matrix = ( | |
| # Downgrade, upgrade, or keep client version? | |
| ("downgrade",), | |
| ("upgrade",), | |
| ("keep",), | |
| ) | |
| def test_check_for_updates( | |
| test_params: tuple[str], | |
| mocker: MockerFixture, | |
| ): | |
| # Unpack test params | |
| (bump_client_version,) = test_params | |
| # Modify client version as needed | |
| current_version = murfey.__version__ | |
| supported_client_version = murfey.__supported_client_version__ | |
| major, minor, patch = Version(current_version).release | |
| # Adjust the perceived client version in the function being tested | |
| if bump_client_version == "downgrade": | |
| support_client_version_parts = Version(supported_client_version).release | |
| if patch == 0: | |
| if minor == 0: | |
| if major == 0: | |
| # This can't be downgraded, so skip | |
| pytest.skip("This version can't be downgraded anymore; skipping") | |
| else: | |
| major = support_client_version_parts[0] - 1 | |
| print(f"Downgraded major version to {major}") | |
| else: | |
| minor = support_client_version_parts[1] - 1 | |
| print(f"Downgraded minor version to {minor}") | |
| else: | |
| patch = support_client_version_parts[2] - 1 | |
| print(f"Downgraded patch version to {patch}") | |
| elif bump_client_version == "upgrade": | |
| patch += 1 | |
| print(f"Bumped patch version to {patch}") | |
| mock_client_version = f"{major}.{minor}.{patch}" | |
| # Run the version check query and get a response to patch in later | |
| api_base = urlparse(base_url, allow_fragments=False) | |
| proxy_path = api_base.path.rstrip("/") | |
| version_check_path = url_path_for("bootstrap.version", "get_version") | |
| version_check_query = f"client_version={mock_client_version}" | |
| version_check_url = api_base._replace( | |
| path=f"{proxy_path}{version_check_path}", | |
| query=version_check_query, | |
| ) | |
| version_check_response = client.get(f"{version_check_path}?{version_check_query}") | |
| # Check that the endpoint works as expected | |
| assert version_check_response.status_code == 200 | |
| assert version_check_response.json() == { | |
| "server": current_version, | |
| "oldest-supported-client": supported_client_version, | |
| "client-needs-update": True if bump_client_version == "downgrade" else False, | |
| "client-needs-downgrade": True if bump_client_version == "upgrade" else False, | |
| } | |
| # Patch the URL parse result | |
| mock_parse = mocker.patch("murfey.instrument_server.urlparse") | |
| mock_parse.return_value = api_base | |
| # Patch the result of get | |
| mock_get = mocker.patch("murfey.client.update.requests.get") | |
| mock_get.return_value = version_check_response | |
| # Patch the installation function | |
| mock_install = mocker.patch("murfey.client.update.install_murfey") | |
| # Patch the perceived client version | |
| mocker.patch("murfey.client.update.murfey.__version__", new=mock_client_version) | |
| # If changing the client version, check that 'install_murfey' and 'exit' are called | |
| if bump_client_version in ("upgrade", "downgrade"): | |
| with pytest.raises(SystemExit) as exc_info: | |
| check_for_updates() | |
| mock_install.assert_called_once() | |
| # Check that 'exit' is called with the correct message | |
| assert exc_info.value.code == UPDATE_SUCCESS | |
| # If client version is the same, 'install_murfey' shouldn't be called | |
| else: | |
| check_for_updates() | |
| mock_install.assert_not_called() | |
| # Check that the query URL is correct | |
| mock_get.assert_called_once_with(version_check_url.geturl()) | |
| start_instrument_server_test_matrix = ( | |
| # Host | Port | |
| ( | |
| None, | |
| None, | |
| ), # Test default values | |
| ( | |
| "127.0.0.1", | |
| 8000, | |
| ), # Test manually included values | |
| ) | |
| def test_start_instrument_server( | |
| mocker: MockerFixture, | |
| mock_client_configuration, | |
| test_params: tuple[Optional[str], Optional[int]], | |
| ): | |
| # Unpack test params | |
| host, port = test_params | |
| # Patch the 'read_config' function | |
| _ = mocker.patch( | |
| "murfey.util.client.read_config", return_value=mock_client_configuration | |
| ) | |
| # Mock the HTTPSHandler (test it separately in a unit test) | |
| mock_https_handler_instance = MagicMock() | |
| mock_https_handler_instance.level = logging.INFO | |
| mock_https_handler_instance.setLevel.return_value = None | |
| mock_https_handler = mocker.patch( | |
| "murfey.util.logging.HTTPSHandler", | |
| spec=HTTPSHandler, | |
| ) | |
| mock_https_handler.return_value = mock_https_handler_instance | |
| # Patch the Uvicorn Server instance | |
| mock_server = mocker.patch("uvicorn.Server") | |
| # Disable 'run'; we just want to confirm it's called correctly | |
| mock_server.run.return_value = lambda: None | |
| # Construct the expected Uvicorn Config object and save it as a dict | |
| expected_config = vars( | |
| uvicorn.Config( | |
| "murfey.instrument_server.main:app", | |
| host=host if host is not None else "0.0.0.0", | |
| port=port if port is not None else 8001, | |
| log_config=None, | |
| ws_ping_interval=300, | |
| ws_ping_timeout=300, | |
| ) | |
| ) | |
| # Construct the arguments to pass to the instrument server | |
| sys.argv = [ | |
| "murfey.instrument_server", | |
| ] | |
| # Add host and port if they're present | |
| if host is not None: | |
| sys.argv.extend(["--host", host]) | |
| if port is not None: | |
| sys.argv.extend(["--port", str(port)]) | |
| # Run the function | |
| run() | |
| # Check that the server was called with the correct arguments | |
| args, kwargs = mock_server.call_args | |
| actual_config = vars(kwargs["config"]) | |
| assert expected_config == actual_config | |
Xet Storage Details
- Size:
- 6.69 kB
- Xet hash:
- b4eb5e146ccbcf7d0e3838534f89b07bba543e25caf216bed3b8e037f60dec76
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.