Files
LEAF/tests/mock_vyos_server.py
2026-11-15 17:42:55 +01:00

177 lines
7.2 KiB
Python

#!/usr/bin/env python3
"""Mock VyOS HTTP API (2026.03 subset) for offline E2E tests.
Endpoints: GET /info ; POST /configure|/retrieve|/show|/config-file (multipart form: data, key)
State: in-memory address-group; member list mirrored to --state-file on every mutation.
Semantics mirrored from docs: bad key -> 401; semantic errors -> success:false + error.
"""
from __future__ import annotations
import argparse
import email.parser
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
STATE = {"members": set(), "config_comments": {}}
LOCK = threading.Lock()
def dump_state(path: str) -> None:
with open(path, "w") as fh:
json.dump({"members": sorted(STATE["members"])}, fh)
def parse_form(handler) -> dict:
ctype = handler.headers.get("Content-Type", "")
length = int(handler.headers.get("Content-Length", "0"))
body = handler.rfile.read(length)
if "multipart/form-data" in ctype:
import email
import email.policy
msg = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(
b"Content-Type: " + ctype.encode() + b"\r\nMIME-Version: 1.0\r\n\r\n" + body)
out = {}
for part in msg.walk():
if part.get_content_type() == "multipart/form-data":
continue
disp = part.get("Content-Disposition", "")
if "name=" not in disp:
continue
name = disp.split('name="', 1)[1].split('"', 1)[0]
out[name] = part.get_payload(decode=True).decode()
return out
# urlencoded fallback
from urllib.parse import parse_qs
return {k: v[0] for k, v in parse_qs(body.decode()).items()}
class Handler(BaseHTTPRequestHandler):
key_expected = "testkey"
state_file = "mock_state.json"
log_lines = []
def log_message(self, fmt, *args): # quiet
Handler.log_lines.append(fmt % args)
def _send(self, code: int, obj) -> None:
body = json.dumps(obj).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self):
if self.path == "/info":
self._send(200, {"version": "VYOS mock (22.04 mock for 2026.03 semantics)",
"api": {"status": "healthy"}})
else:
self._send(404, {"success": False, "error": "not found"})
def do_POST(self):
form = parse_form(self)
if form.get("key") != self.key_expected:
self._send(401, {"success": False, "error": "bad auth token"})
return
try:
payload = json.loads(form.get("data", "{}"))
except json.JSONDecodeError:
self._send(400, {"success": False, "error": "data is not valid json"})
return
path = self.path.rstrip("/")
try:
if path == "/configure":
self.handle_configure(payload)
elif path == "/retrieve":
self.handle_retrieve(payload)
elif path == "/show":
self._send(200, {"success": True, "data": "\n".join(
f"[{k}] {v}" for k, v in STATE["config_comments"].items())})
elif path == "/config-file":
if payload.get("op") == "save":
self._send(200, {"success": True})
else:
self._send(400, {"success": False, "error": "unknown op"})
else:
self._send(404, {"success": False, "error": "no endpoint"})
except Exception as exc: # mock: keep simple
self._send(500, {"success": False, "error": f"mock internal: {exc}"})
# ------------------------------------------------------------ configure
def _group_path(self, tokens) -> bool:
return (len(tokens) >= 6 and tokens[:4] ==
["firewall", "group", "address-group", "IDS-BLOCK"] and
tokens[4] == "address")
@staticmethod
def _member(tokens) -> str:
return tokens[5]
def handle_configure(self, payload) -> None:
ops = payload if isinstance(payload, list) else [payload]
with LOCK:
for op in ops:
if not isinstance(op, dict):
self._send(400, {"success": False, "error": "op must be object"})
return
kind, tokens = op.get("op"), op.get("path", [])
if kind not in ("set", "delete", "comment") or not self._group_path(tokens):
self._send(400, {"success": False,
"error": f"mock: unhandled op/path {kind} {tokens}"})
return
member = self._member(tokens)
if kind == "comment":
STATE["config_comments"][member] = op.get("comment", "")
continue
if kind == "set":
STATE["members"].add(member)
else:
STATE["members"].discard(member)
dump_state(self.state_file)
self._send(200, {"success": True,
"comments": [STATE["config_comments"].get(self._member(o["path"]), "")
for o in ops
if isinstance(o.get("path"), list) and self._group_path(o["path"])]})
# ------------------------------------------------------------ retrieve
def handle_retrieve(self, payload) -> None:
if payload.get("op") == "showConfig" and payload.get("path") == ["firewall"]:
self._send(200, {"success": True, "data": {"ipv4": {"forward": {"filter": {"rule": {
"8": {"action": "drop", "destination": {"group": {"address-group": "IDS-BLOCK"}}},
"9": {"action": "drop", "source": {"group": {"address-group": "IDS-BLOCK"}}}
}}}}}})
return
if payload.get("op") != "returnValues":
self._send(400, {"success": False, "error": "mock: only returnValues supported"})
return
tokens = payload.get("path", [])
if (len(tokens) == 5 and tokens[:4] ==
["firewall", "group", "address-group", "IDS-BLOCK"] and tokens[4] == "address"):
with LOCK:
self._send(200, {"success": True, "data": sorted(STATE["members"])})
else:
self._send(400, {"success": False, "error": f"mock: no values for {tokens}"})
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--port", type=int, default=18443)
ap.add_argument("--state-file", default="mock_state.json")
ap.add_argument("--key", default="testkey")
args = ap.parse_args()
Handler.state_file = args.state_file
Handler.key_expected = args.key
try: # allow pre-seeding foreign members
with open(args.state_file) as fh:
STATE["members"] = set(json.load(fh).get("members", []))
except FileNotFoundError:
pass
srv = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
print(f"mock vyos api on 127.0.0.1:{args.port} state={args.state_file}", flush=True)
srv.serve_forever()
if __name__ == "__main__":
main()