diracx-testing 0.0.1a23__tar.gz → 0.0.1a25__tar.gz

{diracx_testing-0.0.1a23 → diracx_testing-0.0.1a25}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: diracx-testing
-Version: 0.0.1a23
+Version: 0.0.1a25
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research

diracx_testing-0.0.1a25/src/diracx/testing/__init__.py

@@ -0,0 +1,47 @@
+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_pem,
+    pytest_addoption,
+    pytest_collection_modifyitems,
+    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",
+    "pytest_collection_modifyitems",
+    "private_key_pem",
+    "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.1a25/src/diracx/testing/entrypoints.py

@@ -0,0 +1,67 @@
+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 = get_installed_entry_points()
+    current_eps = 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`",
+        )

{diracx_testing-0.0.1a23 → diracx_testing-0.0.1a25}/src/diracx/testing/mock_osdb.py

@@ -42,8 +42,8 @@ class MockOSDBMixin:
         from diracx.db.sql.utils import DateNowColumn
 
         # Dynamically create a subclass of BaseSQLDB so we get clearer errors
-        MockedDB = type(f"Mocked{self.__class__.__name__}", (sql_utils.BaseSQLDB,), {})
-        self._sql_db = MockedDB(connection_kwargs["sqlalchemy_dsn"])
+        mocked_db = type(f"Mocked{self.__class__.__name__}", (sql_utils.BaseSQLDB,), {})
+        self._sql_db = mocked_db(connection_kwargs["sqlalchemy_dsn"])
 
         # Dynamically create the table definition based on the fields
         columns = [
@@ -53,16 +53,16 @@ class MockOSDBMixin:
         for field, field_type in self.fields.items():
             match field_type["type"]:
                 case "date":
-                    ColumnType = DateNowColumn
+                    column_type = DateNowColumn
                 case "long":
-                    ColumnType = partial(Column, type_=Integer)
+                    column_type = partial(Column, type_=Integer)
                 case "keyword":
-                    ColumnType = partial(Column, type_=String(255))
+                    column_type = partial(Column, type_=String(255))
                 case "text":
-                    ColumnType = partial(Column, type_=String(64 * 1024))
+                    column_type = partial(Column, type_=String(64 * 1024))
                 case _:
                     raise NotImplementedError(f"Unknown field type: {field_type=}")
-            columns.append(ColumnType(field, default=None))
+            columns.append(column_type(field, default=None))
         self._sql_db.metadata = MetaData()
         self._table = Table("dummy", self._sql_db.metadata, *columns)
 
@@ -72,18 +72,22 @@ class MockOSDBMixin:
             yield
 
     async def __aenter__(self):
-        await self._sql_db.__aenter__()
+        """Enter the request context.
+
+        This is a no-op as the real OpenSearch class doesn't use transactions.
+        Instead we enter a transaction in each method that needs it.
+        """
         return self
 
     async def __aexit__(self, exc_type, exc_value, traceback):
-        await self._sql_db.__aexit__(exc_type, exc_value, traceback)
+        pass
 
     async def create_index_template(self) -> None:
         async with self._sql_db.engine.begin() as conn:
             await conn.run_sync(self._sql_db.metadata.create_all)
 
     async def upsert(self, doc_id, document) -> None:
-        async with self:
+        async with self._sql_db:
             values = {}
             for key, value in document.items():
                 if key in self.fields:
@@ -106,7 +110,7 @@ class MockOSDBMixin:
         per_page: int = 100,
         page: int | None = None,
     ) -> tuple[int, list[dict[Any, Any]]]:
-        async with self:
+        async with self._sql_db:
             # Apply selection
             if parameters:
                 columns = []
@@ -150,7 +154,8 @@ class MockOSDBMixin:
         return results
 
     async def ping(self):
-        return await self._sql_db.ping()
+        async with self._sql_db:
+            return await self._sql_db.ping()
 
 
 def fake_available_osdb_implementations(name, *, real_available_implementations):
@@ -158,6 +163,6 @@ def fake_available_osdb_implementations(name, *, real_available_implementations)
 
     # Dynamically generate a class that inherits from the first implementation
     # but that also has the MockOSDBMixin
-    MockParameterDB = type(name, (MockOSDBMixin, implementations[0]), {})
+    mock_parameter_db = type(name, (MockOSDBMixin, implementations[0]), {})
 
-    return [MockParameterDB] + implementations
+    return [mock_parameter_db] + implementations

diracx_testing-0.0.1a23/src/diracx/testing/__init__.py → diracx_testing-0.0.1a25/src/diracx/testing/utils.py

@@ -1,3 +1,5 @@
+"""Utilities for testing DiracX."""
+
 from __future__ import annotations
 
 # TODO: this needs a lot of documentation, in particular what will matter for users
@@ -8,14 +10,11 @@ import os
 import re
 import ssl
 import subprocess
-import tomllib
-from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 from functools import partial
 from html.parser import HTMLParser
-from importlib.metadata import PackageNotFoundError, distribution, entry_points
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Generator
 from urllib.parse import parse_qs, urljoin, urlparse
 from uuid import uuid4
 
@@ -83,14 +82,16 @@ def fernet_key() -> str:
 
 
 @pytest.fixture(scope="session")
-def test_dev_settings() -> DevelopmentSettings:
+def test_dev_settings() -> Generator[DevelopmentSettings, None, None]:
     from diracx.core.settings import DevelopmentSettings
 
     yield DevelopmentSettings()
 
 
 @pytest.fixture(scope="session")
-def test_auth_settings(private_key_pem, fernet_key) -> AuthSettings:
+def test_auth_settings(
+    private_key_pem, fernet_key
+) -> Generator[AuthSettings, None, None]:
     from diracx.routers.utils.users import AuthSettings
 
     yield AuthSettings(
@@ -169,11 +170,13 @@ class ClientFactory:
         class AlwaysAllowAccessPolicy(BaseAccessPolicy):
             """Dummy access policy."""
 
+            @staticmethod
             async def policy(
                 policy_name: str, user_info: AuthorizedUserInfo, /, **kwargs
             ):
                 pass
 
+            @staticmethod
             def enrich_tokens(access_payload: dict, refresh_payload: dict):
 
                 return {"PolicySpecific": "OpenAccessForTest"}, {}
@@ -249,6 +252,7 @@ class ClientFactory:
         assert (
             self.app.dependency_overrides == {} and self.app.lifetime_functions == []
         ), "configure cannot be nested"
+
         for k, v in self.all_dependency_overrides.items():
 
             class_name = k.__self__.__name__
@@ -281,17 +285,26 @@ class ClientFactory:
         import sqlalchemy
         from sqlalchemy.util.concurrency import greenlet_spawn
 
+        from diracx.db.os.utils import BaseOSDB
         from diracx.db.sql.utils import BaseSQLDB
+        from diracx.testing.mock_osdb import MockOSDBMixin
 
         for k, v in self.app.dependency_overrides.items():
-            # Ignore dependency overrides which aren't BaseSQLDB.transaction
-            if (
-                isinstance(v, UnavailableDependency)
-                or k.__func__ != BaseSQLDB.transaction.__func__
+            # Ignore dependency overrides which aren't BaseSQLDB.transaction or BaseOSDB.session
+            if isinstance(v, UnavailableDependency) or k.__func__ not in (
+                BaseSQLDB.transaction.__func__,
+                BaseOSDB.session.__func__,
             ):
+
                 continue
+
             # The first argument of the overridden BaseSQLDB.transaction is the DB object
             db = v.args[0]
+            # We expect the OS DB to be mocked with sqlite, so use the
+            # internal DB
+            if isinstance(db, MockOSDBMixin):
+                db = db._sql_db
+
             assert isinstance(db, BaseSQLDB), (k, db)
 
             # set PRAGMA foreign_keys=ON if sqlite
@@ -638,7 +651,7 @@ async def test_login(monkeypatch, capfd, cli_env):
     # Run the login command
     with monkeypatch.context() as m:
         m.setattr("asyncio.sleep", fake_sleep)
-        await cli.login(vo="diracAdmin", group=None, property=None)
+        await cli.auth.login(vo="diracAdmin", group=None, property=None)
     captured = capfd.readouterr()
     assert "Login successful!" in captured.out
     assert captured.err == ""
@@ -689,63 +702,3 @@ def do_device_flow_with_dex(url: str, ca_path: str) -> None:
 
     # This should have redirected to the DiracX page that shows the login is complete
     assert "Please close the window" in r.text
-
-
-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 = get_installed_entry_points()
-    current_eps = 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`",
-        )

{diracx_testing-0.0.1a23 → diracx_testing-0.0.1a25}/src/diracx_testing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: diracx-testing
-Version: 0.0.1a23
+Version: 0.0.1a25
 Summary: TODO
 License: GPL-3.0-only
 Classifier: Intended Audience :: Science/Research

{diracx_testing-0.0.1a23 → diracx_testing-0.0.1a25}/src/diracx_testing.egg-info/SOURCES.txt

@@ -2,9 +2,11 @@ README.md
 pyproject.toml
 src/diracx/testing/__init__.py
 src/diracx/testing/dummy_osdb.py
+src/diracx/testing/entrypoints.py
 src/diracx/testing/mock_osdb.py
 src/diracx/testing/osdb.py
 src/diracx/testing/routers.py
+src/diracx/testing/utils.py
 src/diracx_testing.egg-info/PKG-INFO
 src/diracx_testing.egg-info/SOURCES.txt
 src/diracx_testing.egg-info/dependency_links.txt