test_client.py

"""Tests for client.py — mocked subprocess + httpx."""

from __future__ import annotations

import asyncio
import json
from unittest import mock

import pytest
import httpx

from client import TailscaleCLI, TailscaleAPI, CLIError

SAMPLE_STATUS = {
    "Version": "1.62.0",
    "BackendState": "Running",
    "TUN": True,
    "TailscaleIPs": ["100.64.0.1", "fd7a:115c:a1e0::1"],
    "Self": {
        "ID": "self-123",
        "HostName": "truffle",
        "DNSName": "truffle.tail1234.ts.net.",
        "TailscaleIPs": ["100.64.0.1", "fd7a:115c:a1e0::1"],
        "OS": "linux",
        "Online": True,
        "PublicKey": "key1",
        "UserID": 1,
    },
    "Peer": {
        "key2": {
            "ID": "peer-456",
            "HostName": "laptop",
            "DNSName": "laptop.tail1234.ts.net.",
            "TailscaleIPs": ["100.64.0.2"],
            "OS": "macOS",
            "Online": True,
            "PublicKey": "key2",
            "UserID": 2,
            "LastSeen": "2025-01-01T00:00:00Z",
            "ExitNode": False,
            "ExitNodeOption": True,
        },
    },
    "MagicDNSSuffix": "tail1234.ts.net",
}


def _make_proc(stdout: str = "", stderr: str = "", returncode: int = 0):
    """Create a mock process for create_subprocess_exec."""
    proc = mock.AsyncMock()
    proc.communicate.return_value = (
        stdout.encode() if stdout else b"",
        stderr.encode() if stderr else b"",
    )
    proc.returncode = returncode
    proc.kill = mock.Mock()
    return proc


# --- TailscaleCLI tests ---


class TestTailscaleCLI:
    @pytest.fixture
    def cli(self):
        return TailscaleCLI()

    @pytest.mark.asyncio
    async def test_status(self, cli):
        proc = _make_proc(stdout=json.dumps(SAMPLE_STATUS))
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            result = await cli.status()
        assert result["BackendState"] == "Running"
        assert result["Self"]["HostName"] == "truffle"

    @pytest.mark.asyncio
    async def test_status_failure(self, cli):
        proc = _make_proc(stderr="tailscale not running", returncode=1)
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            with pytest.raises(CLIError, match="tailscale not running"):
                await cli.status()

    @pytest.mark.asyncio
    async def test_ping(self, cli):
        proc = _make_proc(stdout="pong from laptop (100.64.0.2) via DERP(nyc)")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            result = await cli.ping("laptop", count=1)
        assert "pong" in result

    @pytest.mark.asyncio
    async def test_up(self, cli):
        proc = _make_proc(stdout="Success.")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            result = await cli.up("tskey-auth-abc", hostname="mydevice")
        assert result == "Success."
        call_args = mock_exec.call_args[0]
        assert "tailscale" in call_args
        assert "up" in call_args
        assert "--authkey=tskey-auth-abc" in call_args
        assert "--hostname=mydevice" in call_args

    @pytest.mark.asyncio
    async def test_down(self, cli):
        proc = _make_proc(stdout="")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            result = await cli.down()
        assert result == ""

    @pytest.mark.asyncio
    async def test_set_exit_node(self, cli):
        proc = _make_proc(stdout="")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            await cli.set_exit_node("laptop")
        call_args = mock_exec.call_args[0]
        assert "--exit-node=laptop" in call_args

    @pytest.mark.asyncio
    async def test_clear_exit_node(self, cli):
        proc = _make_proc(stdout="")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            await cli.clear_exit_node()
        call_args = mock_exec.call_args[0]
        assert "--exit-node=" in call_args

    @pytest.mark.asyncio
    async def test_ip(self, cli):
        proc = _make_proc(stdout="100.64.0.1\nfd7a:115c:a1e0::1\n")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            result = await cli.ip()
        assert result == ["100.64.0.1", "fd7a:115c:a1e0::1"]

    @pytest.mark.asyncio
    async def test_version(self, cli):
        proc = _make_proc(stdout="1.62.0")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            result = await cli.version()
        assert result == "1.62.0"

    @pytest.mark.asyncio
    async def test_self_node(self, cli):
        proc = _make_proc(stdout=json.dumps(SAMPLE_STATUS))
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            node = await cli.self_node()
        assert node["HostName"] == "truffle"

    @pytest.mark.asyncio
    async def test_peers(self, cli):
        proc = _make_proc(stdout=json.dumps(SAMPLE_STATUS))
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            peers = await cli.peers()
        assert len(peers) == 1
        assert peers[0]["HostName"] == "laptop"

    @pytest.mark.asyncio
    async def test_is_connected_true(self, cli):
        proc = _make_proc(stdout=json.dumps(SAMPLE_STATUS))
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            assert await cli.is_connected() is True

    @pytest.mark.asyncio
    async def test_is_connected_false_on_error(self, cli):
        proc = _make_proc(stderr="not running", returncode=1)
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc):
            assert await cli.is_connected() is False

    @pytest.mark.asyncio
    async def test_file_send(self, cli):
        proc = _make_proc(stdout="")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            result = await cli.file_send("/tmp/test.txt", "laptop")
        call_args = mock_exec.call_args[0]
        assert "file" in call_args
        assert "cp" in call_args
        assert "/tmp/test.txt" in call_args
        assert "laptop:" in call_args

    @pytest.mark.asyncio
    async def test_file_get(self, cli):
        proc = _make_proc(stdout="received 1 file")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            result = await cli.file_get("/tmp/received")
        call_args = mock_exec.call_args[0]
        assert "file" in call_args
        assert "get" in call_args
        assert "/tmp/received" in call_args
        assert "received 1 file" in result

    @pytest.mark.asyncio
    async def test_file_get_with_wait(self, cli):
        proc = _make_proc(stdout="received 1 file")
        with mock.patch("asyncio.create_subprocess_exec", return_value=proc) as mock_exec:
            result = await cli.file_get("/tmp/received", wait=True)
        call_args = mock_exec.call_args[0]
        assert "--wait" in call_args


