BIG BIG BIG BIG BIG UPDATES

Co-authored-by: Copilot <[email protected]>

backend/tests/services/test_health.py

@@ -0,0 +1,43 @@
+import asyncio
+
+from models.proxy import ProxyDocument
+from models.service import ServiceEndpointDocument
+from services.mitmproxy.health import check_proxy
+
+
+def test_check_proxy_reports_upstream_and_proxy_healthy():
+    async def run():
+        upstream = await asyncio.start_server(http_handler, "127.0.0.1", 0)
+        proxy = await asyncio.start_server(http_handler, "127.0.0.1", 0)
+        try:
+            upstream_port = upstream.sockets[0].getsockname()[1]
+            proxy_port = proxy.sockets[0].getsockname()[1]
+            document = ProxyDocument(
+                proxy_port=proxy_port,
+                name="health",
+                code="",
+                service=ServiceEndpointDocument(port=upstream_port),
+            )
+
+            health = await check_proxy(document)
+        finally:
+            upstream.close()
+            proxy.close()
+            await upstream.wait_closed()
+            await proxy.wait_closed()
+
+        assert health["overall"] == "healthy"
+        assert [check["target"] for check in health["checks"]] == [
+            "upstream",
+            "proxy",
+        ]
+
+    asyncio.run(run())
+
+
+async def http_handler(reader, writer):
+    await reader.readline()
+    writer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
+    await writer.drain()
+    writer.close()
+    await writer.wait_closed()

backend/tests/services/test_mitmproxy_manager.py

@@ -0,0 +1,75 @@
+import asyncio
+from pathlib import Path
+
+from models.proxy import ProxyDocument
+from models.service import ServiceEndpointDocument
+from services.mitmproxy.manager import MitmdumpManager
+
+
+def make_proxy(**updates):
+    data = {
+        "proxy_port": 8080,
+        "name": "svc",
+        "code": "",
+        "service": ServiceEndpointDocument(port=9000),
+    }
+    data.update(updates)
+    return ProxyDocument(**data)
+
+
+def test_reverse_mode_is_built_from_service():
+    manager = MitmdumpManager()
+    proxy = make_proxy(protocol="tcp")
+
+    command = manager.build_command(
+        "mitmdump",
+        proxy,
+        9100,
+        Path("/tmp/addon.py"),
+        Path("/tmp/conf/config.yaml"),
+    )
+
+    assert "reverse:tcp://127.0.0.1:9100@8080" in command
+    assert "--listen-port" not in command
+
+
+def test_raw_mode_spec_overrides_generated_mode():
+    manager = MitmdumpManager()
+    proxy = make_proxy(mode="regular", mode_spec="wireguard:/tmp/wg.conf@51820")
+
+    command = manager.build_command(
+        "mitmdump",
+        proxy,
+        None,
+        Path("/tmp/addon.py"),
+        Path("/tmp/conf/config.yaml"),
+    )
+
+    assert "wireguard:/tmp/wg.conf@51820" in command
+    assert "--listen-port" not in command
+
+
+def test_regular_mode_uses_proxy_port_as_listen_port():
+    manager = MitmdumpManager()
+    proxy = make_proxy(mode="regular")
+
+    command = manager.build_command(
+        "mitmdump",
+        proxy,
+        None,
+        Path("/tmp/addon.py"),
+        Path("/tmp/conf/config.yaml"),
+    )
+
+    assert "regular" in command
+    assert command[-2:] == ["--listen-port", "8080"]
+
+
+def test_running_document_without_pid_is_treated_as_stopped():
+    manager = MitmdumpManager()
+    proxy = make_proxy(status="running", pid=None)
+
+    async def run():
+        return await manager.status(proxy)
+
+    assert asyncio.run(run()) == "stopped"

backend/tests/services/test_mitmproxy_options.py

@@ -0,0 +1,51 @@
+import pytest
+from services.mitmproxy.options import (
+    MitmOption,
+    parse_options,
+    public_options,
+    validate_value,
+)
+
+
+def test_parse_options_extracts_types_and_choices():
+    text = """
+# Enable feature. Type bool.
+enabled: false
+
+# Valid values are 'eager', 'lazy'.
+strategy: eager
+
+# Hosts. Type sequence of str.
+hosts: []
+"""
+    options = parse_options(
+        text,
+        {"enabled": False, "strategy": "eager", "hosts": []},
+    )
+
+    assert options["enabled"].value_type == "bool"
+    assert options["strategy"].choices == ["eager", "lazy"]
+    assert options["hosts"].value_type == "sequence of str"
+
+
+@pytest.mark.parametrize(
+    ("option", "value", "message"),
+    [
+        (MitmOption("anticache", "bool", False, "", []), "true", "expected bool"),
+        (MitmOption("flow_detail", "int", 1, "", []), "1", "expected int"),
+        (MitmOption("allow_hosts", "sequence of str", [], "", []), "x", "list[str]"),
+        (MitmOption("strategy", "unknown", "eager", "", ["eager"]), "lazy", "one of"),
+    ],
+)
+def test_validate_value_rejects_wrong_types(option, value, message):
+    assert message in validate_value(option, value)
+
+
+def test_public_options_include_docs_links():
+    options = {
+        "flow_detail": MitmOption("flow_detail", "int", 1, "Flow detail.", []),
+    }
+
+    public = public_options(options)
+
+    assert public[0]["docs_url"].endswith("#flow_detail")

backend/tests/services/test_python_lsp.py

@@ -0,0 +1,30 @@
+from services.editor import python_lsp
+
+
+def test_encode_message():
+    message = '{"jsonrpc":"2.0"}'
+
+    payload = python_lsp.encode_message(message)
+
+    assert payload.endswith(message.encode("utf-8"))
+    assert payload.startswith(
+        f"Content-Length: {len(message.encode('utf-8'))}\r\n\r\n".encode("ascii")
+    )
+
+
+def test_frame_buffer_reads_split_messages():
+    buffer = python_lsp.LspFrameBuffer()
+    first = python_lsp.encode_message('{"id":1}')
+    second = python_lsp.encode_message('{"id":2}')
+
+    parts = [
+        first[:12],
+        first[12:] + second[:10],
+        second[10:],
+    ]
+
+    messages: list[str] = []
+    for part in parts:
+        messages.extend(buffer.feed(part))
+
+    assert messages == ['{"id":1}', '{"id":2}']