refactored: to utilise the google adk and production grade agent

tests/test_adk_architecture.py

@@ -0,0 +1,212 @@
+"""Comprehensive test suite for Google ADK Multi-Agent Architecture & PostgreSQL Persistence."""
+
+import pytest
+import uuid
+from starlette.testclient import TestClient
+
+from app.adk.agents import (
+    DiscoveryAgent,
+    ArchitectureDesignAgent,
+    ValidationReviewAgent,
+    PackagingAgent,
+    OrchestratorLoopAgent,
+    build_adk_multi_agent_system,
+)
+from app.adk.artifacts import PostgresArtifactRepository
+from app.adk.evaluation import ADKEvaluator
+from app.adk.runners import ADKAgentRunner
+from app.adk.sessions import PostgresSessionService
+from app.adk.tools import ADK_TOOLS
+from app.adk.workflows import create_gcp_adk_workflow
+from app.agent import app
+from app.config import get_settings
+from app.database import get_db_manager
+from app.skills.loader import SkillLoader
+
+
+@pytest.fixture
+def skill_loader():
+    settings = get_settings()
+    loader = SkillLoader(settings.SKILLS_DIR)
+    loader.load_skills()
+    return loader
+
+
+@pytest.fixture
+def client():
+    return TestClient(app)
+
+
+def test_database_manager_operations():
+    """Verify PostgreSQL database manager schema initialization & CRUD operations."""
+    db = get_db_manager()
+    session_id = f"test-sess-{uuid.uuid4()}"
+    execution_id = f"test-exec-{uuid.uuid4()}"
+
+    # 1. Save and retrieve session
+    saved = db.save_session(session_id, "TestAgent", {"key": "value"})
+    assert saved is True
+
+    session_data = db.get_session(session_id)
+    assert session_data is not None
+    assert session_data["agent_name"] == "TestAgent"
+    assert session_data["state_data"]["key"] == "value"
+
+    # 2. Save workflow execution
+    saved_exec = db.save_workflow_execution(
+        execution_id=execution_id,
+        session_id=session_id,
+        status="completed",
+        current_phase="package",
+        loop_count=1,
+        request_summary="Unit test workflow request",
+        results={"passed": True},
+    )
+    assert saved_exec is True
+
+    # 3. Save artifact
+    art_saved = db.save_artifact(
+        artifact_id=f"art-{uuid.uuid4()}",
+        execution_id=execution_id,
+        artifact_type="markdown",
+        file_path="docs/test.md",
+        content="# Test Content",
+    )
+    assert art_saved is True
+
+    # 4. Record review log
+    log_saved = db.record_orchestrator_log(
+        log_id=f"log-{uuid.uuid4()}",
+        execution_id=execution_id,
+        iteration=1,
+        review_status="APPROVED",
+        reviewer_agent="ValidationReviewAgent",
+        feedback="Passed all checks",
+    )
+    assert log_saved is True
+
+
+def test_adk_tools():
+    """Verify google.adk.tools wrappers."""
+    assert len(ADK_TOOLS) == 6
+    tool_names = [t.name for t in ADK_TOOLS]
+    assert "validate_mermaid_diagram" in tool_names
+    assert "validate_terraform_syntax" in tool_names
+    assert "validate_repository_artifacts" in tool_names
+    assert "developerknowledge_search_documents" in tool_names
+    assert "developerknowledge_get_documents" in tool_names
+    assert "developerknowledge_answer_query" in tool_names
+
+
+def test_adk_postgres_session_service():
+    """Verify PostgresSessionService creating, getting, and saving session state."""
+    session_service = PostgresSessionService()
+    session_id = f"adk-session-{uuid.uuid4()}"
+
+    sess = session_service.create_session("GCP_ADK_Agent", session_id=session_id)
+    assert sess.session_id == session_id
+    assert sess.agent_name == "GCP_ADK_Agent"
+
+    sess.state["counter"] = 42
+    saved = session_service.save_session(sess)
+    assert saved is True
+
+    fetched = session_service.get_session(session_id)
+    assert fetched is not None
+    assert fetched.state.get("counter") == 42
+
+
+def test_adk_orchestrator_loop_agent(skill_loader):
+    """Verify OrchestratorLoopAgent multi-agent loop review cycle."""
+    orchestrator = build_adk_multi_agent_system(skill_loader, max_iterations=3)
+    assert orchestrator.name == "OrchestratorLoopAgent"
+    assert orchestrator.max_iterations == 3
+
+    initial_state = {
+        "execution_id": str(uuid.uuid4()),
+        "workflow_request": "Event-driven regional HTTP application",
+        "target_dir": ".",
+        "active_skills": [],
+    }
+
+    final_state = orchestrator.execute(initial_state)
+    assert final_state.get("validation_passed") is True
+    assert final_state.get("loop_completed_successfully") is True
+    assert len(final_state.get("active_skills", [])) == 5
+
+
+def test_adk_workflow_composition(skill_loader):
+    """Verify google.adk.workflows Workflow composition."""
+    workflow = create_gcp_adk_workflow(skill_loader, max_iterations=2)
+    assert workflow.name == "GCP_Solution_Architecture_Workflow"
+    assert len(workflow.steps) == 1
+
+    initial_state = {
+        "execution_id": str(uuid.uuid4()),
+        "workflow_request": "Event-driven architecture test",
+        "target_dir": ".",
+        "active_skills": [],
+    }
+
+    result = workflow.execute(initial_state)
+    assert result.get("validation_passed") is True
+
+
+def test_adk_agent_runner():
+    """Verify ADKAgentRunner execution and artifact persistence."""
+    runner = ADKAgentRunner()
+    session_id = f"runner-session-{uuid.uuid4()}"
+
+    res = runner.run_execution(
+        session_id=session_id,
+        request_summary="High scale ingestion workflow",
+        target_dir=".",
+    )
+
+    assert res["status"] == "success"
+    assert res["validation_passed"] is True
+    assert "solution_guide" in res["artifacts"]
+
+    # Verify session persists in Postgres DB
+    session_service = PostgresSessionService()
+    sess = session_service.get_session(session_id)
+    assert sess is not None
+
+
+def test_adk_evaluator():
+    """Verify ADKEvaluator executing benchmark cases."""
+    evaluator = ADKEvaluator()
+    case = {
+        "id": "case-test",
+        "workflow_request": "Event-driven regional HTTP application",
+        "rubric": {
+            "required_products": ["Cloud Run", "Pub/Sub", "Cloud Storage"],
+            "requires_mermaid": True,
+            "requires_terraform": True,
+            "requires_guide_sections": ["Functional requirements", "Selected products"],
+        },
+    }
+
+    res = evaluator.evaluate_benchmark_case(case)
+    assert res["passed"] is True
+    assert res["percentage"] >= 80.0
+
+
+def test_starlette_session_api_endpoint(client):
+    """Verify Starlette API GET /sessions/{session_id} route."""
+    session_id = f"api-sess-{uuid.uuid4()}"
+
+    # First run workflow to populate session
+    payload = {
+        "session_id": session_id,
+        "request": "Test session retrieval route",
+    }
+    gen_resp = client.post("/generate", json=payload)
+    assert gen_resp.status_code == 200
+
+    # Query session
+    sess_resp = client.get(f"/sessions/{session_id}")
+    assert sess_resp.status_code == 200
+    sess_data = sess_resp.json()
+    assert sess_data["session_id"] == session_id
+    assert sess_data["agent_name"] == "OrchestratorLoopAgent"