diracx-testing 0.0.4__tar.gz

diracx_testing-0.0.4/.gitignore

@@ -0,0 +1,98 @@
+# Python
+*.py[cod]
+
+# Conda
+.conda
+
+# C extensions
+*.so
+var
+sdist
+lib
+lib64
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+develop-eggs
+.installed.cfg
+*.whl
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+.ruff_cache
+.mypy_cache
+
+# Eclipse
+.project
+.pydevproject
+.pyproject
+.settings
+.metadata
+
+#VSCode
+.vscode
+.env
+
+# Vim
+.*.sw[a-z]
+*.un~
+Session.vim
+*~
+
+# Intellij
+.idea/
+LHCbDIRAC.iml
+
+# MaxOSX files
+.DS_Store
+
+# test stuff
+.pytest_cache
+.cache
+__pycache__
+pytests.xml
+nosetests.xml
+coverage.xml
+Local_*
+.hypothesis
+*.gz
+htmlcov/
+*.xml.temp
+
+#remove in case we want a specific LHCb one
+.pylintrc
+
+# docs
+# this is auto generated
+docs/source/CodeDocumentation/
+docs/source/AdministratorGuide/Configuration/ExampleConfig.rst
+docs/source/AdministratorGuide/CommandReference
+docs/source/UserGuide/CommandReference
+docs/_build
+docs/source/_build
+
+
+# CMT junk
+/*/*/x86_64-*-*-*/
+*/*/cmt/Makefile
+
+# pixi environments
+.pixi
+pixi.lock
+*.egg-info

diracx_testing-0.0.4/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: diracx-testing
+Version: 0.0.4
+Summary: TODO
+License: GPL-3.0-only
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.11
+Requires-Dist: httpx
+Requires-Dist: joserfc
+Requires-Dist: pytest
+Requires-Dist: pytest-asyncio==1.0.0
+Requires-Dist: pytest-cov
+Requires-Dist: pytest-github-actions-annotate-failures
+Requires-Dist: pytest-xdist
+Requires-Dist: uuid-utils
+Provides-Extra: testing

diracx_testing-0.0.4/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "diracx-testing"
+description = "TODO"
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = []
+license = {text = "GPL-3.0-only"}
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Topic :: System :: Distributed Computing",
+]
+dependencies = [
+    "pytest",
+    "pytest-asyncio==1.0.0",
+    "pytest-cov",
+    "pytest-xdist",
+    "httpx",
+    "joserfc",
+    "uuid-utils",
+    "pytest-github-actions-annotate-failures",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+testing = [
+    "diracx-testing",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+root = ".."
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/diracx"]

diracx_testing-0.0.4/src/diracx/testing/__init__.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from .entrypoints import verify_entry_points
+from .utils import (
+    ClientFactory,
+    aio_moto,
+    cli_env,
+    client_factory,
+    demo_dir,
+    demo_kubectl_env,
+    demo_urls,
+    do_device_flow_with_dex,
+    fernet_key,
+    private_key,
+    pytest_addoption,
+    session_client_factory,
+    test_auth_settings,
+    test_dev_settings,
+    test_login,
+    test_sandbox_settings,
+    with_cli_login,
+    with_config_repo,
+)
+
+__all__ = (
+    "verify_entry_points",
+    "ClientFactory",
+    "do_device_flow_with_dex",
+    "test_login",
+    "pytest_addoption",
+    "private_key",
+    "fernet_key",
+    "test_dev_settings",
+    "test_auth_settings",
+    "aio_moto",
+    "test_sandbox_settings",
+    "session_client_factory",
+    "client_factory",
+    "with_config_repo",
+    "demo_dir",
+    "demo_urls",
+    "demo_kubectl_env",
+    "cli_env",
+    "with_cli_login",
+)

diracx_testing-0.0.4/src/diracx/testing/__main__.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import shlex
+import subprocess
+from importlib.resources import as_file, files
+from pathlib import Path
+from typing import NoReturn
+
+SCRIPTS_BASE = files("diracx.testing").joinpath("scripts")
+
+
+def parse_args() -> None:
+    """Access to various utility scripts for testing DiracX and extensions."""
+    parser = argparse.ArgumentParser(description="Utility for testing DiracX.")
+    sp = parser.add_subparsers(dest="command", required=True)
+
+    # Create the 'coverage' argument group.
+    coverage_p = sp.add_parser("coverage", help="Coverage related commands")
+    coverage_sp = coverage_p.add_subparsers(dest="subcommand", required=True)
+
+    # Add the 'collect-demo' command under 'coverage'.
+    collect_demo_p = coverage_sp.add_parser(
+        "collect-demo", help="Collect demo coverage"
+    )
+    collect_demo_p.add_argument(
+        "--demo-dir",
+        required=True,
+        type=Path,
+        help="Path to the .demo dir of the diracx-charts repo.",
+    )
+    collect_demo_p.set_defaults(func=lambda a: coverage_collect_demo(a.demo_dir))
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+def coverage_collect_demo(demo_dir: Path) -> NoReturn:
+    """Collect coverage data from a running instance of the demo.
+
+    This script is primarily intended for use in CI/CD pipelines.
+    """
+    from diracx.core.extensions import extensions_by_priority
+
+    client_extension_name = min(extensions_by_priority(), key=lambda x: x == "diracx")
+
+    with as_file(SCRIPTS_BASE / "collect_demo_coverage.sh") as script_file:
+        cmd = ["bash", str(script_file), "--demo-dir", str(demo_dir)]
+        if client_extension_name in {"diracx", "gubbins"}:
+            cmd += ["--diracx-repo", str(Path.cwd())]
+            if client_extension_name == "gubbins":
+                cmd += ["--extension-name", "gubbins"]
+                cmd += ["--extension-repo", str(Path.cwd() / "extensions" / "gubbins")]
+        else:
+            cmd += ["--extension-name", client_extension_name]
+            cmd += ["--extension-repo", str(Path.cwd())]
+        print("Running:", shlex.join(cmd))
+        proc = subprocess.run(cmd, check=False)
+    if proc.returncode == 0:
+        print("Process completed successfully.")
+    else:
+        print("Process failed with return code", proc.returncode)
+    raise SystemExit(proc.returncode)
+
+
+if __name__ == "__main__":
+    parse_args()

diracx_testing-0.0.4/src/diracx/testing/client_generation.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+__all__ = [
+    "regenerate_client",
+]
+
+import argparse
+import ast
+import importlib.util
+import json
+import os
+import shlex
+import subprocess
+import sys
+from importlib.metadata import Distribution
+from pathlib import Path
+from urllib.parse import urlparse
+
+import git
+
+AUTOREST_VERSION = "3.7.1"
+AUTOREST_CORE_VERSION = "3.10.4"
+AUTOREST_PUGINS = {
+    "@autorest/python": "6.34.2",
+    "@autorest/modelerfour": "4.23.7",
+}
+
+
+def extract_static_all(path):
+    tree = ast.parse(path.read_text(), filename=path)
+
+    name_to_module = {}
+    for node in tree.body:
+        if isinstance(node, ast.ImportFrom):
+            # Skip wildcard imports (like 'from ... import *')
+            for alias in node.names:
+                if alias.name == "*":
+                    continue
+                # Use the alias if available, otherwise the original name.
+                local_name = alias.asname if alias.asname else alias.name
+                name_to_module[local_name] = node.module
+
+    # Look for the first top-level assignment to __all__
+    for node in tree.body:
+        if not isinstance(node, ast.Assign):
+            continue
+        for target in node.targets:
+            if not (isinstance(target, ast.Name) and target.id == "__all__"):
+                continue
+            return {
+                name: name_to_module.get(name) for name in ast.literal_eval(node.value)
+            }
+    raise NotImplementedError("__all__ not found")
+
+
+def fixup_models_init(generated_dir, extension_name):
+    """Workaround for https://github.com/python/mypy/issues/15300."""
+    models_init_path = generated_dir / "models" / "__init__.py"
+    # Enums cannot be extended, so we don't need to patch them
+    object_names = {
+        name
+        for name, module in extract_static_all(models_init_path).items()
+        if module != "_enums"
+    }
+
+    patch_module = "diracx.client._generated.models._patch"
+    spec = importlib.util.find_spec(patch_module)
+    if spec is None or spec.origin is None:
+        raise ImportError(f"Cannot locate {patch_module} package")
+    missing = set(extract_static_all(Path(spec.origin))) - set(object_names)
+    missing_formatted = "\n".join(f'            "{name}",' for name in missing)
+
+    with models_init_path.open("a") as fh:
+        fh.write(
+            "if TYPE_CHECKING:\n"
+            "    __all__.extend(\n"
+            "        [\n"
+            f"{missing_formatted}"
+            "        ]\n"
+            "    )\n"
+        )
+
+
+def _module_path(module_name: str) -> Path:
+    """Get the path to a module.
+
+    Args:
+        module_name: The name of the module.
+
+    Returns:
+        The path to the module.
+
+    """
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        raise ImportError("Cannot locate client_module package")
+    if spec.origin is None:
+        raise ImportError(
+            "Cannot locate client_module package, did you forget the __init__.py?"
+        )
+    return Path(spec.origin).parent
+
+
+def regenerate_client(openapi_spec: Path, client_module: str):
+    """Regenerate the AutoREST client and run pre-commit checks on it.
+
+    This test is skipped by default, and can be enabled by passing
+    --regenerate-client to pytest. It is intended to be run manually
+    when the API changes.
+
+    The reason this is a test is that it is the only way to get access to the
+    test_client fixture, which is required to get the OpenAPI spec.
+
+    WARNING: This test will modify the source code of the client!
+    """
+    client_root = _module_path(client_module)
+
+    # If the client is not an editable install, we need to find the source code
+    direct_url = Distribution.from_name(client_module).read_text("direct_url.json")
+    pkg_url_info = json.loads(direct_url)
+    if not pkg_url_info.get("dir_info", {}).get("editable", False):
+        src_url = pkg_url_info.get("url")
+        if src_url is None:
+            raise ValueError("No URL found in direct_url.json")
+        url_info = urlparse(src_url)
+        if url_info.scheme != "file":
+            raise ValueError("URL is not a file URL")
+        pkg_root = Path(url_info.path) / "src" / client_module.replace(".", "/")
+        if not pkg_root.is_dir():
+            raise NotImplementedError(
+                "Failed to resolve client sources", client_module, pkg_root
+            )
+        client_root = pkg_root
+
+    if not pkg_url_info.get("dir_info", {}).get("editable", False):
+        raise NotImplementedError(
+            "Client generation from non-editable install is not yet supported",
+        )
+
+    assert client_root.is_dir()
+    assert client_root.name == "client"
+    assert (client_root / "_generated").is_dir()
+    extension_name = client_root.parent.name
+
+    repo_root = client_root.parents[3]
+    if extension_name == "gubbins" and not (repo_root / ".git").is_dir():
+        # Gubbins is special because it has a different structure due to being
+        # in a subdirectory of diracx
+        repo_root = repo_root.parents[1]
+    assert (repo_root / ".git").is_dir()
+    repo = git.Repo(repo_root)
+    generated_dir = client_root / "_generated"
+    if repo.is_dirty(path=generated_dir):
+        raise AssertionError(
+            "Client is currently in a modified state, skipping regeneration"
+        )
+
+    cmd = ["autorest", f"--version={AUTOREST_CORE_VERSION}"]
+    for plugin, version in AUTOREST_PUGINS.items():
+        cmd.append(f"--use={plugin}@{version}")
+    cmd += [
+        "--python",
+        f"--input-file={openapi_spec}",
+        "--models-mode=msrest",
+        "--namespace=_generated",
+        f"--output-folder={client_root}",
+    ]
+
+    if "AUTOREST_HOME" in os.environ:
+        os.makedirs(os.environ["AUTOREST_HOME"], exist_ok=True)
+
+    # ruff: disable=S603
+    subprocess.run(cmd, check=True)
+
+    if extension_name != "diracx":
+        # For now we don't support extending the models in extensions. To make
+        # this clear manually remove the automatically generated _patch.py file
+        # and fixup the __init__.py file to use the diracx one.
+        (generated_dir / "models" / "_patch.py").unlink()
+        models_init_path = generated_dir / "models" / "__init__.py"
+        models_init = models_init_path.read_text()
+        assert models_init.count("from ._patch import") == 4
+        models_init = models_init.replace(
+            "from ._patch import",
+            "from diracx.client._generated.models._patch import",
+        )
+        models_init_path.write_text(models_init)
+
+    fixup_models_init(generated_dir, extension_name)
+
+    cmd = ["pre-commit", "run", "--all-files"]
+    print("Running pre-commit...")
+    subprocess.run(cmd, check=False, cwd=repo_root)
+    print("Re-running pre-commit...")
+    proc = subprocess.run(cmd, check=False, cwd=repo_root)
+    if proc.returncode == 0 and not repo.is_dirty(path=generated_dir):
+        return
+    # Show the diff to aid debugging
+    print(repo.git.diff(generated_dir))
+    if proc.returncode != 0:
+        raise AssertionError("Pre-commit failed")
+    raise AssertionError("Client was regenerated with changes")
+
+
+def main():
+    from diracx.core.extensions import extensions_by_priority
+
+    parser = argparse.ArgumentParser(
+        description="Regenerate the AutoREST client and run pre-commit checks on it."
+    )
+    parser.parse_args()
+
+    client_extension_name = min(extensions_by_priority(), key=lambda x: x == "diracx")
+
+    cmd = ["npm", "install", "-g", f"autorest@{AUTOREST_VERSION}"]
+    print("Ensuring autorest is installed by running", shlex.join(cmd))
+    subprocess.run(cmd, check=True)
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "pytest",
+        "-pdiracx.testing",
+        "--import-mode=importlib",
+        "--no-cov",
+        f"--regenerate-client={client_extension_name}",
+        str(Path(__file__).parent / "client_generation_pytest.py"),
+    ]
+    print("Generating client for", client_extension_name)
+    print("Running:", shlex.join(cmd))
+    subprocess.run(cmd, check=True)
+
+
+if __name__ == "__main__":
+    main()

diracx_testing-0.0.4/src/diracx/testing/client_generation_pytest.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import pytest
+
+from diracx.testing.client_generation import regenerate_client
+
+pytestmark = pytest.mark.enabled_dependencies([])
+
+
+@pytest.fixture
+def test_client(client_factory):
+    with client_factory.unauthenticated() as client:
+        yield client
+
+
+def test_regenerate_client(test_client, tmp_path, request):
+    """Regenerate the AutoREST client and run pre-commit checks on it.
+
+    This test is skipped by default, and can be enabled by passing
+    --regenerate-client to pytest. It is intended to be run manually
+    when the API changes.
+
+    The reason this is a test is that it is the only way to get access to the
+    test_client fixture, which is required to get the OpenAPI spec.
+
+    WARNING: This test will modify the source code of the client!
+    """
+    client_name = request.config.getoption("--regenerate-client")
+    if client_name is None:
+        pytest.skip("--regenerate-client not specified")
+
+    r = test_client.get("/api/openapi.json")
+    r.raise_for_status()
+    openapi_spec = tmp_path / "openapi.json"
+    openapi_spec.write_text(r.text)
+
+    regenerate_client(openapi_spec, f"{client_name}.client")

diracx_testing-0.0.4/src/diracx/testing/dummy_osdb.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import secrets
+
+from diracx.db.os.utils import BaseOSDB
+
+
+class DummyOSDB(BaseOSDB):
+    """Example DiracX OpenSearch database class for testing.
+
+    A new random prefix is created each time the class is defined to ensure
+    test runs are independent of each other.
+    """
+
+    fields = {
+        "DateField": {"type": "date"},
+        "IntField": {"type": "long"},
+        "KeywordField0": {"type": "keyword"},
+        "KeywordField1": {"type": "keyword"},
+        "KeywordField2": {"type": "keyword"},
+        "TextField": {"type": "text"},
+    }
+
+    def __init__(self, *args, **kwargs):
+        # Randomize the index prefix to ensure tests are independent
+        self.index_prefix = f"dummy_{secrets.token_hex(8)}"
+        super().__init__(*args, **kwargs)
+
+    def index_name(self, vo: str, doc_id: int) -> str:
+        return f"{self.index_prefix}-{doc_id // 1e6:.0f}m"

diracx_testing-0.0.4/src/diracx/testing/entrypoints.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import tomllib
+from collections import defaultdict
+from importlib.metadata import PackageNotFoundError, distribution, entry_points
+
+import pytest
+
+
+def get_installed_entry_points():
+    """Retrieve the installed entry points from the environment."""
+    entry_pts = entry_points()
+    diracx_eps = defaultdict(dict)
+    for group in entry_pts.groups:
+        if "diracx" in group:
+            for ep in entry_pts.select(group=group):
+                diracx_eps[group][ep.name] = ep.value
+    return dict(diracx_eps)
+
+
+def get_entry_points_from_toml(toml_file):
+    """Parse entry points from pyproject.toml."""
+    with open(toml_file, "rb") as f:
+        pyproject = tomllib.load(f)
+    package_name = pyproject["project"]["name"]
+    return package_name, pyproject.get("project", {}).get("entry-points", {})
+
+
+def get_current_entry_points(repo_base) -> bool:
+    """Create current entry points dict for comparison."""
+    current_eps = {}
+    for toml_file in repo_base.glob("diracx-*/pyproject.toml"):
+        package_name, entry_pts = get_entry_points_from_toml(f"{toml_file}")
+        # Ignore packages that are not installed
+        try:
+            distribution(package_name)
+        except PackageNotFoundError:
+            continue
+        # Merge the entry points
+        for key, value in entry_pts.items():
+            current_eps[key] = current_eps.get(key, {}) | value
+    return current_eps
+
+
+@pytest.fixture(scope="session", autouse=True)
+def verify_entry_points(request, pytestconfig):
+    try:
+        ini_toml_name = tomllib.loads(pytestconfig.inipath.read_text())["project"][
+            "name"
+        ]
+    except tomllib.TOMLDecodeError:
+        return
+    if ini_toml_name == "diracx":
+        repo_base = pytestconfig.inipath.parent
+    elif ini_toml_name.startswith("diracx-"):
+        repo_base = pytestconfig.inipath.parent.parent
+    else:
+        return
+
+    installed_eps = set(get_installed_entry_points())
+    current_eps = set(get_current_entry_points(repo_base))
+
+    if installed_eps != current_eps:
+        pytest.fail(
+            "Project and installed entry-points are not consistent. "
+            "You should run `pip install -r requirements-dev.txt`"
+            f"{installed_eps-current_eps=}",
+            f"{current_eps-installed_eps=}",
+        )