reloia/thePlug
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BIG BIG BIG BIG BIG UPDATES

Browse Source 
Co-authored-by: Copilot <[email protected]>
This commit is contained in:
gabdevele
2026-05-04 23:59:48 +02:00
co-authored by Copilot
Unverified
parent 46f7cd6a5f
commit 93ba8e9ac2
88 changed files with 7591 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/tests/api/test_auth.py
+112
View File
@@ -0,0 +1,112 @@
import importlib
from datetime import UTC, datetime, timedelta
from core.security import AuthContext, get_auth_context
from models.auth import AccessTokenPayload, AuthUserDocument
auth_router_module = importlib.import_module("api.auth.router")
def test_login_success_returns_bearer_token(client, monkeypatch: object):
user = AuthUserDocument(username="admin", password_hash="stored-hash")
async def fake_get_user_by_username(username: str) -> AuthUserDocument | None:
assert username == "admin"
return user
def fake_verify_password(plain_password: str, password_hash: str) -> bool:
return plain_password == "secret" and password_hash == "stored-hash"
def fake_create_access_token(*, subject: str) -> str:
assert subject == "admin"
return "token-123"
monkeypatch.setattr(
auth_router_module,
"get_user_by_username",
fake_get_user_by_username,
)
monkeypatch.setattr(auth_router_module, "verify_password", fake_verify_password)
monkeypatch.setattr(
auth_router_module,
"create_access_token",
fake_create_access_token,
)
response = client.post(
"/auth/login",
json={"username": "admin", "password": "secret"},
)
assert response.status_code == 200
assert response.json() == {"access_token": "token-123", "token_type": "bearer"}
def test_login_invalid_credentials_returns_401(client, monkeypatch: object):
async def fake_get_user_by_username(_: str) -> None:
return None
monkeypatch.setattr(
auth_router_module,
"get_user_by_username",
fake_get_user_by_username,
)
response = client.post(
"/auth/login",
json={"username": "admin", "password": "wrong"},
)
assert response.status_code == 401
assert response.json()["detail"] == "Invalid username or password"
assert response.headers["www-authenticate"] == "Bearer"
def test_logout_revokes_active_token(client, monkeypatch: object):
captured: dict[str, object] = {}
async def fake_revoke_token(*, jti: str, expires_at: datetime) -> None:
captured["jti"] = jti
captured["expires_at"] = expires_at
monkeypatch.setattr(auth_router_module, "revoke_token", fake_revoke_token)
response = client.post("/auth/logout")
assert response.status_code == 204
assert captured["jti"] == "test-jti"
assert isinstance(captured["expires_at"], datetime)
def test_logout_skips_revocation_when_token_is_expired(
client,
fake_user: AuthUserDocument,
monkeypatch: object,
):
state = {"called": False}
async def fake_revoke_token(*, jti: str, expires_at: datetime) -> None:
state["called"] = True
monkeypatch.setattr(auth_router_module, "revoke_token", fake_revoke_token)
expired_payload = AccessTokenPayload(
sub=fake_user.username,
jti="expired-jti",
exp=int((datetime.now(UTC) - timedelta(minutes=1)).timestamp()),
)
expired_context = AuthContext(
token="expired-token",
user=fake_user,
payload=expired_payload,
)
async def override_auth_context() -> AuthContext:
return expired_context
client.app.dependency_overrides[get_auth_context] = override_auth_context
response = client.post("/auth/logout")
assert response.status_code == 204
assert state["called"] is False
backend/tests/api/test_editor_router.py
+52
View File
@@ -0,0 +1,52 @@
import pytest
from services.editor import python_lsp
from starlette.websockets import WebSocketDisconnect
def test_python_editor_session(client, monkeypatch):
session = python_lsp.PythonEditorSession(
root_path=python_lsp.WORKSPACE_ROOT,
file_path=python_lsp.WORKSPACE_ROOT / python_lsp.ENTRY_FILE,
)
monkeypatch.setattr("api.editor.router.python_lsp.lsp_binary", lambda: "/bin/lsp")
monkeypatch.setattr("api.editor.router.python_lsp.get_session", lambda: session)
response = client.get("/proxy/editor/python/session")
assert response.status_code == 200
assert response.json() == {
"root_uri": session.root_uri,
"file_uri": session.file_uri,
}
def test_python_editor_socket_rejects_missing_token(client):
with pytest.raises(WebSocketDisconnect) as error:
with client.websocket_connect("/proxy/editor/python/ws"):
pass
assert error.value.code == 4401
def test_python_editor_socket_accepts_token(client, monkeypatch):
accepted = {"value": False}
async def fake_authenticate(_: object) -> None:
return None
async def fake_bridge(websocket, session) -> None:
accepted["value"] = True
await websocket.send_text(session.file_uri)
await websocket.close()
monkeypatch.setattr(
"api.editor.router.authenticate_editor_socket",
fake_authenticate,
)
monkeypatch.setattr("api.editor.router.python_lsp.lsp_binary", lambda: "/bin/lsp")
monkeypatch.setattr("api.editor.router.python_lsp.bridge", fake_bridge)
with client.websocket_connect("/proxy/editor/python/ws?token=test-token") as socket:
assert socket.receive_text().endswith("/proxy_addon.py")
assert accepted["value"] is True
backend/tests/api/test_proxy.py
+460
View File
@@ -0,0 +1,460 @@
import importlib
from core.security import get_auth_context, require_authenticated_user
from models.proxy import ProxyCreateInput, ProxyDocument
from models.service import ServiceEndpointDocument
from services.mitmproxy.examples import BUILTIN_EXAMPLES
from services.mitmproxy.validator import ProxyCodeValidationError
proxy_router_module = importlib.import_module("api.proxy.router")
def make_proxy_document(
*,
proxy_port: int,
name: str = "svc",
code: str = "proxy-code",
port: int = 9000,
) -> ProxyDocument:
return ProxyDocument(
proxy_port=proxy_port,
name=name,
code=code,
service=ServiceEndpointDocument(port=port),
)
def test_proxy_requires_auth_without_dependency_overrides(client):
client.app.dependency_overrides.pop(require_authenticated_user, None)
client.app.dependency_overrides.pop(get_auth_context, None)
response = client.get("/proxy")
assert response.status_code == 401
assert response.json()["detail"] == "Could not validate credentials"
def test_list_proxies_returns_documents(client, monkeypatch: object):
docs = [
make_proxy_document(proxy_port=8080, name="api"),
make_proxy_document(proxy_port=8081, name="worker"),
]
async def fake_list_proxies() -> list[ProxyDocument]:
return docs
monkeypatch.setattr(proxy_router_module, "list_proxy_documents", fake_list_proxies)
response = client.get("/proxy")
assert response.status_code == 200
body = response.json()
assert [item["proxy_port"] for item in body] == [8080, 8081]
def test_get_proxy_returns_404_when_not_found(client, monkeypatch: object):
async def fake_get_proxy_by_port(proxy_port: int) -> None:
return None
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
response = client.get("/proxy/9999")
assert response.status_code == 404
assert response.json()["detail"] == "Proxy not found"
def test_create_proxy_returns_409_on_port_conflict(client, monkeypatch: object):
existing = make_proxy_document(proxy_port=3671)
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 3671
return existing
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
response = client.post(
"/proxy",
json={
"proxy_port": 3671,
"name": "new",
"code": "abc",
"service": {"port": 8080},
},
)
assert response.status_code == 409
assert response.json()["detail"] == "Proxy already exists on port 3671"
def test_create_proxy_returns_created_document(client, monkeypatch: object):
captured: dict[str, object] = {}
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 4040
return None
async def fake_create_proxy(payload: ProxyCreateInput) -> ProxyDocument:
captured["proxy_port"] = payload.proxy_port
captured["name"] = payload.name
captured["service"] = payload.service.model_dump(exclude_none=True)
captured["code"] = payload.code
captured["protocol"] = payload.protocol
return make_proxy_document(
proxy_port=payload.proxy_port,
name=payload.name,
code=payload.code,
port=payload.service.port,
)
async def fake_validate_proxy_code(code: str) -> None:
assert code == "def proxy_handler():\n return 'ok'\n"
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
monkeypatch.setattr(
proxy_router_module,
"validate_proxy_code",
fake_validate_proxy_code,
)
monkeypatch.setattr(proxy_router_module, "create_proxy", fake_create_proxy)
response = client.post(
"/proxy",
json={
"proxy_port": 4040,
"name": "edge",
"code": "def proxy_handler():\n return 'ok'\n",
"service": {"port": 8181},
},
)
assert response.status_code == 201
assert response.json()["proxy_port"] == 4040
assert captured == {
"proxy_port": 4040,
"name": "edge",
"service": {"host": "127.0.0.1", "port": 8181},
"code": "def proxy_handler():\n return 'ok'\n",
"protocol": "http",
}
def test_create_proxy_returns_422_when_code_validation_fails(
client,
monkeypatch: object,
):
create_called = False
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 4000
return None
async def fake_validate_proxy_code(code: str) -> None:
assert code == "invalid-code"
raise ProxyCodeValidationError(
"Proxy code contains ruff violations",
errors=[
{
"code": "F821",
"message": "Undefined name `missing_symbol`",
"location": {"row": 1, "column": 1},
}
],
)
async def fake_create_proxy(
*,
proxy_port: int,
name: str,
service: dict[str, object],
code: str,
) -> ProxyDocument:
nonlocal create_called
create_called = True
return make_proxy_document(proxy_port=proxy_port, name=name, code=code)
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
monkeypatch.setattr(
proxy_router_module,
"validate_proxy_code",
fake_validate_proxy_code,
)
monkeypatch.setattr(proxy_router_module, "create_proxy", fake_create_proxy)
response = client.post(
"/proxy",
json={
"proxy_port": 4000,
"name": "broken",
"code": "invalid-code",
"service": {"port": 9000},
},
)
assert response.status_code == 422
body = response.json()["detail"]
assert body["message"] == "Proxy code contains ruff violations"
assert body["errors"][0]["code"] == "F821"
assert create_called is False
def test_update_proxy_returns_422_when_code_validation_fails(
client,
monkeypatch: object,
):
update_called = False
async def fake_validate_proxy_code(code: str) -> None:
assert code == "invalid-code"
raise ProxyCodeValidationError(
"Proxy code has invalid Python syntax",
errors=[
{
"code": "COMPILE",
"message": "invalid syntax",
"location": {"row": 1, "column": 1},
}
],
)
async def fake_update_proxy(
proxy_port: int,
payload: object,
) -> ProxyDocument | None:
nonlocal update_called
update_called = True
return make_proxy_document(proxy_port=proxy_port)
monkeypatch.setattr(
proxy_router_module,
"validate_proxy_code",
fake_validate_proxy_code,
)
monkeypatch.setattr(proxy_router_module, "update_proxy", fake_update_proxy)
response = client.put(
"/proxy/8123",
json={"code": "invalid-code"},
)
assert response.status_code == 422
body = response.json()["detail"]
assert body["message"] == "Proxy code has invalid Python syntax"
assert body["errors"][0]["code"] == "COMPILE"
assert update_called is False
def test_start_proxy_updates_runtime_state(client, monkeypatch: object):
proxy = make_proxy_document(proxy_port=4040)
captured: dict[str, object] = {}
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 4040
return proxy
class FakeManager:
async def start(self, document: ProxyDocument) -> dict[str, object]:
assert document.proxy_port == 4040
return {
"status": "running",
"pid": 1234,
"script_path": "/tmp/theplug/addons/4040.py",
"log_path": "/tmp/theplug/logs/4040.log",
"service.upstream_port": 9000,
"last_error": None,
}
async def fake_update_proxy_runtime(
proxy_port: int,
values: dict[str, object],
) -> ProxyDocument:
captured["proxy_port"] = proxy_port
captured["values"] = values
return proxy.model_copy(update={"status": "running", "pid": 1234})
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
monkeypatch.setattr(proxy_router_module, "manager", FakeManager())
monkeypatch.setattr(
proxy_router_module,
"update_proxy_runtime",
fake_update_proxy_runtime,
)
response = client.post("/proxy/4040/start")
assert response.status_code == 200
assert response.json()["status"] == "running"
assert captured["proxy_port"] == 4040
assert captured["values"]["pid"] == 1234
def test_start_proxy_records_runtime_error(client, monkeypatch: object):
proxy = make_proxy_document(proxy_port=4040)
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 4040
return proxy
class FakeManager:
async def start(self, document: ProxyDocument) -> dict[str, object]:
assert document.proxy_port == 4040
raise proxy_router_module.MitmdumpError("mitmdump executable not found")
async def fake_update_proxy_runtime(
proxy_port: int,
values: dict[str, object],
) -> ProxyDocument:
assert proxy_port == 4040
assert values == {
"status": "error",
"last_error": "mitmdump executable not found",
}
return proxy.model_copy(
update={"status": "error", "last_error": values["last_error"]}
)
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
monkeypatch.setattr(proxy_router_module, "manager", FakeManager())
monkeypatch.setattr(
proxy_router_module,
"update_proxy_runtime",
fake_update_proxy_runtime,
)
response = client.post("/proxy/4040/start")
assert response.status_code == 200
assert response.json()["status"] == "error"
assert response.json()["last_error"] == "mitmdump executable not found"
def test_stop_proxy_updates_runtime_state(client, monkeypatch: object):
proxy = make_proxy_document(proxy_port=4040).model_copy(
update={"status": "running", "pid": 1234}
)
async def fake_get_proxy_by_port(proxy_port: int) -> ProxyDocument | None:
assert proxy_port == 4040
return proxy
class FakeManager:
async def stop(self, document: ProxyDocument) -> dict[str, object]:
assert document.pid == 1234
return {
"status": "stopped",
"pid": None,
"service.upstream_port": None,
"last_error": None,
}
async def fake_update_proxy_runtime(
proxy_port: int,
values: dict[str, object],
) -> ProxyDocument:
assert proxy_port == 4040
assert values["status"] == "stopped"
return proxy.model_copy(update={"status": "stopped", "pid": None})
monkeypatch.setattr(
proxy_router_module,
"get_proxy_by_port",
fake_get_proxy_by_port,
)
monkeypatch.setattr(proxy_router_module, "manager", FakeManager())
monkeypatch.setattr(
proxy_router_module,
"update_proxy_runtime",
fake_update_proxy_runtime,
)
response = client.post("/proxy/4040/stop")
assert response.status_code == 200
assert response.json()["status"] == "stopped"
def test_list_mitmproxy_examples_returns_builtins_and_custom(client, monkeypatch):
async def fake_list_custom_examples():
return []
monkeypatch.setattr(
proxy_router_module,
"list_custom_examples",
fake_list_custom_examples,
)
response = client.get("/proxy/mitmproxy/examples")
assert response.status_code == 200
body = response.json()
assert len(body) == len(BUILTIN_EXAMPLES)
assert body[0]["built_in"] is True
def test_create_mitmproxy_example_validates_and_persists(client, monkeypatch):
captured = {}
async def fake_validate_proxy_code(code: str) -> None:
captured["validated"] = code
async def fake_create_custom_example(payload):
captured["payload"] = payload
return {
"id": payload.id,
"name": payload.name,
"description": payload.description,
"category": payload.category,
"code": payload.code,
"source_url": payload.source_url,
"built_in": False,
}
monkeypatch.setattr(
proxy_router_module,
"validate_proxy_code",
fake_validate_proxy_code,
)
monkeypatch.setattr(
proxy_router_module,
"create_custom_example",
fake_create_custom_example,
)
response = client.post(
"/proxy/mitmproxy/examples",
json={
"id": "custom-header",
"name": "Custom header",
"description": "Adds a custom response header",
"category": "http",
"code": "def response(flow):\n pass\n",
},
)
assert response.status_code == 201
assert response.json()["id"] == "custom-header"
assert captured["validated"] == "def response(flow):\n pass\n"