init

backend/app/api/v1/endpoints/audit_rule.py

@@ -23,7 +23,7 @@ async def list_audit_rules(
     db_type: Optional[str] = None,
     is_enabled: Optional[bool] = None,
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
+    current_user: User = Depends(require_role("admin", "dba", "auditor")),
 ):
     stmt = select(AuditRule).order_by(AuditRule.id)
     if rule_type:
@@ -62,7 +62,7 @@ async def create_audit_rule(
 @router.get("/stats/summary")
 async def rule_stats(
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
+    current_user: User = Depends(require_role("admin", "dba", "auditor")),
 ):
     total_stmt = select(func.count(AuditRule.id))
     total = (await db.execute(total_stmt)).scalar()
@@ -130,7 +130,7 @@ async def seed_audit_rules(
 async def get_audit_rule(
     rule_id: int,
     db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
+    current_user: User = Depends(require_role("admin", "dba", "auditor")),
 ):
     result = await db.execute(select(AuditRule).where(AuditRule.id == rule_id))
     rule = result.scalar_one_or_none()

backend/app/api/v1/endpoints/db_types.py

@@ -49,7 +49,6 @@ DB_TYPE_INFO: Dict[str, Dict[str, Any]] = {
             "查看索引": "SHOW INDEX FROM table_name",
             "查看连接": "SHOW PROCESSLIST",
             "查看状态": "SHOW STATUS LIKE 'Threads%'",
-            "查看慢查询": "SELECT * FROM mysql.slow_log ORDER BY start_time DESC LIMIT 20",
         },
         "limitations": [
             "不支持存储过程调用",

backend/app/api/v1/endpoints/instance_detail.py

@@ -217,42 +217,6 @@ async def show_grants(
         raise HTTPException(status_code=500, detail="查询权限失败: " + str(e))
 
 
-# ---- Slow Queries ----
-
-@router.get("/{instance_id}/detail/slow-queries")
-async def slow_queries(
-    instance_id: int,
-    database: Optional[str] = Query(None, description="数据库名"),
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
-):
-    instance = await _get_decrypted_instance(db, instance_id)
-    # P0: 权限检查
-    await check_instance_access(current_user, instance, db)
-    if instance.db_type != "mysql":
-        raise HTTPException(status_code=400, detail="仅支持MySQL实例")
-    try:
-        # Try querying mysql.slow_log table first
-        try:
-            sql = (
-                "SELECT start_time, user_host, query_time, lock_time, "
-                "rows_sent, rows_examined, sql_text "
-                "FROM mysql.slow_log ORDER BY start_time DESC LIMIT 100"
-            )
-            rows = await _mysql_query(instance, sql, database=database)
-            return rows
-        except Exception:
-            # Fallback: show slow query variables
-            rows = await _mysql_query(
-                instance,
-                "SHOW VARIABLES LIKE 'slow%'",
-                database=database,
-            )
-            return rows
-    except Exception as e:
-        raise HTTPException(status_code=500, detail="查询慢查询失败: " + str(e))
-
-
 # ---- Processlist ----
 
 @router.get("/{instance_id}/detail/processlist")

backend/app/api/v1/endpoints/ldap_config.py

@@ -100,12 +100,11 @@ async def test_ldap_connection(
     db: AsyncSession = Depends(get_db),
     current_user: User = Depends(require_role("admin")),
 ):
-    """测试 LDAP 连接 — 使用 mock 模拟"""
+    """测试 LDAP 连接"""
     ldap = await _get_existing(db)
     if not ldap:
         raise HTTPException(status_code=404, detail="LDAP 配置不存在，请先创建")
 
-    # Use mock for testing — python-ldap may not be installed
     try:
         import ldap as _ldap  # noqa
         # Real LDAP test path
@@ -131,12 +130,9 @@ async def test_ldap_connection(
         return {"success": True, "message": f"LDAP 连接成功，用户 {data.test_user} 验证通过"}
 
     except ImportError:
-        # Mock path — python-ldap not installed
-        host = ldap.ldap_host
-        port = ldap.ldap_port
         return {
-            "success": True,
-            "message": f"[Mock] LDAP 连接模拟成功 ({host}:{port})，用户 {data.test_user} 验证通过",
+            "success": False,
+            "message": "python-ldap 未安装，无法测试 LDAP 连接。请执行: pip install python-ldap",
         }
     except Exception as e:
         return {"success": False, "message": f"LDAP 连接失败: {str(e)}"}

backend/app/api/v1/endpoints/notification.py

@@ -124,7 +124,9 @@ async def test_notification(
     db: AsyncSession = Depends(get_db),
     current_user: User = Depends(require_role("admin")),
 ):
-    """测试发送通知 — 目前返回模拟结果"""
+    """测试发送通知 — 实际发送测试消息到配置的渠道。"""
+    from app.services.notification_sender import NotificationSender
+
     result = await db.execute(
         select(NotificationChannel).where(NotificationChannel.id == channel_id)
     )
@@ -133,24 +135,19 @@ async def test_notification(
         raise HTTPException(status_code=404, detail="通知渠道不存在")
 
     config = json.loads(channel.config) if channel.config else {}
-    channel_type = channel.channel_type
-
-    # Simulated test — in production this would actually send a message
-    if channel_type == "dingtalk":
-        if not config.get("webhook_url"):
-            return {"success": False, "message": "缺少 webhook_url 配置"}
-        return {"success": True, "message": f"钉钉测试消息已发送至 {config['webhook_url'][:30]}..."}
-
-    elif channel_type == "webhook_feishu":
-        if not config.get("webhook_url"):
-            return {"success": False, "message": "缺少 webhook_url 配置"}
-        return {"success": True, "message": f"飞书测试消息已发送至 {config['webhook_url'][:30]}..."}
-
-    elif channel_type == "email":
-        required = ["smtp_host", "smtp_port", "smtp_user", "from_addr"]
-        missing = [k for k in required if not config.get(k)]
-        if missing:
-            return {"success": False, "message": f"缺少必要配置: {', '.join(missing)}"}
-        return {"success": True, "message": f"邮件测试已发送: {config['smtp_user']} -> test@example.com"}
-
-    return {"success": False, "message": f"不支持的通知类型: {channel_type}"}
+    sender = NotificationSender()
+    test_data = {
+        "title": "测试通知",
+        "applicant": current_user.display_name or current_user.username,
+        "db_type": "mysql",
+        "target_database": "test_db",
+        "sql_preview": "SELECT 1",
+        "priority": "normal",
+        "approver": "系统",
+        "ticket_id": "TEST",
+        "result": "成功",
+        "duration": "10",
+        "affected_rows": "0",
+    }
+    result = await sender.send(channel.channel_type, config, "ticket_created", test_data)
+    return result

backend/app/api/v1/endpoints/slow_log.py

@@ -1,103 +0,0 @@
-"""慢日志 API。"""
-from typing import Optional
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.core.database import get_db
-from app.core.security import get_current_user, require_role
-from app.core.crypto import decrypt_password
-from app.models.user import User
-from app.models.instance import Instance
-from app.services.slow_log_collector import SlowLogCollector
-
-router = APIRouter(prefix="/slow-logs", tags=["慢日志分析"])
-
-
-@router.get("/instances/{instance_id}")
-async def list_slow_logs(
-    instance_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
-):
-    """获取指定实例的慢日志。"""
-    result = await db.execute(select(Instance).where(Instance.id == instance_id))
-    instance = result.scalar_one_or_none()
-    if not instance:
-        raise HTTPException(status_code=404, detail="数据源不存在")
-
-    collector = SlowLogCollector()
-    logs = collector.get_slow_logs(instance_id)
-
-    return {
-        "instance_id": instance_id,
-        "total": len(logs),
-        "logs": [log.to_dict() for log in logs],
-    }
-
-
-@router.post("/instances/{instance_id}/collect")
-async def collect_slow_logs(
-    instance_id: int,
-    database: str = "",
-    limit: int = 50,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
-):
-    """手动收集慢日志。"""
-    result = await db.execute(select(Instance).where(Instance.id == instance_id))
-    instance = result.scalar_one_or_none()
-    if not instance:
-        raise HTTPException(status_code=404, detail="数据源不存在")
-
-    if not database:
-        database = instance.database or ""
-
-    collector = SlowLogCollector()
-    instance.password = decrypt_password(instance.password)
-
-    try:
-        if instance.db_type == "mysql":
-            logs = await collector.collect_mysql_slow_logs(instance, database, limit)
-        elif instance.db_type in ("postgres", "postgresql"):
-            logs = await collector.collect_postgres_slow_logs(instance, database, limit)
-        else:
-            raise HTTPException(status_code=400, detail=f"不支持的类型: {instance.db_type}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"收集失败: {str(e)}")
-
-    await collector.save_slow_logs(instance_id, logs)
-    report = collector.get_report(instance_id)
-
-    return report.to_dict()
-
-
-@router.get("/instances/{instance_id}/report")
-async def slow_log_report(
-    instance_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(require_role("admin", "dba")),
-):
-    """获取慢日志分析报告。"""
-    collector = SlowLogCollector()
-    report = collector.get_report(instance_id)
-    return report.to_dict()
-
-
-@router.get("/dashboard/top")
-async def dashboard_top_queries(
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """仪表盘慢查询 TOP 10。"""
-    collector = SlowLogCollector()
-    all_logs = []
-    for instance_id, logs in collector._logs.items():
-        all_logs.extend(logs)
-
-    # 全局 TOP 10
-    top = sorted(all_logs, key=lambda x: x.avg_time_ms, reverse=True)[:10]
-    return {
-        "total_instances": len(collector._logs),
-        "top_queries": [q.to_dict() for q in top],
-    }

backend/app/api/v1/router.py

@@ -5,7 +5,7 @@ from app.api.v1.endpoints import (
     announcement, notification, ldap_config,
     instance_detail, backup, redis, dictionary,
     instance_group, masking_rule, rollback,
-    workflow, impact, schema_drift, slow_log, pool,
+    workflow, impact, schema_drift, pool,
     mongo, query_history, sql_assistant, db_types,
     settings,
 )
@@ -34,7 +34,6 @@ api_router.include_router(rollback.router)
 api_router.include_router(workflow.router)
 api_router.include_router(impact.router)
 api_router.include_router(schema_drift.router)
-api_router.include_router(slow_log.router)
 api_router.include_router(pool.router)
 api_router.include_router(query_history.router)
 api_router.include_router(sql_assistant.router)

backend/app/main.py

@@ -29,17 +29,27 @@ async def seed_workflows():
 
 
 async def seed_data():
-    """Create default admin user from environment config."""
+    """Create default users with different roles."""
+    from app.core.security import hash_password
+
+    default_users = [
+        {"username": "admin", "display_name": "超级管理员", "role": "admin", "password": "admin123"},
+        {"username": "dba", "display_name": "张三", "role": "dba", "password": "admin123"},
+        {"username": "auditor", "display_name": "老六", "role": "auditor", "password": "admin123"},
+        {"username": "developer", "display_name": "路人甲", "role": "developer", "password": "admin123"},
+    ]
+
     async with async_session() as db:
-        result = await db.execute(select(User).where(User.username == settings.ADMIN_USERNAME))
-        if not result.scalar_one_or_none():
-            db.add(User(
-                username=settings.ADMIN_USERNAME,
-                display_name="管理员",
-                role="admin",
-                hashed_password=hash_password(settings.ADMIN_PASSWORD),
-            ))
-            await db.commit()
+        for u in default_users:
+            result = await db.execute(select(User).where(User.username == u["username"]))
+            if not result.scalar_one_or_none():
+                db.add(User(
+                    username=u["username"],
+                    display_name=u["display_name"],
+                    role=u["role"],
+                    hashed_password=hash_password(u["password"]),
+                ))
+        await db.commit()
 
 
 @asynccontextmanager
@@ -62,7 +72,6 @@ async def lifespan(app: FastAPI):
     import app.models.notification_template  # noqa
     import app.models.scheduled_task  # noqa
     import app.models.schema_revision  # noqa
-    import app.models.slow_log  # noqa
     import app.models.query_history  # noqa
 
     await init_db()

backend/app/models/slow_log.py

@@ -1,21 +0,0 @@
-"""慢日志模型。"""
-from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey, func
-
-from app.core.database import Base
-
-
-class SlowLog(Base):
-    """慢日志记录。"""
-    __tablename__ = "slow_logs"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    instance_id = Column(Integer, ForeignKey("instances.id"), nullable=False)
-    database = Column(String(100), nullable=True)
-    sql_digest = Column(String(64), nullable=True)
-    sql_text = Column(Text, nullable=True)
-    execution_count = Column(Integer, default=1)
-    avg_time_ms = Column(Integer, nullable=True)
-    max_time_ms = Column(Integer, nullable=True)
-    rows_examined = Column(Integer, nullable=True)
-    rows_sent = Column(Integer, nullable=True)
-    created_at = Column(DateTime, server_default=func.now())

backend/app/models/user.py

@@ -13,7 +13,7 @@ class User(Base):
     email = Column(String(100), unique=True, nullable=True)
     phone = Column(String(20), nullable=True)
     hashed_password = Column(String(200), nullable=False)
-    role = Column(String(20), nullable=False, default="developer")  # admin / dba / developer / guest
+    role = Column(String(20), nullable=False, default="developer")  # admin / dba / auditor / developer / guest
     is_active = Column(Boolean, default=True)
     last_login = Column(DateTime, nullable=True)
     created_at = Column(DateTime, server_default=func.now())

backend/app/services/notification_sender.py

@@ -18,40 +18,40 @@ class NotificationSender:
     # 内置消息模板
     TEMPLATES = {
         "ticket_created": {
-            "title": "📝 新工单待审批: {title}",
-            "body": "**申请人**: {applicant}\\n**数据库**: {db_type}@{target_database}\\n**SQL摘要**: {sql_preview}\\n**优先级**: {priority}",
+            "title": "新工单待审批: {title}",
+            "body": "**申请人**: {applicant}\n**数据库**: {db_type}@{target_database}\n**SQL摘要**: {sql_preview}",
         },
         "ticket_approved": {
-            "title": "✅ 工单已审批通过: {title}",
-            "body": "**审批人**: {approver}\\n**工单ID**: {ticket_id}\\n**状态**: 已批准，可执行",
+            "title": "工单已审批通过: {title}",
+            "body": "**审批人**: {approver}\n**工单ID**: {ticket_id}\n**状态**: 已批准，可执行",
         },
         "ticket_rejected": {
-            "title": "❌ 工单已被拒绝: {title}",
-            "body": "**审批人**: {approver}\\n**拒绝原因**: {comment}\\n**工单ID**: {ticket_id}",
+            "title": "工单已被拒绝: {title}",
+            "body": "**审批人**: {approver}\n**拒绝原因**: {comment}\n**工单ID**: {ticket_id}",
         },
         "ticket_executed": {
-            "title": "🚀 工单执行完成: {title}",
-            "body": "**执行结果**: {result}\\n**耗时**: {duration}ms\\n**影响行数**: {affected_rows}",
+            "title": "工单执行完成: {title}",
+            "body": "**执行结果**: {result}\n**耗时**: {duration}ms\n**影响行数**: {affected_rows}",
         },
         "ticket_failed": {
-            "title": "⚠️ 工单执行失败: {title}",
-            "body": "**错误信息**: {error}\\n**工单ID**: {ticket_id}\\n请及时处理",
+            "title": "工单执行失败: {title}",
+            "body": "**错误信息**: {error}\n**工单ID**: {ticket_id}\n请及时处理",
         },
         "ticket_rollback": {
-            "title": "🔄 工单已回滚: {title}",
-            "body": "**回滚人**: {operator}\\n**工单ID**: {ticket_id}",
+            "title": "工单已回滚: {title}",
+            "body": "**回滚人**: {operator}\n**工单ID**: {ticket_id}",
         },
         "backup_completed": {
-            "title": "💾 备份完成: {title}",
-            "body": "**数据库**: {database}\\n**文件大小**: {size}\\n**耗时**: {duration}s",
+            "title": "备份完成: {title}",
+            "body": "**数据库**: {database}\n**文件大小**: {size}\n**耗时**: {duration}s",
         },
         "backup_failed": {
-            "title": "❌ 备份失败: {title}",
-            "body": "**错误信息**: {error}\\n请检查数据库连接和磁盘空间",
+            "title": "备份失败: {title}",
+            "body": "**错误信息**: {error}\n请检查数据库连接和磁盘空间",
         },
         "schema_drift_detected": {
-            "title": "🔍 检测到 Schema 漂移: {instance_name}",
-            "body": "**数据库**: {database}\\n**发现 {drift_count} 处变更**:\\n{drift_details}",
+            "title": "检测到 Schema 漂移: {instance_name}",
+            "body": "**数据库**: {database}\n**发现 {drift_count} 处变更**:\n{drift_details}",
         },
     }
 
@@ -101,6 +101,9 @@ class NotificationSender:
         title = template["title"].format(**data)
         body = template["body"].format(**data)
 
+        # 钉钉 markdown 单个 \n 视为空格，需要 \n\n 才能换行
+        body = body.replace("\n", "\n\n")
+
         payload = {
             "msgtype": "markdown",
             "markdown": {

backend/app/services/slow_log_collector.py

@@ -1,269 +0,0 @@
-"""慢日志收集器 — 从数据库收集和分析慢查询日志。
-
-支持:
-- MySQL: performance_schema.events_statements_summary_by_digest
-- PostgreSQL: pg_stat_statements
-
-生成慢查询报告，包含 TOP N 慢查询、执行时间趋势等。
-"""
-import hashlib
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import List, Dict, Any, Optional
-
-from app.models.instance import Instance
-from app.services.db_connector import DBConnector
-from app.core.crypto import decrypt_password
-
-
-@dataclass
-class SlowLogEntry:
-    """慢日志条目。"""
-    sql_digest: str           # SQL 指纹
-    sql_text: str             # 归一化 SQL
-    execution_count: int      # 执行次数
-    avg_time_ms: float        # 平均执行时间(ms)
-    max_time_ms: float        # 最大执行时间(ms)
-    min_time_ms: float        # 最小执行时间(ms)
-    rows_examined: int        # 扫描行数
-    rows_sent: int            # 返回行数
-    first_seen: Optional[str] = None
-    last_seen: Optional[str] = None
-
-    def to_dict(self) -> dict:
-        return {
-            "sql_digest": self.sql_digest,
-            "sql_text": self.sql_text[:200] if self.sql_text else "",
-            "execution_count": self.execution_count,
-            "avg_time_ms": round(self.avg_time_ms, 2),
-            "max_time_ms": round(self.max_time_ms, 2),
-            "min_time_ms": round(self.min_time_ms, 2),
-            "rows_examined": self.rows_examined,
-            "rows_sent": self.rows_sent,
-            "first_seen": self.first_seen,
-            "last_seen": self.last_seen,
-        }
-
-
-@dataclass
-class SlowLogReport:
-    """慢日志分析报告。"""
-    total_slow_queries: int
-    avg_execution_time_ms: float
-    max_execution_time_ms: float
-    top_queries: List[SlowLogEntry]
-    time_distribution: Dict[str, int]  # 按时间段分布
-
-    def to_dict(self) -> dict:
-        return {
-            "total_slow_queries": self.total_slow_queries,
-            "avg_execution_time_ms": round(self.avg_execution_time_ms, 2),
-            "max_execution_time_ms": round(self.max_execution_time_ms, 2),
-            "top_queries": [q.to_dict() for q in self.top_queries],
-            "time_distribution": self.time_distribution,
-        }
-
-
-class SlowLogCollector:
-    """慢日志收集器。"""
-
-    # 内存中的慢日志存储: {instance_id: [SlowLogEntry, ...]}
-    _logs: Dict[int, List[SlowLogEntry]] = {}
-
-    async def collect_mysql_slow_logs(self, instance: Instance,
-                                       database: str,
-                                       limit: int = 50) -> List[SlowLogEntry]:
-        """从 MySQL performance_schema 收集慢日志。
-
-        需要 MySQL 开启 performance_schema。
-        """
-        sql = """
-        SELECT
-            DIGEST_TEXT as sql_text,
-            COUNT_STAR as execution_count,
-            ROUND(AVG_TIMER_WAIT / 1000000000, 3) as avg_time_ms,
-            ROUND(MAX_TIMER_WAIT / 1000000000, 3) as max_time_ms,
-            ROUND(MIN_TIMER_WAIT / 1000000000, 3) as min_time_ms,
-            SUM_ROWS_EXAMINED as rows_examined,
-            SUM_ROWS_SENT as rows_sent,
-            FIRST_SEEN,
-            LAST_SEEN
-        FROM performance_schema.events_statements_summary_by_digest
-        WHERE SCHEMA_NAME = %s
-          AND AVG_TIMER_WAIT > 100000000000  -- > 100ms
-        ORDER BY AVG_TIMER_WAIT DESC
-        LIMIT %s
-        """
-
-        try:
-            instance.password = decrypt_password(instance.password)
-            rows, _ = await DBConnector._query_mysql(instance, "performance_schema", sql)
-        except Exception as e:
-            # performance_schema 可能不可用，使用替代查询
-            return await self._collect_mysql_slow_logs_fallback(instance, database, limit)
-
-        entries = []
-        for row in rows:
-            sql_text = row.get("sql_text", "")
-            digest = hashlib.md5(sql_text.encode()).hexdigest()[:16]
-            entries.append(SlowLogEntry(
-                sql_digest=digest,
-                sql_text=sql_text[:500],
-                execution_count=int(row.get("execution_count", 0) or 0),
-                avg_time_ms=float(row.get("avg_time_ms", 0) or 0),
-                max_time_ms=float(row.get("max_time_ms", 0) or 0),
-                min_time_ms=float(row.get("min_time_ms", 0) or 0),
-                rows_examined=int(row.get("rows_examined", 0) or 0),
-                rows_sent=int(row.get("rows_sent", 0) or 0),
-                first_seen=str(row.get("FIRST_SEEN", "")) if row.get("FIRST_SEEN") else None,
-                last_seen=str(row.get("LAST_SEEN", "")) if row.get("LAST_SEEN") else None,
-            ))
-
-        return entries
-
-    async def _collect_mysql_slow_logs_fallback(self, instance: Instance,
-                                                  database: str,
-                                                  limit: int) -> List[SlowLogEntry]:
-        """备用方案：使用 SHOW PROCESSLIST 获取当前慢查询。"""
-        sql = "SHOW FULL PROCESSLIST"
-
-        try:
-            instance.password = decrypt_password(instance.password)
-            rows, _ = await DBConnector._query_mysql(instance, database, sql)
-        except Exception:
-            return []
-
-        entries = []
-        for row in rows:
-            time_val = row.get("Time", 0)
-            info = row.get("Info", "")
-            if time_val and int(time_val) > 1 and info and len(info) > 10:
-                digest = hashlib.md5(info.encode()).hexdigest()[:16]
-                entries.append(SlowLogEntry(
-                    sql_digest=digest,
-                    sql_text=info[:500],
-                    execution_count=1,
-                    avg_time_ms=float(time_val) * 1000,
-                    max_time_ms=float(time_val) * 1000,
-                    min_time_ms=float(time_val) * 1000,
-                    rows_examined=0,
-                    rows_sent=0,
-                ))
-
-        return entries[:limit]
-
-    async def collect_postgres_slow_logs(self, instance: Instance,
-                                          database: str,
-                                          limit: int = 50) -> List[SlowLogEntry]:
-        """从 PostgreSQL pg_stat_statements 收集慢日志。
-
-        需要安装 pg_stat_statements 扩展。
-        """
-        sql = """
-        SELECT
-            query as sql_text,
-            calls as execution_count,
-            ROUND((total_exec_time / calls)::numeric, 3) as avg_time_ms,
-            ROUND(max_exec_time::numeric, 3) as max_time_ms,
-            ROUND(min_exec_time::numeric, 3) as min_time_ms,
-            rows as rows_examined,
-            rows as rows_sent
-        FROM pg_stat_statements
-        WHERE dbid = (SELECT oid FROM pg_database WHERE datname = $1)
-          AND total_exec_time / calls > 100  -- > 100ms
-        ORDER BY total_exec_time / calls DESC
-        LIMIT $2
-        """
-
-        try:
-            instance.password = decrypt_password(instance.password)
-            # 需要先创建扩展
-            await DBConnector._query_postgres(instance, database,
-                "CREATE EXTENSION IF NOT EXISTS pg_stat_statements")
-            rows, _ = await DBConnector._query_postgres(instance, database, sql)
-        except Exception:
-            # pg_stat_statements 可能不可用
-            return []
-
-        entries = []
-        for row in rows:
-            sql_text = row.get("sql_text", "")
-            digest = hashlib.md5(sql_text.encode()).hexdigest()[:16]
-            entries.append(SlowLogEntry(
-                sql_digest=digest,
-                sql_text=sql_text[:500],
-                execution_count=int(row.get("execution_count", 0) or 0),
-                avg_time_ms=float(row.get("avg_time_ms", 0) or 0),
-                max_time_ms=float(row.get("max_time_ms", 0) or 0),
-                min_time_ms=float(row.get("min_time_ms", 0) or 0),
-                rows_examined=int(row.get("rows_examined", 0) or 0),
-                rows_sent=int(row.get("rows_sent", 0) or 0),
-            ))
-
-        return entries
-
-    async def save_slow_logs(self, instance_id: int,
-                              logs: List[SlowLogEntry]) -> None:
-        """保存慢日志到内存存储。"""
-        if instance_id not in self._logs:
-            self._logs[instance_id] = []
-
-        # 追加新日志，限制每个实例最多保存 1000 条
-        self._logs[instance_id].extend(logs)
-        if len(self._logs[instance_id]) > 1000:
-            self._logs[instance_id] = self._logs[instance_id][-1000:]
-
-    def get_slow_logs(self, instance_id: int) -> List[SlowLogEntry]:
-        """获取保存的慢日志。"""
-        return self._logs.get(instance_id, [])
-
-    def get_report(self, instance_id: int) -> SlowLogReport:
-        """生成慢日志报告。"""
-        logs = self._logs.get(instance_id, [])
-
-        if not logs:
-            return SlowLogReport(
-                total_slow_queries=0,
-                avg_execution_time_ms=0,
-                max_execution_time_ms=0,
-                top_queries=[],
-                time_distribution={},
-            )
-
-        total_avg = sum(q.avg_time_ms for q in logs) / len(logs)
-        max_time = max(q.max_time_ms for q in logs)
-
-        # 按执行时间分布
-        distribution = {
-            "0-100ms": 0,
-            "100-500ms": 0,
-            "500ms-1s": 0,
-            "1s-5s": 0,
-            ">5s": 0,
-        }
-        for q in logs:
-            if q.avg_time_ms < 100:
-                distribution["0-100ms"] += 1
-            elif q.avg_time_ms < 500:
-                distribution["100-500ms"] += 1
-            elif q.avg_time_ms < 1000:
-                distribution["500ms-1s"] += 1
-            elif q.avg_time_ms < 5000:
-                distribution["1s-5s"] += 1
-            else:
-                distribution[">5s"] += 1
-
-        # TOP 10
-        top = sorted(logs, key=lambda x: x.avg_time_ms, reverse=True)[:10]
-
-        return SlowLogReport(
-            total_slow_queries=len(logs),
-            avg_execution_time_ms=round(total_avg, 2),
-            max_execution_time_ms=round(max_time, 2),
-            top_queries=top,
-            time_distribution=distribution,
-        )
-
-    def clear_logs(self, instance_id: int) -> None:
-        """清除指定实例的慢日志。"""
-        self._logs.pop(instance_id, None)

backend/tests/conftest.py

@@ -17,7 +17,6 @@ from app.models.announcement import Announcement
 from app.models.notification import NotificationChannel
 from app.models.ldap_config import LdapConfig
 from app.models.backup import Backup
-from app.models.slow_log import SlowLog
 from app.models.scheduled_task import ScheduledTask
 from app.models.schema_revision import SchemaRevision
 from app.models.masking_rule import MaskingRule

backend/tests/test_instance_detail.py

@@ -177,28 +177,6 @@ class TestShowGrants:
             assert len(data["grants"]) >= 1
 
 
-class TestSlowQueries:
-    async def test_slow_queries_success(self, client: AsyncClient, test_instance, admin_token):
-        mock_conn, _ = _mock_mysql_connection([
-            {"start_time": "2024-01-01 00:00:00", "user_host": "root[root]@localhost",
-             "query_time": "00:00:05", "lock_time": "00:00:00", "rows_sent": 1,
-             "rows_examined": 1000, "sql_text": "SELECT * FROM big_table"},
-        ])
-
-        mock_aiomysql = _make_aiomysql_mock()
-        mock_aiomysql.connect = AsyncMock(return_value=mock_conn)
-
-        with patch.dict(sys.modules, {"aiomysql": mock_aiomysql}):
-            resp = await client.get(
-                "/api/v1/instances/" + str(test_instance.id) + "/detail/slow-queries",
-                params={"database": "test_db"},
-                headers=auth_header(admin_token),
-            )
-            assert resp.status_code == 200
-            data = resp.json()
-            assert isinstance(data, list)
-
-
 class TestProcesslist:
     async def test_show_processlist_success(self, client: AsyncClient, test_instance, admin_token):
         mock_conn, _ = _mock_mysql_connection([

backend/tests/test_ldap_config.py

@@ -267,8 +267,8 @@ async def test_create_ldap_config_empty_password(client: AsyncClient, admin_toke
 # ────────────────────────────────────────────────────────────────────
 
 @pytest.mark.asyncio
-async def test_ldap_connection_mock_success(client: AsyncClient, admin_token: str):
-    """配置存在时 POST /test 在 mock 模式下应返回 success=True"""
+async def test_ldap_connection_real_failure(client: AsyncClient, admin_token: str):
+    """配置存在时 POST /test 应尝试真实连接，测试环境无 LDAP 服务器则返回 success=False"""
     await client.put(
         "/api/v1/ldap-config",
         json=VALID_LDAP_PAYLOAD,
@@ -282,11 +282,10 @@ async def test_ldap_connection_mock_success(client: AsyncClient, admin_token: st
     )
     assert resp.status_code == 200
     data = resp.json()
-    assert data["success"] is True
-    # mock 模式消息中包含 Mock 字样
-    assert "Mock" in data["message"]
-    # 消息中应包含主机和测试用户信息
-    assert "zhangsan" in data["message"]
+    # 测试环境无真实 LDAP 服务器，连接应失败
+    assert data["success"] is False
+    # 消息中应包含连接错误信息
+    assert any(kw in data["message"] for kw in ["error", "fail", "未安装", "连接失败", "LDAP"])
 
 
 @pytest.mark.asyncio

backend/tests/test_notification.py

@@ -1,5 +1,6 @@
 """Comprehensive tests for NotificationChannel CRUD, permissions, config masking, and test-send."""
 import pytest
+from unittest.mock import AsyncMock, patch
 from httpx import AsyncClient
 
 from tests.conftest import auth_header
@@ -268,7 +269,9 @@ async def test_delete_nonexistent_channel(client: AsyncClient, admin_token: str)
 
 
 @pytest.mark.asyncio
-async def test_send_dingtalk_success(client: AsyncClient, admin_token: str):
+@patch("app.services.notification_sender.NotificationSender.send", new_callable=AsyncMock)
+async def test_send_dingtalk_success(mock_send, client: AsyncClient, admin_token: str):
+    mock_send.return_value = {"success": True, "message": "钉钉测试消息发送成功"}
     create = await client.post(BASE, json=DINGTALK_PAYLOAD, headers=auth_header(admin_token))
     cid = create.json()["id"]
 
@@ -297,7 +300,9 @@ async def test_send_dingtalk_missing_webhook(client: AsyncClient, admin_token: s
 
 
 @pytest.mark.asyncio
-async def test_send_feishu_success(client: AsyncClient, admin_token: str):
+@patch("app.services.notification_sender.NotificationSender.send", new_callable=AsyncMock)
+async def test_send_feishu_success(mock_send, client: AsyncClient, admin_token: str):
+    mock_send.return_value = {"success": True, "message": "飞书测试消息发送成功"}
     create = await client.post(BASE, json=FEISHU_PAYLOAD, headers=auth_header(admin_token))
     cid = create.json()["id"]
 
@@ -325,7 +330,9 @@ async def test_send_feishu_missing_webhook(client: AsyncClient, admin_token: str
 
 
 @pytest.mark.asyncio
-async def test_send_email_success(client: AsyncClient, admin_token: str):
+@patch("app.services.notification_sender.NotificationSender.send", new_callable=AsyncMock)
+async def test_send_email_success(mock_send, client: AsyncClient, admin_token: str):
+    mock_send.return_value = {"success": True, "message": "邮件测试消息发送成功"}
     create = await client.post(BASE, json=EMAIL_PAYLOAD, headers=auth_header(admin_token))
     cid = create.json()["id"]
 
@@ -351,9 +358,7 @@ async def test_send_email_missing_smtp_config(client: AsyncClient, admin_token:
     assert resp.status_code == 200
     data = resp.json()
     assert data["success"] is False
-    assert "smtp_port" in data["message"]
     assert "smtp_user" in data["message"]
-    assert "from_addr" in data["message"]
 
 
 @pytest.mark.asyncio

backend/tests/test_settings.py

@@ -2,6 +2,7 @@
 import json
 
 import pytest
+from unittest.mock import AsyncMock, patch
 from httpx import AsyncClient
 
 from tests.conftest import auth_header
@@ -194,13 +195,15 @@ async def test_delete_notification_channel(client: AsyncClient, admin_token: str
 
 
 @pytest.mark.asyncio
-async def test_notification_test_endpoint(client: AsyncClient, admin_token: str):
+@patch("app.services.notification_sender.NotificationSender.send", new_callable=AsyncMock)
+async def test_notification_test_endpoint(mock_send, client: AsyncClient, admin_token: str):
+    mock_send.return_value = {"success": True, "message": "钉钉测试消息发送成功"}
     create = await client.post(
         "/api/v1/notifications",
         json={
             "name": "钉钉测试",
             "channel_type": "dingtalk",
-            "config": {"webhook_url": "https://oapi.dingtalk.com/robot/send?access_token=test"},
+            "config": {"webhook_url": "https://oapi.dingtalk.com/robot/send?access_token=***"},
             "is_enabled": True,
         },
         headers=auth_header(admin_token),
@@ -365,9 +368,8 @@ async def test_ldap_test_connection(client: AsyncClient, admin_token: str):
     )
     assert resp.status_code == 200
     data = resp.json()
-    # Mock mode should return success
-    assert data["success"] is True
-    assert "Mock" in data["message"]
+    # 测试环境无真实 LDAP 服务器，应返回失败
+    assert data["success"] is False
 
 
 @pytest.mark.asyncio

backend/tests/test_slow_log.py

@@ -1,433 +0,0 @@
-"""慢日志 API 端点测试 — P1 审计闭环。
-
-测试范围:
-- 慢日志列表查看
-- 慢日志收集（需mock数据库连接）
-- 慢日志分析报告
-- 仪表盘 TOP 10 查询
-- 权限控制（仅 admin/dba）
-"""
-import pytest
-import pytest_asyncio
-from unittest.mock import patch, AsyncMock, MagicMock
-from httpx import AsyncClient
-
-from app.core.security import create_access_token, hash_password
-from app.models.user import User
-from app.models.instance import Instance
-from app.services.slow_log_collector import SlowLogCollector, SlowLogEntry, SlowLogReport
-
-
-@pytest_asyncio.fixture
-async def admin_headers(admin_token: str) -> dict:
-    return {"Authorization": f"Bearer {admin_token}"}
-
-
-@pytest_asyncio.fixture
-async def dba_headers(dba_token: str) -> dict:
-    return {"Authorization": f"Bearer {dba_token}"}
-
-
-@pytest_asyncio.fixture
-async def developer_headers(developer_token: str) -> dict:
-    return {"Authorization": f"Bearer {developer_token}"}
-
-
-@pytest_asyncio.fixture
-async def guest_headers(guest_token: str) -> dict:
-    return {"Authorization": f"Bearer {guest_token}"}
-
-
-# ── SlowLogEntry 和 SlowLogReport 单元测试 ──
-
-
-class TestSlowLogModels:
-    """慢日志数据模型测试。"""
-
-    def test_slow_log_entry_to_dict(self):
-        """测试 SlowLogEntry 序列化。"""
-        entry = SlowLogEntry(
-            sql_digest="abc123",
-            sql_text="SELECT * FROM users WHERE id = ?",
-            execution_count=100,
-            avg_time_ms=250.456,
-            max_time_ms=1000.789,
-            min_time_ms=50.123,
-            rows_examined=10000,
-            rows_sent=100,
-            first_seen="2025-01-01 00:00:00",
-            last_seen="2025-01-02 00:00:00",
-        )
-        d = entry.to_dict()
-        assert d["sql_digest"] == "abc123"
-        assert d["execution_count"] == 100
-        assert d["avg_time_ms"] == 250.46  # rounded
-        assert d["rows_examined"] == 10000
-        assert d["first_seen"] == "2025-01-01 00:00:00"
-
-    def test_slow_log_entry_long_sql_truncated(self):
-        """测试长SQL被截断。"""
-        long_sql = "SELECT * FROM t WHERE " + "id = 1 AND " * 100
-        entry = SlowLogEntry(
-            sql_digest="x", sql_text=long_sql,
-            execution_count=1, avg_time_ms=100,
-            max_time_ms=100, min_time_ms=100,
-            rows_examined=1, rows_sent=1,
-        )
-        d = entry.to_dict()
-        assert len(d["sql_text"]) <= 200
-
-    def test_slow_log_report_to_dict(self):
-        """测试 SlowLogReport 序列化。"""
-        entry = SlowLogEntry(
-            sql_digest="abc", sql_text="SELECT 1",
-            execution_count=1, avg_time_ms=100,
-            max_time_ms=100, min_time_ms=100,
-            rows_examined=1, rows_sent=1,
-        )
-        report = SlowLogReport(
-            total_slow_queries=1,
-            avg_execution_time_ms=100.555,
-            max_execution_time_ms=100.0,
-            top_queries=[entry],
-            time_distribution={"00-06": 0, "06-12": 1, "12-18": 0, "18-24": 0},
-        )
-        d = report.to_dict()
-        assert d["total_slow_queries"] == 1
-        assert d["avg_execution_time_ms"] == 100.56
-        assert len(d["top_queries"]) == 1
-        assert d["time_distribution"]["06-12"] == 1
-
-
-# ── SlowLogCollector 单元测试 ──
-
-
-class TestSlowLogCollector:
-    """慢日志收集器单元测试。"""
-
-    def test_save_and_get_slow_logs(self):
-        """测试保存和获取慢日志。"""
-        collector = SlowLogCollector()
-        collector._logs = {}
-
-        entries = [
-            SlowLogEntry(
-                sql_digest=f"digest_{i}", sql_text=f"SELECT {i}",
-                execution_count=i + 1, avg_time_ms=100 * (i + 1),
-                max_time_ms=200 * (i + 1), min_time_ms=10,
-                rows_examined=1000 * (i + 1), rows_sent=10,
-            )
-            for i in range(3)
-        ]
-
-        import asyncio
-        asyncio.get_event_loop().run_until_complete(
-            collector.save_slow_logs(1, entries)
-        )
-
-        logs = collector.get_slow_logs(1)
-        assert len(logs) == 3
-
-    def test_get_slow_logs_empty(self):
-        """测试获取不存在的实例慢日志。"""
-        collector = SlowLogCollector()
-        collector._logs = {}
-        logs = collector.get_slow_logs(999)
-        assert logs == []
-
-    def test_get_report_empty(self):
-        """测试获取空报告。"""
-        collector = SlowLogCollector()
-        collector._logs = {}
-        report = collector.get_report(999)
-        assert report.total_slow_queries == 0
-
-    def test_get_report_with_data(self):
-        """测试获取有数据的报告。"""
-        collector = SlowLogCollector()
-        entries = [
-            SlowLogEntry(
-                sql_digest="d1", sql_text="SELECT * FROM users",
-                execution_count=10, avg_time_ms=500,
-                max_time_ms=1000, min_time_ms=200,
-                rows_examined=50000, rows_sent=100,
-            ),
-            SlowLogEntry(
-                sql_digest="d2", sql_text="SELECT * FROM orders",
-                execution_count=5, avg_time_ms=300,
-                max_time_ms=600, min_time_ms=100,
-                rows_examined=30000, rows_sent=50,
-            ),
-        ]
-
-        import asyncio
-        asyncio.get_event_loop().run_until_complete(
-            collector.save_slow_logs(1, entries)
-        )
-
-        report = collector.get_report(1)
-        assert report.total_slow_queries == 2
-        assert report.max_execution_time_ms == 1000
-        assert len(report.top_queries) <= 20  # TOP 20 max
-
-
-# ── API 端点权限测试 ──
-
-
-class TestSlowLogAPIPermissions:
-    """慢日志 API 权限控制测试。"""
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_unauthorized(self, client: AsyncClient):
-        """测试未认证访问。"""
-        resp = await client.get("/api/v1/slow-logs/instances/1")
-        assert resp.status_code == 401
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_developer_forbidden(
-        self, client: AsyncClient, developer_headers: dict
-    ):
-        """测试开发者无权查看慢日志。"""
-        resp = await client.get(
-            "/api/v1/slow-logs/instances/1",
-            headers=developer_headers,
-        )
-        assert resp.status_code == 403
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_guest_forbidden(
-        self, client: AsyncClient, guest_headers: dict
-    ):
-        """测试访客无权查看慢日志。"""
-        resp = await client.get(
-            "/api/v1/slow-logs/instances/1",
-            headers=guest_headers,
-        )
-        assert resp.status_code == 403
-
-    @pytest.mark.asyncio
-    async def test_collect_slow_logs_developer_forbidden(
-        self, client: AsyncClient, developer_headers: dict
-    ):
-        """测试开发者无权收集慢日志。"""
-        resp = await client.post(
-            "/api/v1/slow-logs/instances/1/collect",
-            headers=developer_headers,
-        )
-        assert resp.status_code == 403
-
-    @pytest.mark.asyncio
-    async def test_report_developer_forbidden(
-        self, client: AsyncClient, developer_headers: dict
-    ):
-        """测试开发者无权查看报告。"""
-        resp = await client.get(
-            "/api/v1/slow-logs/instances/1/report",
-            headers=developer_headers,
-        )
-        assert resp.status_code == 403
-
-
-# ── API 端点功能测试 ──
-
-
-class TestSlowLogAPIFunctional:
-    """慢日志 API 功能测试。"""
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_not_found(
-        self, client: AsyncClient, admin_headers: dict, db
-    ):
-        """测试查看不存在实例的慢日志。"""
-        resp = await client.get(
-            "/api/v1/slow-logs/instances/999",
-            headers=admin_headers,
-        )
-        assert resp.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_empty(
-        self, client: AsyncClient, admin_headers: dict, test_instance
-    ):
-        """测试查看实例慢日志（空列表）。"""
-        collector = SlowLogCollector()
-        collector._logs = {}
-
-        with patch.object(SlowLogCollector, '_logs', {}):
-            resp = await client.get(
-                f"/api/v1/slow-logs/instances/{test_instance.id}",
-                headers=admin_headers,
-            )
-            assert resp.status_code == 200
-            data = resp.json()
-            assert data["instance_id"] == test_instance.id
-            assert data["total"] == 0
-            assert data["logs"] == []
-
-    @pytest.mark.asyncio
-    async def test_list_slow_logs_with_data(
-        self, client: AsyncClient, admin_headers: dict, test_instance
-    ):
-        """测试查看实例慢日志（有数据）。"""
-        entries = [
-            SlowLogEntry(
-                sql_digest="d1", sql_text="SELECT * FROM users",
-                execution_count=10, avg_time_ms=500,
-                max_time_ms=1000, min_time_ms=200,
-                rows_examined=50000, rows_sent=100,
-            ),
-        ]
-
-        collector = SlowLogCollector()
-        collector._logs = {test_instance.id: entries}
-
-        with patch.object(SlowLogCollector, '_logs', {test_instance.id: entries}):
-            resp = await client.get(
-                f"/api/v1/slow-logs/instances/{test_instance.id}",
-                headers=admin_headers,
-            )
-            assert resp.status_code == 200
-            data = resp.json()
-            assert data["total"] == 1
-            assert data["logs"][0]["sql_digest"] == "d1"
-
-    @pytest.mark.asyncio
-    async def test_collect_slow_logs_unsupported_type(
-        self, client: AsyncClient, admin_headers: dict, db
-    ):
-        """测试收集不支持类型的慢日志。"""
-        # 创建Redis实例（redis不支持慢日志收集）
-        instance = Instance(
-            name="测试Redis", db_type="redis",
-            host="127.0.0.1", port=6379,
-            username="", password="test123",
-            database="0", env="development",
-            status="disconnected",
-        )
-        db.add(instance)
-        await db.commit()
-        await db.refresh(instance)
-
-        # endpoint先解密密码再检查类型，可能返回400或500
-        resp = await client.post(
-            f"/api/v1/slow-logs/instances/{instance.id}/collect",
-            headers=admin_headers,
-        )
-        # 接受400（不支持类型）或500（解密/连接错误）
-        assert resp.status_code in (400, 500)
-
-    @pytest.mark.asyncio
-    async def test_collect_slow_logs_not_found(
-        self, client: AsyncClient, admin_headers: dict
-    ):
-        """测试收集不存在实例的慢日志。"""
-        resp = await client.post(
-            "/api/v1/slow-logs/instances/999/collect",
-            headers=admin_headers,
-        )
-        assert resp.status_code == 404
-
-    @pytest.mark.asyncio
-    async def test_report_not_found(
-        self, client: AsyncClient, admin_headers: dict
-    ):
-        """测试获取不存在实例的报告。"""
-        resp = await client.get(
-            "/api/v1/slow-logs/instances/999/report",
-            headers=admin_headers,
-        )
-        # 报告端点不检查实例存在性，返回空报告
-        assert resp.status_code == 200
-
-    @pytest.mark.asyncio
-    async def test_dashboard_top_queries(
-        self, client: AsyncClient, admin_headers: dict
-    ):
-        """测试仪表盘 TOP 查询。"""
-        collector = SlowLogCollector()
-        collector._logs = {}
-
-        with patch.object(SlowLogCollector, '_logs', {}):
-            resp = await client.get(
-                "/api/v1/slow-logs/dashboard/top",
-                headers=admin_headers,
-            )
-            assert resp.status_code == 200
-            data = resp.json()
-            assert "total_instances" in data
-            assert "top_queries" in data
-
-    @pytest.mark.asyncio
-    async def test_dashboard_top_queries_with_data(
-        self, client: AsyncClient, admin_headers: dict
-    ):
-        """测试仪表盘 TOP 查询（有数据）。"""
-        entries = [
-            SlowLogEntry(
-                sql_digest=f"d{i}", sql_text=f"SELECT {i}",
-                execution_count=i + 1, avg_time_ms=100 * (i + 1),
-                max_time_ms=200 * (i + 1), min_time_ms=10,
-                rows_examined=1000, rows_sent=10,
-            )
-            for i in range(15)
-        ]
-
-        with patch.object(SlowLogCollector, '_logs', {1: entries}):
-            resp = await client.get(
-                "/api/v1/slow-logs/dashboard/top",
-                headers=admin_headers,
-            )
-            assert resp.status_code == 200
-            data = resp.json()
-            assert data["total_instances"] == 1
-            assert len(data["top_queries"]) <= 10  # TOP 10
-
-    @pytest.mark.asyncio
-    async def test_dba_can_access_slow_logs(
-        self, client: AsyncClient, dba_headers: dict, test_instance
-    ):
-        """测试DBA可以查看慢日志。"""
-        with patch.object(SlowLogCollector, '_logs', {}):
-            resp = await client.get(
-                f"/api/v1/slow-logs/instances/{test_instance.id}",
-                headers=dba_headers,
-            )
-            assert resp.status_code == 200
-
-    @pytest.mark.asyncio
-    async def test_dba_can_collect_slow_logs(
-        self, client: AsyncClient, dba_headers: dict, test_instance
-    ):
-        """测试DBA可以收集慢日志。"""
-        # mock collect方法避免真实数据库连接
-        mock_entries = [
-            SlowLogEntry(
-                sql_digest="d1", sql_text="SELECT 1",
-                execution_count=1, avg_time_ms=100,
-                max_time_ms=100, min_time_ms=100,
-                rows_examined=1, rows_sent=1,
-            )
-        ]
-        with patch.object(
-            SlowLogCollector, 'collect_mysql_slow_logs',
-            return_value=mock_entries
-        ):
-            resp = await client.post(
-                f"/api/v1/slow-logs/instances/{test_instance.id}/collect",
-                headers=dba_headers,
-            )
-            # 可能500因为save方法，但至少不被403拒绝
-            assert resp.status_code in (200, 500)
-
-    @pytest.mark.asyncio
-    async def test_dashboard_any_authenticated_user(
-        self, client: AsyncClient, developer_headers: dict
-    ):
-        """测试仪表盘TOP查询对所有登录用户开放。"""
-        with patch.object(SlowLogCollector, '_logs', {}):
-            resp = await client.get(
-                "/api/v1/slow-logs/dashboard/top",
-                headers=developer_headers,
-            )
-            # dashboard/top 使用 get_current_user（不是 require_role）
-            assert resp.status_code == 200