Initial commit: VoIdeaAI - voice-first AI idea assistant

app/agents/qa_tester_agent.py

@@ -0,0 +1,458 @@
+"""QATesterAgent v2 — real functional testing with API + Playwright E2E.
+
+Modes:
+  - api: HTTP tests against backend endpoints
+  - e2e: Playwright headless browser tests against UI (skip if unavailable)
+  - full: both modes
+
+Creates temp users, runs tests, cleans up. Reports bugs to FixAgent via LogEntry.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.agents.base import AgentResult, AgentStatus, AgentTrigger, BaseAgent
+from app.models.log import LogEntry
+from app.models.user import User
+from app.core.config import get_settings
+from app.core.security import get_password_hash
+
+logger = logging.getLogger("voidea.qa_tester")
+
+PLAYWRIGHT_AVAILABLE = False
+try:
+    from playwright.async_api import async_playwright
+    PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    pass
+
+TEST_BASE_URL = os.environ.get("TEST_BASE_URL", "http://localhost:8020")
+TEST_FRONTEND_URL = os.environ.get("TEST_FRONTEND_URL", "http://localhost:3000")
+
+
+class QATesterAgent(BaseAgent):
+    """Functional testing agent with API + E2E browser tests."""
+
+    name = "qa_tester_agent"
+    version = "2.0.0"
+    description = "API + E2E testing with temp users and auto-cleanup"
+    triggers = [
+        AgentTrigger.MANUAL,
+        AgentTrigger.CRON,
+        AgentTrigger.PRE_COMMIT,
+    ]
+
+    def __init__(self, session: AsyncSession | None = None):
+        super().__init__()
+        self._session = session
+        self._temp_users: list[dict[str, Any]] = []
+        self._bugs: list[dict[str, Any]] = []
+        self._settings = get_settings()
+
+    # ── Main ──
+
+    async def run(self, context: dict[str, Any] | None = None) -> AgentResult:
+        start = time.time()
+        await self.set_running("qa_testing")
+
+        try:
+            action = (context or {}).get("action", "full")
+
+            if action == "api":
+                result = await self._run_api_tests()
+            elif action == "e2e":
+                result = await self._run_e2e_tests()
+            elif action == "vitest":
+                result = await self._run_vitest_tests()
+            elif action == "cleanup":
+                result = await self._cleanup_all()
+            elif action == "status":
+                result = await self._get_status()
+            else:
+                result = await self._run_full()
+
+            result.duration_ms = int((time.time() - start) * 1000)
+            await self.set_idle()
+            await self._report_bugs()
+            return result
+
+        except Exception as e:
+            await self.set_error(str(e))
+            return AgentResult(
+                success=False,
+                message=f"QATesterAgent failed: {str(e)}",
+                errors=[str(e)],
+            )
+
+    # ── Full suite ──
+
+    async def _run_full(self) -> AgentResult:
+        api_result = await self._run_api_tests()
+        e2e_result = await self._run_e2e_tests()
+        vitest_result = await self._run_vitest_tests()
+        total_bugs = self._bugs.copy()
+        combined_success = api_result.success or e2e_result.success or vitest_result.success
+        combined_msg = f"API: {api_result.message} | E2E: {e2e_result.message} | Vitest: {vitest_result.message}"
+        combined_data = {
+            "api": api_result.data,
+            "e2e": e2e_result.data,
+            "vitest": vitest_result.data,
+            "bugs": total_bugs,
+        }
+        await self._cleanup_all()
+        return AgentResult(
+            success=combined_success,
+            message=combined_msg,
+            data=combined_data,
+            errors=api_result.errors + e2e_result.errors + vitest_result.errors,
+        )
+
+    # ── API tests ──
+
+    async def _run_api_tests(self) -> AgentResult:
+        import httpx
+
+        temp_user = await self._create_temp_user()
+        if not temp_user:
+            return AgentResult(success=False, message="Failed to create temp user", errors=["Temp user creation failed"])
+
+        tests = []
+        base = TEST_BASE_URL
+
+        async with httpx.AsyncClient(base_url=base, timeout=15.0) as client:
+            # 1. Health check
+            try:
+                r = await client.get("/health")
+                tests.append({"name": "health_check", "passed": r.status_code == 200, "detail": f"GET /health → {r.status_code}"})
+            except Exception as e:
+                tests.append({"name": "health_check", "passed": False, "detail": str(e)})
+
+            # 2. Register (same user could conflict, so check)
+            email = temp_user["email"]
+            password = temp_user["password"]
+            try:
+                r = await client.post("/api/v1/auth/register", json={"email": email, "password": password, "display_name": "Test User", "accepted_terms": True})
+                tests.append({"name": "register", "passed": r.status_code in (201, 409), "detail": f"POST /auth/register → {r.status_code}"})
+            except Exception as e:
+                tests.append({"name": "register", "passed": False, "detail": str(e)})
+
+            # 3. Login
+            access_token = None
+            try:
+                r = await client.post("/api/v1/auth/login", json={"email": email, "password": password})
+                if r.status_code == 200:
+                    data = r.json()
+                    access_token = data.get("access_token")
+                tests.append({"name": "login", "passed": r.status_code == 200, "detail": f"POST /auth/login → {r.status_code}"})
+            except Exception as e:
+                tests.append({"name": "login", "passed": False, "detail": str(e)})
+
+            if access_token:
+                headers = {"Authorization": f"Bearer {access_token}"}
+
+                # 4. Get me
+                try:
+                    r = await client.get("/api/v1/users/me", headers=headers)
+                    tests.append({"name": "get_me", "passed": r.status_code == 200, "detail": f"GET /users/me → {r.status_code}"})
+                except Exception as e:
+                    tests.append({"name": "get_me", "passed": False, "detail": str(e)})
+
+                # 5. Create idea
+                idea_id = None
+                try:
+                    r = await client.post("/api/v1/ideas", headers=headers, json={"title": "Test idea from QA", "content": "This is a test idea created by QATesterAgent"})
+                    if r.status_code in (200, 201):
+                        idea_data = r.json()
+                        idea_id = idea_data.get("id")
+                    tests.append({"name": "create_idea", "passed": r.status_code in (200, 201), "detail": f"POST /ideas → {r.status_code}"})
+                except Exception as e:
+                    tests.append({"name": "create_idea", "passed": False, "detail": str(e)})
+
+                # 6. List ideas
+                try:
+                    r = await client.get("/api/v1/ideas", headers=headers)
+                    tests.append({"name": "list_ideas", "passed": r.status_code == 200, "detail": f"GET /ideas → {r.status_code}"})
+                except Exception as e:
+                    tests.append({"name": "list_ideas", "passed": False, "detail": str(e)})
+
+                # 7. Delete test idea
+                if idea_id:
+                    try:
+                        r = await client.delete(f"/api/v1/ideas/{idea_id}", headers=headers)
+                        tests.append({"name": "delete_idea", "passed": r.status_code in (204, 200), "detail": f"DELETE /ideas/{idea_id} → {r.status_code}"})
+                    except Exception as e:
+                        tests.append({"name": "delete_idea", "passed": False, "detail": str(e)})
+
+                # 8. Voice settings
+                try:
+                    r = await client.get("/api/v1/users/me/voice-settings", headers=headers)
+                    tests.append({"name": "voice_settings", "passed": r.status_code == 200, "detail": f"GET /voice-settings → {r.status_code}"})
+                except Exception as e:
+                    tests.append({"name": "voice_settings", "passed": False, "detail": str(e)})
+
+                # 9. Public config
+                try:
+                    r = await client.get("/api/v1/config/public")
+                    tests.append({"name": "public_config", "passed": r.status_code == 200, "detail": f"GET /config/public → {r.status_code}"})
+                except Exception as e:
+                    tests.append({"name": "public_config", "passed": False, "detail": str(e)})
+
+        passed = sum(1 for t in tests if t["passed"])
+        failed = [t for t in tests if not t["passed"]]
+        if failed:
+            self._bugs.extend({
+                "test": t["name"],
+                "detail": t["detail"],
+                "source": "api",
+                "severity": "medium",
+            } for t in failed)
+
+        return AgentResult(
+            success=len(failed) == 0,
+            message=f"API tests: {passed}/{len(tests)} passed",
+            data={"total": len(tests), "passed": passed, "failed": len(failed), "tests": tests, "bugs": self._bugs},
+            errors=[f"{t['name']}: {t['detail']}" for t in failed],
+        )
+
+    # ── Vitest (frontend unit tests) ──
+
+    async def _run_vitest_tests(self) -> AgentResult:
+        webui_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "webui")
+        if not os.path.isdir(os.path.join(webui_dir, "node_modules")):
+            return AgentResult(
+                success=True,
+                message="Vitest пропущен: node_modules не найдены",
+                data={"skipped": True, "reason": "node_modules not found"},
+            )
+
+        import subprocess
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "npx", "vitest", "run", "--reporter=json",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=webui_dir,
+            )
+            stdout, stderr = await proc.communicate()
+            output = stdout.decode("utf-8", errors="replace")
+
+            if proc.returncode != 0:
+                logger.warning("Vitest exited with code %d: %s", proc.returncode, stderr.decode()[:200])
+
+            # Vitest JSON output starts after potential Vite banner
+            json_start = output.find("{")
+            if json_start == -1:
+                return AgentResult(
+                    success=False,
+                    message="Vitest: JSON output not found",
+                    errors=[output[:500]],
+                )
+
+            import json as json_mod
+            data = json_mod.loads(output[json_start:])
+            total = data.get("total", 0)
+            passed = sum(1 for f in data.get("files", []) if f.get("result") == "passed")
+            failed_files = [f for f in data.get("files", []) if f.get("result") != "passed"]
+
+            if failed_files:
+                for ff in failed_files:
+                    filepath = ff.get("filepath", ff.get("name", "unknown"))
+                    self._bugs.append({
+                        "test": filepath,
+                        "detail": f"Vitest failed: {json_mod.dumps(ff.get('failureMessage', 'unknown'))}",
+                        "source": "vitest",
+                        "severity": "high",
+                    })
+
+            return AgentResult(
+                success=len(failed_files) == 0,
+                message=f"Vitest: {passed}/{total} passed",
+                data={"total": total, "passed": passed, "failed": len(failed_files), "files": data.get("files", [])},
+                errors=[f"{f.get('filepath', '?')} failed" for f in failed_files],
+            )
+
+        except FileNotFoundError:
+            return AgentResult(
+                success=True,
+                message="Vitest пропущен: npx не найден",
+                data={"skipped": True, "reason": "npx not found"},
+            )
+
+    # ── E2E tests (Playwright) ──
+
+    async def _run_e2e_tests(self) -> AgentResult:
+        if not PLAYWRIGHT_AVAILABLE:
+            return AgentResult(
+                success=True,
+                message="Playwright не установлен, E2E тесты пропущены",
+                data={"skipped": True, "reason": "playwright not installed"},
+            )
+
+        tests = []
+        frontend_url = TEST_FRONTEND_URL
+
+        try:
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=True, args=["--no-sandbox"])
+                page = await browser.new_page()
+
+                # 1. Landing page loads
+                try:
+                    await page.goto(frontend_url, wait_until="networkidle", timeout=30000)
+                    title = await page.title()
+                    tests.append({"name": "landing_loads", "passed": bool(title), "detail": f"Title: {title[:50]}"})
+                except Exception as e:
+                    tests.append({"name": "landing_loads", "passed": False, "detail": str(e)})
+
+                # 2. Navigate to /login
+                try:
+                    await page.goto(f"{frontend_url}/login", wait_until="networkidle", timeout=15000)
+                    has_form = await page.query_selector('input[type="email"], input[name="email"]') is not None
+                    tests.append({"name": "login_page", "passed": has_form, "detail": "Login form found" if has_form else "No email input"})
+                except Exception as e:
+                    tests.append({"name": "login_page", "passed": False, "detail": str(e)})
+
+                # 3. Navigate to /register
+                try:
+                    await page.goto(f"{frontend_url}/register", wait_until="networkidle", timeout=15000)
+                    has_register_form = await page.query_selector('input[type="password"]') is not None
+                    tests.append({"name": "register_page", "passed": has_register_form, "detail": "Register form found" if has_register_form else "No password input"})
+                except Exception as e:
+                    tests.append({"name": "register_page", "passed": False, "detail": str(e)})
+
+                # 4. Dashboard (may redirect to login)
+                try:
+                    await page.goto(f"{frontend_url}/dashboard", wait_until="networkidle", timeout=15000)
+                    tests.append({"name": "dashboard_redirect", "passed": True, "detail": f"URL: {page.url[:60]}"})
+                except Exception as e:
+                    tests.append({"name": "dashboard_redirect", "passed": False, "detail": str(e)})
+
+                # 5. Check dark mode toggle exists
+                try:
+                    await page.goto(f"{frontend_url}/settings", wait_until="networkidle", timeout=15000)
+                    tests.append({"name": "settings_page", "passed": True, "detail": f"Settings loaded: {page.url[:60]}"})
+                except Exception as e:
+                    tests.append({"name": "settings_page", "passed": False, "detail": str(e)})
+
+                await browser.close()
+
+        except Exception as e:
+            return AgentResult(
+                success=False,
+                message=f"E2E tests failed: {str(e)}",
+                errors=[str(e)],
+            )
+
+        passed = sum(1 for t in tests if t["passed"])
+        failed = [t for t in tests if not t["passed"]]
+        if failed:
+            self._bugs.extend({
+                "test": t["name"],
+                "detail": t["detail"],
+                "source": "e2e",
+                "severity": "high",
+            } for t in failed)
+
+        return AgentResult(
+            success=len(failed) == 0,
+            message=f"E2E tests: {passed}/{len(tests)} passed",
+            data={"total": len(tests), "passed": passed, "failed": len(failed), "tests": tests, "bugs": self._bugs},
+            errors=[f"{t['name']}: {t['detail']}" for t in failed],
+        )
+
+    # ── Temp user management ──
+
+    async def _create_temp_user(self) -> dict[str, Any] | None:
+        if not self._session:
+            return {"email": "test@voidea.test", "password": "test123", "simulated": True}
+
+        temp_id = str(uuid4())[:8]
+        email = f"qa_test_{temp_id}@voidea.test"
+        password = f"qa_pass_{temp_id}"
+
+        user = User(
+            id=uuid4(),
+            email=email,
+            password_hash=get_password_hash(password),
+            is_active=True,
+            role="user",
+            display_name=f"QA Test {temp_id}",
+        )
+        self._session.add(user)
+        await self._session.commit()
+
+        entry = {"id": str(user.id), "email": email, "password": password}
+        self._temp_users.append(entry)
+        return entry
+
+    async def _cleanup_all(self) -> AgentResult:
+        if not self._session or not self._temp_users:
+            return AgentResult(success=True, message="No cleanup needed", data={"cleaned": 0})
+
+        cleaned = 0
+        for entry in self._temp_users:
+            try:
+                stmt = delete(User).where(User.id == entry.get("id"))
+                await self._session.execute(stmt)
+                cleaned += 1
+            except Exception as e:
+                logger.warning("Cleanup failed for %s: %s", entry.get("email"), e)
+
+        await self._session.commit()
+        self._temp_users = []
+        return AgentResult(success=True, message=f"Cleaned up {cleaned} temp users", data={"cleaned": cleaned})
+
+    async def _report_bugs(self):
+        """Write bugs as LogEntries for FixAgent."""
+        if not self._bugs or not self._session:
+            return
+        for bug in self._bugs:
+            log = LogEntry(
+                level="ERROR" if bug.get("severity") == "high" else "WARNING",
+                source="qa_tester_agent",
+                message=f"Bug: {bug['test']} — {bug['detail']}",
+                details=json.dumps(bug, ensure_ascii=False),
+                created_at=datetime.now(timezone.utc),
+            )
+            self._session.add(log)
+        try:
+            await self._session.commit()
+        except Exception:
+            pass
+
+    async def _get_status(self) -> AgentResult:
+        return AgentResult(
+            success=True,
+            message="QATesterAgent v2 status",
+            data={
+                "temp_users": len(self._temp_users),
+                "bugs_found": len(self._bugs),
+                "playwright_available": PLAYWRIGHT_AVAILABLE,
+                "api_base_url": TEST_BASE_URL,
+                "frontend_url": TEST_FRONTEND_URL,
+                "status": self.status.value,
+            },
+        )
+
+    async def health_check(self) -> bool:
+        return True
+
+    async def get_metrics(self) -> dict[str, Any]:
+        return {
+            "agent_id": self.name,
+            "version": self.version,
+            "status": self.status.value,
+            "temp_users_current": len(self._temp_users),
+            "bugs_found": len(self._bugs),
+            "playwright_available": PLAYWRIGHT_AVAILABLE,
+        }