perfact-api-base 0.6__tar.gz → 0.7__tar.gz

perfact_api_base-0.7/.gitea/workflows/check.yml

@@ -0,0 +1,17 @@
+name: Tox tests
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request: {}
+
+jobs:
+  build:
+    runs-on: perfact-build-trixie
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+    - name: Test with tox
+      run: tox

{perfact_api_base-0.6 → perfact_api_base-0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-base
-Version: 0.6
+Version: 0.7
 Summary: PerFact API - base package for common infrastructure
 Author-email: Viktor Dick <viktor.dick@perfact.de>
 License: GPL-2.0-or-later

{perfact_api_base-0.6 → perfact_api_base-0.7}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=61.2", "setuptools-scm>=8.0"]
+requires = ["setuptools>=78", "setuptools-scm>=8.0"]
 build-backend = "setuptools.build_meta"
 
 [project]

{perfact_api_base-0.6 → perfact_api_base-0.7}/src/perfact/api/base/__init__.py

@@ -1,4 +1,5 @@
 from .authinfo import AuthInfo
+from .discovery import generic_discover
 from .model import Base, PydanticBase, View
 from .visibility import (
     VisibilityAwareModel,
@@ -14,4 +15,5 @@ __all__ = [
     "VisibilityAwareModel",
     "VisibilityPolicy",
     "VisibilityPolicyRegistry",
+    "generic_discover",
 ]

perfact_api_base-0.7/src/perfact/api/base/discovery.py

@@ -0,0 +1,33 @@
+import logging
+from importlib.metadata import entry_points
+from typing import TypeVar
+
+log = logging.getLogger("perfact.api.base.discovery")
+
+T = TypeVar("T")
+
+
+def generic_discover(registry: T, entrypoint_group: str) -> T:
+    """
+    generic discovery loader. Finds all modules with the given entrypoint_group.
+    Every module is loaded and the load()-method is called with the given loader.
+    """
+
+    if not entrypoint_group:
+        raise RuntimeError("No entrypoint_group defined, discovery not possible.")
+
+    modules_count = 0
+    log.info(f"start discovery for {entrypoint_group}")
+    for ep in entry_points(group=entrypoint_group):
+        log.info(f" try to include {ep.value}")
+
+        try:
+            ep.load()(registry)
+            modules_count += 1
+        except Exception:
+            log.exception(f" failed to include plugin {ep.value}")
+    log.info(
+        f"finished discovery, included {modules_count} plugins for {entrypoint_group}"
+    )
+
+    return registry

{perfact_api_base-0.6 → perfact_api_base-0.7}/src/perfact_api_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perfact-api-base
-Version: 0.6
+Version: 0.7
 Summary: PerFact API - base package for common infrastructure
 Author-email: Viktor Dick <viktor.dick@perfact.de>
 License: GPL-2.0-or-later

{perfact_api_base-0.6 → perfact_api_base-0.7}/src/perfact_api_base.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ tox.ini
 .vscode/settings.json
 src/perfact/api/base/__init__.py
 src/perfact/api/base/authinfo.py
+src/perfact/api/base/discovery.py
 src/perfact/api/base/model.py
 src/perfact/api/base/py.typed
 src/perfact/api/base/visibility.py
@@ -16,4 +17,8 @@ src/perfact_api_base.egg-info/SOURCES.txt
 src/perfact_api_base.egg-info/dependency_links.txt
 src/perfact_api_base.egg-info/requires.txt
 src/perfact_api_base.egg-info/top_level.txt
+tests/conftest.py
+tests/test_authinfo.py
+tests/test_discovery.py
+tests/test_model.py
 tests/test_visibility_policy.py

perfact_api_base-0.7/tests/conftest.py

@@ -0,0 +1,61 @@
+import pytest
+from pytest_postgresql import factories
+from sqlalchemy import URL, create_engine, text
+from sqlalchemy.orm import Session
+
+from perfact.api.base.model import Base
+
+postgresql_proc = factories.postgresql_proc(port=None)
+
+
+@pytest.fixture(scope="module")
+def engine(postgresql_proc):
+    """Module-scoped engine: creates DB, db_username() function, and all tables once."""
+    admin_url = URL.create(
+        "postgresql+psycopg",
+        username=postgresql_proc.user,
+        host=postgresql_proc.host,
+        port=postgresql_proc.port,
+        database="postgres",
+    )
+    db_name = "test_perfact_base"
+    admin_engine = create_engine(admin_url, isolation_level="AUTOCOMMIT")
+    with admin_engine.connect() as conn:
+        conn.execute(text(f"DROP DATABASE IF EXISTS {db_name}"))
+        conn.execute(text(f"CREATE DATABASE {db_name}"))
+    admin_engine.dispose()
+
+    test_url = URL.create(
+        "postgresql+psycopg",
+        username=postgresql_proc.user,
+        host=postgresql_proc.host,
+        port=postgresql_proc.port,
+        database=db_name,
+    )
+    eng = create_engine(test_url)
+    with eng.connect() as conn:
+        conn.execute(
+            text(
+                "CREATE OR REPLACE FUNCTION db_username() "
+                "RETURNS text AS $$ SELECT current_user $$ LANGUAGE SQL"
+            )
+        )
+        conn.commit()
+    Base.metadata.create_all(eng)
+
+    yield eng
+
+    Base.metadata.drop_all(eng)
+    eng.dispose()
+    admin_engine2 = create_engine(admin_url, isolation_level="AUTOCOMMIT")
+    with admin_engine2.connect() as conn:
+        conn.execute(text(f"DROP DATABASE IF EXISTS {db_name}"))
+    admin_engine2.dispose()
+
+
+@pytest.fixture
+def session(engine):
+    """Function-scoped session that rolls back after each test for isolation."""
+    with Session(engine) as sess:
+        yield sess
+        sess.rollback()

perfact_api_base-0.7/tests/test_authinfo.py

@@ -0,0 +1,8 @@
+from perfact.api.base.authinfo import AuthInfo
+
+
+def test_get_unauthorized_authinfo():
+    info = AuthInfo.get_unauthorized_authinfo()
+    assert info.name is None
+    assert info.roles == []
+    assert info.appstc is None

perfact_api_base-0.7/tests/test_discovery.py

@@ -0,0 +1,55 @@
+from importlib.metadata import EntryPoint
+from unittest.mock import patch
+
+import pytest
+
+from perfact.api.base.discovery import generic_discover
+
+
+class _Registry:
+    def __init__(self):
+        self.calls = []
+
+
+def _loader_ok(registry: _Registry) -> None:
+    registry.calls.append("ok")
+
+
+def _loader_fail(registry: _Registry) -> None:
+    raise ValueError("plugin broken")
+
+
+def _ep(name: str) -> EntryPoint:
+    return EntryPoint(name=name, group="test.group", value=f"{__name__}:{name}")
+
+
+def test_empty_entrypoint_group_raises():
+    with pytest.raises(RuntimeError, match="No entrypoint_group defined"):
+        generic_discover(_Registry(), "")
+
+
+def test_no_plugins_returns_registry():
+    registry = _Registry()
+    with patch("perfact.api.base.discovery.entry_points", return_value=[]):
+        result = generic_discover(registry, "test.group")
+    assert result is registry
+    assert result.calls == []
+
+
+def test_plugin_loaded_and_called():
+    registry = _Registry()
+    with patch(
+        "perfact.api.base.discovery.entry_points", return_value=[_ep("_loader_ok")]
+    ):
+        result = generic_discover(registry, "test.group")
+    assert result.calls == ["ok"]
+
+
+def test_plugin_load_exception_continues():
+    registry = _Registry()
+    with patch(
+        "perfact.api.base.discovery.entry_points", return_value=[_ep("_loader_fail")]
+    ):
+        result = generic_discover(registry, "test.group")
+    assert result is registry
+    assert result.calls == []

perfact_api_base-0.7/tests/test_model.py

@@ -0,0 +1,276 @@
+from datetime import datetime
+
+from sqlalchemy import BigInteger, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from perfact.api.base.model import Base, ForeignKey, View, relationship
+
+# ---------------------------------------------------------------------------
+# Test models (registered in Base.metadata at import time)
+# ---------------------------------------------------------------------------
+
+
+class Article(Base):
+    title: Mapped[str]
+    word_count: Mapped[int]
+
+
+class Tag(Base):
+    __tablename__ = "tag"
+    label: Mapped[str]
+
+
+class ExplicitColModel(Base):
+    # Column with an explicit DB name — should not be prefixed
+    raw: Mapped[str] = mapped_column("explicit_raw")
+
+
+class Category(Base):
+    name: Mapped[str]
+    posts: Mapped[list["Post"]] = relationship(back_populates="category")
+
+
+class Post(Base):
+    headline: Mapped[str]
+    # Cross-model FK: use object reference so it resolves after Category's columns
+    # are already prefixed (string "category.id" would fail at that point)
+    category_id: Mapped[int] = mapped_column(ForeignKey(Category.id))
+    category: Mapped[Category] = relationship(back_populates="posts")
+
+
+class TreeNode(Base):
+    label: Mapped[str]
+    # Self-referential FK: string form works because it resolves during
+    # super().__init_subclass__(), before the prefix step runs
+    parent_treenode_id: Mapped[int | None] = mapped_column(ForeignKey("treenode.id"))
+
+
+class DiffKeyModel(Base):
+    # key differs from name: the prefix guard (col.name == col.key) is False,
+    # so this column is intentionally left unprefixed
+    value: Mapped[str] = mapped_column("explicit_db_name", key="different_key")
+
+
+class ReportView(View):
+    __tablename__ = "v_report"
+    # View columns carry explicit names so they match the SQL view definition
+    id: Mapped[int] = mapped_column("id", primary_key=True)
+    summary: Mapped[str] = mapped_column("summary")
+
+
+# ---------------------------------------------------------------------------
+# Unit tests — no database required
+# ---------------------------------------------------------------------------
+
+
+class TestTableName:
+    def test_auto_lowercase(self):
+        assert Article.__tablename__ == "article"
+
+    def test_explicit_preserved(self):
+        assert Tag.__tablename__ == "tag"
+
+
+class TestColumnPrefixing:
+    def test_own_columns_prefixed(self):
+        names = {c.name for c in Article.__table__.columns}
+        assert "article_title" in names
+        assert "article_word_count" in names
+
+    def test_inherited_columns_prefixed(self):
+        names = {c.name for c in Article.__table__.columns}
+        assert "article_id" in names
+        assert "article_modtime" in names
+        assert "article_author" in names
+
+    def test_unprefixed_names_absent(self):
+        names = {c.name for c in Article.__table__.columns}
+        assert "title" not in names
+        assert "id" not in names
+
+    def test_explicit_tablename_used_as_prefix(self):
+        names = {c.name for c in Tag.__table__.columns}
+        assert "tag_label" in names
+
+    def test_explicit_column_name_used_as_base(self):
+        # mapped_column("explicit_raw") → name=key="explicit_raw" → prefixed using
+        # the explicit name, not the Python attribute name "raw"
+        names = {c.name for c in ExplicitColModel.__table__.columns}
+        assert "explicitcolmodel_explicit_raw" in names
+        assert "explicitcolmodel_raw" not in names
+
+    def test_fk_column_prefixed(self):
+        names = {c.name for c in Post.__table__.columns}
+        assert "post_category_id" in names
+
+    def test_self_ref_fk_column_prefixed(self):
+        names = {c.name for c in TreeNode.__table__.columns}
+        assert "treenode_parent_treenode_id" in names
+
+    def test_column_with_different_key_not_prefixed(self):
+        # col.name != col.key → guard skips it; DB name stays as declared
+        names = {c.name for c in DiffKeyModel.__table__.columns}
+        assert "explicit_db_name" in names
+        assert "diffkeymodel_explicit_db_name" not in names
+
+    def test_abstract_subclass_skips_prefix_step(self):
+        # Abstract subclasses never get __table__, so __init_subclass__ exits
+        # at the hasattr guard without attempting any column renaming
+        class InlineAbstract(Base):
+            __abstract__ = True
+
+        assert not hasattr(InlineAbstract, "__table__")
+
+
+class TestColumnProperties:
+    def test_id_is_primary_key(self):
+        pk = {c.name for c in Article.__table__.primary_key.columns}
+        assert "article_id" in pk
+
+    def test_modtime_has_server_default(self):
+        # Table.c index uses original keys; find by name via iteration
+        col = next(c for c in Article.__table__.columns if c.name == "article_modtime")
+        assert col.server_default is not None
+
+    def test_author_is_nullable(self):
+        col = next(c for c in Article.__table__.columns if c.name == "article_author")
+        assert col.nullable is True
+
+    def test_author_has_server_default(self):
+        col = next(c for c in Article.__table__.columns if c.name == "article_author")
+        assert col.server_default is not None
+
+
+class TestTypeAnnotationMap:
+    def test_base_str_maps_to_string(self):
+        assert isinstance(Base.type_annotation_map[str], String)
+
+    def test_base_int_maps_to_biginteger(self):
+        assert isinstance(Base.type_annotation_map[int], BigInteger)
+
+    def test_view_str_maps_to_string(self):
+        assert isinstance(View.type_annotation_map[str], String)
+
+    def test_view_int_maps_to_biginteger(self):
+        assert isinstance(View.type_annotation_map[int], BigInteger)
+
+
+class TestViewClass:
+    def test_columns_not_prefixed(self):
+        names = {c.name for c in ReportView.__table__.columns}
+        assert "id" in names
+        assert "summary" in names
+        assert "v_report_id" not in names
+
+    def test_not_in_base_metadata(self):
+        assert "v_report" not in Base.metadata.tables
+
+    def test_in_view_metadata(self):
+        assert "v_report" in View.metadata.tables
+
+
+class TestReexports:
+    def test_foreignkey_is_sqlalchemy_class(self):
+        from sqlalchemy import ForeignKey as SAFK
+
+        assert ForeignKey is SAFK
+
+    def test_relationship_is_sqlalchemy_function(self):
+        from sqlalchemy.orm import relationship as sa_rel
+
+        assert relationship is sa_rel
+
+
+# ---------------------------------------------------------------------------
+# Integration tests — require the `engine` / `session` fixtures (PostgreSQL)
+# ---------------------------------------------------------------------------
+
+
+class TestDatabaseOperations:
+    def test_tables_created(self, engine):
+        from sqlalchemy import inspect as sa_inspect
+
+        tables = sa_inspect(engine).get_table_names()
+        assert "article" in tables
+        assert "tag" in tables
+        assert "category" in tables
+        assert "post" in tables
+        assert "treenode" in tables
+
+    def test_view_not_created_as_table(self, engine):
+        from sqlalchemy import inspect as sa_inspect
+
+        tables = sa_inspect(engine).get_table_names()
+        assert "v_report" not in tables
+
+    def test_insert_and_retrieve(self, session):
+        article = Article(title="Hello", word_count=500)
+        session.add(article)
+        session.flush()
+        result = session.get(Article, article.id)
+        assert result is not None
+        assert result.title == "Hello"
+        assert result.word_count == 500
+
+    def test_id_auto_assigned(self, session):
+        article = Article(title="Numbered", word_count=1)
+        session.add(article)
+        session.flush()
+        assert isinstance(article.id, int)
+        assert article.id > 0
+
+    def test_modtime_auto_set_by_server(self, session):
+        article = Article(title="Timed", word_count=1)
+        session.add(article)
+        session.flush()
+        session.refresh(article)
+        assert isinstance(article.modtime, datetime)
+
+    def test_author_auto_set_by_server(self, session):
+        article = Article(title="Authored", word_count=1)
+        session.add(article)
+        session.flush()
+        session.refresh(article)
+        assert article.author is not None
+
+    def test_author_can_be_explicitly_set(self, session):
+        # author=None omits the column → server default fires; an explicit string
+        # value takes precedence over the server default
+        article = Article(title="Override", word_count=1, author="custom_user")
+        session.add(article)
+        session.flush()
+        session.refresh(article)
+        assert article.author == "custom_user"
+
+    def test_fk_relationship(self, session):
+        cat = Category(name="Science")
+        post = Post(headline="Big Discovery", category=cat)
+        session.add_all([cat, post])
+        session.flush()
+        session.refresh(cat)
+        assert len(cat.posts) == 1
+        assert cat.posts[0].headline == "Big Discovery"
+
+    def test_fk_back_reference(self, session):
+        cat = Category(name="Tech")
+        post = Post(headline="AI News", category=cat)
+        session.add_all([cat, post])
+        session.flush()
+        session.refresh(post)
+        assert post.category.name == "Tech"
+
+    def test_self_referential_fk(self, session):
+        root = TreeNode(label="root")
+        session.add(root)
+        session.flush()
+        child = TreeNode(label="child", parent_treenode_id=root.id)
+        session.add(child)
+        session.flush()
+        assert child.parent_treenode_id == root.id
+
+    def test_session_isolation_via_rollback(self, session):
+        # Data inserted here is rolled back by the fixture — other tests are unaffected
+        article = Article(title="Ephemeral", word_count=0)
+        session.add(article)
+        session.flush()
+        assert session.get(Article, article.id) is not None

{perfact_api_base-0.6 → perfact_api_base-0.7}/tox.ini

@@ -2,9 +2,8 @@
 envlist = py3
 isolated_build = true
 
-[pytest]
-
 [testenv]
+pythonpath = {toxinidir}
 deps =
     ruff
     pytest
@@ -21,4 +20,4 @@ commands =
     ruff check
     bandit --configfile bandit.yml -r src
     mypy src
-    # pytest --doctest-modules --cov-branch --cov=src --cov-report=term-missing {posargs:src}
+    pytest --cov-branch --cov=perfact.api.base --cov-report=term-missing --cov-fail-under=100 {posargs:tests}

perfact_api_base-0.6/.gitea/workflows/check.yml

@@ -1,26 +0,0 @@
-name: Tox tests
-on:
-  push:
-    branches:
-      - 'main'
-  pull_request: {}
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        python -m pip install tox tox-gh-actions
-    - name: Test with tox
-      run: tox