feat(B-NOTIF): Notification→Message Konsolidierung — System-Channel, post_system_message(), Migration

B-NOTIF-SYS: CommConversation um is_system Feld erweitert, get_or_create_system_channel()
B-NOTIF-EVT: post_system_message() in kommunikation/services.py — erstellt CommMessage im System-Channel
- create_notification() als deprecated Wrapper delegiert auf post_system_message()
- Text-Block + action_card Block mit Deep-Link, Metadata: notification_type/severity/entity_ref
B-NOTIF-PREF: NotificationPreference als Routing-Konfiguration, stumm/disabled respektiert
B-NOTIF-MIG: Migration 0120 — Notifications → CommMessages migriert, notifications_legacy View
B-NOTIF-DEPREC: Notification-Routes als deprecated markiert, keine Routes entfernt
B-NOTIF-TEST: 19 Tests in test_notification_migration.py — alle grün
- System-Channel, post_system_message, create_notification Wrapper, Preferences, Unread-Badge, Migration Mapping, Sensitive Fields

tests/test_notification_migration.py

@@ -0,0 +1,597 @@
+"""Tests for notification-to-communication consolidation (B-NOTIF-* + B-NOTIF-TEST)."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.notifications import create_notification, post_system_message
+from app.models.notification import Notification, NotificationPreference, NotificationType
+from app.plugins.builtins.kommunikation.models import (
+    CommConversation,
+    CommMessage,
+    CommMessageBlock,
+    CommMessageRead,
+    CommParticipant,
+)
+from app.plugins.builtins.kommunikation.services import get_or_create_system_channel
+from tests.conftest import seed_tenant_and_users
+
+
+@pytest.mark.asyncio
+class TestSystemChannel:
+    """B-NOTIF-SYS: System channel creation and properties."""
+
+    async def test_get_or_create_system_channel_creates_channel(self, db_session: AsyncSession):
+        """get_or_create_system_channel creates a system channel with is_system=True."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+
+        conv = await get_or_create_system_channel(db_session, tenant_id)
+        await db_session.flush()
+
+        assert conv is not None
+        assert conv.is_system is True
+        assert conv.is_locked is True
+        assert conv.title == "System Channel"
+        assert conv.created_by_type == "system"
+        assert conv.tenant_id == tenant_id
+
+    async def test_get_or_create_system_channel_is_idempotent(self, db_session: AsyncSession):
+        """Calling get_or_create_system_channel twice returns the same channel."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+
+        conv1 = await get_or_create_system_channel(db_session, tenant_id)
+        await db_session.flush()
+        conv2 = await get_or_create_system_channel(db_session, tenant_id)
+        await db_session.flush()
+
+        assert conv1.id == conv2.id
+
+    async def test_system_channel_has_all_users_as_participants(self, db_session: AsyncSession):
+        """All tenant users are automatically added as participants."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+
+        conv = await get_or_create_system_channel(db_session, tenant_id)
+        await db_session.flush()
+
+        result = await db_session.execute(
+            select(CommParticipant).where(
+                CommParticipant.conversation_id == conv.id,
+                CommParticipant.left_at.is_(None),
+            )
+        )
+        participants = result.scalars().all()
+        participant_ids = {p.participant_id for p in participants}
+
+        # admin_a, viewer_a, editor_a are all in tenant_a
+        assert seed["admin_a"].id in participant_ids
+        assert seed["viewer_a"].id in participant_ids
+        assert seed["editor_a"].id in participant_ids
+
+    async def test_system_channel_is_tenant_scoped(self, db_session: AsyncSession):
+        """Different tenants get different system channels."""
+        seed = await seed_tenant_and_users(db_session)
+
+        conv_a = await get_or_create_system_channel(db_session, seed["tenant_a"].id)
+        conv_b = await get_or_create_system_channel(db_session, seed["tenant_b"].id)
+        await db_session.flush()
+
+        assert conv_a.id != conv_b.id
+        assert conv_a.tenant_id == seed["tenant_a"].id
+        assert conv_b.tenant_id == seed["tenant_b"].id
+
+
+@pytest.mark.asyncio
+class TestPostSystemMessage:
+    """B-NOTIF-EVT: post_system_message creates typed system messages."""
+
+    async def test_post_system_message_creates_comm_message(self, db_session: AsyncSession):
+        """post_system_message creates a CommMessage in the system channel."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Test Notification",
+            body="This is a test body",
+        )
+        await db_session.flush()
+
+        assert msg is not None
+        assert msg.sender_type == "system"
+        assert "Test Notification" in msg.content
+        assert "This is a test body" in msg.content
+        assert msg.metadata_["notification_type"] == "info"
+        assert msg.metadata_["severity"] == "info"
+        assert msg.metadata_["target_user_id"] == str(user_id)
+
+    async def test_post_system_message_creates_text_block(self, db_session: AsyncSession):
+        """post_system_message creates a text block with title and body."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Block Test",
+            body="Block body",
+        )
+        await db_session.flush()
+
+        result = await db_session.execute(
+            select(CommMessageBlock).where(
+                CommMessageBlock.message_id == msg.id,
+            ).order_by(CommMessageBlock.sort_order)
+        )
+        blocks = result.scalars().all()
+
+        assert len(blocks) >= 1
+        text_block = blocks[0]
+        assert text_block.block_type == "text"
+        assert text_block.block_data["title"] == "Block Test"
+        assert text_block.block_data["body"] == "Block body"
+
+    async def test_post_system_message_with_entity_creates_action_card(self, db_session: AsyncSession):
+        """post_system_message with entity_type/entity_id creates an action_card block."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+        entity_id = seed["company_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Entity Notification",
+            body="Check this entity",
+            entity_type="contact",
+            entity_id=entity_id,
+        )
+        await db_session.flush()
+
+        result = await db_session.execute(
+            select(CommMessageBlock).where(
+                CommMessageBlock.message_id == msg.id,
+            ).order_by(CommMessageBlock.sort_order)
+        )
+        blocks = result.scalars().all()
+
+        assert len(blocks) == 2
+        assert blocks[0].block_type == "text"
+        assert blocks[1].block_type == "action_card"
+        assert blocks[1].block_data["entity_type"] == "contact"
+        assert blocks[1].block_data["entity_id"] == str(entity_id)
+
+        # Check metadata entity_ref
+        assert msg.metadata_["entity_ref"]["entity_type"] == "contact"
+        assert msg.metadata_["entity_ref"]["entity_id"] == str(entity_id)
+
+    async def test_post_system_message_severity_in_metadata(self, db_session: AsyncSession):
+        """post_system_message stores severity in message metadata."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="alert",
+            title="Critical Alert",
+            body="Something happened",
+            severity="critical",
+        )
+        await db_session.flush()
+
+        assert msg.metadata_["severity"] == "critical"
+        assert msg.metadata_["notification_type"] == "alert"
+
+
+@pytest.mark.asyncio
+class TestCreateNotificationWrapper:
+    """B-NOTIF-EVT: create_notification delegates to post_system_message."""
+
+    async def test_create_notification_delegates_to_post_system_message(self, db_session: AsyncSession):
+        """create_notification creates both a CommMessage and a legacy Notification."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        notif = await create_notification(
+            db_session, tenant_id, user_id,
+            type="info",
+            title="Wrapper Test",
+            body="Wrapper body",
+        )
+        await db_session.flush()
+
+        # Legacy notification created
+        assert notif is not None
+        assert notif.title == "Wrapper Test"
+        assert notif.type == "info"
+
+        # CommMessage also created in system channel
+        result = await db_session.execute(
+            select(CommMessage).where(
+                CommMessage.tenant_id == tenant_id,
+                CommMessage.sender_type == "system",
+            )
+        )
+        comm_msgs = result.scalars().all()
+        assert len(comm_msgs) >= 1
+        assert any("Wrapper Test" in m.content for m in comm_msgs)
+
+    async def test_create_notification_returns_none_when_muted(self, db_session: AsyncSession):
+        """create_notification returns None when user has disabled the type."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        # Create a notification type and disable it for the user
+        ntype = NotificationType(
+            type_key="muted_type",
+            plugin_name="test",
+            category="general",
+            label="Muted Type",
+            is_enabled_by_default=True,
+        )
+        db_session.add(ntype)
+        await db_session.flush()
+
+        pref = NotificationPreference(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            type_key="muted_type",
+            is_enabled=False,
+        )
+        db_session.add(pref)
+        await db_session.flush()
+
+        notif = await create_notification(
+            db_session, tenant_id, user_id,
+            type="muted_type",
+            title="Should Not Appear",
+            body="Should be muted",
+        )
+        await db_session.flush()
+
+        assert notif is None
+
+        # Verify no CommMessage was created with this title
+        result = await db_session.execute(
+            select(CommMessage).where(
+                CommMessage.tenant_id == tenant_id,
+                CommMessage.content.like("%Should Not Appear%"),
+            )
+        )
+        comm_msgs = result.scalars().all()
+        assert len(comm_msgs) == 0
+
+
+@pytest.mark.asyncio
+class TestNotificationPreferences:
+    """B-NOTIF-PREF: Delivery preferences are respected."""
+
+    async def test_post_system_message_respects_muted_preference(self, db_session: AsyncSession):
+        """post_system_message returns None when user has muted the type."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        ntype = NotificationType(
+            type_key="muted_alert",
+            plugin_name="test",
+            category="general",
+            label="Muted Alert",
+            is_enabled_by_default=True,
+        )
+        db_session.add(ntype)
+        await db_session.flush()
+
+        pref = NotificationPreference(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            type_key="muted_alert",
+            is_enabled=False,
+        )
+        db_session.add(pref)
+        await db_session.flush()
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="muted_alert",
+            title="Muted Message",
+            body="Should not be posted",
+        )
+        await db_session.flush()
+
+        assert msg is None
+
+    async def test_post_system_message_respects_disabled_by_default(self, db_session: AsyncSession):
+        """post_system_message returns None when type is disabled by default and no explicit preference."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        ntype = NotificationType(
+            type_key="disabled_default",
+            plugin_name="test",
+            category="general",
+            label="Disabled By Default",
+            is_enabled_by_default=False,
+        )
+        db_session.add(ntype)
+        await db_session.flush()
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="disabled_default",
+            title="Should Not Appear",
+            body="Disabled by default",
+        )
+        await db_session.flush()
+
+        assert msg is None
+
+    async def test_post_system_message_with_enabled_preference(self, db_session: AsyncSession):
+        """post_system_message creates message when preference is enabled."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        ntype = NotificationType(
+            type_key="enabled_type",
+            plugin_name="test",
+            category="general",
+            label="Enabled Type",
+            is_enabled_by_default=False,
+        )
+        db_session.add(ntype)
+        await db_session.flush()
+
+        pref = NotificationPreference(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            type_key="enabled_type",
+            is_enabled=True,
+        )
+        db_session.add(pref)
+        await db_session.flush()
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="enabled_type",
+            title="Enabled Message",
+            body="Should be posted",
+        )
+        await db_session.flush()
+
+        assert msg is not None
+        assert "Enabled Message" in msg.content
+
+
+@pytest.mark.asyncio
+class TestUnreadBadge:
+    """B-NOTIF-TEST: Unread badge via CommMessageRead."""
+
+    async def test_system_message_unread_for_new_user(self, db_session: AsyncSession):
+        """New system messages are unread (no CommMessageRead entry)."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Unread Test",
+            body="Should be unread",
+        )
+        await db_session.flush()
+
+        # Check no CommMessageRead exists for this user+conversation
+        result = await db_session.execute(
+            select(CommMessageRead).where(
+                CommMessageRead.conversation_id == msg.conversation_id,
+                CommMessageRead.user_id == user_id,
+            )
+        )
+        read_state = result.scalar_one_or_none()
+        assert read_state is None  # No read state = unread
+
+    async def test_mark_system_message_read_creates_read_state(self, db_session: AsyncSession):
+        """Marking a system message read creates CommMessageRead entry."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Read Test",
+            body="Will be marked read",
+        )
+        await db_session.flush()
+
+        # Create read state
+        read_state = CommMessageRead(
+            tenant_id=tenant_id,
+            conversation_id=msg.conversation_id,
+            user_id=user_id,
+            last_read_msg_id=msg.id,
+            last_read_at=datetime.now(UTC),
+        )
+        db_session.add(read_state)
+        await db_session.flush()
+
+        # Verify read state exists
+        result = await db_session.execute(
+            select(CommMessageRead).where(
+                CommMessageRead.conversation_id == msg.conversation_id,
+                CommMessageRead.user_id == user_id,
+            )
+        )
+        saved = result.scalar_one_or_none()
+        assert saved is not None
+        assert saved.last_read_msg_id == msg.id
+
+
+@pytest.mark.asyncio
+class TestNotificationMigrationMapping:
+    """B-NOTIF-MIG: Migration mapping from Notification to CommMessage."""
+
+    async def test_notification_fields_map_to_comm_message(self, db_session: AsyncSession):
+        """Notification fields map correctly to CommMessage metadata and blocks."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+        entity_id = seed["company_a"].id
+
+        # Create a notification via the wrapper (which creates both legacy + comm)
+        notif = await create_notification(
+            db_session, tenant_id, user_id,
+            type="mail_received",
+            title="New Mail",
+            body="You have a new mail",
+            entity_type="contact",
+            entity_id=entity_id,
+        )
+        await db_session.flush()
+
+        # Find the corresponding CommMessage
+        result = await db_session.execute(
+            select(CommMessage).where(
+                CommMessage.tenant_id == tenant_id,
+                CommMessage.sender_type == "system",
+            ).order_by(CommMessage.created_at.desc())
+        )
+        comm_msg = result.scalars().first()
+        assert comm_msg is not None
+
+        # Field mapping checks
+        assert comm_msg.metadata_["notification_type"] == "mail_received"
+        assert comm_msg.metadata_["severity"] == "info"
+        assert comm_msg.metadata_["entity_ref"]["entity_type"] == "contact"
+        assert comm_msg.metadata_["entity_ref"]["entity_id"] == str(entity_id)
+
+        # Check blocks
+        blocks_result = await db_session.execute(
+            select(CommMessageBlock).where(
+                CommMessageBlock.message_id == comm_msg.id,
+            ).order_by(CommMessageBlock.sort_order)
+        )
+        blocks = blocks_result.scalars().all()
+        assert len(blocks) == 2  # text + action_card
+        assert blocks[0].block_type == "text"
+        assert blocks[1].block_type == "action_card"
+
+    async def test_notification_read_at_maps_to_comm_message_read(self, db_session: AsyncSession):
+        """Notification.read_at maps to CommMessageRead entry."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        notif = await create_notification(
+            db_session, tenant_id, user_id,
+            type="info",
+            title="Read Mapping Test",
+            body="Will be read",
+        )
+        await db_session.flush()
+
+        # Mark notification as read
+        notif.read_at = datetime.now(UTC)
+        await db_session.flush()
+
+        # Find the CommMessage
+        result = await db_session.execute(
+            select(CommMessage).where(
+                CommMessage.tenant_id == tenant_id,
+                CommMessage.sender_type == "system",
+            ).order_by(CommMessage.created_at.desc())
+        )
+        comm_msg = result.scalars().first()
+        assert comm_msg is not None
+
+        # Create CommMessageRead (simulating what migration does)
+        read_state = CommMessageRead(
+            tenant_id=tenant_id,
+            conversation_id=comm_msg.conversation_id,
+            user_id=user_id,
+            last_read_msg_id=comm_msg.id,
+            last_read_at=notif.read_at,
+        )
+        db_session.add(read_state)
+        await db_session.flush()
+
+        # Verify
+        read_result = await db_session.execute(
+            select(CommMessageRead).where(
+                CommMessageRead.conversation_id == comm_msg.conversation_id,
+                CommMessageRead.user_id == user_id,
+            )
+        )
+        saved = read_result.scalar_one_or_none()
+        assert saved is not None
+        assert saved.last_read_at is not None
+
+
+@pytest.mark.asyncio
+class TestSensitiveFieldsExcluded:
+    """B-NOTIF-TEST: Sensitive fields are excluded from system messages."""
+
+    async def test_no_password_or_secret_in_message(self, db_session: AsyncSession):
+        """System messages do not contain password hashes or secret values."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Security Test",
+            body="Normal body text",
+        )
+        await db_session.flush()
+
+        # Check message content and metadata for sensitive patterns
+        sensitive_patterns = ["password", "hash", "secret", "token", "api_key"]
+        content_lower = msg.content.lower()
+        metadata_str = str(msg.metadata_).lower()
+
+        for pattern in sensitive_patterns:
+            assert pattern not in content_lower, f"Sensitive pattern '{pattern}' found in content"
+            assert pattern not in metadata_str, f"Sensitive pattern '{pattern}' found in metadata"
+
+    async def test_blocks_exclude_sensitive_data(self, db_session: AsyncSession):
+        """Message blocks do not contain sensitive data."""
+        seed = await seed_tenant_and_users(db_session)
+        tenant_id = seed["tenant_a"].id
+        user_id = seed["admin_a"].id
+
+        msg = await post_system_message(
+            db_session, tenant_id, user_id,
+            message_type="info",
+            title="Block Security Test",
+            body="Normal block text",
+        )
+        await db_session.flush()
+
+        result = await db_session.execute(
+            select(CommMessageBlock).where(
+                CommMessageBlock.message_id == msg.id,
+            )
+        )
+        blocks = result.scalars().all()
+
+        for block in blocks:
+            block_str = str(block.block_data).lower()
+            assert "password" not in block_str
+            assert "secret" not in block_str
+            assert "token" not in block_str