test_server.py

"""
Tests for the CloseClaw REST API server.

The server is started on a random OS-assigned port (port=0) for each test
class so tests are fully isolated and never conflict with existing services.
All Ollama and hardware calls are mocked so tests run without a live backend.
"""

from __future__ import annotations

import json
import threading
import http.client
from pathlib import Path
from unittest.mock import MagicMock, patch

import pytest

from closeclaw.config import Config
from closeclaw.agent import Agent
from closeclaw.server import CloseClawServer, create_server, VERSION


# ─── Helpers ──────────────────────────────────────────────────────────────────

def _make_config(tmp_path: Path) -> Config:
    config = Config(config_path=tmp_path / "config.toml")
    config._base = tmp_path / ".closeclaw"
    config._data["skills"]["dir"] = str(config._base / "skills")
    config._data["memory"]["db_path"] = str(config._base / "memory.db")
    return config


def _make_agent(tmp_path: Path, model: str = "test-model") -> Agent:
    config = _make_config(tmp_path)
    return Agent(config, model=model, skills_dirs=[])


def _get(port: int, path: str) -> tuple:
    """GET request → (status_code, parsed_json_body)."""
    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
    conn.request("GET", path)
    resp = conn.getresponse()
    body = json.loads(resp.read())
    headers = {k.lower(): v for k, v in resp.getheaders()}
    conn.close()
    return resp.status, body, headers


def _post(port: int, path: str, body: dict) -> tuple:
    """POST JSON request → (status_code, parsed_json_body)."""
    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
    data = json.dumps(body).encode()
    conn.request(
        "POST", path, body=data, headers={"Content-Type": "application/json"}
    )
    resp = conn.getresponse()
    result = json.loads(resp.read())
    conn.close()
    return resp.status, result


def _post_raw(port: int, path: str, raw: bytes, content_type: str = "application/json") -> tuple:
    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
    conn.request("POST", path, body=raw, headers={"Content-Type": content_type})
    resp = conn.getresponse()
    body = resp.read()
    status = resp.status
    conn.close()
    return status, body


def _post_sse(port: int, path: str, body: dict) -> list:
    """POST and collect SSE events; returns list of parsed event dicts."""
    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
    data = json.dumps(body).encode()
    conn.request(
        "POST", path, body=data, headers={"Content-Type": "application/json"}
    )
    resp = conn.getresponse()
    raw = resp.read()
    conn.close()

    events = []
    for block in raw.decode("utf-8").split("\n\n"):
        block = block.strip()
        if block.startswith("data: "):
            try:
                events.append(json.loads(block[6:]))
            except json.JSONDecodeError:
                pass
    return events


# ─── Fixtures ─────────────────────────────────────────────────────────────────

@pytest.fixture
def server(tmp_path):
    """Start a server on a random port, yield (server, port), then shut down."""
    agent = _make_agent(tmp_path)
    config = _make_config(tmp_path)
    srv = CloseClawServer(("127.0.0.1", 0), agent=agent, config=config)
    port = srv.server_address[1]
    t = threading.Thread(target=srv.serve_forever, daemon=True)
    t.start()
    yield srv, port
    srv.shutdown()
    srv.server_close()


# ─── /health ──────────────────────────────────────────────────────────────────

class TestHealthEndpoint:
    def test_returns_200_ok(self, server):
        _, port = server
        status, body, _ = _get(port, "/health")
        assert status == 200
        assert body["status"] == "ok"

    def test_includes_version(self, server):
        _, port = server
        _, body, _ = _get(port, "/health")
        assert body["version"] == VERSION

    def test_cors_header_present(self, server):
        _, port = server
        _, _, headers = _get(port, "/health")
        assert headers.get("access-control-allow-origin") == "*"


# ─── /models ──────────────────────────────────────────────────────────────────