# --- TailscaleAPI tests ---


class TestTailscaleAPI:
    @pytest.fixture
    def api(self):
        return TailscaleAPI(
            api_key="tskey-api-test",
            tailnet="example.com",
            base_url="https://api.tailscale.com/api/v2",
        )

    @pytest.mark.asyncio
    async def test_list_devices(self, api):
        devices = [
            {"id": "dev1", "name": "laptop", "hostname": "laptop", "os": "macOS"},
        ]
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"devices": devices}
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.list_devices()
        assert len(result) == 1
        assert result[0]["hostname"] == "laptop"

    @pytest.mark.asyncio
    async def test_get_device(self, api):
        device = {"id": "dev1", "name": "laptop"}
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = device
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.get_device("dev1")
        assert result["id"] == "dev1"

    @pytest.mark.asyncio
    async def test_authorize_device(self, api):
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"authorized": True}
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.authorize_device("dev1")
        assert result["authorized"] is True

    @pytest.mark.asyncio
    async def test_delete_device(self, api):
        mock_response = mock.Mock()
        mock_response.status_code = 204
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.delete_device("dev1")
        assert result is True

    @pytest.mark.asyncio
    async def test_get_device_routes(self, api):
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            "advertisedRoutes": ["10.0.0.0/24"],
            "enabledRoutes": ["10.0.0.0/24"],
        }
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.get_device_routes("dev1")
        assert "advertisedRoutes" in result

    @pytest.mark.asyncio
    async def test_set_device_routes(self, api):
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"routes": ["10.0.0.0/24"]}
        mock_response.raise_for_status = mock.Mock()

        with mock.patch.object(api._http, "request", return_value=mock_response):
            result = await api.set_device_routes("dev1", ["10.0.0.0/24"])
        assert "routes" in result

    @pytest.mark.asyncio
    async def test_no_api_key_raises(self):
        api = TailscaleAPI(api_key="", tailnet="example.com")
        assert api.available is False
        with pytest.raises(ValueError, match="TAILSCALE_API_KEY is required"):
            await api.list_devices()

    @pytest.mark.asyncio
    async def test_close(self, api):
        with mock.patch.object(api._http, "aclose") as mock_close:
            await api.close()
        mock_close.assert_called_once()