tests/test_workspace_integration.py

"""
Integration tests for the Workspace API router.

Tests verify:
- Endpoints are mounted and accept validated requests
- Document sections include user stories, functional/non-functional requirements, and use cases
- API rejects invalid input with proper validation errors
"""

from fastapi.testclient import TestClient


class TestWorkspaceEndpointsMounted:
    """Verify all workspace endpoints are mounted and responding."""

    def test_evaluate_endpoint_exists(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/evaluate", json={"idea": ""})
        assert response.status_code == 200

    def test_evaluate_rejects_missing_body(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/evaluate")
        assert response.status_code == 422

    def test_directions_endpoint_exists(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/directions", json={"answers": {}})
        assert response.status_code == 200

    def test_directions_rejects_missing_body(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/directions")
        assert response.status_code == 422

    def test_generate_endpoint_exists(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/generate", json={
            "direction_id": "dir-a",
            "brief": "Build a task manager"
        })
        assert response.status_code == 200

    def test_generate_rejects_missing_body(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/generate")
        assert response.status_code == 422

    def test_refine_endpoint_exists(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/refine", json={
            "section_id": "sec-test",
            "content": "Some content",
            "prompt": "Make it better"
        })
        assert response.status_code == 200

    def test_refine_rejects_missing_body(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/refine")
        assert response.status_code == 422


class TestDocumentSectionsIncludeRequirements:
    """Verify document generation sections include user stories, requirements, and use cases."""

    def test_sections_include_user_stories(self):
        """SECTIONS must include a User Stories section."""
        from app.services.workspace_service import SECTIONS
        section_titles = [s["title"].lower() for s in SECTIONS]
        assert any("user stor" in t for t in section_titles), \
            f"SECTIONS must include 'User Stories' but got: {section_titles}"

    def test_sections_include_functional_requirements(self):
        """SECTIONS must include a Functional Requirements section."""
        from app.services.workspace_service import SECTIONS
        section_titles = [s["title"].lower() for s in SECTIONS]
        assert any("functional requirement" in t for t in section_titles), \
            f"SECTIONS must include 'Functional Requirements' but got: {section_titles}"

    def test_sections_include_non_functional_requirements(self):
        """SECTIONS must include a Non-Functional Requirements section."""
        from app.services.workspace_service import SECTIONS
        section_titles = [s["title"].lower() for s in SECTIONS]
        assert any("non-functional" in t or "non functional" in t for t in section_titles), \
            f"SECTIONS must include 'Non-Functional Requirements' but got: {section_titles}"

    def test_sections_include_use_cases(self):
        """SECTIONS must include a Use Cases section."""
        from app.services.workspace_service import SECTIONS
        section_titles = [s["title"].lower() for s in SECTIONS]
        assert any("use case" in t for t in section_titles), \
            f"SECTIONS must include 'Use Cases' but got: {section_titles}"


class TestEvaluateEndpointSchema:
    """Verify the evaluate endpoint returns correct response schema."""

    def test_evaluate_returns_correct_structure(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/evaluate", json={
            "idea": "Build a task management app with AI-powered prioritization"
        })
        assert response.status_code == 200
        data = response.json()
        assert "scores" in data
        assert "overall_score" in data
        assert "threshold_met" in data
        assert "weak_dimensions" in data
        assert "targeted_questions" in data

    def test_evaluate_empty_idea_returns_fallback(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/evaluate", json={"idea": ""})
        assert response.status_code == 200
        data = response.json()
        assert data["overall_score"] == 0.0
        assert data["threshold_met"] is False
        assert len(data["targeted_questions"]) > 0


class TestDirectionsEndpointSchema:
    """Verify the directions endpoint returns correct response schema."""

    def test_directions_returns_correct_structure(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/directions", json={
            "answers": {"q1": "B2C", "q2": "Web app", "q3": "Task management", "q4": "AI-powered prioritization"}
        })
        assert response.status_code == 200
        data = response.json()
        assert "directions" in data
        assert isinstance(data["directions"], list)
        if len(data["directions"]) > 0:
            direction = data["directions"][0]
            assert "id" in direction
            assert "title" in direction
            assert "description" in direction
            assert "tags" in direction

    def test_directions_empty_answers_returns_fallback(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/directions", json={"answers": {}})
        assert response.status_code == 200
        data = response.json()
        assert len(data["directions"]) >= 2


class TestRefineEndpoint:
    """Verify the refine endpoint handles edge cases gracefully."""

    def test_refine_empty_content_returns_original(self, authenticated_client):
        client = authenticated_client
        response = client.post("/api/workspace/refine", json={
            "section_id": "sec-test",
            "content": "",
            "prompt": "Make it better"
        })
        assert response.status_code == 200
        data = response.json()
        assert data["section_id"] == "sec-test"
        assert data["content"] == ""

    def test_refine_survives_braces_in_section_content(self):
        """Braces in user content must not break prompt assembly.

        Technical sections routinely contain `{...}` - JSON samples, code, route
        templates like `/prd/{session_id}`. `str.format` does not re-format the
        values it substitutes, so this is safe today; the test pins that, and
        pins that a successful refine returns refined content rather than
        silently handing back the original (the shape every swallowed failure in
        this function takes).
        """
        import asyncio

        from app.services import workspace_service

        content = 'Call `GET /prd/{session_id}` and read {"status": "ok"}.'
        prompt = "Add an example with {placeholders}"
        seen: dict[str, str] = {}

        class _StubStructured:
            async def ainvoke(self, messages):
                seen["system"] = messages[0]["content"]
                return workspace_service.RefinedSection(
                    content="Refined body.", suggestions=["a", "b"]
                )

        class _StubLLM:
            def with_structured_output(self, _schema):
                return _StubStructured()

        original = workspace_service.get_chat_model
        workspace_service.get_chat_model = lambda **kwargs: _StubLLM()
        try:
            result = asyncio.run(
                workspace_service.refine_section("sec-1", content, prompt)
            )
        finally:
            workspace_service.get_chat_model = original

        # Refine actually happened rather than silently returning the original.
        assert result["content"] == "Refined body."
        # ...and both pieces of user text reached the model intact.
        assert content in seen["system"]
        assert prompt in seen["system"]


class TestPipelineGenerationPath:
    """Guards the path /api/workspace/generate actually takes.

    `SECTIONS` and the tests above now describe only the degraded single-agent
    fallback, used when the orchestrator cannot start. Workspace generation
    normally runs the full agent team, and nothing above would notice if that
    mapping broke - these cover it.
    """

    def test_section_ids_round_trip_to_roles(self):
        """Every agent's section id must map back to that agent.

        `save_workspace` uses this inverse to decide which sections are agent
        output; if it stops round-tripping, saved projects silently lose every
        agent and the dashboard reports "No output".
        """
        from app.services.workspace_service import (
            _role_section_id,
            pipeline_section_order,
            role_for_section_id,
        )

        for role in pipeline_section_order():
            assert role_for_section_id(_role_section_id(role)) == role

    def test_legacy_section_ids_are_not_mistaken_for_roles(self):
        """Fallback section ids must not be read as agent output."""
        from app.services.workspace_service import SECTIONS, role_for_section_id

        for section in SECTIONS:
            assert role_for_section_id(section["id"]) is None

    def test_pipeline_order_matches_the_orchestrator(self):
        """The section order must be derived from the phases, not restated."""
        from app.core.pipeline_orchestrator import PipelineOrchestrator
        from app.services.workspace_service import pipeline_section_order

        expected = [
            role.value
            for role in PipelineOrchestrator.PHASE_1
            + PipelineOrchestrator.PHASE_2
            + PipelineOrchestrator.PHASE_3
        ]
        assert pipeline_section_order() == expected
        assert len(expected) == 11

    def test_titles_render_acronyms(self):
        """`.title()` alone produces "Ux Designer" and "Qa Strategist"."""
        from app.services.workspace_service import _role_section_title

        assert _role_section_title("ux_designer") == "UX Designer"
        assert _role_section_title("api_designer") == "API Designer"
        assert _role_section_title("qa_strategist") == "QA Strategist"
        assert _role_section_title("devops_architect") == "DevOps Architect"
        assert _role_section_title("solution_architect") == "Solution Architect"

    def test_save_puts_agent_output_at_top_level_and_metadata_under_underscore(self):
        """The dashboard reads `artifacts` as a role -> markdown map.

        Writing workspace metadata at the top level made a saved spec report
        "4 Agents" and render chips reading "type" and "brief".
        """
        from sqlalchemy import create_engine
        from sqlalchemy.orm import sessionmaker

        from app.core.database import Base
        from app.core import models
        from app.services.workspace_service import _role_section_id, save_workspace

        # Its own in-memory engine - never the shared one, whose teardown is
        # destructive elsewhere in this suite.
        engine = create_engine("sqlite://")
        Base.metadata.create_all(engine)
        db = sessionmaker(bind=engine)()
        try:
            user = models.User(
                id=1, google_id="g", email="w@example.com", full_name="W", role="user"
            )
            db.add(user)
            db.commit()

            sections = [
                {
                    "id": _role_section_id("solution_architect"),
                    "title": "Solution Architect",
                    "content": "## Architecture\nContent.",
                    "order": 0,
                },
                {
                    "id": "sec-overview",
                    "title": "Project Overview",
                    "content": "Fallback section.",
                    "order": 1,
                },
            ]
            project = save_workspace(
                db=db,
                current_user=user,
                title="T",
                direction_id="dir-a",
                brief="b",
                sections=sections,
            )

            assert project.artifacts["solution_architect"] == "## Architecture\nContent."
            assert "_workspace" in project.artifacts
            assert len(project.artifacts["_workspace"]["sections"]) == 2
            # Metadata must not sit alongside roles, or it gets counted as one.
            for key in ("type", "direction_id", "brief", "sections"):
                assert key not in project.artifacts
            # The fallback section has no role, so it is not agent output.
            roles = [k for k in project.artifacts if not k.startswith("_")]
            assert roles == ["solution_architect"]
        finally:
            db.close()
            engine.dispose()


class TestWorkspaceRequiresAuth:
    """The workspace routes are the most expensive in the app.

    `/generate` runs the whole 12-agent pipeline and the other four are each an
    authoring-tier call. Only `/save` used to require a caller, so anyone who
    could reach the host could spend the project's NVIDIA credits.
    """

    ROUTES = [
        ("/api/workspace/evaluate", {"idea": "x"}),
        ("/api/workspace/clarify", {"idea": "x"}),
        ("/api/workspace/directions", {"answers": {}}),
        ("/api/workspace/generate", {"direction_id": "d", "brief": "b"}),
        ("/api/workspace/refine", {"section_id": "s", "content": "c", "prompt": "p"}),
        ("/api/workspace/save", {"title": "t", "artifacts": {}}),
    ]

    def test_every_route_rejects_anonymous_callers(self):
        from app.main import app

        client = TestClient(app)
        allowed = [
            path for path, body in self.ROUTES
            if client.post(path, json=body).status_code != 401
        ]
        assert not allowed, f"Reachable without credentials: {allowed}"