class TestModelsEndpoint:
    def test_returns_model_list(self, server):
        _, port = server
        with patch("closeclaw.server.ModelManager") as MockMM:
            inst = MockMM.return_value
            inst.list_models.return_value = ["llama3.2:3b", "phi3:mini"]
            inst.is_available.return_value = True
            status, body, _ = _get(port, "/models")
        assert status == 200
        assert isinstance(body["models"], list)

    def test_ollama_unavailable_flag(self, server):
        _, port = server
        with patch("closeclaw.server.ModelManager") as MockMM:
            inst = MockMM.return_value
            inst.list_models.return_value = []
            inst.is_available.return_value = False
            _, body, _ = _get(port, "/models")
        assert body["models"] == []
        assert body["ollama_available"] is False

    def test_ollama_available_flag(self, server):
        _, port = server
        with patch("closeclaw.server.ModelManager") as MockMM:
            inst = MockMM.return_value
            inst.list_models.return_value = ["llama3.2:3b"]
            inst.is_available.return_value = True
            _, body, _ = _get(port, "/models")
        assert body["ollama_available"] is True


# ─── /skills ──────────────────────────────────────────────────────────────────

class TestSkillsEndpoint:
    def test_returns_skills_list(self, server):
        _, port = server
        status, body, _ = _get(port, "/skills")
        assert status == 200
        assert "skills" in body
        assert isinstance(body["skills"], list)

    def test_empty_when_no_skills(self, server):
        # Default test config has no skills dir, so list is empty.
        _, port = server
        _, body, _ = _get(port, "/skills")
        # Should not error; may be empty list.
        assert isinstance(body["skills"], list)

    def test_skill_fields(self, tmp_path):
        """Skills returned include required fields."""
        skill_dir = tmp_path / "myskill"
        skill_dir.mkdir()
        (skill_dir / "skill.toml").write_text("""
[skill]
id = "myskill"
name = "My Skill"
version = "2.0.0"
description = "Does stuff"
""")
        config = _make_config(tmp_path)
        config._data["skills"]["dir"] = str(tmp_path)
        agent = Agent(config, model="test", skills_dirs=[])
        srv = CloseClawServer(("127.0.0.1", 0), agent=agent, config=config)
        port = srv.server_address[1]
        t = threading.Thread(target=srv.serve_forever, daemon=True)
        t.start()
        try:
            _, body, _ = _get(port, "/skills")
            skills = body["skills"]
            assert any(s["id"] == "myskill" for s in skills)
            skill = next(s for s in skills if s["id"] == "myskill")
            for field in ("id", "name", "version", "description", "keywords"):
                assert field in skill
        finally:
            srv.shutdown()
            srv.server_close()


# ─── /hardware ────────────────────────────────────────────────────────────────

class TestHardwareEndpoint:
    def test_returns_hardware_fields(self, server):
        _, port = server
        status, body, _ = _get(port, "/hardware")
        assert status == 200
        for field in (
            "cpu_arch", "cpu_cores", "total_ram_mb", "free_ram_mb",
            "has_cuda", "has_metal", "os_name", "recommended_model", "profile_name",
        ):
            assert field in body, f"missing field: {field}"

    def test_has_gpu_fields(self, server):
        _, port = server
        _, body, _ = _get(port, "/hardware")
        assert "gpu_name" in body
        assert "gpu_vram_mb" in body
        assert "is_raspberry_pi" in body


# ─── POST /chat (non-streaming) ───────────────────────────────────────────────

