diracx-testing 0.0.1a23__py3-none-any.whl → 0.0.1a24__py3-none-any.whl

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/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)
 
@@ -158,6 +158,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