Files
leocrm/tests/test_n4_scope_declarations.py
T

218 lines
8.3 KiB
Python
Raw Normal View History

"""N4 — Scope-Deklarationen der restlichen Module (Phase N, letzter Task).
Plugins declare workspace_scopes() for: tasks (only_mine), kommunikation
(conversation_ids), wiki (category_ids subtree), reports (template_ids),
agents (agent_ids), tags (tag_ids), search (entity_types — dynamic from the
provider registry). Core contributions add navigation (default_route) and
dashboard (widget_app_ids — the workspace limits the offered widget TYPES,
never the personal layout, Phase M boundary).
"""
from __future__ import annotations
import pytest
from app.schemas.workspace import WorkspaceModuleScopes
N4_PLUGINS = (
"tasks",
"kommunikation",
"wiki",
"report_generator",
"automation",
"tags",
"unified_search",
)
N4_MODULES = {
"tasks",
"communication",
"wiki",
"reports",
"agents",
"tags",
"search",
"navigation",
"dashboard",
}
# ─── Unit: Contract-Deklarationen der N4-Plugins ──────────────
@pytest.mark.parametrize("plugin_name", N4_PLUGINS)
def test_contract_declares_valid_scopes(plugin_name: str):
"""Every N4 plugin declares workspace_scopes() with valid contributions."""
from app.plugins.builtins.contracts import get_contract
contract = get_contract(plugin_name)
assert contract is not None, f"Contract für {plugin_name} fehlt"
fn = getattr(contract, "workspace_scopes", None)
assert callable(fn), f"{plugin_name} deklariert workspace_scopes() nicht"
contributions = fn() or []
assert contributions, f"{plugin_name}: mindestens eine Contribution"
for contribution in contributions:
WorkspaceModuleScopes.model_validate(contribution)
def _dims_for(plugin_name: str) -> dict[str, dict]:
from app.plugins.builtins.contracts import get_contract
return {
d["key"]: d
for c in get_contract(plugin_name).workspace_scopes()
for d in c["dimensions"]
}
def test_tasks_declares_only_mine_toggle():
"""Roadmap N4 tasks: „nur meine" — reiner Toggle ohne Wertequelle."""
dims = _dims_for("tasks")
assert "only_mine" in dims
assert dims["only_mine"]["control"] == "toggle"
assert dims["only_mine"]["value_source"] is None
# module_key tasks (Menüpfad /tasks)
from app.plugins.builtins.contracts import get_contract
keys = [c["module_key"] for c in get_contract("tasks").workspace_scopes()]
assert "tasks" in keys
def test_kommunikation_declares_conversation_ids():
"""Roadmap N4 Kommunikation: Räume-Teilmengen."""
dims = _dims_for("kommunikation")
assert "conversation_ids" in dims
assert dims["conversation_ids"]["control"] == "multiselect"
assert dims["conversation_ids"]["value_source"]["endpoint"] == "/api/v1/comm/conversations"
from app.plugins.builtins.contracts import get_contract
keys = [c["module_key"] for c in get_contract("kommunikation").workspace_scopes()]
assert "communication" in keys # Menüpfad /communication
def test_wiki_declares_category_ids():
"""Roadmap N4 Wiki: Kategorien-Teilmengen (Subtree wie contacts/dms)."""
dims = _dims_for("wiki")
assert "category_ids" in dims
assert dims["category_ids"]["value_source"]["endpoint"] == "/api/v1/wiki/categories"
assert dims["category_ids"]["value_source"]["items_path"] == "items"
def test_reports_declares_template_ids():
"""Roadmap N4 Reports/Dokumente: Vorlagen-Teilmengen."""
dims = _dims_for("report_generator")
assert "template_ids" in dims
assert dims["template_ids"]["value_source"]["endpoint"] == "/api/v1/reports/print-templates"
assert dims["template_ids"]["value_source"]["items_path"] == "items"
from app.plugins.builtins.contracts import get_contract
keys = [c["module_key"] for c in get_contract("report_generator").workspace_scopes()]
assert "reports" in keys # Menüpfad /reports
def test_automation_declares_agent_ids():
"""Roadmap N4 Automation: Agenten-Teilmengen (module_key agents)."""
dims = _dims_for("automation")
assert "agent_ids" in dims
assert dims["agent_ids"]["value_source"]["endpoint"] == "/api/v1/agents"
assert dims["agent_ids"]["value_source"]["items_path"] == "items"
from app.plugins.builtins.contracts import get_contract
keys = [c["module_key"] for c in get_contract("automation").workspace_scopes()]
assert "agents" in keys # page route /agents (kein Menüeintrag)
def test_tags_declares_tag_ids():
"""Roadmap N4 Tags: Tag-Teilmengen."""
dims = _dims_for("tags")
assert "tag_ids" in dims
assert dims["tag_ids"]["value_source"]["endpoint"] == "/api/v1/tags"
assert dims["tag_ids"]["value_source"]["value_key"] == "id"
def test_search_declares_entity_types_with_current_providers():
"""Roadmap N4 Suche: Provider-Teilmengen — Optionen dynamisch aus der
Provider-Registry (Contract liefert sie zur Aufrufzeit)."""
from app.plugins.builtins.contracts import get_contract
contributions = get_contract("unified_search").workspace_scopes()
keys = [c["module_key"] for c in contributions]
assert "search" in keys
dims = {d["key"]: d for c in contributions for d in c["dimensions"]}
assert "entity_types" in dims
assert dims["entity_types"]["control"] == "multiselect"
# Dynamic options: reflect the currently registered providers
values = {o["value"] for o in dims["entity_types"]["options"]}
assert {"contact", "task", "mail"} <= values, (
f"entity_types-Optionen enthalten nicht Core-Provider: {values}"
)
# ─── Unit: Core-Beiträge (navigation, dashboard) ───────────────
def test_core_contributions_navigation_and_dashboard():
"""Core-Module navigation + dashboard contribute scope dimensions via the
aggregator (they are core-owned, not plugin-owned)."""
from app.services.workspace_scope_service import get_scope_definitions
modules = get_scope_definitions()
assert "navigation" in modules, "navigation-Beitrag fehlt"
nav_dims = {d["key"]: d for d in modules["navigation"]}
assert nav_dims["default_route"]["control"] == "select"
route_values = {o["value"] for o in nav_dims["default_route"]["options"]}
assert "/" in route_values
assert "/contacts" in route_values
assert "dashboard" in modules, "dashboard-Beitrag fehlt"
dash_dims = {d["key"]: d for d in modules["dashboard"]}
assert dash_dims["widget_app_ids"]["control"] == "multiselect"
source = dash_dims["widget_app_ids"]["value_source"]
assert source["endpoint"] == "/api/v1/miniapps?host=dashboard"
assert source["value_key"] == "app_id"
def test_aggregator_covers_all_n4_modules():
"""The aggregated registry covers every N4 module (plugin + core)."""
from app.services.workspace_scope_service import get_scope_definitions
modules = get_scope_definitions()
for key in N4_MODULES:
assert key in modules, f"Modul {key} fehlt in den Scope-Definitionen"
assert modules[key], f"{key}: Dimensionen leer"
# ─── Unit: deklarierte Value-Endpoints existieren (OpenAPI) ────
async def test_n4_value_endpoints_exist(app):
"""Every N4 value_source endpoint must exist as a GET route — checked via
OpenAPI (app.routes carries only _IncludedRouter wrappers, N1 lesson)."""
from app.plugins.builtins.contracts import get_contract
paths = app.openapi().get("paths", {})
get_paths = {p for p, ops in paths.items() if "get" in ops}
for plugin_name in N4_PLUGINS:
contract = get_contract(plugin_name)
for contribution in contract.workspace_scopes() or []:
for dim in contribution.get("dimensions", []):
source = dim.get("value_source")
if not source:
continue
endpoint_path = source["endpoint"].split("?")[0]
assert endpoint_path in get_paths, (
f"{plugin_name}: deklarierter Value-Endpoint {endpoint_path} "
"existiert nicht als GET-Route"
)
def test_navigation_routes_are_valid_paths():
"""Navigation default_route options must be real frontend paths."""
from app.services.workspace_scope_service import get_scope_definitions
nav = {d["key"]: d for d in get_scope_definitions()["navigation"]}
for option in nav["default_route"]["options"]:
assert option["value"].startswith("/"), (
f"Route {option['value']} muss mit / beginnen"
)