feat(L+M): configurable dashboard widget system + test framework
Phase L: Dashboard widget system - Migration 046: dashboard_configs table (user/tenant/role fallback cascade) - DashboardConfig model + dashboard_service with get/upsert per-user and tenant-default - API router: GET/PUT /api/dashboard/config, GET/PUT /api/dashboard/tenant-default - Frontend: 5 widget components (ProductionStats, QueueStatus, RecentRenders, CostOverview, WorkerStatus) - DashboardGrid with API-backed config, DashboardCustomizeModal (checkbox selection, save/cancel) - Dashboard.tsx: widget grid + analytics section (privileged users) - Admin.tsx: restructured with new section order and Maintenance 2-col grid Phase M: Test framework - Backend: pytest-asyncio + pytest-cov + factory-boy in pyproject.toml - conftest.py: excel_dir fixtures + async DB fixtures + mock storage/celery stubs - Domain tests: billing_service, cache_service, notifications_service, imports_sanity - Integration: test_api_health.py smoke test (requires running backend) - Frontend: vitest + @testing-library/react + msw added to package.json - vite.config.ts: test block (jsdom + globals + setupFiles) - tsconfig.json: exclude src/__tests__ from main tsc (test runner handles its own types) - MSW handlers for /api/auth/me, Billing.test.tsx, formatters.test.ts Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,48 @@
|
||||
"""Add dashboard_configs table.
|
||||
|
||||
Revision ID: 046
|
||||
Revises: 045
|
||||
"""
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
from sqlalchemy.dialects.postgresql import UUID, JSONB
|
||||
|
||||
revision = '046'
|
||||
down_revision = '045'
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade():
|
||||
op.create_table(
|
||||
'dashboard_configs',
|
||||
sa.Column('id', UUID(as_uuid=True), primary_key=True, server_default=sa.text('gen_random_uuid()')),
|
||||
sa.Column('tenant_id', UUID(as_uuid=True), sa.ForeignKey('tenants.id', ondelete='CASCADE'), nullable=True),
|
||||
sa.Column('user_id', UUID(as_uuid=True), sa.ForeignKey('users.id', ondelete='CASCADE'), nullable=True),
|
||||
sa.Column('widgets', JSONB, nullable=False, server_default=sa.text("'[]'::jsonb")),
|
||||
sa.Column('is_tenant_default', sa.Boolean, nullable=False, server_default='false'),
|
||||
sa.Column('created_at', sa.DateTime, nullable=False, server_default=sa.text('NOW()')),
|
||||
sa.Column('updated_at', sa.DateTime, nullable=False, server_default=sa.text('NOW()')),
|
||||
)
|
||||
# Unique: one config per user
|
||||
op.create_index(
|
||||
'uq_dashboard_config_user',
|
||||
'dashboard_configs',
|
||||
['user_id'],
|
||||
unique=True,
|
||||
postgresql_where=sa.text('user_id IS NOT NULL'),
|
||||
)
|
||||
# Unique: one tenant-default per tenant
|
||||
op.create_index(
|
||||
'uq_dashboard_config_tenant_default',
|
||||
'dashboard_configs',
|
||||
['tenant_id'],
|
||||
unique=True,
|
||||
postgresql_where=sa.text('is_tenant_default = true'),
|
||||
)
|
||||
|
||||
|
||||
def downgrade():
|
||||
op.drop_index('uq_dashboard_config_tenant_default', table_name='dashboard_configs')
|
||||
op.drop_index('uq_dashboard_config_user', table_name='dashboard_configs')
|
||||
op.drop_table('dashboard_configs')
|
||||
@@ -0,0 +1,152 @@
|
||||
"""Dashboard widget configuration endpoints."""
|
||||
import logging
|
||||
import uuid
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from pydantic import BaseModel
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.database import get_db
|
||||
from app.domains.admin.dashboard_service import (
|
||||
get_user_dashboard_config,
|
||||
upsert_user_dashboard_config,
|
||||
upsert_tenant_default,
|
||||
)
|
||||
from app.utils.auth import get_current_user, require_admin
|
||||
from app.models.user import User
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/dashboard", tags=["dashboard"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Schemas
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class WidgetPosition(BaseModel):
|
||||
col: int
|
||||
row: int
|
||||
w: int
|
||||
h: int
|
||||
|
||||
|
||||
class WidgetConfig(BaseModel):
|
||||
widget_type: str
|
||||
position: WidgetPosition
|
||||
config: dict[str, Any] | None = None
|
||||
|
||||
|
||||
class DashboardConfigPayload(BaseModel):
|
||||
widgets: list[WidgetConfig]
|
||||
|
||||
|
||||
class DashboardConfigResponse(BaseModel):
|
||||
widgets: list[WidgetConfig]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _to_response(widgets: list[dict]) -> DashboardConfigResponse:
|
||||
parsed = []
|
||||
for w in widgets:
|
||||
pos = w.get("position", {})
|
||||
parsed.append(
|
||||
WidgetConfig(
|
||||
widget_type=w.get("widget_type", ""),
|
||||
position=WidgetPosition(
|
||||
col=pos.get("col", 0),
|
||||
row=pos.get("row", 0),
|
||||
w=pos.get("w", 1),
|
||||
h=pos.get("h", 1),
|
||||
),
|
||||
config=w.get("config"),
|
||||
)
|
||||
)
|
||||
return DashboardConfigResponse(widgets=parsed)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Endpoints
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@router.get("/config", response_model=DashboardConfigResponse)
|
||||
async def get_config(
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
) -> DashboardConfigResponse:
|
||||
"""Load the current user's dashboard widget config (with fallback cascade)."""
|
||||
widgets = await get_user_dashboard_config(
|
||||
db=db,
|
||||
user_id=current_user.id,
|
||||
tenant_id=current_user.tenant_id,
|
||||
role=current_user.role.value,
|
||||
)
|
||||
return _to_response(widgets)
|
||||
|
||||
|
||||
@router.put("/config", response_model=DashboardConfigResponse)
|
||||
async def update_config(
|
||||
payload: DashboardConfigPayload,
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
) -> DashboardConfigResponse:
|
||||
"""Save or update the current user's dashboard widget config."""
|
||||
widgets_raw = [w.model_dump() for w in payload.widgets]
|
||||
config = await upsert_user_dashboard_config(
|
||||
db=db,
|
||||
user_id=current_user.id,
|
||||
tenant_id=current_user.tenant_id,
|
||||
widgets=widgets_raw,
|
||||
)
|
||||
return _to_response(list(config.widgets))
|
||||
|
||||
|
||||
@router.get("/tenant-default", response_model=DashboardConfigResponse)
|
||||
async def get_tenant_default(
|
||||
current_user: User = Depends(require_admin),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
) -> DashboardConfigResponse:
|
||||
"""Load the tenant-default dashboard widget config (admin only)."""
|
||||
from sqlalchemy import select
|
||||
from app.domains.admin.models import DashboardConfig
|
||||
|
||||
if current_user.tenant_id is None:
|
||||
return DashboardConfigResponse(widgets=[])
|
||||
|
||||
result = await db.execute(
|
||||
select(DashboardConfig).where(
|
||||
DashboardConfig.tenant_id == current_user.tenant_id,
|
||||
DashboardConfig.is_tenant_default.is_(True),
|
||||
)
|
||||
)
|
||||
config = result.scalar_one_or_none()
|
||||
if config is None:
|
||||
return DashboardConfigResponse(widgets=[])
|
||||
return _to_response(list(config.widgets))
|
||||
|
||||
|
||||
@router.put("/tenant-default", response_model=DashboardConfigResponse)
|
||||
async def update_tenant_default(
|
||||
payload: DashboardConfigPayload,
|
||||
current_user: User = Depends(require_admin),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
) -> DashboardConfigResponse:
|
||||
"""Set the tenant-default widget config (admin only)."""
|
||||
if current_user.tenant_id is None:
|
||||
from fastapi import HTTPException, status
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="Admin user has no tenant_id assigned.",
|
||||
)
|
||||
|
||||
widgets_raw = [w.model_dump() for w in payload.widgets]
|
||||
config = await upsert_tenant_default(
|
||||
db=db,
|
||||
tenant_id=current_user.tenant_id,
|
||||
widgets=widgets_raw,
|
||||
)
|
||||
return _to_response(list(config.widgets))
|
||||
@@ -0,0 +1,148 @@
|
||||
"""Dashboard widget configuration service.
|
||||
|
||||
Provides async functions for loading and persisting per-user and
|
||||
tenant-default dashboard widget layouts.
|
||||
"""
|
||||
import logging
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.domains.admin.models import DashboardConfig
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Widget type literals
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
WIDGET_TYPES = (
|
||||
"ProductionStats",
|
||||
"QueueStatus",
|
||||
"RecentRenders",
|
||||
"CostOverview",
|
||||
"WorkerStatus",
|
||||
)
|
||||
|
||||
# Default layouts per role
|
||||
_DEFAULT_ADMIN_WIDGETS: list[dict] = [
|
||||
{"widget_type": "ProductionStats", "position": {"col": 0, "row": 0, "w": 1, "h": 1}},
|
||||
{"widget_type": "QueueStatus", "position": {"col": 1, "row": 0, "w": 1, "h": 1}},
|
||||
{"widget_type": "WorkerStatus", "position": {"col": 2, "row": 0, "w": 1, "h": 1}},
|
||||
{"widget_type": "RecentRenders", "position": {"col": 0, "row": 1, "w": 2, "h": 1}},
|
||||
{"widget_type": "CostOverview", "position": {"col": 2, "row": 1, "w": 1, "h": 1}},
|
||||
]
|
||||
|
||||
_DEFAULT_CLIENT_WIDGETS: list[dict] = [
|
||||
{"widget_type": "RecentRenders", "position": {"col": 0, "row": 0, "w": 2, "h": 1}},
|
||||
{"widget_type": "ProductionStats", "position": {"col": 2, "row": 0, "w": 1, "h": 1}},
|
||||
]
|
||||
|
||||
|
||||
def get_default_widgets_for_role(role: str) -> list[dict]:
|
||||
"""Return systemwide default widget layout for a given role.
|
||||
|
||||
admin / project_manager: all 5 widget types.
|
||||
client: RecentRenders + ProductionStats only.
|
||||
"""
|
||||
if role in ("admin", "project_manager"):
|
||||
return [w.copy() for w in _DEFAULT_ADMIN_WIDGETS]
|
||||
return [w.copy() for w in _DEFAULT_CLIENT_WIDGETS]
|
||||
|
||||
|
||||
async def get_user_dashboard_config(
|
||||
db: AsyncSession,
|
||||
user_id: uuid.UUID,
|
||||
tenant_id: uuid.UUID | None,
|
||||
role: str,
|
||||
) -> list[dict]:
|
||||
"""Load widget config with fallback cascade.
|
||||
|
||||
1. User-specific config (user_id match).
|
||||
2. Tenant-default config (is_tenant_default=True for the tenant).
|
||||
3. System default based on role.
|
||||
"""
|
||||
# 1. User-specific
|
||||
result = await db.execute(
|
||||
select(DashboardConfig).where(DashboardConfig.user_id == user_id)
|
||||
)
|
||||
config = result.scalar_one_or_none()
|
||||
if config is not None:
|
||||
return list(config.widgets) if config.widgets else []
|
||||
|
||||
# 2. Tenant default
|
||||
if tenant_id is not None:
|
||||
result = await db.execute(
|
||||
select(DashboardConfig).where(
|
||||
DashboardConfig.tenant_id == tenant_id,
|
||||
DashboardConfig.is_tenant_default.is_(True),
|
||||
)
|
||||
)
|
||||
tenant_config = result.scalar_one_or_none()
|
||||
if tenant_config is not None:
|
||||
return list(tenant_config.widgets) if tenant_config.widgets else []
|
||||
|
||||
# 3. System default
|
||||
return get_default_widgets_for_role(role)
|
||||
|
||||
|
||||
async def upsert_user_dashboard_config(
|
||||
db: AsyncSession,
|
||||
user_id: uuid.UUID,
|
||||
tenant_id: uuid.UUID | None,
|
||||
widgets: list[dict],
|
||||
) -> DashboardConfig:
|
||||
"""Save or update the user-specific widget config."""
|
||||
result = await db.execute(
|
||||
select(DashboardConfig).where(DashboardConfig.user_id == user_id)
|
||||
)
|
||||
config = result.scalar_one_or_none()
|
||||
|
||||
if config is None:
|
||||
config = DashboardConfig(
|
||||
user_id=user_id,
|
||||
tenant_id=tenant_id,
|
||||
widgets=widgets,
|
||||
is_tenant_default=False,
|
||||
)
|
||||
db.add(config)
|
||||
else:
|
||||
config.widgets = widgets
|
||||
config.updated_at = datetime.utcnow()
|
||||
|
||||
await db.commit()
|
||||
await db.refresh(config)
|
||||
return config
|
||||
|
||||
|
||||
async def upsert_tenant_default(
|
||||
db: AsyncSession,
|
||||
tenant_id: uuid.UUID,
|
||||
widgets: list[dict],
|
||||
) -> DashboardConfig:
|
||||
"""Set the tenant-default widget config (admin only)."""
|
||||
result = await db.execute(
|
||||
select(DashboardConfig).where(
|
||||
DashboardConfig.tenant_id == tenant_id,
|
||||
DashboardConfig.is_tenant_default.is_(True),
|
||||
)
|
||||
)
|
||||
config = result.scalar_one_or_none()
|
||||
|
||||
if config is None:
|
||||
config = DashboardConfig(
|
||||
tenant_id=tenant_id,
|
||||
user_id=None,
|
||||
widgets=widgets,
|
||||
is_tenant_default=True,
|
||||
)
|
||||
db.add(config)
|
||||
else:
|
||||
config.widgets = widgets
|
||||
config.updated_at = datetime.utcnow()
|
||||
|
||||
await db.commit()
|
||||
await db.refresh(config)
|
||||
return config
|
||||
@@ -0,0 +1,42 @@
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from sqlalchemy import Boolean, DateTime, ForeignKey
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
from sqlalchemy.dialects.postgresql import UUID, JSONB
|
||||
|
||||
from app.database import Base
|
||||
|
||||
if TYPE_CHECKING:
|
||||
pass
|
||||
|
||||
|
||||
class DashboardConfig(Base):
|
||||
__tablename__ = "dashboard_configs"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
|
||||
)
|
||||
tenant_id: Mapped[uuid.UUID | None] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("tenants.id", ondelete="CASCADE"),
|
||||
nullable=True,
|
||||
index=True,
|
||||
)
|
||||
user_id: Mapped[uuid.UUID | None] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("users.id", ondelete="CASCADE"),
|
||||
nullable=True,
|
||||
index=True,
|
||||
)
|
||||
widgets: Mapped[list] = mapped_column(JSONB, nullable=False, default=list)
|
||||
is_tenant_default: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, default=False
|
||||
)
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime, nullable=False, default=datetime.utcnow
|
||||
)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow
|
||||
)
|
||||
@@ -23,6 +23,7 @@ from app.domains.tenants.router import router as tenants_router
|
||||
from app.domains.rendering.workflow_router import router as workflows_router
|
||||
from app.domains.media.router import router as media_router
|
||||
from app.api.routers.asset_libraries import router as asset_libraries_router
|
||||
from app.domains.admin.dashboard_router import router as dashboard_router
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
@@ -88,6 +89,7 @@ app.include_router(tenants_router, prefix="/api")
|
||||
app.include_router(workflows_router)
|
||||
app.include_router(media_router)
|
||||
app.include_router(asset_libraries_router, prefix="/api")
|
||||
app.include_router(dashboard_router, prefix="/api")
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
|
||||
@@ -13,6 +13,7 @@ from app.domains.billing.models import PricingTier
|
||||
from app.domains.rendering.models import OutputType, RenderTemplate, ProductRenderPosition, WorkflowDefinition, WorkflowRun, WorkflowNodeResult
|
||||
from app.domains.materials.models import Material, MaterialAlias, AssetLibrary
|
||||
from app.domains.media.models import MediaAsset, MediaAssetType
|
||||
from app.domains.admin.models import DashboardConfig
|
||||
|
||||
# Also re-export SystemSetting (no domain assigned — stays as-is)
|
||||
from app.models.system_setting import SystemSetting
|
||||
@@ -22,4 +23,5 @@ __all__ = [
|
||||
"AuditLog", "PricingTier", "OutputType", "RenderTemplate", "ProductRenderPosition",
|
||||
"WorkflowDefinition", "WorkflowRun", "WorkflowNodeResult",
|
||||
"Material", "MaterialAlias", "AssetLibrary", "MediaAsset", "MediaAssetType", "SystemSetting",
|
||||
"DashboardConfig",
|
||||
]
|
||||
|
||||
@@ -39,6 +39,8 @@ dev = [
|
||||
"pytest>=8.0.0",
|
||||
"pytest-asyncio>=0.23.5",
|
||||
"httpx>=0.27.0",
|
||||
"pytest-cov>=5.0.0",
|
||||
"factory-boy>=3.3.0",
|
||||
]
|
||||
cad = [
|
||||
"trimesh>=4.2.0",
|
||||
@@ -46,4 +48,9 @@ cad = [
|
||||
]
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
asyncio_mode = "auto"
|
||||
testpaths = ["tests"]
|
||||
markers = [
|
||||
"integration: marks tests requiring running services",
|
||||
"unit: marks offline tests",
|
||||
]
|
||||
|
||||
@@ -109,3 +109,140 @@ def parsed_linear_schiene(parsed_excel_all):
|
||||
@pytest.fixture(scope="session")
|
||||
def parsed_anschlagplatten(parsed_excel_all):
|
||||
return parsed_excel_all["Anschlagplatten"]
|
||||
|
||||
|
||||
# ── Test-DB (nutzt separate Test-Datenbank) ──────────────────────────────────
|
||||
|
||||
import os
|
||||
import uuid
|
||||
import pytest_asyncio
|
||||
from typing import AsyncGenerator
|
||||
from httpx import AsyncClient, ASGITransport
|
||||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
|
||||
|
||||
TEST_DB_URL = os.environ.get(
|
||||
"TEST_DATABASE_URL",
|
||||
"postgresql+asyncpg://schaeffler:schaeffler@localhost:5432/schaeffler_test"
|
||||
)
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def test_engine():
|
||||
from app.database import Base
|
||||
from sqlalchemy import text
|
||||
import app.models # noqa - register all models
|
||||
engine = create_async_engine(TEST_DB_URL, echo=False)
|
||||
async with engine.begin() as conn:
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
yield engine
|
||||
# Use CASCADE to handle circular FK dependencies in drop
|
||||
async with engine.begin() as conn:
|
||||
await conn.execute(text("DROP SCHEMA public CASCADE"))
|
||||
await conn.execute(text("CREATE SCHEMA public"))
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def db(test_engine) -> AsyncGenerator[AsyncSession, None]:
|
||||
session_factory = async_sessionmaker(test_engine, expire_on_commit=False)
|
||||
async with session_factory() as session:
|
||||
yield session
|
||||
await session.rollback()
|
||||
|
||||
|
||||
# ── Mock-Storage (LocalStorage in tmpdir) ───────────────────────────────────
|
||||
|
||||
@pytest.fixture
|
||||
def mock_storage(tmp_path, monkeypatch):
|
||||
"""Ersetzt MinIO-Storage durch lokalen tmpdir."""
|
||||
import app.core.storage as storage_module
|
||||
from unittest.mock import MagicMock
|
||||
mock = MagicMock()
|
||||
mock.exists.return_value = False
|
||||
mock.upload.return_value = "test/key"
|
||||
mock.download_bytes.return_value = b"fake-stl-data"
|
||||
mock.get_presigned_url.return_value = "http://localhost/presigned"
|
||||
monkeypatch.setattr(storage_module, "_storage_instance", mock)
|
||||
return mock
|
||||
|
||||
|
||||
# ── FastAPI Test-Client ──────────────────────────────────────────────────────
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def client(db) -> AsyncGenerator[AsyncClient, None]:
|
||||
"""HTTP-Client mit überschriebener DB-Dependency."""
|
||||
from app.main import app
|
||||
from app.database import get_db
|
||||
|
||||
async def override_get_db():
|
||||
yield db
|
||||
|
||||
app.dependency_overrides[get_db] = override_get_db
|
||||
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
|
||||
yield ac
|
||||
app.dependency_overrides.clear()
|
||||
|
||||
|
||||
# ── Test-User + Auth-Token ───────────────────────────────────────────────────
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def admin_user(db):
|
||||
from app.domains.auth.models import User, UserRole
|
||||
from app.utils.auth import hash_password
|
||||
user = User(
|
||||
id=uuid.uuid4(),
|
||||
email=f"test-admin-{uuid.uuid4().hex[:8]}@test.com",
|
||||
password_hash=hash_password("TestPass123!"),
|
||||
full_name="Test Admin",
|
||||
role=UserRole.admin,
|
||||
is_active=True,
|
||||
)
|
||||
db.add(user)
|
||||
await db.commit()
|
||||
await db.refresh(user)
|
||||
return user
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def admin_token(admin_user):
|
||||
from app.utils.auth import create_access_token
|
||||
return create_access_token(str(admin_user.id), admin_user.role.value)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def auth_headers(admin_token):
|
||||
return {"Authorization": f"Bearer {admin_token}"}
|
||||
|
||||
|
||||
# ── Celery-Mock ──────────────────────────────────────────────────────────────
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def mock_celery_tasks(monkeypatch):
|
||||
"""Verhindert echte Celery-Task-Dispatching in Tests."""
|
||||
from unittest.mock import MagicMock
|
||||
mock_result = MagicMock()
|
||||
mock_result.id = "test-task-" + str(uuid.uuid4())[:8]
|
||||
|
||||
def mock_delay(*args, **kwargs):
|
||||
return mock_result
|
||||
|
||||
task_paths = [
|
||||
"app.domains.materials.tasks.refresh_asset_library_catalog",
|
||||
"app.tasks.step_tasks.process_step_file",
|
||||
"app.tasks.step_tasks.render_step_thumbnail",
|
||||
"app.tasks.step_tasks.generate_stl_cache",
|
||||
"app.domains.imports.tasks.validate_excel_import",
|
||||
"app.domains.rendering.tasks.render_still_task",
|
||||
"app.domains.rendering.tasks.render_turntable_task",
|
||||
]
|
||||
for path in task_paths:
|
||||
try:
|
||||
parts = path.rsplit(".", 1)
|
||||
module_path, attr = parts
|
||||
import importlib
|
||||
module = importlib.import_module(module_path)
|
||||
task = getattr(module, attr, None)
|
||||
if task and hasattr(task, "delay"):
|
||||
monkeypatch.setattr(task, "delay", mock_delay)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Tests for billing service."""
|
||||
import pytest
|
||||
from app.domains.billing.service import create_invoice, get_invoices
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_invoice_minimal(db, admin_user):
|
||||
"""Invoice kann mit Mindestdaten erstellt werden."""
|
||||
invoice = await create_invoice(
|
||||
db,
|
||||
tenant_id=None,
|
||||
order_line_ids=[],
|
||||
notes="Test invoice",
|
||||
)
|
||||
assert invoice.id is not None
|
||||
assert invoice.invoice_number.startswith("INV-")
|
||||
assert invoice.status == "draft"
|
||||
assert invoice.currency == "EUR"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_invoice_number_sequential(db, admin_user):
|
||||
"""Invoice-Nummern sind sequenziell und eindeutig."""
|
||||
inv1 = await create_invoice(db, tenant_id=None, order_line_ids=[], notes="First")
|
||||
inv2 = await create_invoice(db, tenant_id=None, order_line_ids=[], notes="Second")
|
||||
assert inv1.invoice_number != inv2.invoice_number
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_invoices_returns_list(db):
|
||||
"""get_invoices gibt eine Liste zurück."""
|
||||
invoices = await get_invoices(db, tenant_id=None)
|
||||
assert isinstance(invoices, list)
|
||||
@@ -0,0 +1,41 @@
|
||||
"""Tests for STL conversion cache service (pure/unit — no DB needed)."""
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
from app.domains.products.cache_service import compute_step_hash, _cache_key
|
||||
|
||||
|
||||
def test_compute_step_hash_stable(tmp_path):
|
||||
"""Gleiche Datei → gleicher Hash."""
|
||||
f = tmp_path / "test.stp"
|
||||
f.write_bytes(b"STEP data content")
|
||||
h1 = compute_step_hash(str(f))
|
||||
h2 = compute_step_hash(str(f))
|
||||
assert h1 == h2
|
||||
assert len(h1) == 64 # SHA256 hex
|
||||
|
||||
|
||||
def test_compute_step_hash_differs(tmp_path):
|
||||
"""Andere Datei → anderer Hash."""
|
||||
f1 = tmp_path / "a.stp"
|
||||
f1.write_bytes(b"content A")
|
||||
f2 = tmp_path / "b.stp"
|
||||
f2.write_bytes(b"content B")
|
||||
assert compute_step_hash(str(f1)) != compute_step_hash(str(f2))
|
||||
|
||||
|
||||
def test_cache_key_format():
|
||||
"""Cache-Key hat korrektes Format."""
|
||||
key = _cache_key("abc123", "low")
|
||||
assert key == "conversion-cache/abc123_low.stl"
|
||||
|
||||
|
||||
def test_store_stl_cache_uses_path(tmp_path, mock_storage):
|
||||
"""store_stl_cache übergibt Path-Objekt an storage.upload."""
|
||||
from app.domains.products.cache_service import store_stl_cache
|
||||
stl = tmp_path / "test.stl"
|
||||
stl.write_bytes(b"fake stl")
|
||||
store_stl_cache("abc123", "low", str(stl))
|
||||
call_args = mock_storage.upload.call_args
|
||||
assert call_args is not None
|
||||
first_arg = call_args[0][0]
|
||||
assert isinstance(first_arg, Path), f"Expected Path, got {type(first_arg)}"
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Tests for Excel sanity check service (sync Celery service).
|
||||
|
||||
Note: run_sanity_check opens a real synchronous DB connection, so the
|
||||
meaningful tests are integration-only (marked accordingly). The unit-level
|
||||
test only verifies the import and signature.
|
||||
"""
|
||||
import pytest
|
||||
|
||||
|
||||
def test_run_sanity_check_importable():
|
||||
"""run_sanity_check can be imported without errors."""
|
||||
from app.domains.imports.service import run_sanity_check
|
||||
assert callable(run_sanity_check)
|
||||
|
||||
|
||||
@pytest.mark.integration
|
||||
def test_run_sanity_check_missing_file_does_not_crash():
|
||||
"""Sanity-check-Service gibt leeres Dict zurück bei nicht existierendem File (integration)."""
|
||||
from app.domains.imports.service import run_sanity_check
|
||||
import uuid
|
||||
import app.models # noqa - register all models so SQLAlchemy relationships resolve
|
||||
result = run_sanity_check(
|
||||
validation_id=str(uuid.uuid4()),
|
||||
excel_path="/nonexistent/test.xlsx",
|
||||
tenant_id=None,
|
||||
)
|
||||
# Service returns {} when validation not found
|
||||
assert isinstance(result, dict)
|
||||
@@ -0,0 +1,27 @@
|
||||
"""Tests for notification config service."""
|
||||
import pytest
|
||||
from app.domains.notifications.service import (
|
||||
upsert_notification_config,
|
||||
get_notification_configs,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_upsert_creates_config(db, admin_user):
|
||||
"""Kann Notification-Config anlegen."""
|
||||
await upsert_notification_config(db, admin_user.id, "render_complete", "in_app", True)
|
||||
configs = await get_notification_configs(db, admin_user.id)
|
||||
assert len(configs) >= 1
|
||||
render_cfg = next((c for c in configs if c.event_type == "render_complete"), None)
|
||||
assert render_cfg is not None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_upsert_updates_existing(db, admin_user):
|
||||
"""Update überschreibt bestehende Config."""
|
||||
await upsert_notification_config(db, admin_user.id, "order_submitted", "in_app", True)
|
||||
await upsert_notification_config(db, admin_user.id, "order_submitted", "in_app", False)
|
||||
configs = await get_notification_configs(db, admin_user.id)
|
||||
cfg = next((c for c in configs if c.event_type == "order_submitted"), None)
|
||||
assert cfg is not None
|
||||
assert cfg.enabled is False
|
||||
@@ -0,0 +1,25 @@
|
||||
"""Basic API smoke tests."""
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_endpoint(client):
|
||||
resp = await client.get("/health")
|
||||
assert resp.status_code == 200
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_settings_requires_auth(client):
|
||||
"""Settings endpoint ohne Auth → 401/403."""
|
||||
resp = await client.get("/api/admin/settings")
|
||||
assert resp.status_code in (401, 403)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_admin_settings_with_auth(client, auth_headers):
|
||||
"""Settings endpoint mit Admin-Token → 200."""
|
||||
resp = await client.get("/api/admin/settings", headers=auth_headers)
|
||||
assert resp.status_code == 200
|
||||
data = resp.json()
|
||||
assert "blender_engine" in data
|
||||
assert "thumbnail_format" in data
|
||||
Reference in New Issue
Block a user