Files
myrzx_bot/ranch_web/tests/test_base_path.py
T
AttilaNet e26d37e9c5 revert: restore the original pre-redesign web console
Revert 688aad3, 39ac03a, c84dc36, and ff6a828 in reverse chronological order. Restore the exact tracked tree from 99aff42 while preserving history.

Validation: 29 authentication and base-path tests passed offline. All 23 prior UI browser tests ran in system Edge: 22 passed initially; the fake-login test passed on an unchanged isolated retry. Live game HTTP was blocked throughout browser validation.
2026-11-11 10:08:02 +08:00

244 lines
13 KiB
Python

"""Offline regressions for preserved and stripped reverse-proxy prefixes."""
from html.parser import HTMLParser
from http.cookies import SimpleCookie
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from fastapi.testclient import TestClient
from ranch_web.app import create_app
from ranch_web.config import COOKIE_NAME, WebConfig
from ranch_web.tests.test_api import FakeManager, FakeUpdates
BASE = "/myrzx_bot"
ORIGIN = "https://ranch.example"
class _Proxy:
"""Keep the browser URL/cookies external while changing the upstream path."""
def __init__(self, app, strip):
self.app, self.strip = app, strip
async def __call__(self, scope, receive, send):
if scope["type"] == "http" and self.strip:
path = scope["path"]
if path == BASE or path.startswith(BASE + "/"):
scope = {**scope, "path": path[len(BASE):] or "/",
"raw_path": scope["raw_path"][len(BASE):] or b"/"}
await self.app(scope, receive, send)
class _Document(HTMLParser):
def __init__(self, content):
super().__init__()
self.prefixes, self.urls = [], []
self.feed(content)
def handle_starttag(self, tag, attrs):
attrs = dict(attrs)
if tag == "meta" and attrs.get("name") == "ranch-web-base-path":
self.prefixes.append(attrs.get("content"))
for name in ("src", "href", "action"):
if name in attrs and attrs[name].startswith("/"):
self.urls.append((name, attrs[name]))
class BasePathTests(unittest.TestCase):
def setUp(self):
temporary = self.enterContext(tempfile.TemporaryDirectory(prefix="ranch-base-path-"))
self.root = Path(temporary)
self.manager, self.updates = FakeManager(), FakeUpdates()
self.enterContext(patch("requests.sessions.Session.request", side_effect=AssertionError("No network")))
self.enterContext(patch("socket.create_connection", side_effect=AssertionError("No network")))
def client(self, strip=False, base_path=BASE, base_url=ORIGIN):
settings = WebConfig.from_env({"RANCH_WEB_BASE_PATH": base_path}, data_dir=self.root,
password="offline", secure_cookie=True,
allowed_hosts=("ranch.example",))
app = create_app(manager=self.manager, updates=self.updates, config=settings)
return self.enterContext(TestClient(_Proxy(app, strip), base_url=base_url,
client=("192.0.2.1", 50000)))
def login(self, client, prefix=BASE):
response = client.post(prefix + "/api/auth/login", json={"password": "offline"},
headers={"Origin": ORIGIN})
self.assertEqual(response.status_code, 200, response.text)
return response
def cookies(self, response):
result = {}
for header in response.headers.get_list("set-cookie"):
parsed = SimpleCookie()
parsed.load(header)
cookie = parsed[COOKIE_NAME]
result[cookie["path"]] = cookie
return result
def test_base_path_environment_and_validation(self):
self.assertEqual(WebConfig.from_env({"RANCH_WEB_BASE_PATH": BASE}).base_path, BASE)
self.assertEqual(WebConfig.from_env({}).base_path, "")
for value in ("/", "myrzx_bot", BASE + "/", "//evil", "/a/../b", "/a?b", "/a%2fb"):
with self.subTest(value=value), self.assertRaises(ValueError):
WebConfig.from_env({"RANCH_WEB_BASE_PATH": value})
def test_exact_mount_redirects_to_slash_preserving_query(self):
client = self.client()
for suffix in ("", "?next=%2Fapi%2Faccounts"):
response = client.get(BASE + suffix, follow_redirects=False)
self.assertEqual(response.status_code, 307)
self.assertEqual(response.headers["location"], BASE + "/" + suffix)
response = client.get(BASE + "/", follow_redirects=False)
self.assertEqual(response.status_code, 303)
self.assertEqual(response.headers["location"], BASE + "/login")
def test_login_html_assets_and_authenticated_workbench(self):
for strip in (False, True):
with self.subTest(strip=strip):
client = self.client(strip)
for path in ("/login", "/static/login.html"):
response = client.get(BASE + path)
self.assertEqual(response.status_code, 200)
document = _Document(response.text)
self.assertEqual(document.prefixes, [BASE])
self.assertIn(("action", BASE + "/api/auth/login"), document.urls)
self.assertIn(("src", BASE + "/static/login.js"), document.urls)
for name, url in document.urls:
self.assertTrue(url.startswith(BASE + "/"), url)
self.assertNotIn(BASE + BASE, url)
if name != "action":
self.assertEqual(client.get(url).status_code, 200, url)
for path in ("/", "/static/index.html", "/static/app.js"):
response = client.get(BASE + path, follow_redirects=False)
self.assertEqual(response.status_code, 303)
self.assertEqual(response.headers["location"], BASE + "/login")
self.login(client)
for path in ("/login", "/static/login.html"):
response = client.get(BASE + path, follow_redirects=False)
self.assertEqual(response.status_code, 303)
self.assertEqual(response.headers["location"], BASE + "/")
for path in ("/", "/static/index.html"):
response = client.get(BASE + path)
self.assertEqual(response.status_code, 200)
document = _Document(response.text)
self.assertEqual(document.prefixes, [BASE])
self.assertIn(("src", BASE + "/static/app.js"), document.urls)
self.assertEqual(response.headers["cache-control"], "no-store")
self.assertEqual(client.get(BASE + "/static/app.js").status_code, 200)
self.assertEqual(self.manager.calls, [])
def test_secure_cookie_scope_logout_and_revoked_session(self):
for strip in (False, True):
with self.subTest(strip=strip):
client = self.client(strip)
cookies = self.cookies(self.login(client))
cookie = cookies[BASE]
self.assertTrue(cookie["secure"])
self.assertTrue(cookie["httponly"])
self.assertEqual(cookie["samesite"], "strict")
self.assertFalse(cookie["domain"])
for path in ("/", "/api", BASE + "/api"):
self.assertEqual(cookies[path]["max-age"], "0")
token = client.cookies.get(COOKIE_NAME)
self.assertEqual(client.get(BASE + "/api/accounts").status_code, 200)
for url in (ORIGIN + "/api/accounts", ORIGIN + BASE + "x/api/accounts",
"http://ranch.example" + BASE + "/api/accounts"):
self.assertNotIn("cookie", client.build_request("GET", url).headers)
response = client.post(BASE + "/api/auth/logout", headers={"Origin": ORIGIN})
self.assertEqual(response.status_code, 200)
self.assertEqual(set(self.cookies(response)), {BASE, "/", "/api", BASE + "/api"})
self.assertTrue(all(c["max-age"] == "0" for c in self.cookies(response).values()))
self.assertEqual(list(client.cookies.jar), [])
response = client.get(BASE + "/api/accounts", headers={"Cookie": f"{COOKIE_NAME}={token}"})
self.assertEqual(response.status_code, 401)
def test_auth_and_csrf_apply_in_both_proxy_modes(self):
for strip in (False, True):
with self.subTest(strip=strip):
client = self.client(strip)
for path in ("/api/accounts", "/api/accounts/", "/api/system/updates"):
response = client.get(BASE + path)
self.assertEqual(response.status_code, 401)
self.assertEqual(response.json()["error"]["code"], "authentication_required")
for path, payload in (("/api/auth/login", {"password": "offline"}),
("/api/auth/logout", {}), ("/api/accounts", {"demo": True})):
response = client.post(BASE + path, json=payload,
headers={"Origin": "https://attacker.example"})
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json()["error"]["code"], "invalid_origin")
self.login(client)
response = client.post(BASE + "/api/auth/logout", headers={"Sec-Fetch-Site": "cross-site"})
self.assertEqual(response.status_code, 403)
self.assertTrue(client.get(BASE + "/api/auth/status").json()["authenticated"])
response = client.post(BASE + "/api/accounts", json={"demo": True}, headers={"Origin": ORIGIN})
self.assertEqual(response.status_code, 201)
response = client.get(BASE + "/api/accounts/", follow_redirects=False)
self.assertEqual(response.status_code, 307)
self.assertEqual(response.headers["location"], ORIGIN + BASE + "/api/accounts")
def test_double_prefix_and_forged_forwarded_prefix_cannot_bypass_boundary(self):
for strip in (False, True):
for forged in (BASE, BASE + BASE, "/api"):
with self.subTest(strip=strip, forged=forged):
client = self.client(strip)
headers = {"X-Forwarded-Prefix": forged}
response = client.get(BASE + "/api/accounts", headers=headers)
self.assertEqual(response.status_code, 401)
response = client.get(BASE + "/", headers=headers, follow_redirects=False)
self.assertEqual(response.headers["location"], BASE + "/login")
for path in ("/api/accounts", "/static/index.html"):
response = client.get(BASE + BASE + path, headers=headers, follow_redirects=False)
# After proxy stripping this is indistinguishable from a
# preserved path, so it must still hit the normal gate.
expected = (401 if path.startswith("/api/") else 303) if strip else 404
self.assertEqual(response.status_code, expected)
if expected == 401:
self.assertEqual(response.json()["error"]["code"], "authentication_required")
elif expected == 303:
self.assertEqual(response.headers["location"], BASE + "/login")
response = client.post(BASE + BASE + "/api/accounts", json={"demo": True}, headers=headers)
self.assertEqual(response.status_code, 401 if strip else 404)
response = client.post(BASE + BASE + "/api/accounts", json={},
headers={**headers, "Origin": "https://attacker.example"})
self.assertEqual(response.status_code, 403 if strip else 404)
response = client.post(BASE + "/api/accounts", json={},
headers={**headers, "Origin": "https://attacker.example"})
self.assertEqual(response.status_code, 403)
self.assertEqual(self.manager.calls, [])
self.assertEqual(self.updates.calls, [])
def test_localhost_health_remains_public_with_or_without_prefix(self):
for strip in (False, True):
with self.subTest(strip=strip):
client = self.client(strip, base_url="http://localhost")
for path in ("/api/health", BASE + "/api/health"):
response = client.get(path)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["status"], "ok")
self.assertEqual(response.headers["cache-control"], "no-store")
self.assertNotIn("set-cookie", response.headers)
self.assertEqual(self.manager.calls, [])
self.assertEqual(self.updates.calls, [])
def test_root_deployment_ignores_forwarded_prefix_and_keeps_root_cookie(self):
client = self.client(base_path="")
response = client.get("/", headers={"X-Forwarded-Prefix": BASE}, follow_redirects=False)
self.assertEqual(response.headers["location"], "/login")
response = client.get("/login")
self.assertEqual(_Document(response.text).prefixes, [""])
self.assertIn(("src", "/static/login.js"), _Document(response.text).urls)
self.assertEqual(client.get("/api/accounts").status_code, 401)
cookies = self.cookies(self.login(client, prefix=""))
self.assertEqual(set(cookies), {"/", "/api"})
self.assertNotEqual(cookies["/"]["max-age"], "0")
self.assertEqual(client.get("/api/accounts").status_code, 200)
self.assertEqual(client.get("/api/health").status_code, 200)
if __name__ == "__main__":
unittest.main()