class TestChatJsonEndpoint:
    def test_missing_message_returns_400(self, server):
        _, port = server
        status, body = _post(port, "/chat", {"stream": False})
        assert status == 400
        assert "error" in body

    def test_empty_message_returns_400(self, server):
        _, port = server
        status, body = _post(port, "/chat", {"message": "   ", "stream": False})
        assert status == 400

    def test_invalid_json_returns_400(self, server):
        _, port = server
        status, _ = _post_raw(port, "/chat", b"not json at all")
        assert status == 400

    def test_successful_response_shape(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            yield "Hello from mock!"

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            status, body = _post(port, "/chat", {"message": "hi", "stream": False})

        assert status == 200
        assert "response" in body
        assert "Hello from mock!" in body["response"]
        assert "model" in body
        assert "iterations" in body
        assert "tool_calls" in body
        assert "skill_calls" in body
        assert "tokens_approx" in body

    def test_model_override_applied(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            yield "ok"

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            _post(port, "/chat", {
                "message": "hi", "stream": False, "model": "phi3:mini"
            })

        assert srv.agent.get_active_model() == "phi3:mini"

    def test_tool_calls_in_response(self, server):
        srv, port = server
        call_count = [0]

        def mock_chat(model, messages, temperature, top_p, stream):
            if call_count[0] == 0:
                call_count[0] += 1
                yield '[TOOL:shell command="echo hello"]'
            else:
                yield "Done."

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            status, body = _post(port, "/chat", {"message": "run echo", "stream": False})

        assert status == 200
        assert len(body["tool_calls"]) >= 1
        assert body["tool_calls"][0]["tool"] == "shell"


# ─── POST /chat (SSE streaming) ───────────────────────────────────────────────

class TestChatSSEEndpoint:
    def test_streams_token_events(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            yield "Hello"
            yield " world"

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            events = _post_sse(port, "/chat", {"message": "hi"})

        token_events = [e for e in events if e.get("type") == "token"]
        assert len(token_events) >= 1
        combined = "".join(e["content"] for e in token_events)
        assert "Hello" in combined

    def test_final_done_event(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            yield "Final"

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            events = _post_sse(port, "/chat", {"message": "test"})

        done_events = [e for e in events if e.get("type") == "done"]
        assert len(done_events) == 1
        assert done_events[0]["response"] == "Final"
        assert "model" in done_events[0]

    def test_done_event_assembles_full_response(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            for word in ["The", " quick", " brown", " fox"]:
                yield word

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            events = _post_sse(port, "/chat", {"message": "story"})

        done = next(e for e in events if e.get("type") == "done")
        assert done["response"] == "The quick brown fox"

    def test_content_type_is_sse(self, server):
        srv, port = server

        def mock_chat(model, messages, temperature, top_p, stream):
            yield "hi"

        with patch.object(srv.agent.model_manager, "chat", side_effect=mock_chat):
            conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
            data = json.dumps({"message": "hi"}).encode()
            conn.request("POST", "/chat", body=data,
                         headers={"Content-Type": "application/json"})
            resp = conn.getresponse()
            resp.read()
            ct = resp.getheader("Content-Type")
            conn.close()

        assert ct is not None
        assert "text/event-stream" in ct

    def test_missing_message_still_400_not_sse(self, server):
        _, port = server
        # stream=True (default) but no message → should get JSON 400
        status, body = _post(port, "/chat", {})
        assert status == 400


# ─── Routing / 404 ────────────────────────────────────────────────────────────

class TestRouting:
    def test_get_unknown_path_404(self, server):
        _, port = server
        status, body, _ = _get(port, "/nonexistent")
        assert status == 404
        assert "error" in body

    def test_post_unknown_path_404(self, server):
        _, port = server
        status, body = _post(port, "/unknown", {})
        assert status == 404

    def test_options_preflight_200(self, server):
        _, port = server
        conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)
        conn.request("OPTIONS", "/chat")
        resp = conn.getresponse()
        resp.read()
        conn.close()
        assert resp.status == 200
        assert resp.getheader("Access-Control-Allow-Methods") is not None


# ─── create_server factory ────────────────────────────────────────────────────

class TestCreateServer:
    def test_returns_closeclaw_server(self, tmp_path):
        config = _make_config(tmp_path)
        with patch("closeclaw.server.detect_hardware") as mock_hw:
            mock_hw.return_value = MagicMock(recommended_model="llama3.2:3b")
            srv = create_server(port=0, config=config)
        assert isinstance(srv, CloseClawServer)
        assert srv.agent is not None
        srv.server_close()

    def test_uses_provided_model(self, tmp_path):
        config = _make_config(tmp_path)
        srv = create_server(port=0, model="custom-model", config=config)
        assert srv.agent.get_active_model() == "custom-model"
        srv.server_close()

    def test_auto_selects_model_when_none(self, tmp_path):
        config = _make_config(tmp_path)
        config._data["model"]["selection"] = "auto"
        with patch("closeclaw.server.detect_hardware") as mock_hw:
            mock_hw.return_value = MagicMock(recommended_model="phi3:mini")
            srv = create_server(port=0, config=config)
        assert srv.agent.get_active_model() == "phi3:mini"
        srv.server_close()

    def test_binds_to_requested_port(self, tmp_path):
        config = _make_config(tmp_path)
        srv = create_server(port=0, model="m", config=config)
        assert srv.server_address[1] > 0
        srv.server_close()